agentroam 0.2.0-preview.7 → 0.2.0-preview.9

package/dist/opencode-runtime-manager.test.js

@@ -0,0 +1,79 @@
+import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { OPENCODE_RUNTIME_VERSION, managedOpenCodeBinaryCandidates, parseOpenCodeVersion, resolveOpenCodeRuntime, } from "./opencode-runtime-manager.js";
+const roots = [];
+afterEach(async () => {
+    await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+async function executable(name = "opencode") {
+    const root = await mkdtemp(join(tmpdir(), "agentroam-opencode-"));
+    roots.push(root);
+    const path = join(root, name);
+    await writeFile(path, "#!/bin/sh\nexit 0\n");
+    await chmod(path, 0o755);
+    return { root, path };
+}
+describe("resolveOpenCodeRuntime", () => {
+    it("prefers a compatible absolute override", async () => {
+        const binary = await executable();
+        const run = vi.fn(async (_command, args) => ({
+            stdout: args[0] === "--version" ? `opencode ${OPENCODE_RUNTIME_VERSION}` : "help",
+            stderr: "",
+        }));
+        await expect(resolveOpenCodeRuntime({
+            dataDir: binary.root,
+            target: "darwin-arm64",
+            environment: { AGENT_OPENCODE_BIN: binary.path, PATH: "" },
+            platform: "darwin",
+            dependencies: { run },
+        })).resolves.toEqual({ executable: binary.path, version: OPENCODE_RUNTIME_VERSION, source: "explicit" });
+        expect(run).toHaveBeenCalledWith(binary.path, ["serve", "--help"], 5_000);
+    });
+    it("rejects relative explicit overrides", async () => {
+        await expect(resolveOpenCodeRuntime({
+            dataDir: "/data",
+            target: "darwin-arm64",
+            environment: { AGENT_OPENCODE_BIN: "opencode", PATH: "" },
+            platform: "darwin",
+        })).rejects.toThrow("absolute path");
+    });
+    it("uses a compatible PATH executable", async () => {
+        const binary = await executable();
+        await expect(resolveOpenCodeRuntime({
+            dataDir: join(binary.root, "data"),
+            target: "darwin-arm64",
+            environment: { PATH: binary.root },
+            platform: "darwin",
+            dependencies: { run: async () => ({ stdout: OPENCODE_RUNTIME_VERSION, stderr: "" }) },
+        })).resolves.toMatchObject({ executable: binary.path, source: "global" });
+    });
+    it("reuses a validated managed installation", async () => {
+        const root = await mkdtemp(join(tmpdir(), "agentroam-opencode-managed-"));
+        roots.push(root);
+        const managedRoot = join(root, "runtimes", "opencode", OPENCODE_RUNTIME_VERSION);
+        const candidate = managedOpenCodeBinaryCandidates(managedRoot, "darwin")[0];
+        await mkdir(join(candidate, ".."), { recursive: true });
+        await writeFile(candidate, "#!/bin/sh\nexit 0\n");
+        await chmod(candidate, 0o755);
+        await expect(resolveOpenCodeRuntime({
+            dataDir: root,
+            target: "darwin-arm64",
+            environment: { PATH: "" },
+            platform: "darwin",
+            dependencies: { run: async () => ({ stdout: OPENCODE_RUNTIME_VERSION, stderr: "" }) },
+        })).resolves.toEqual({ executable: candidate, version: OPENCODE_RUNTIME_VERSION, source: "managed" });
+    });
+});
+describe("OpenCode runtime helpers", () => {
+    it("parses only semantic versions", () => {
+        expect(parseOpenCodeVersion("opencode 1.18.27")).toBe("1.18.27");
+        expect(parseOpenCodeVersion("dev")).toBeNull();
+    });
+    it("keeps managed binary candidates under the runtime root", () => {
+        expect(managedOpenCodeBinaryCandidates("/data/runtime", "darwin")[0])
+            .toBe("/data/runtime/node_modules/opencode-ai/bin/opencode.exe");
+        expect(managedOpenCodeBinaryCandidates("C:\\runtime", "win32").some((path) => path.endsWith("opencode.cmd"))).toBe(true);
+    });
+});

package/dist/platform-packages.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname } from "node:path";
-export const AGENTROAM_VERSION = "0.2.0-preview.7";
+export const AGENTROAM_VERSION = "0.2.0-preview.9";
 export const PLATFORM_PACKAGES = {
     "darwin-arm64": {
         runtime: "agentroam-runtime-darwin-arm64",

package/dist/platform.js

@@ -1,7 +1,4 @@
-export function detectPlatform(platform = process.platform, arch = process.arch, nodeVersion = process.versions.node) {
-    const major = Number(nodeVersion.split(".")[0]);
-    if (major !== 22)
-        throw Object.assign(new Error(`Node.js 22 required (current ${nodeVersion})`), { exitCode: 2 });
+export function detectPlatformTarget(platform = process.platform, arch = process.arch) {
     if (platform === "darwin" && arch === "arm64")
         return "darwin-arm64";
     if (platform === "darwin" && arch === "x64")
@@ -10,3 +7,10 @@ export function detectPlatform(platform = process.platform, arch = process.arch,
         return "windows-amd64";
     throw Object.assign(new Error(`unsupported platform: ${platform}-${arch}`), { exitCode: 2 });
 }
+export function detectPlatform(platform = process.platform, arch = process.arch, nodeVersion = process.versions.node) {
+    const major = Number(nodeVersion.split(".")[0]);
+    if (major !== 22) {
+        throw Object.assign(new Error(`Node.js 22 required (current ${nodeVersion})`), { exitCode: 2 });
+    }
+    return detectPlatformTarget(platform, arch);
+}

package/dist/platform.test.js

@@ -1,3 +1,18 @@
 import { describe, expect, it } from "vitest";
-import { detectPlatform } from "./platform.js";
-describe("detectPlatform", () => { it("maps supported targets", () => { expect(detectPlatform("darwin", "arm64", "22.1.0")).toBe("darwin-arm64"); expect(detectPlatform("win32", "x64", "22.1.0")).toBe("windows-amd64"); }); it("rejects unsupported versions", () => expect(() => detectPlatform("darwin", "arm64", "23.0.0")).toThrow("Node.js 22")); });
+import { detectPlatform, detectPlatformTarget } from "./platform.js";
+describe("detectPlatform", () => {
+    it("maps supported targets", () => {
+        expect(detectPlatform("darwin", "arm64", "22.1.0")).toBe("darwin-arm64");
+        expect(detectPlatform("win32", "x64", "22.1.0")).toBe("windows-amd64");
+    });
+    it("detects a target before Node version validation", () => {
+        expect(detectPlatformTarget("darwin", "arm64")).toBe("darwin-arm64");
+        expect(detectPlatformTarget("win32", "x64")).toBe("windows-amd64");
+    });
+    it("rejects unsupported versions", () => {
+        expect(() => detectPlatform("darwin", "arm64", "23.0.0")).toThrow("Node.js 22");
+    });
+    it("rejects unsupported platforms", () => {
+        expect(() => detectPlatformTarget("linux", "x64")).toThrow("unsupported platform");
+    });
+});

package/dist/power/sleep-inhibitor.js

@@ -0,0 +1,151 @@
+import { spawn } from "node:child_process";
+export async function acquireSleepInhibitor(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const pid = options.pid ?? process.pid;
+    const spawnProcess = options.spawnProcess ?? spawn;
+    const readyTimeoutMs = options.readyTimeoutMs ?? 5_000;
+    const stopTimeoutMs = options.stopTimeoutMs ?? 2_000;
+    if (platform === "darwin") {
+        const child = spawnProcess("/usr/bin/caffeinate", ["-i", "-w", String(pid)], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        await waitForSpawn(child, readyTimeoutMs, "macOS idle-sleep inhibitor");
+        return monitorChild(child, stopTimeoutMs, "macOS idle-sleep inhibitor");
+    }
+    if (platform === "win32") {
+        const script = buildWindowsSleepInhibitorScript(pid);
+        const child = spawnProcess("powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy", "Bypass",
+            "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64"),
+        ], {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        await waitForReadyLine(child, readyTimeoutMs);
+        return monitorChild(child, stopTimeoutMs, "Windows idle-sleep inhibitor");
+    }
+    throw new Error(`idle-sleep prevention is unsupported on ${platform}`);
+}
+export function buildWindowsSleepInhibitorScript(parentPid) {
+    return String.raw `
+$ErrorActionPreference = "Stop"
+$source = @'
+using System;
+using System.Runtime.InteropServices;
+public static class AgentRoamPower {
+  [DllImport("kernel32.dll", SetLastError = true)]
+  public static extern uint SetThreadExecutionState(uint esFlags);
+}
+'@
+Add-Type -TypeDefinition $source
+$continuous = [uint32]::Parse("80000000", [Globalization.NumberStyles]::HexNumber)
+$systemRequired = [uint32]1
+$result = [AgentRoamPower]::SetThreadExecutionState($continuous -bor $systemRequired)
+if ($result -eq 0) { throw "SetThreadExecutionState failed" }
+[Console]::Out.WriteLine("AGENTROAM_SLEEP_INHIBITOR_READY")
+try {
+  Wait-Process -Id ${parentPid}
+} finally {
+  [void][AgentRoamPower]::SetThreadExecutionState($continuous)
+}
+`;
+}
+function waitForSpawn(child, timeoutMs, label) {
+    return new Promise((resolveReady, rejectReady) => {
+        const timeout = setTimeout(() => finish(new Error(`${label} did not start within ${timeoutMs}ms`)), timeoutMs);
+        const onError = (error) => finish(error);
+        const onExit = (code, signal) => {
+            finish(new Error(`${label} exited before readiness (${formatExit(code, signal)})`));
+        };
+        const onSpawn = () => finish();
+        const finish = (error) => {
+            clearTimeout(timeout);
+            child.removeListener("error", onError);
+            child.removeListener("exit", onExit);
+            child.removeListener("spawn", onSpawn);
+            if (error)
+                rejectReady(error);
+            else
+                resolveReady();
+        };
+        child.once("error", onError);
+        child.once("exit", onExit);
+        child.once("spawn", onSpawn);
+    });
+}
+function waitForReadyLine(child, timeoutMs) {
+    return new Promise((resolveReady, rejectReady) => {
+        let stdout = "";
+        let stderr = "";
+        const timeout = setTimeout(() => {
+            finish(new Error(`Windows idle-sleep inhibitor did not become ready within ${timeoutMs}ms`));
+        }, timeoutMs);
+        const onStdout = (chunk) => {
+            stdout += chunk.toString();
+            if (stdout.includes("AGENTROAM_SLEEP_INHIBITOR_READY"))
+                finish();
+        };
+        const onStderr = (chunk) => { stderr += chunk.toString(); };
+        const onError = (error) => finish(error);
+        const onExit = (code, signal) => {
+            const detail = stderr.trim();
+            finish(new Error(`Windows idle-sleep inhibitor exited before readiness (${formatExit(code, signal)})${detail ? `: ${detail}` : ""}`));
+        };
+        const finish = (error) => {
+            clearTimeout(timeout);
+            child.stdout?.removeListener("data", onStdout);
+            child.stderr?.removeListener("data", onStderr);
+            child.removeListener("error", onError);
+            child.removeListener("exit", onExit);
+            if (error)
+                rejectReady(error);
+            else
+                resolveReady();
+        };
+        child.stdout?.on("data", onStdout);
+        child.stderr?.on("data", onStderr);
+        child.once("error", onError);
+        child.once("exit", onExit);
+    });
+}
+function monitorChild(child, stopTimeoutMs, label) {
+    let releasing = false;
+    let released = false;
+    let resolveLost;
+    const lost = new Promise((resolvePromise) => { resolveLost = resolvePromise; });
+    const exited = new Promise((resolveExit) => {
+        child.once("exit", (code, signal) => {
+            if (!releasing)
+                resolveLost(new Error(`${label} stopped unexpectedly (${formatExit(code, signal)})`));
+            resolveExit();
+        });
+        child.once("error", (error) => {
+            if (!releasing)
+                resolveLost(error);
+        });
+    });
+    return {
+        lost,
+        async release() {
+            if (released)
+                return;
+            released = true;
+            releasing = true;
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            child.kill("SIGTERM");
+            await Promise.race([exited, delay(stopTimeoutMs)]);
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill("SIGKILL");
+        },
+    };
+}
+function formatExit(code, signal) {
+    return signal ? `signal ${signal}` : `exit ${code ?? 1}`;
+}
+function delay(timeoutMs) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, timeoutMs));
+}

package/dist/power/sleep-inhibitor.test.js

@@ -0,0 +1,104 @@
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+import { acquireSleepInhibitor, buildWindowsSleepInhibitorScript } from "./sleep-inhibitor.js";
+function fakeChild(withPipes = false) {
+    const child = new EventEmitter();
+    Object.assign(child, {
+        pid: 9001,
+        exitCode: null,
+        signalCode: null,
+        stdout: withPipes ? new PassThrough() : null,
+        stderr: withPipes ? new PassThrough() : null,
+        kill: vi.fn((signal) => {
+            Object.assign(child, { signalCode: signal });
+            queueMicrotask(() => child.emit("exit", null, signal));
+            return true;
+        }),
+    });
+    return child;
+}
+describe("sleep inhibitor", () => {
+    it("uses caffeinate to prevent idle sleep without preventing display sleep", async () => {
+        const child = fakeChild();
+        const spawnProcess = vi.fn(() => {
+            queueMicrotask(() => child.emit("spawn"));
+            return child;
+        });
+        const inhibitor = await acquireSleepInhibitor({
+            platform: "darwin",
+            pid: 4321,
+            spawnProcess: spawnProcess,
+            readyTimeoutMs: 50,
+            stopTimeoutMs: 50,
+        });
+        expect(spawnProcess).toHaveBeenCalledWith("/usr/bin/caffeinate", ["-i", "-w", "4321"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        const calls = spawnProcess.mock.calls;
+        expect(calls[0][1]).not.toContain("-d");
+        await inhibitor.release();
+        await inhibitor.release();
+        expect(child.kill).toHaveBeenCalledTimes(1);
+    });
+    it("uses only the Windows system-required execution state", async () => {
+        const child = fakeChild(true);
+        const spawnProcess = vi.fn(() => {
+            queueMicrotask(() => {
+                child.emit("spawn");
+                child.stdout.write("AGENTROAM_SLEEP_INHIBITOR_READY\n");
+            });
+            return child;
+        });
+        const inhibitor = await acquireSleepInhibitor({
+            platform: "win32",
+            pid: 7654,
+            spawnProcess: spawnProcess,
+            readyTimeoutMs: 50,
+            stopTimeoutMs: 50,
+        });
+        const calls = spawnProcess.mock.calls;
+        const args = calls[0][1];
+        const script = Buffer.from(args[args.indexOf("-EncodedCommand") + 1], "base64").toString("utf16le");
+        expect(script).toContain("SetThreadExecutionState");
+        expect(script).toContain("$systemRequired = [uint32]1");
+        expect(script).toContain("Wait-Process -Id 7654");
+        expect(script).not.toContain("ES_DISPLAY_REQUIRED");
+        await inhibitor.release();
+    });
+    it("reports a helper that stops after acquisition", async () => {
+        const child = fakeChild();
+        const spawnProcess = vi.fn(() => {
+            queueMicrotask(() => child.emit("spawn"));
+            return child;
+        });
+        const inhibitor = await acquireSleepInhibitor({
+            platform: "darwin",
+            spawnProcess: spawnProcess,
+            readyTimeoutMs: 50,
+        });
+        Object.assign(child, { exitCode: 3 });
+        child.emit("exit", 3, null);
+        await expect(inhibitor.lost).resolves.toMatchObject({ message: expect.stringContaining("stopped unexpectedly") });
+    });
+    it("rejects unsupported platforms and early helper failures", async () => {
+        await expect(acquireSleepInhibitor({ platform: "linux" })).rejects.toThrow("unsupported on linux");
+        const child = fakeChild();
+        const spawnProcess = vi.fn(() => {
+            queueMicrotask(() => child.emit("error", new Error("missing caffeinate")));
+            return child;
+        });
+        await expect(acquireSleepInhibitor({
+            platform: "darwin",
+            spawnProcess: spawnProcess,
+            readyTimeoutMs: 50,
+        })).rejects.toThrow("missing caffeinate");
+    });
+    it("builds a Windows helper that clears its assertion in finally", () => {
+        const script = buildWindowsSleepInhibitorScript(123);
+        expect(script).toContain("$continuous -bor $systemRequired");
+        expect(script).toContain("finally");
+        expect(script).toContain("SetThreadExecutionState($continuous)");
+    });
+});

package/dist/runtime-manager.js

@@ -1,25 +1,35 @@
 import { mkdir } from "node:fs/promises";
 import { delimiter, resolve } from "node:path";
+import { resolveCodexRuntime, } from "./codex-runtime-manager.js";
 import { repairNativeRuntimePermissions } from "./native-runtime.js";
+import { resolveOpenCodeRuntime, } from "./opencode-runtime-manager.js";
 import { resolvePlatformRuntime } from "./platform-packages.js";
 import { findAvailablePort } from "./port.js";
 import { ProcessSupervisor } from "./process-supervisor.js";
 export class RuntimeManager {
     supervisor;
-    constructor(supervisor = new ProcessSupervisor()) {
+    codexResolver;
+    report;
+    opencodeResolver;
+    constructor(supervisor = new ProcessSupervisor(), codexResolver = resolveCodexRuntime, report = (message) => process.stderr.write(`${message}\n`), opencodeResolver = resolveOpenCodeRuntime) {
         this.supervisor = supervisor;
+        this.codexResolver = codexResolver;
+        this.report = report;
+        this.opencodeResolver = opencodeResolver;
     }
     async start(options, pairing, target) {
         const port = await findAvailablePort(options.port);
         const dataDir = resolve(options.dataDir);
         await Promise.all(["data", "bin", "cache", "logs"].map((name) => mkdir(resolve(dataDir, name), { recursive: true })));
+        const codexEnvironment = await prepareCodexRuntimeEnvironment(process.env, { dataDir, target }, this.codexResolver, this.report);
+        const childEnvironment = await prepareOpenCodeRuntimeEnvironment(codexEnvironment, { dataDir, target }, this.opencodeResolver, this.report);
         const { runtimeRoot } = resolvePlatformRuntime(target);
         await repairNativeRuntimePermissions(runtimeRoot);
         const gateway = resolve(runtimeRoot, "ws-server.mjs");
         const child = this.supervisor.spawn(process.execPath, [gateway], {
             cwd: runtimeRoot,
             env: {
-                ...process.env,
+                ...childEnvironment,
                 NODE_ENV: "production",
                 NEXT_DIST_DIR: ".next",
                 PORT: String(port),
@@ -50,6 +60,44 @@ export class RuntimeManager {
         };
     }
 }
+export async function prepareCodexRuntimeEnvironment(environment, options, resolver = resolveCodexRuntime, report = (message) => process.stderr.write(`${message}\n`)) {
+    const childEnvironment = { ...environment };
+    report(`Checking Codex ${options.target} runtime...`);
+    try {
+        const resolution = await resolver({
+            ...options,
+            environment,
+            onProgress: report,
+        });
+        childEnvironment.AGENT_CODEX_BIN = resolution.executable;
+        delete childEnvironment.AGENT_CODEX_RUNTIME_ERROR;
+        report(`Codex ${resolution.version} (${resolution.source}): ${resolution.executable}`);
+    }
+    catch (error) {
+        delete childEnvironment.AGENT_CODEX_BIN;
+        const message = error instanceof Error ? error.message : String(error);
+        childEnvironment.AGENT_CODEX_RUNTIME_ERROR = message;
+        report(`Codex unavailable; AgentRoam will continue without Codex sessions: ${message}`);
+    }
+    return childEnvironment;
+}
+export async function prepareOpenCodeRuntimeEnvironment(environment, options, resolver = resolveOpenCodeRuntime, report = (message) => process.stderr.write(`${message}\n`)) {
+    const childEnvironment = { ...environment };
+    report(`Checking OpenCode ${options.target} runtime...`);
+    try {
+        const resolution = await resolver({ ...options, environment, onProgress: report });
+        childEnvironment.AGENT_OPENCODE_BIN = resolution.executable;
+        delete childEnvironment.AGENT_OPENCODE_RUNTIME_ERROR;
+        report(`OpenCode ${resolution.version} (${resolution.source}): ${resolution.executable}`);
+    }
+    catch (error) {
+        delete childEnvironment.AGENT_OPENCODE_BIN;
+        const message = error instanceof Error ? error.message : String(error);
+        childEnvironment.AGENT_OPENCODE_RUNTIME_ERROR = message;
+        report(`OpenCode unavailable; AgentRoam will continue without OpenCode sessions: ${message}`);
+    }
+    return childEnvironment;
+}
 async function waitForHealth(url, child, timeoutMs) {
     const end = Date.now() + timeoutMs;
     while (Date.now() < end) {

package/dist/runtime-manager.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest";
+import { prepareCodexRuntimeEnvironment, prepareOpenCodeRuntimeEnvironment } from "./runtime-manager.js";
+describe("prepareCodexRuntimeEnvironment", () => {
+    it("injects the resolved absolute Codex executable", async () => {
+        const report = vi.fn();
+        const environment = await prepareCodexRuntimeEnvironment({ PATH: "/bin" }, { dataDir: "/data", target: "windows-amd64" }, async () => ({
+            executable: "D:\\AgentRoam\\codex.exe",
+            version: "0.153.0",
+            source: "managed",
+        }), report);
+        expect(environment.AGENT_CODEX_BIN).toBe("D:\\AgentRoam\\codex.exe");
+        expect(environment.AGENT_CODEX_RUNTIME_ERROR).toBeUndefined();
+        expect(report).toHaveBeenCalledWith(expect.stringContaining("managed"));
+    });
+    it("removes an unusable inherited override and keeps startup available", async () => {
+        const report = vi.fn();
+        const environment = await prepareCodexRuntimeEnvironment({ PATH: "/bin", AGENT_CODEX_BIN: "/missing/codex" }, { dataDir: "/data", target: "darwin-arm64" }, async () => { throw new Error("download failed"); }, report);
+        expect(environment.AGENT_CODEX_BIN).toBeUndefined();
+        expect(environment.AGENT_CODEX_RUNTIME_ERROR).toBe("download failed");
+        expect(environment.PATH).toBe("/bin");
+        expect(report).toHaveBeenLastCalledWith(expect.stringContaining("continue without Codex sessions"));
+    });
+});
+describe("prepareOpenCodeRuntimeEnvironment", () => {
+    it("injects OpenCode independently from Codex", async () => {
+        const environment = await prepareOpenCodeRuntimeEnvironment({ PATH: "/bin", AGENT_CODEX_BIN: "/managed/codex" }, { dataDir: "/data", target: "darwin-arm64" }, async () => ({ executable: "/managed/opencode", version: "1.18.27", source: "managed" }), vi.fn());
+        expect(environment).toMatchObject({
+            AGENT_CODEX_BIN: "/managed/codex",
+            AGENT_OPENCODE_BIN: "/managed/opencode",
+        });
+    });
+    it("records OpenCode failure without removing Codex", async () => {
+        const environment = await prepareOpenCodeRuntimeEnvironment({ AGENT_CODEX_BIN: "/managed/codex", AGENT_OPENCODE_BIN: "/bad/opencode" }, { dataDir: "/data", target: "darwin-arm64" }, async () => { throw new Error("OpenCode download failed"); }, vi.fn());
+        expect(environment.AGENT_CODEX_BIN).toBe("/managed/codex");
+        expect(environment.AGENT_OPENCODE_BIN).toBeUndefined();
+        expect(environment.AGENT_OPENCODE_RUNTIME_ERROR).toBe("OpenCode download failed");
+    });
+});