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/Tests/OpenClawIPCTests/RuntimeLocatorTests.swift

@@ -0,0 +1,125 @@
+import Foundation
+import Testing
+@testable import OpenClaw
+
+struct RuntimeLocatorTests {
+    private func makeTempExecutable(contents: String) throws -> URL {
+        let dir = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+            .appendingPathComponent(UUID().uuidString, isDirectory: true)
+        try FileManager().createDirectory(at: dir, withIntermediateDirectories: true)
+        let path = dir.appendingPathComponent("node")
+        try contents.write(to: path, atomically: true, encoding: .utf8)
+        try FileManager().setAttributes([.posixPermissions: 0o755], ofItemAtPath: path.path)
+        return path
+    }
+
+    @Test func `resolve succeeds with valid node`() throws {
+        let script = """
+        #!/bin/sh
+        echo v22.19.0
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .success(res) = result else {
+            Issue.record("Expected success, got \(result)")
+            return
+        }
+        #expect(res.path == node.path)
+        #expect(res.version == RuntimeVersion(major: 22, minor: 19, patch: 0))
+    }
+
+    @Test func `resolve fails on boundary below minimum`() throws {
+        let script = """
+        #!/bin/sh
+        echo v22.18.9
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .failure(.unsupported(_, found, path, _)) = result else {
+            Issue.record("Expected unsupported error, got \(result)")
+            return
+        }
+        #expect(found == RuntimeVersion(major: 22, minor: 18, patch: 9))
+        #expect(path == node.path)
+    }
+
+    @Test func `resolve rejects early node 23`() throws {
+        let script = """
+        #!/bin/sh
+        echo v23.7.0
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .failure(.unsupported(_, found, path, _)) = result else {
+            Issue.record("Expected unsupported error, got \(result)")
+            return
+        }
+        #expect(found == RuntimeVersion(major: 23, minor: 7, patch: 0))
+        #expect(path == node.path)
+    }
+
+    @Test func `resolve accepts node 23 with statement columns`() throws {
+        let script = """
+        #!/bin/sh
+        echo v23.11.0
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .success(res) = result else {
+            Issue.record("Expected success, got \(result)")
+            return
+        }
+        #expect(res.path == node.path)
+        #expect(res.version == RuntimeVersion(major: 23, minor: 11, patch: 0))
+    }
+
+    @Test func `resolve fails when too old`() throws {
+        let script = """
+        #!/bin/sh
+        echo v18.2.0
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .failure(.unsupported(_, found, path, _)) = result else {
+            Issue.record("Expected unsupported error, got \(result)")
+            return
+        }
+        #expect(found == RuntimeVersion(major: 18, minor: 2, patch: 0))
+        #expect(path == node.path)
+    }
+
+    @Test func `resolve fails when version unparsable`() throws {
+        let script = """
+        #!/bin/sh
+        echo node-version:unknown
+        """
+        let node = try self.makeTempExecutable(contents: script)
+        let result = RuntimeLocator.resolve(searchPaths: [node.deletingLastPathComponent().path])
+        guard case let .failure(.versionParse(_, raw, path, _)) = result else {
+            Issue.record("Expected versionParse error, got \(result)")
+            return
+        }
+        #expect(raw.contains("unknown"))
+        #expect(path == node.path)
+    }
+
+    @Test func `describe failure includes paths`() {
+        let msg = RuntimeLocator.describeFailure(.notFound(searchPaths: ["/tmp/a", "/tmp/b"]))
+        #expect(msg.contains("Node >=22.19.0 <23 or >=23.11.0"))
+        #expect(msg.contains("PATH searched: /tmp/a:/tmp/b"))
+
+        let parseMsg = RuntimeLocator.describeFailure(
+            .versionParse(
+                kind: .node,
+                raw: "garbage",
+                path: "/usr/local/bin/node",
+                searchPaths: ["/usr/local/bin"]))
+        #expect(parseMsg.contains("Node >=22.19.0 <23 or >=23.11.0"))
+    }
+
+    @Test func `runtime version parses with leading V and metadata`() {
+        #expect(RuntimeVersion.from(string: "v22.1.3") == RuntimeVersion(major: 22, minor: 1, patch: 3))
+        #expect(RuntimeVersion.from(string: "node 22.3.0-alpha.1") == RuntimeVersion(major: 22, minor: 3, patch: 0))
+        #expect(RuntimeVersion.from(string: "bogus") == nil)
+    }
+}