Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

apps/macos/Sources/OpenClaw/ChannelsStore+Config.swift

@@ -0,0 +1,359 @@
+import Foundation
+import OpenClawProtocol
+
+extension ChannelsStore {
+    func loadConfigSchema(force: Bool = false) async {
+        let sourceKey = self.currentConfigCacheSourceKey()
+        self.resetConfigSchemaCacheIfSourceChanged(sourceKey)
+        if !force, self.configSchema != nil {
+            return
+        }
+        guard !self.queueConfigSchemaReloadIfLoading(sourceKey: sourceKey, force: force) else { return }
+        self.configSchemaLoading = true
+        self.configSchemaLoadingSourceKey = sourceKey
+        defer {
+            self.configSchemaLoading = false
+            self.configSchemaLoadingSourceKey = nil
+        }
+
+        var requestSourceKey = sourceKey
+
+        while true {
+            self.configSchemaLoadingSourceKey = requestSourceKey
+            do {
+                let res: ConfigSchemaResponse = try await GatewayConnection.shared.requestDecoded(
+                    method: .configSchema,
+                    params: nil,
+                    timeoutMs: 8000)
+                self.applyConfigSchemaResponse(res, sourceKey: requestSourceKey)
+            } catch {
+                self.configStatus = error.localizedDescription
+            }
+
+            guard self.configSchemaReloadPending else { break }
+            self.configSchemaReloadPending = false
+            requestSourceKey = self.currentConfigCacheSourceKey()
+            self.resetConfigSchemaCacheIfSourceChanged(requestSourceKey)
+        }
+    }
+
+    @discardableResult
+    func loadConfigSchemaLookup(path: String, force: Bool = false) async -> ConfigSchemaLookupNode? {
+        let sourceKey = self.currentConfigCacheSourceKey()
+        self.resetConfigSchemaCacheIfSourceChanged(sourceKey)
+        let normalizedPath = Self.normalizeConfigLookupPath(path)
+        if !force, let cached = self.configLookupNode(path: normalizedPath) {
+            return cached
+        }
+        if self.configLookupLoadingPaths.contains(normalizedPath) {
+            return self.configLookupNode(path: normalizedPath)
+        }
+
+        self.configLookupLoadingPaths.insert(normalizedPath)
+        defer { self.configLookupLoadingPaths.remove(normalizedPath) }
+
+        do {
+            let res: ConfigSchemaLookupResult = try await GatewayConnection.shared.requestDecoded(
+                method: .configSchemaLookup,
+                params: ["path": AnyCodable(normalizedPath)],
+                timeoutMs: 5000)
+            guard let node = self.makeConfigLookupNode(res) else {
+                self.configStatus = "Config schema lookup returned an unsupported payload."
+                return nil
+            }
+            self.applyConfigLookupNode(node, sourceKey: sourceKey)
+            return node
+        } catch {
+            self.configStatus = error.localizedDescription
+            return nil
+        }
+    }
+
+    func loadConfig(force: Bool = true) async {
+        let sourceKey = self.currentConfigCacheSourceKey()
+        self.resetConfigCacheIfSourceChanged(sourceKey)
+        if !force, self.configLoaded {
+            return
+        }
+        guard !self.queueConfigReloadIfLoading(sourceKey: sourceKey, force: force) else { return }
+        self.configLoading = true
+        self.configLoadingSourceKey = sourceKey
+        defer {
+            self.configLoading = false
+            self.configLoadingSourceKey = nil
+        }
+
+        var requestForce = force
+        var requestSourceKey = sourceKey
+
+        while true {
+            self.configLoadingSourceKey = requestSourceKey
+            do {
+                let snap: ConfigSnapshot = try await GatewayConnection.shared.requestDecoded(
+                    method: .configGet,
+                    params: nil,
+                    timeoutMs: 10000)
+                self.applyConfigSnapshot(snap, sourceKey: requestSourceKey, force: requestForce)
+            } catch {
+                self.configStatus = error.localizedDescription
+            }
+
+            guard self.configForceReloadPending else { break }
+            self.configForceReloadPending = false
+            requestForce = true
+            requestSourceKey = self.currentConfigCacheSourceKey()
+            self.resetConfigCacheIfSourceChanged(requestSourceKey)
+        }
+    }
+
+    func applyConfigSnapshot(_ snap: ConfigSnapshot, sourceKey: String, force: Bool) {
+        guard self.configSourceKey == sourceKey else { return }
+        guard force || !self.configDirty else { return }
+
+        self.configStatus = snap.valid == false
+            ? "Config invalid; fix it in ~/.openclaw/openclaw.json."
+            : nil
+        self.configRoot = snap.config?.mapValues { $0.foundationValue } ?? [:]
+        self.configDraft = cloneConfigValue(self.configRoot) as? [String: Any] ?? self.configRoot
+        self.configDirty = false
+        self.configLoaded = true
+        self.configSourceKey = sourceKey
+
+        self.applyUIConfig(snap)
+    }
+
+    func applyConfigSchemaResponse(_ res: ConfigSchemaResponse, sourceKey: String) {
+        guard self.configSchemaSourceKey == sourceKey else { return }
+
+        let schemaValue = res.schema.foundationValue
+        self.configSchema = ConfigSchemaNode(raw: schemaValue)
+        let hintValues = res.uihints.mapValues { $0.foundationValue }
+        self.configUiHints = decodeUiHints(hintValues)
+        self.configSchemaSourceKey = sourceKey
+    }
+
+    func configLookupNode(path: String) -> ConfigSchemaLookupNode? {
+        let normalizedPath = Self.normalizeConfigLookupPath(path)
+        if normalizedPath == "." {
+            return self.configLookupRoot
+        }
+        return self.configLookupCache[normalizedPath]
+    }
+
+    func makeConfigLookupNode(_ res: ConfigSchemaLookupResult) -> ConfigSchemaLookupNode? {
+        let schemaValue = res.schema.foundationValue
+        guard let schema = ConfigSchemaNode(raw: schemaValue) else { return nil }
+        let hint = res.hint.map { ConfigUiHint(raw: $0.mapValues(\.foundationValue)) }
+        let children = res.children.compactMap(ConfigSchemaLookupChild.init(raw:))
+        return ConfigSchemaLookupNode(
+            path: Self.normalizeConfigLookupPath(res.path),
+            schema: schema,
+            hint: hint,
+            hintPath: res.hintpath,
+            children: children)
+    }
+
+    func applyConfigLookupNode(_ node: ConfigSchemaLookupNode, sourceKey: String) {
+        guard self.configSchemaSourceKey == sourceKey else { return }
+        if node.path == "." {
+            self.configLookupRoot = node
+        } else {
+            self.configLookupCache[node.path] = node
+        }
+        if let hint = node.hint {
+            self.configUiHints[node.path] = hint
+        }
+        for child in node.children {
+            if let hint = child.hint {
+                self.configUiHints[child.path] = hint
+            }
+        }
+    }
+
+    private func applyUIConfig(_ snap: ConfigSnapshot) {
+        let ui = snap.config?["ui"]?.dictionaryValue
+        let rawSeam = ui?["seamColor"]?.stringValue?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        AppStateStore.shared.seamColorHex = rawSeam.isEmpty ? nil : rawSeam
+    }
+
+    func channelConfigSchema(for channelId: String) -> ConfigSchemaNode? {
+        guard let root = self.configSchema else { return nil }
+        return root.node(at: [.key("channels"), .key(channelId)])
+    }
+
+    func configValue(at path: ConfigPath) -> Any? {
+        if let value = valueAtPath(self.configDraft, path: path) {
+            return value
+        }
+        guard path.count >= 2 else { return nil }
+        if case .key("channels") = path[0], case .key = path[1] {
+            let fallbackPath = Array(path.dropFirst())
+            return valueAtPath(self.configDraft, path: fallbackPath)
+        }
+        return nil
+    }
+
+    func updateConfigValue(path: ConfigPath, value: Any?) {
+        var root: Any = self.configDraft
+        setValue(&root, path: path, value: value)
+        self.configDraft = root as? [String: Any] ?? self.configDraft
+        self.configDirty = true
+    }
+
+    func saveConfigDraft() async {
+        guard !self.isSavingConfig else { return }
+        self.isSavingConfig = true
+        defer { self.isSavingConfig = false }
+
+        do {
+            try await ConfigStore.save(self.configDraft)
+            await self.loadConfig()
+        } catch {
+            self.configStatus = error.localizedDescription
+        }
+    }
+
+    func reloadConfigDraft() async {
+        await self.loadConfig(force: true)
+    }
+
+    func resetConfigSchemaCacheIfSourceChanged(_ sourceKey: String) {
+        guard let cachedSourceKey = self.configSchemaSourceKey else {
+            self.configSchemaSourceKey = sourceKey
+            return
+        }
+        guard cachedSourceKey != sourceKey else { return }
+        self.configSchema = nil
+        self.configLookupRoot = nil
+        self.configLookupCache.removeAll(keepingCapacity: true)
+        self.configLookupLoadingPaths.removeAll(keepingCapacity: true)
+        self.configUiHints = [:]
+        self.configSchemaSourceKey = sourceKey
+    }
+
+    func resetConfigCacheIfSourceChanged(_ sourceKey: String) {
+        guard let cachedSourceKey = self.configSourceKey else {
+            self.configSourceKey = sourceKey
+            return
+        }
+        guard cachedSourceKey != sourceKey else { return }
+        self.configRoot = [:]
+        self.configDraft = [:]
+        self.configDirty = false
+        self.configLoaded = false
+        self.configSourceKey = sourceKey
+    }
+
+    func queueConfigReloadIfLoading(sourceKey: String, force: Bool) -> Bool {
+        guard self.configLoading else { return false }
+        if force || self.configLoadingSourceKey != sourceKey {
+            self.configForceReloadPending = true
+        }
+        return true
+    }
+
+    func queueConfigSchemaReloadIfLoading(sourceKey: String, force: Bool) -> Bool {
+        guard self.configSchemaLoading else { return false }
+        if force || self.configSchemaLoadingSourceKey != sourceKey {
+            self.configSchemaReloadPending = true
+        }
+        return true
+    }
+
+    private func currentConfigCacheSourceKey() -> String {
+        let root = OpenClawConfigFile.loadDict()
+        let settings = CommandResolver.connectionSettings(configRoot: root)
+        let env = ProcessInfo.processInfo.environment
+        return [
+            "mode:\(settings.mode.rawValue)",
+            "target:\(settings.target)",
+            "identity:\(settings.identity)",
+            "project:\(settings.projectRoot)",
+            "cli:\(settings.cliPath)",
+            "port:\(GatewayEnvironment.gatewayPort())",
+            "gateway:\(Self.configFingerprint(root["gateway"]))",
+            "token:\(Self.configFingerprint(env["OPENCLAW_GATEWAY_TOKEN"]))",
+            "password:\(Self.configFingerprint(env["OPENCLAW_GATEWAY_PASSWORD"]))",
+        ].joined(separator: "|")
+    }
+
+    static func normalizeConfigLookupPath(_ path: String) -> String {
+        let trimmed = path.trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? "." : trimmed
+    }
+
+    private static func configFingerprint(_ value: Any?) -> String {
+        guard let value else { return "nil" }
+        if JSONSerialization.isValidJSONObject(value),
+           let data = try? JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])
+        {
+            return "\(data.count):\(data.hashValue)"
+        }
+        let text = String(describing: value)
+        return "\(text.count):\(text.hashValue)"
+    }
+}
+
+private func valueAtPath(_ root: Any, path: ConfigPath) -> Any? {
+    var current: Any? = root
+    for segment in path {
+        switch segment {
+        case let .key(key):
+            guard let dict = current as? [String: Any] else { return nil }
+            current = dict[key]
+        case let .index(index):
+            guard let array = current as? [Any], array.indices.contains(index) else { return nil }
+            current = array[index]
+        }
+    }
+    return current
+}
+
+private func setValue(_ root: inout Any, path: ConfigPath, value: Any?) {
+    guard let segment = path.first else { return }
+    switch segment {
+    case let .key(key):
+        var dict = root as? [String: Any] ?? [:]
+        if path.count == 1 {
+            if let value {
+                dict[key] = value
+            } else {
+                dict.removeValue(forKey: key)
+            }
+            root = dict
+            return
+        }
+        var child = dict[key] ?? [:]
+        setValue(&child, path: Array(path.dropFirst()), value: value)
+        dict[key] = child
+        root = dict
+    case let .index(index):
+        var array = root as? [Any] ?? []
+        if index >= array.count {
+            array.append(contentsOf: repeatElement(NSNull() as Any, count: index - array.count + 1))
+        }
+        if path.count == 1 {
+            if let value {
+                array[index] = value
+            } else if array.indices.contains(index) {
+                array.remove(at: index)
+            }
+            root = array
+            return
+        }
+        var child = array[index]
+        setValue(&child, path: Array(path.dropFirst()), value: value)
+        array[index] = child
+        root = array
+    }
+}
+
+private func cloneConfigValue(_ value: Any) -> Any {
+    guard JSONSerialization.isValidJSONObject(value) else { return value }
+    do {
+        let data = try JSONSerialization.data(withJSONObject: value, options: [])
+        return try JSONSerialization.jsonObject(with: data, options: [])
+    } catch {
+        return value
+    }
+}