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/ios/Sources/Onboarding/GatewayOnboardingReset.swift

@@ -0,0 +1,46 @@
+import Foundation
+import OpenClawKit
+
+enum GatewayOnboardingReset {
+    @MainActor
+    static func prepareForBootstrapPairing(
+        appModel: NodeAppModel,
+        instanceId: String,
+        defaults: UserDefaults = .standard)
+    {
+        appModel.disconnectGateway()
+
+        let trimmedInstanceId = instanceId.trimmingCharacters(in: .whitespacesAndNewlines)
+        if !trimmedInstanceId.isEmpty {
+            GatewaySettingsStore.deleteGatewayCredentials(instanceId: trimmedInstanceId)
+        }
+
+        let deviceId = DeviceIdentityStore.loadOrCreate().deviceId
+        DeviceAuthStore.clearToken(deviceId: deviceId, role: "node")
+        DeviceAuthStore.clearToken(deviceId: deviceId, role: "operator")
+        DeviceAuthStore.clearAll(profile: .shareExtension)
+
+        GatewaySettingsStore.clearLastGatewayConnection(defaults: defaults)
+        GatewaySettingsStore.clearPreferredGatewayStableID(defaults: defaults)
+        GatewaySettingsStore.clearLastDiscoveredGatewayStableID(defaults: defaults)
+        GatewayTLSStore.clearAllFingerprints()
+        defaults.set(false, forKey: "gateway.autoconnect")
+    }
+
+    @MainActor
+    static func reset(
+        appModel: NodeAppModel,
+        instanceId: String,
+        defaults: UserDefaults = .standard)
+    {
+        self.prepareForBootstrapPairing(appModel: appModel, instanceId: instanceId, defaults: defaults)
+        OnboardingStateStore.reset(defaults: defaults)
+
+        defaults.set(false, forKey: "gateway.onboardingComplete")
+        defaults.set(false, forKey: "gateway.hasConnectedOnce")
+        defaults.set(false, forKey: "gateway.manual.enabled")
+        defaults.set("", forKey: "gateway.manual.host")
+        defaults.set("", forKey: "gateway.setupCode")
+        defaults.set(defaults.integer(forKey: "onboarding.requestID") + 1, forKey: "onboarding.requestID")
+    }
+}

apps/ios/Sources/Onboarding/OnboardingStateStore.swift

@@ -0,0 +1,67 @@
+import Foundation
+
+enum OnboardingConnectionMode: String, CaseIterable {
+    case homeNetwork = "home_network"
+    case remoteDomain = "remote_domain"
+    case developerLocal = "developer_local"
+
+    var title: String {
+        switch self {
+        case .homeNetwork:
+            "Home Network"
+        case .remoteDomain:
+            "Remote Domain"
+        case .developerLocal:
+            "Same Machine (Dev)"
+        }
+    }
+}
+
+enum OnboardingStateStore {
+    private static let completedDefaultsKey = "onboarding.completed"
+    private static let firstRunIntroSeenDefaultsKey = "onboarding.first_run_intro_seen"
+    private static let lastModeDefaultsKey = "onboarding.last_mode"
+    private static let lastSuccessTimeDefaultsKey = "onboarding.last_success_time"
+
+    @MainActor
+    static func shouldPresentOnLaunch(
+        appModel: NodeAppModel,
+        defaults: UserDefaults = .standard,
+        hasSavedGatewayConnection: Bool? = nil)
+        -> Bool
+    {
+        if defaults.bool(forKey: self.completedDefaultsKey) { return false }
+        let hasSavedGatewayConnection =
+            hasSavedGatewayConnection ?? (GatewaySettingsStore.loadLastGatewayConnection() != nil)
+        if hasSavedGatewayConnection { return false }
+        return appModel.gatewayServerName == nil
+    }
+
+    static func markCompleted(mode: OnboardingConnectionMode? = nil, defaults: UserDefaults = .standard) {
+        defaults.set(true, forKey: self.completedDefaultsKey)
+        if let mode {
+            defaults.set(mode.rawValue, forKey: self.lastModeDefaultsKey)
+        }
+        defaults.set(Int(Date().timeIntervalSince1970), forKey: Self.lastSuccessTimeDefaultsKey)
+    }
+
+    static func shouldPresentFirstRunIntro(defaults: UserDefaults = .standard) -> Bool {
+        !defaults.bool(forKey: self.firstRunIntroSeenDefaultsKey)
+    }
+
+    static func markFirstRunIntroSeen(defaults: UserDefaults = .standard) {
+        defaults.set(true, forKey: self.firstRunIntroSeenDefaultsKey)
+    }
+
+    static func reset(defaults: UserDefaults = .standard) {
+        defaults.set(false, forKey: self.completedDefaultsKey)
+        defaults.set(false, forKey: self.firstRunIntroSeenDefaultsKey)
+    }
+
+    static func lastMode(defaults: UserDefaults = .standard) -> OnboardingConnectionMode? {
+        let raw = defaults.string(forKey: Self.lastModeDefaultsKey)?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        guard !raw.isEmpty else { return nil }
+        return OnboardingConnectionMode(rawValue: raw)
+    }
+}

apps/ios/Sources/Onboarding/OnboardingWizardSteps.swift

@@ -0,0 +1,246 @@
+import SwiftUI
+import UIKit
+
+private enum OnboardingLayout {
+    static let contentMaxWidth: CGFloat = 680
+}
+
+struct OnboardingIntroStep: View {
+    let onContinue: () -> Void
+
+    private static let features: [(icon: String, title: String, detail: String)] = [
+        ("link", "Connect your gateway", "Pair with a quick QR scan."),
+        ("hand.raised.fill", "You choose permissions", "Grant only the tools you want."),
+        ("bubble.left.and.bubble.right.fill", "Chat, voice, and camera", "All from your phone."),
+    ]
+
+    var body: some View {
+        VStack(spacing: 0) {
+            ScrollView {
+                VStack(spacing: 0) {
+                    OpenClawProMark(size: 76, shadowRadius: 12)
+                        .padding(.top, 32)
+                        .padding(.bottom, 20)
+
+                    Text("Welcome to OpenClaw")
+                        .font(OpenClawType.title1)
+                        .multilineTextAlignment(.center)
+                        .padding(.horizontal, 24)
+                        .padding(.bottom, 40)
+
+                    VStack(alignment: .leading, spacing: 28) {
+                        ForEach(Array(Self.features.enumerated()), id: \.offset) { _, feature in
+                            OnboardingFeatureRow(icon: feature.icon, title: feature.title, detail: feature.detail)
+                        }
+
+                        GroupBox {
+                            Text(
+                                "The connected agent can use capabilities you enable, including camera, "
+                                    + "microphone, photos, contacts, calendar, and location. Continue only if "
+                                    + "you trust the gateway and agent.")
+                                .font(OpenClawType.footnote)
+                                .foregroundStyle(.secondary)
+                                .fixedSize(horizontal: false, vertical: true)
+                        } label: {
+                            Label("Security", systemImage: "lock.shield.fill")
+                                .font(OpenClawType.headline)
+                        }
+                        .tint(OpenClawBrand.warn)
+                    }
+                    .padding(.horizontal, 12)
+                }
+                .frame(maxWidth: .infinity)
+                .padding(.horizontal, 20)
+            }
+            .scrollBounceBehavior(.basedOnSize)
+
+            VStack(spacing: 16) {
+                Text("You can change permissions later in Settings.")
+                    .font(OpenClawType.footnote)
+                    .foregroundStyle(.secondary)
+                    .frame(maxWidth: .infinity, alignment: .center)
+
+                Button(action: self.onContinue) {
+                    Text("Continue")
+                        .font(OpenClawType.headline)
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.borderedProminent)
+                .controlSize(.large)
+                .tint(OpenClawBrand.accent)
+            }
+            .padding(.horizontal, 20)
+            .padding(.top, 12)
+            .padding(.bottom, 16)
+        }
+        .frame(maxWidth: OnboardingLayout.contentMaxWidth)
+        .frame(maxWidth: .infinity)
+    }
+}
+
+/// Inline command styled like a keyboard key so shell/chat commands stand out from prose.
+struct KeycapText: View {
+    let text: String
+
+    init(_ text: String) {
+        self.text = text
+    }
+
+    var body: some View {
+        Text(self.text)
+            .font(OpenClawType.monoFootnote)
+            .padding(.horizontal, 9)
+            .padding(.vertical, 4)
+            .background {
+                RoundedRectangle(cornerRadius: 7, style: .continuous)
+                    .fill(Color(uiColor: .secondarySystemFill))
+                    .overlay {
+                        RoundedRectangle(cornerRadius: 7, style: .continuous)
+                            .strokeBorder(Color(uiColor: .separator).opacity(0.6), lineWidth: 0.5)
+                    }
+            }
+    }
+}
+
+private struct OnboardingFeatureRow: View {
+    let icon: String
+    let title: String
+    let detail: String
+
+    var body: some View {
+        HStack(alignment: .top, spacing: 16) {
+            Image(systemName: self.icon)
+                .font(OpenClawType.title2)
+                .foregroundStyle(OpenClawBrand.accent)
+                .frame(width: 34, alignment: .center)
+                .accessibilityHidden(true)
+
+            VStack(alignment: .leading, spacing: 2) {
+                Text(self.title)
+                    .font(OpenClawType.headline)
+                Text(self.detail)
+                    .font(OpenClawType.subhead)
+                    .foregroundStyle(.secondary)
+                    .fixedSize(horizontal: false, vertical: true)
+            }
+        }
+    }
+}
+
+struct OnboardingWelcomeStep: View {
+    let statusLine: String
+    let onScanQRCode: () -> Void
+    let onManualSetup: () -> Void
+
+    @State private var pairCommandCopied = false
+
+    var body: some View {
+        VStack(spacing: 0) {
+            Spacer()
+
+            Image(systemName: "qrcode.viewfinder")
+                .font(.system(size: 64))
+                .foregroundStyle(OpenClawBrand.accent)
+                .padding(.bottom, 24)
+
+            Text("Connect Gateway")
+                .font(OpenClawType.title1)
+                .padding(.bottom, 12)
+
+            HStack(spacing: 8) {
+                KeycapText("/pair qr")
+                Button {
+                    var transaction = Transaction()
+                    transaction.disablesAnimations = true
+                    withTransaction(transaction) {
+                        UIPasteboard.general.string = "/pair qr"
+                        self.pairCommandCopied = true
+                    }
+                } label: {
+                    Label(
+                        self.pairCommandCopied ? "Copied" : "Copy",
+                        systemImage: self.pairCommandCopied ? "checkmark" : "doc.on.doc")
+                        .font(OpenClawType.captionSemiBold)
+                }
+                .buttonStyle(.bordered)
+                .controlSize(.small)
+                .tint(.primary)
+                .animation(nil, value: self.pairCommandCopied)
+                .accessibilityLabel(self.pairCommandCopied ? "Pair command copied" : "Copy pair command")
+                .accessibilityIdentifier("onboarding-copy-pair-command")
+            }
+            .padding(.bottom, 10)
+
+            Text("Run this in your OpenClaw chat, then scan the code.")
+                .font(OpenClawType.subhead)
+                .foregroundStyle(.secondary)
+                .multilineTextAlignment(.center)
+                .padding(.horizontal, 40)
+
+            Spacer()
+
+            VStack(spacing: 4) {
+                Button {
+                    self.onScanQRCode()
+                } label: {
+                    Label("Scan QR Code", systemImage: "qrcode")
+                        .font(OpenClawType.headline)
+                        .frame(maxWidth: .infinity)
+                }
+                .buttonStyle(.borderedProminent)
+                .controlSize(.large)
+                .tint(OpenClawBrand.accent)
+
+                Button(action: self.onManualSetup) {
+                    Text("Set Up Manually")
+                        .font(OpenClawType.headline)
+                }
+                .buttonStyle(.borderless)
+                .controlSize(.large)
+                .tint(OpenClawBrand.accent)
+                .padding(.top, 12)
+            }
+            .padding(.horizontal, OpenClawSpacing.space6)
+            .padding(.bottom, 12)
+
+            if !self.statusLine.isEmpty {
+                Text(self.statusLine)
+                    .font(OpenClawType.footnote)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+                    .padding(.horizontal, 24)
+            }
+
+            Color.clear.frame(height: 12)
+        }
+        .frame(maxWidth: OnboardingLayout.contentMaxWidth)
+        .frame(maxWidth: .infinity)
+    }
+}
+
+struct OnboardingModeRow: View {
+    let title: String
+    let subtitle: String
+    let selected: Bool
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: self.action) {
+            HStack {
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(self.title)
+                        .font(OpenClawType.headline)
+                    Text(self.subtitle)
+                        .font(OpenClawType.footnote)
+                        .foregroundStyle(.secondary)
+                }
+                Spacer()
+                Image(systemName: self.selected ? "checkmark.circle.fill" : "circle")
+                    .foregroundStyle(self.selected ? OpenClawBrand.accent : Color.secondary)
+            }
+            .contentShape(Rectangle())
+        }
+        .font(OpenClawType.subhead)
+        .buttonStyle(.plain)
+    }
+}

apps/ios/Sources/Onboarding/QRScannerView.swift

@@ -0,0 +1,95 @@
+import OpenClawKit
+import SwiftUI
+import VisionKit
+
+struct QRScannerView: UIViewControllerRepresentable {
+    let onGatewayLink: (GatewayConnectDeepLink) -> Void
+    let onSetupCode: (String) -> Void
+    let onError: (String) -> Void
+    let onDismiss: () -> Void
+
+    func makeUIViewController(context: Context) -> UIViewController {
+        guard DataScannerViewController.isSupported else {
+            context.coordinator.reportError("QR scanning is not supported on this device.")
+            return UIViewController()
+        }
+        guard DataScannerViewController.isAvailable else {
+            context.coordinator.reportError("Camera scanning is currently unavailable.")
+            return UIViewController()
+        }
+        let scanner = DataScannerViewController(
+            recognizedDataTypes: [.barcode(symbologies: [.qr])],
+            isHighlightingEnabled: true)
+        scanner.delegate = context.coordinator
+        do {
+            try scanner.startScanning()
+        } catch {
+            context.coordinator.reportError("Could not start QR scanner.")
+        }
+        return scanner
+    }
+
+    func updateUIViewController(_: UIViewController, context _: Context) {}
+
+    static func dismantleUIViewController(_ uiViewController: UIViewController, coordinator: Coordinator) {
+        if let scanner = uiViewController as? DataScannerViewController {
+            scanner.stopScanning()
+        }
+        coordinator.parent.onDismiss()
+    }
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator(parent: self)
+    }
+
+    final class Coordinator: NSObject, DataScannerViewControllerDelegate {
+        let parent: QRScannerView
+        private var handled = false
+        private var reportedError = false
+
+        init(parent: QRScannerView) {
+            self.parent = parent
+        }
+
+        func reportError(_ message: String) {
+            guard !self.reportedError else { return }
+            self.reportedError = true
+            Task { @MainActor in
+                self.parent.onError(message)
+            }
+        }
+
+        func dataScanner(_: DataScannerViewController, didAdd items: [RecognizedItem], allItems _: [RecognizedItem]) {
+            guard !self.handled else { return }
+            for item in items {
+                guard case let .barcode(barcode) = item,
+                      let payload = barcode.payloadStringValue
+                else { continue }
+
+                if let link = GatewayConnectDeepLink.fromSetupInput(payload) {
+                    self.handled = true
+                    Task { @MainActor in
+                        self.parent.onGatewayLink(link)
+                    }
+                    return
+                }
+                if AppleReviewDemoMode.isSetupCode(payload) {
+                    self.handled = true
+                    Task { @MainActor in
+                        self.parent.onSetupCode(payload)
+                    }
+                    return
+                }
+            }
+        }
+
+        func dataScanner(_: DataScannerViewController, didRemove _: [RecognizedItem], allItems _: [RecognizedItem]) {}
+
+        func dataScanner(
+            _: DataScannerViewController,
+            becameUnavailableWithError _: DataScannerViewController.ScanningUnavailable)
+        {
+            self.reportError("Camera is not available on this device.")
+        }
+    }
+}