@neuralnomads/codenomad-dev 0.18.0-dev-20260727-269cff64 → 0.18.0-dev-20260804-c16cc005

package/dist/background-processes/manager.js

@@ -2,6 +2,7 @@ import { spawn, spawnSync } from "child_process";
 import { createWriteStream, existsSync, promises as fs } from "fs";
 import path from "path";
 import { randomBytes } from "crypto";
+import { createInstanceClient } from "../workspaces/instance-client";
 const ROOT_DIR = ".codenomad/background_processes";
 const INDEX_FILE = "index.json";
 const OUTPUT_FILE = "output.txt";
@@ -511,38 +512,22 @@ export class BackgroundProcessManager {
         const notify = record.notify;
         if (!notify || !record.terminalReason)
             return;
-        if (!this.deps.workspaceManager.get(workspaceId)) {
-            throw new Error("Workspace not found");
-        }
-        const port = this.deps.workspaceManager.getInstancePort(workspaceId);
-        if (!port) {
-            throw new Error("Workspace instance is not ready");
-        }
-        const targetUrl = `http://127.0.0.1:${port}/session/${encodeURIComponent(notify.sessionID)}/prompt_async`;
-        const headers = {
-            "content-type": "application/json",
-        };
-        const authorization = this.deps.workspaceManager.getInstanceAuthorizationHeader(workspaceId);
-        if (authorization) {
-            headers.authorization = authorization;
-        }
-        const response = await fetch(targetUrl, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-                parts: [
-                    {
-                        type: "text",
-                        text: this.buildSyntheticCompletionPrompt(record),
-                        synthetic: true,
-                    },
-                ],
-            }),
+        const client = createInstanceClient(this.deps.workspaceManager, workspaceId, {
+            directory: notify.directory,
         });
-        if (!response.ok) {
-            const message = await response.text().catch(() => "");
-            throw new Error(message || `Prompt request failed with ${response.status}`);
+        if (!client) {
+            throw new Error("Workspace instance is not ready");
         }
+        await client.session.promptAsync({
+            sessionID: notify.sessionID,
+            parts: [
+                {
+                    type: "text",
+                    text: this.buildSyntheticCompletionPrompt(record),
+                    synthetic: true,
+                },
+            ],
+        }, { throwOnError: true });
     }
     buildCompletionPrompt(record) {
         const ref = `Background process "${record.title}" (${record.id})`;

package/dist/background-processes/manager.test.js

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { BackgroundProcessManager } from "./manager";
+const WORKSPACE_ID = "ws-test";
+const SESSION_ID = "sess-1";
+const INSTANCE_PORT = 9999;
+const AUTH_HEADER = "Basic test-auth";
+const TERMINAL_TIMEOUT_MS = 3000;
+/**
+ * Drives the real {@link BackgroundProcessManager} lifecycle (spawn a
+ * fast-exiting command with notify enabled) against a mocked transport, so the
+ * migrated `sendCompletionPrompt` path — factory + SDK client + `fetch` — is
+ * exercised end to end without touching production wiring.
+ *
+ * The workspace temp directory is intentionally left in place (under
+ * `os.tmpdir()`, OS-reaped): removing it from the test races the manager's
+ * asynchronous finalization writes, which intermittently fail with ENOENT.
+ */
+async function runCompletionPrompt(fetchImpl) {
+    const requests = [];
+    const originalFetch = globalThis.fetch;
+    // Captured now but swapped in only inside the try below, so a failure during
+    // setup (mkdtemp, manager construction) can't leak the mocked fetch.
+    const fetchMock = (async (input, init) => {
+        const req = input instanceof Request ? input : new Request(String(input), init);
+        requests.push({
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            body: await req.text(),
+        });
+        return fetchImpl(input instanceof Request ? input : req, init);
+    });
+    let warned = false;
+    const logger = {
+        warn: () => { warned = true; },
+        debug: () => { },
+        trace: () => { },
+        info: () => { },
+        error: () => { },
+        fatal: () => { },
+        isLevelEnabled: () => false,
+        level: "info",
+        child: () => logger,
+    };
+    const workspacePath = await fs.mkdtemp(path.join(os.tmpdir(), "bp-test-"));
+    // Distinct from the workspace root so the directory-override assertion is
+    // discriminating: if `sendCompletionPrompt` stops passing `notify.directory`,
+    // the factory would fall back to `workspacePath` and the header check fails.
+    const sessionDir = path.join(workspacePath, "session-worktree");
+    // Resolve once the manager publishes a terminal (non-running) status update.
+    let resolveTerminal = () => { };
+    const terminal = new Promise((resolve) => { resolveTerminal = resolve; });
+    const eventBus = {
+        on: () => { },
+        publish: (event) => {
+            if (event?.type === "instance.event") {
+                const type = event?.event?.type;
+                const status = event?.event?.properties?.process?.status;
+                if (type === "background.process.removed" || (status && status !== "running"))
+                    resolveTerminal();
+            }
+            return true;
+        },
+    };
+    const workspaceManager = {
+        get: () => ({ path: workspacePath }),
+        getInstancePort: () => INSTANCE_PORT,
+        getInstanceAuthorizationHeader: () => AUTH_HEADER,
+    };
+    const manager = new BackgroundProcessManager({ workspaceManager, eventBus, logger });
+    try {
+        globalThis.fetch = fetchMock;
+        await manager.start(WORKSPACE_ID, "test-proc", "true", {
+            notify: true,
+            notification: { sessionID: SESSION_ID, directory: sessionDir },
+        });
+        // The terminal status update is published at the very end of finalize, so
+        // resolving on it is a deterministic completion signal. Fail loudly rather
+        // than racing a silent timeout that could mask a hang.
+        let timeoutHandle;
+        const reachedTerminal = await Promise.race([
+            terminal.then(() => true),
+            new Promise((resolve) => {
+                timeoutHandle = setTimeout(() => resolve(false), TERMINAL_TIMEOUT_MS);
+            }),
+        ]);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (!reachedTerminal) {
+            throw new Error("background process did not reach a terminal state in time");
+        }
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+    return { requests, warned, directory: sessionDir };
+}
+describe("BackgroundProcessManager.sendCompletionPrompt", () => {
+    it("posts the synthetic completion prompt to the instance via the SDK route", async () => {
+        const { requests, directory } = await runCompletionPrompt(async () => new Response("{}", { status: 200, headers: { "content-type": "application/json" } }));
+        const promptCall = requests.find((r) => r.url.includes("/prompt_async"));
+        assert.ok(promptCall, "expected a prompt_async request");
+        assert.equal(promptCall.method, "POST");
+        assert.equal(promptCall.url, `http://127.0.0.1:${INSTANCE_PORT}/session/${SESSION_ID}/prompt_async`);
+        assert.equal(promptCall.headers.get("authorization"), AUTH_HEADER);
+        // The prompt is scoped to the session's directory (a POST keeps the
+        // directory as a header — the SDK only rewrites header→query for GET/HEAD).
+        assert.equal(promptCall.headers.get("x-opencode-directory"), encodeURIComponent(directory));
+        const body = JSON.parse(promptCall.body);
+        assert.equal(body.parts.length, 1);
+        assert.equal(body.parts[0].type, "text");
+        assert.equal(body.parts[0].synthetic, true);
+        assert.match(body.parts[0].text, /test-proc/);
+    });
+    it("swallows a failed prompt and logs it without aborting finalization", async () => {
+        const { warned } = await runCompletionPrompt(async () => new Response("boom", { status: 500 }));
+        assert.equal(warned, true);
+    });
+});

package/dist/index.js

@@ -171,8 +171,8 @@ function resolveHost(input) {
     }
     return trimmed;
 }
-function programHasArg(argv, flag) {
-    return argv.includes(flag);
+export function programHasArg(argv, flag) {
+    return argv.some((argument) => argument === flag || argument.startsWith(`${flag}=`));
 }
 async function main() {
     const options = parseCliOptions(process.argv.slice(2));

package/dist/server/__tests__/listener-retry.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { programHasArg } from "../../index";
+import { shouldRetryPreferredPort } from "../http-server";
+test("automatic listeners retry Windows reserved ports without masking explicit failures", () => {
+    assert.equal(shouldRetryPreferredPort({ code: "EADDRINUSE" }, true, "linux"), true);
+    assert.equal(shouldRetryPreferredPort({ code: "EACCES" }, true, "win32"), true);
+    assert.equal(shouldRetryPreferredPort({ code: "EACCES" }, true, "linux"), false);
+    assert.equal(shouldRetryPreferredPort({ code: "EACCES" }, false, "win32"), false);
+});
+test("explicit listener ports are detected in both supported CLI forms", () => {
+    assert.equal(programHasArg(["--http-port", "9899"], "--http-port"), true);
+    assert.equal(programHasArg(["--https-port=9898"], "--https-port"), true);
+    assert.equal(programHasArg(["--http-porter=9899"], "--http-port"), false);
+});

package/dist/server/http-server.js

@@ -29,6 +29,12 @@ import { BackgroundProcessManager } from "../background-processes/manager";
 import { registerAuthRoutes } from "./routes/auth";
 import { sendUnauthorized, wantsHtml } from "../auth/http-auth";
 import { createOpenCodeUpdateService } from "../opencode-update/service";
+export function shouldRetryPreferredPort(error, autoPortRequested, platform = process.platform) {
+    if (!autoPortRequested)
+        return false;
+    const code = error?.code;
+    return code === "EADDRINUSE" || (platform === "win32" && code === "EACCES");
+}
 export function createHttpServer(deps) {
     // Fastify's type-level RawServer inference gets noisy when toggling HTTP vs HTTPS.
     // We keep the runtime behavior correct and cast the instance to a generic FastifyInstance.
@@ -261,18 +267,12 @@ export function createHttpServer(deps) {
             };
             const autoPortRequested = deps.bindPort === 0;
             const primaryPort = autoPortRequested ? deps.defaultPort : deps.bindPort;
-            const shouldRetryWithEphemeral = (error) => {
-                if (!autoPortRequested)
-                    return false;
-                const err = error;
-                return Boolean(err && err.code === "EADDRINUSE");
-            };
             let listenResult;
             try {
                 listenResult = await attemptListen(primaryPort);
             }
             catch (error) {
-                if (!shouldRetryWithEphemeral(error)) {
+                if (!shouldRetryPreferredPort(error, autoPortRequested)) {
                     throw error;
                 }
                 deps.logger.warn({ err: error, port: primaryPort }, "Preferred port unavailable, retrying on ephemeral port");

package/dist/workspaces/instance-client.js

@@ -1,5 +1,5 @@
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
-const INSTANCE_HOST = "127.0.0.1";
+import { LOOPBACK_HOST } from "./loopback";
 const LOOPBACK_TIMEOUT_MS = 10_000;
 /**
  * Creates an OpenCode SDK client for direct loopback communication with a
@@ -11,8 +11,8 @@ const LOOPBACK_TIMEOUT_MS = 10_000;
  * OpenCode instance directly should use this factory rather than building
  * `http://127.0.0.1:{port}/...` URLs by hand.
  *
- * All requests carry a 10-second timeout — loopback calls should be
- * near-instant; a hang indicates a stuck instance.
+ * Requests carry a 10-second timeout (configurable via `timeoutMs`) —
+ * loopback calls should be near-instant; a hang indicates a stuck instance.
  *
  * The client is cheap to create (object only, no connection); create one per
  * call or cache per instance as needed. Returns `null` when the instance has
@@ -29,13 +29,14 @@ export function createInstanceClient(workspaceManager, instanceId, options = {})
     }
     const workspace = workspaceManager.get(instanceId);
     const timeoutMs = options.timeoutMs ?? LOOPBACK_TIMEOUT_MS;
+    const directory = options.directory ?? workspace?.path;
     return createOpencodeClient({
-        baseUrl: `http://${INSTANCE_HOST}:${port}/`,
+        baseUrl: `http://${LOOPBACK_HOST}:${port}/`,
         headers,
         fetch: (url, init) => fetch(url, {
             ...init,
             signal: init?.signal ?? AbortSignal.timeout(timeoutMs),
         }),
-        ...(workspace?.path ? { directory: workspace.path } : {}),
+        ...(directory ? { directory } : {}),
     });
 }

package/dist/workspaces/instance-client.test.js

@@ -0,0 +1,149 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createInstanceClient } from "./instance-client";
+function makeManager(overrides = {}) {
+    return {
+        getInstancePort: overrides.getInstancePort ?? (() => undefined),
+        getInstanceAuthorizationHeader: overrides.getInstanceAuthorizationHeader ?? (() => undefined),
+        get: overrides.get ?? (() => undefined),
+    };
+}
+/**
+ * Installs a global `fetch` stub that records every outgoing request and
+ * answers a minimal healthy JSON body. Returns the capture buffer and a
+ * restore function. The stub tolerates both `fetch(url, init)` and
+ * `fetch(Request)` invocation styles so it is independent of the SDK's
+ * internal call convention.
+ */
+function installRecordingFetch() {
+    const requests = [];
+    const original = globalThis.fetch;
+    globalThis.fetch = (async (input, init) => {
+        if (input instanceof Request) {
+            requests.push({ url: input.url, headers: new Headers(init?.headers ?? input.headers) });
+        }
+        else {
+            requests.push({ url: String(input), headers: new Headers(init?.headers) });
+        }
+        return new Response(JSON.stringify({ healthy: true }), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    return { requests, restore: () => { globalThis.fetch = original; } };
+}
+describe("createInstanceClient", () => {
+    it("returns null when the instance has no open port", () => {
+        const manager = makeManager({ getInstancePort: () => undefined });
+        assert.equal(createInstanceClient(manager, "ws-1"), null);
+    });
+    it("targets the loopback host and port on outgoing requests", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => ({ path: "/repo" }) });
+            const client = createInstanceClient(manager, "ws-1");
+            assert.ok(client, "expected a client when the instance has a port");
+            await client.global.health();
+            const parsed = new URL(requests[0].url);
+            assert.equal(parsed.hostname, "127.0.0.1");
+            assert.equal(parsed.port, "4321");
+        }
+        finally {
+            restore();
+        }
+    });
+    it("attaches the authorization header when one is configured", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({
+                getInstancePort: () => 4321,
+                getInstanceAuthorizationHeader: () => "Basic abc",
+                get: () => ({ path: "/repo" }),
+            });
+            const client = createInstanceClient(manager, "ws-1");
+            await client.global.health();
+            assert.equal(requests[0].headers.get("authorization"), "Basic abc");
+        }
+        finally {
+            restore();
+        }
+    });
+    it("omits the authorization header when none is configured", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => ({ path: "/repo" }) });
+            const client = createInstanceClient(manager, "ws-1");
+            await client.global.health();
+            assert.equal(requests[0].headers.get("authorization"), null);
+        }
+        finally {
+            restore();
+        }
+    });
+    it("scopes requests to the workspace directory", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => ({ path: "/repo" }) });
+            const client = createInstanceClient(manager, "ws-1");
+            await client.global.health();
+            // GET requests carry directory as a query parameter (see SDK rewrite).
+            assert.equal(new URL(requests[0].url).searchParams.get("directory"), "/repo");
+        }
+        finally {
+            restore();
+        }
+    });
+    it("does not scope requests when the workspace has no path", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => undefined });
+            const client = createInstanceClient(manager, "ws-1");
+            await client.global.health();
+            assert.equal(new URL(requests[0].url).searchParams.get("directory"), null);
+        }
+        finally {
+            restore();
+        }
+    });
+    it("honours an explicit directory override over the workspace root", async () => {
+        const { requests, restore } = installRecordingFetch();
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => ({ path: "/workspace-root" }) });
+            const client = createInstanceClient(manager, "ws-1", {
+                directory: "/explicit/session-dir",
+            });
+            await client.global.health();
+            assert.equal(new URL(requests[0].url).searchParams.get("directory"), "/explicit/session-dir");
+        }
+        finally {
+            restore();
+        }
+    });
+    it("applies the loopback timeout and aborts a stuck instance", async () => {
+        const original = globalThis.fetch;
+        // Never resolves on its own; only settles when the passed signal aborts,
+        // mirroring how a real fetch honours an AbortSignal. Without the factory
+        // timeout this call would hang forever and time the test out.
+        globalThis.fetch = (async (_input, init) => {
+            return new Promise((_resolve, reject) => {
+                const signal = init?.signal;
+                if (!signal)
+                    return;
+                if (signal.aborted)
+                    reject(signal.reason ?? new Error("aborted"));
+                else
+                    signal.addEventListener("abort", () => reject(signal.reason ?? new Error("aborted")));
+            });
+        });
+        try {
+            const manager = makeManager({ getInstancePort: () => 4321, get: () => ({ path: "/repo" }) });
+            const client = createInstanceClient(manager, "ws-1", { timeoutMs: 10 });
+            // SDK methods resolve with { error } rather than throwing by default.
+            const result = await client.global.health();
+            assert.ok(result.error, "expected the stuck-instance call to surface an error");
+        }
+        finally {
+            globalThis.fetch = original;
+        }
+    });
+});

package/dist/workspaces/instance-events.js

@@ -1,6 +1,6 @@
 import { fetch } from "undici";
 import { Agent as UndiciAgent } from "undici";
-const INSTANCE_HOST = "127.0.0.1";
+import { LOOPBACK_HOST } from "./loopback";
 const STREAM_AGENT = new UndiciAgent({ bodyTimeout: 0, headersTimeout: 0 });
 const RECONNECT_DELAY_MS = 1000;
 export class InstanceEventBridge {
@@ -70,7 +70,7 @@ export class InstanceEventBridge {
         }
     }
     async consumeStream(workspaceId, port, signal) {
-        const url = `http://${INSTANCE_HOST}:${port}/global/event`;
+        const url = `http://${LOOPBACK_HOST}:${port}/global/event`;
         const headers = { Accept: "text/event-stream" };
         const authHeader = this.options.workspaceManager.getInstanceAuthorizationHeader(workspaceId);
         if (authHeader) {

package/dist/workspaces/loopback.js

@@ -0,0 +1,8 @@
+/**
+ * Loopback host used for direct in-process communication with a running
+ * OpenCode workspace instance (the server and the instance share a machine).
+ *
+ * Shared by the workspace-instance loopback callers so they agree on the host
+ * instead of each hardcoding their own `127.0.0.1` literal.
+ */
+export const LOOPBACK_HOST = "127.0.0.1";

package/dist/workspaces/manager.js

@@ -11,6 +11,7 @@ import { buildOpencodeConfigContent, getCodeNomadPluginUrl, resolveExistingOpenc
 import { OPENCODE_SERVER_BASE_URL_ENV, buildOpencodeBasicAuthHeader, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, resolveOpencodeServerAuth, } from "./opencode-auth";
 import { resolveWorkspaceIdentity } from "./workspace-identity";
 import { parseWslUncPath } from "./spawn";
+import { LOOPBACK_HOST } from "./loopback";
 const STARTUP_STABILITY_DELAY_MS = 1500;
 const DEFAULT_LAUNCH_TIMEOUT_MS = 30_000;
 const ORDINARY_CREATION_OWNER = "";
@@ -579,6 +580,10 @@ export class WorkspaceManager {
             this.exitDuringStartup(params, "exited before becoming ready"),
         ]);
         const version = await this.waitForInstanceHealth(params);
+        await Promise.race([
+            this.validateInstanceConfiguration(params),
+            this.exitDuringStartup(params, "exited during configuration validation"),
+        ]);
         await Promise.race([
             delay(STARTUP_STABILITY_DELAY_MS, undefined, { signal: params.signal }),
             this.exitDuringStartup(params, "exited shortly after start"),
@@ -606,14 +611,9 @@ export class WorkspaceManager {
         });
     }
     async probeInstance(workspaceId, port, signal) {
-        const url = `http://127.0.0.1:${port}/global/health`;
+        const url = `http://${LOOPBACK_HOST}:${port}/global/health`;
         try {
-            const headers = {};
-            const authHeader = this.opencodeAuth.get(workspaceId)?.authorization;
-            if (authHeader) {
-                headers["Authorization"] = authHeader;
-            }
-            const response = await fetch(url, { headers, signal });
+            const response = await fetch(url, { headers: this.getInstanceRequestHeaders(workspaceId), signal });
             if (!response.ok) {
                 const reason = `/global/health returned HTTP ${response.status}`;
                 this.options.logger.debug({ workspaceId, status: response.status }, "Health probe returned server error");
@@ -635,6 +635,22 @@ export class WorkspaceManager {
             return { ok: false, reason };
         }
     }
+    async validateInstanceConfiguration(params) {
+        const response = await fetch(`http://${LOOPBACK_HOST}:${params.port}/config`, {
+            headers: this.getInstanceRequestHeaders(params.workspaceId),
+            signal: params.signal,
+        });
+        if (response.ok) {
+            await response.body?.cancel();
+            return;
+        }
+        const body = (await response.text()).trim();
+        throw new Error(body || `OpenCode /config returned HTTP ${response.status}`);
+    }
+    getInstanceRequestHeaders(workspaceId) {
+        const authorization = this.opencodeAuth.get(workspaceId)?.authorization;
+        return authorization ? { Authorization: authorization } : {};
+    }
     buildStartupError(workspaceId, phase, exitInfo, lastOutput) {
         const exitDetails = this.describeExit(exitInfo);
         const trimmedOutput = lastOutput.trim();
@@ -656,7 +672,7 @@ export class WorkspaceManager {
             const tryConnect = () => {
                 if (settled)
                     return;
-                const socket = connect({ port, host: "127.0.0.1", signal }, () => {
+                const socket = connect({ port, host: LOOPBACK_HOST, signal }, () => {
                     cleanup();
                     socket.end();
                     resolve();

package/dist/workspaces/manager.test.js

@@ -44,6 +44,7 @@ class ControlledRuntime {
     }
 }
 function createHarness(options = {}) {
+    const { stubReadiness = true, ...managerOptions } = options;
     const eventBus = new EventBus();
     const runtime = new ControlledRuntime();
     const readiness = deferred();
@@ -59,17 +60,20 @@ function createHarness(options = {}) {
         logger: pino({ level: "silent" }),
         getServerBaseUrl: () => "http://127.0.0.1:4000",
         runtime,
-        ...options,
+        ...managerOptions,
     });
-    manager.waitForWorkspaceReadiness = ({ signal }) => Promise.race([
-        readiness.promise,
-        new Promise((_resolve, reject) => {
-            const cancel = () => reject(signal?.reason);
-            signal?.addEventListener("abort", cancel, { once: true });
-            if (signal?.aborted)
-                cancel();
-        }),
-    ]);
+    if (stubReadiness) {
+        ;
+        manager.waitForWorkspaceReadiness = ({ signal }) => Promise.race([
+            readiness.promise,
+            new Promise((_resolve, reject) => {
+                const cancel = () => reject(signal?.reason);
+                signal?.addEventListener("abort", cancel, { once: true });
+                if (signal?.aborted)
+                    cancel();
+            }),
+        ]);
+    }
     return { manager, runtime, readiness, started, stopped };
 }
 async function createReady(harness) {
@@ -81,6 +85,47 @@ async function createReady(harness) {
     return workspaceId;
 }
 describe("workspace manager lifecycle", () => {
+    it("rejects a healthy workspace whose OpenCode configuration is invalid", async () => {
+        const originalFetch = globalThis.fetch;
+        const requests = [];
+        const configError = JSON.stringify({
+            name: "ConfigInvalidError",
+            data: {
+                path: "C:\\Users\\dev\\.config\\opencode\\agents\\invalid.md",
+                issues: [{ path: ["tools", "bash"], message: 'Expected boolean, got "ask"' }],
+            },
+        });
+        globalThis.fetch = (async (input) => {
+            const url = String(input);
+            requests.push(url);
+            if (url.includes("/global/health")) {
+                return new Response(JSON.stringify({ healthy: true, version: "1.18.5" }), {
+                    headers: { "Content-Type": "application/json" },
+                });
+            }
+            return new Response(configError, { status: 400, headers: { "Content-Type": "application/json" } });
+        });
+        try {
+            const harness = createHarness({ stubReadiness: false });
+            harness.manager.waitForPortAvailability = async () => undefined;
+            const creation = harness.manager.create(process.cwd());
+            const workspaceId = await harness.runtime.launchCalled.promise;
+            harness.runtime.resolveLaunch();
+            await assert.rejects(creation, (error) => {
+                assert.ok(error instanceof Error);
+                assert.equal(error.message, configError);
+                return true;
+            });
+            assert.deepEqual(requests.map((url) => new URL(url).pathname), ["/global/health", "/config"]);
+            assert.equal(new URL(requests[1]).search, "");
+            assert.equal(harness.runtime.active.has(workspaceId), false);
+            assert.deepEqual(harness.started, []);
+            assert.deepEqual(harness.manager.list(), []);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
     for (const boundary of ["launch", "readiness", "shutdown"]) {
         it(`cancels and cleans a workspace during ${boundary}`, async () => {
             const harness = createHarness();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-dev",
-  "version": "0.18.0-dev-20260727-269cff64",
+  "version": "0.18.0-dev-20260804-c16cc005",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {

package/public/assets/FilesTab-PxqWVPyo.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/monaco-viewer-CiFg18Ak.js","assets/git-diff-vendor-CYS3ApzA.js","assets/fast-diff-vendor-DgdwVvTQ.js","assets/highlight-vendor-8FKMu9os.js","assets/git-diff-vendor-HAZkIolJ.css"])))=>i.map(i=>d[i]);
+import{a8 as J,m,t as h,i as s,d as u,a as C,u as U,_ as X,f as Y}from"./monaco-viewer-CiFg18Ak.js";import{d as K,b as P,c as $,n as o,S as g,a as w,z as Z,A as p,F as ee}from"./git-diff-vendor-CYS3ApzA.js";import{S as te}from"./SplitFilePanel-DaqtU5jw.js";import{R as V,ay as le,M as ne,az as re,C as ae,e as ie,aA as se}from"./main-oNL0VKfF.js";import{W as oe}from"./wrap-text-CJPfwppv.js";import"./fast-diff-vendor-DgdwVvTQ.js";import"./highlight-vendor-8FKMu9os.js";import"./index-DMYv1E9L.js";var ce=h('<div class="px-2 py-2 border-b border-base"><div class=selector-input-group><div class="flex items-center gap-2 px-3 text-muted"></div><input type=text class=selector-input>'),de=h("<div class=file-list-header><span class=file-list-title></span><span class=file-list-count>"),O=h('<div class="p-3 text-xs text-secondary">'),he=h("<div class=file-list-item><div class=file-list-item-content><div class=file-list-item-path><span class=file-path-text>.."),ue=h('<div class="p-3 text-xs text-error">'),ve=h('<div><div class=file-list-item-content><div class=file-list-item-path><span class=file-path-text></span></div><div class="flex items-center gap-2 shrink-0"><div class=file-list-item-stats><span class="text-[10px] text-secondary"></span></div><button type=button class=git-change-row-action>'),x=h("<div class=file-viewer-empty><span class=file-viewer-empty-text>"),fe=h('<div class="file-viewer-panel flex-1"><div>'),ge=h('<div class="h-full outline-none"tabindex=0>'),we=h("<span>"),be=h("<div class=files-tab-stats><span class=files-tab-stat><span class=files-tab-selected-path><span class=file-path-text>"),Se=h("<button type=button style=margin-inline-start:auto>"),me=h("<button type=button>"),q=h("<button type=button class=files-header-icon-button>"),$e=h("<span class=text-error>");const ye=p(()=>X(()=>import("./monaco-viewer-CiFg18Ak.js").then(e=>e.at),__vite__mapDeps([0,1,2,3,4])).then(e=>({default:e.MonacoFileViewer})));function _e(e){return e?/\.(md|markdown|mdown|mkdn)$/i.test(e):!1}const Te=e=>{const[E,L]=K(""),{isDark:Q}=J(),[N,M]=K(!1);let b;P(()=>{e.browserPath(),L("")});const H=$(()=>[...e.browserEntries()||[]].sort((i,d)=>{const l=i.type==="directory"?0:1,t=d.type==="directory"?0:1;return l!==t?l-t:String(i.name||"").localeCompare(String(d.name||""))})),W=$(()=>E().trim().toLowerCase()),k=$(()=>{const n=W(),i=H();return n?i.filter(d=>String(d.name||"").toLowerCase().includes(n)):i}),y=()=>e.browserLoading()&&e.browserEntries()===null,j=()=>W()?e.t("instanceShell.filesShell.search.empty"):e.t("instanceShell.filesShell.listEmpty"),_=$(()=>_e(e.browserSelectedPath())),S=$(()=>_()&&N());P(()=>{_()||M(!1)});const D=()=>{const n=e.browserSelectedContent();n!=null&&e.onSave(n)},B=async(n,i)=>{i==null||i.stopPropagation();const d=await ie(n);se({message:d?e.t("instanceShell.filesShell.toast.copyPathSuccess"):e.t("instanceShell.filesShell.toast.copyPathError"),variant:d?"success":"error"})};P(()=>{S()&&requestAnimationFrame(()=>b==null?void 0:b.focus())});const T=()=>[(()=>{var n=ce(),i=n.firstChild,d=i.firstChild,l=d.nextSibling;return s(d,o(re,{class:"w-4 h-4"})),l.$$input=t=>L(t.currentTarget.value),w(t=>{var a=e.t("instanceShell.filesShell.search.placeholder"),r=e.t("instanceShell.filesShell.search.ariaLabel");return a!==t.e&&u(l,"placeholder",t.e=a),r!==t.t&&u(l,"aria-label",t.t=r),t},{e:void 0,t:void 0}),w(()=>l.value=E()),n})(),(()=>{var n=de(),i=n.firstChild,d=i.nextSibling;return s(i,()=>e.t("instanceShell.filesShell.fileListTitle")),s(d,()=>k().length),n})(),o(g,{get when(){return e.parentPath()},children:n=>(()=>{var i=he(),d=i.firstChild,l=d.firstChild;return i.$$click=()=>e.onLoadEntries(n()),w(()=>u(l,"title",n())),i})()}),o(g,{get when(){return y()},get children(){var n=O();return s(n,()=>e.t("instanceInfo.loading")),n}}),o(g,{get when(){return m(()=>!e.browserError()&&!y())()&&k().length>0},get fallback(){return m(()=>!y())()?m(()=>!!e.browserError())()?(()=>{var n=ue();return s(n,()=>e.browserError()),n})():(()=>{var n=O();return s(n,j),n})():void 0},get children(){return o(ee,{get each(){return k()},children:n=>(()=>{var i=ve(),d=i.firstChild,l=d.firstChild,t=l.firstChild,a=l.nextSibling,r=a.firstChild,c=r.firstChild,f=r.nextSibling;return i.$$click=()=>{if(n.type==="directory"){e.onLoadEntries(n.path);return}e.onRequestOpenFile(n.path)},s(t,()=>n.name),s(c,()=>n.type),f.$$click=v=>void B(n.path,v),s(f,o(ae,{class:"w-3 h-3"})),w(v=>{var F=`file-list-item ${e.browserSelectedPath()===n.path?"file-list-item-active":""}`,z=n.path,R=n.path,A=e.t("instanceShell.filesShell.actions.copyPath"),I=e.t("instanceShell.filesShell.actions.copyPath");return F!==v.e&&C(i,v.e=F),z!==v.t&&u(i,"title",v.t=z),R!==v.a&&u(l,"title",v.a=R),A!==v.o&&u(f,"title",v.o=A),I!==v.i&&u(f,"aria-label",v.i=I),v},{e:void 0,t:void 0,a:void 0,o:void 0,i:void 0}),i})()})}})],G=n=>{!(n.ctrlKey||n.metaKey)||n.key.toLowerCase()!=="s"||e.browserSelectedSaving()||!e.browserSelectedDirty()||(n.preventDefault(),D())};return m(()=>{const n=()=>e.browserSelectedPath()||e.browserPath(),i=()=>y()?e.t("instanceInfo.loading"):e.t("instanceShell.filesShell.viewerEmpty"),d=()=>(()=>{var l=fe(),t=l.firstChild;return s(t,o(g,{get when(){return e.browserSelectedLoading()},get fallback(){return o(g,{get when(){return e.browserSelectedError()},get fallback(){return o(g,{get when(){return m(()=>!!(e.browserSelectedPath()&&e.browserSelectedContent()!==null))()?{path:e.browserSelectedPath(),content:e.browserSelectedContent()}:null},get fallback(){return(()=>{var a=x(),r=a.firstChild;return s(r,i),a})()},children:a=>o(g,{get when(){return S()},get fallback(){return o(Z,{get fallback(){return(()=>{var r=x(),c=r.firstChild;return s(c,()=>e.t("instanceInfo.loading")),r})()},get children(){return o(ye,{get scopeKey(){return e.scopeKey()},get path(){return a().path},get content(){return a().content},get wordWrap(){return e.wordWrapMode()},get onSave(){return e.onSave},get onContentChange(){return e.onContentChange}})}})},get children(){var r=ge();r.$$mousedown=()=>b==null?void 0:b.focus(),r.$$keydown=G;var c=b;return typeof c=="function"?U(c,r):b=r,s(r,o(ne,{get part(){return{type:"text",text:a().content}},get isDark(){return Q()},escapeRawHtml:!0})),r}})})},children:a=>(()=>{var r=x(),c=r.firstChild;return s(c,a),r})()})},get children(){var a=x(),r=a.firstChild;return s(r,()=>e.t("instanceInfo.loading")),a}})),w(()=>C(t,S()?"file-viewer-content":"file-viewer-content file-viewer-content--monaco")),l})();return o(te,{get header(){return[(()=>{var l=be(),t=l.firstChild,a=t.firstChild,r=a.firstChild;return s(r,n),s(l,o(g,{get when(){return e.browserLoading()},get children(){var c=we();return s(c,()=>e.t("instanceInfo.loading")),c}}),null),s(l,o(g,{get when(){return e.browserError()},children:c=>(()=>{var f=$e();return s(f,c),f})()}),null),w(()=>u(a,"title",n())),l})(),(()=>{var l=Se();return l.$$click=()=>_()&&M(t=>!t),s(l,(()=>{var t=m(()=>!!S());return()=>t()?e.t("instanceShell.filesShell.showSource"):e.t("instanceShell.filesShell.previewMarkdown")})()),w(t=>{var a=`file-viewer-toolbar-button${S()?" active":""}`,r=!_();return a!==t.e&&C(l,t.e=a),r!==t.t&&(l.disabled=t.t=r),t},{e:void 0,t:void 0}),l})(),(()=>{var l=me();return l.$$click=()=>e.onWordWrapModeChange(e.wordWrapMode()==="on"?"off":"on"),s(l,o(oe,{class:"h-4 w-4"})),w(t=>{var a=`file-viewer-toolbar-icon-button${e.wordWrapMode()==="on"?" active":""}`,r=e.wordWrapMode()==="on"?e.t("instanceShell.filesShell.disableWordWrap"):e.t("instanceShell.filesShell.enableWordWrap"),c=e.wordWrapMode()==="on"?e.t("instanceShell.filesShell.disableWordWrap"):e.t("instanceShell.filesShell.enableWordWrap"),f=S();return a!==t.e&&C(l,t.e=a),r!==t.t&&u(l,"title",t.t=r),c!==t.a&&u(l,"aria-label",t.a=c),f!==t.o&&(l.disabled=t.o=f),t},{e:void 0,t:void 0,a:void 0,o:void 0}),l})(),(()=>{var l=q();return l.$$click=D,s(l,o(g,{get when(){return e.browserSelectedSaving()},get fallback(){return o(le,{class:"h-4 w-4"})},get children(){return o(V,{class:"h-4 w-4 animate-spin"})}})),w(t=>{var a=e.t("instanceShell.rightPanel.actions.save")||"Save (Ctrl+S)",r=e.t("instanceShell.rightPanel.actions.save")||"Save",c=e.browserSelectedSaving()||!e.browserSelectedDirty();return a!==t.e&&u(l,"title",t.e=a),r!==t.t&&u(l,"aria-label",t.t=r),c!==t.a&&(l.disabled=t.a=c),t},{e:void 0,t:void 0,a:void 0}),l})(),(()=>{var l=q();return l.$$click=()=>e.onRefresh(),s(l,o(V,{get class(){return`h-4 w-4${e.browserLoading()?" animate-spin":""}`}})),w(t=>{var a=e.t("instanceShell.rightPanel.actions.refresh"),r=e.t("instanceShell.rightPanel.actions.refresh"),c=e.browserLoading();return a!==t.e&&u(l,"title",t.e=a),r!==t.t&&u(l,"aria-label",t.t=r),c!==t.a&&(l.disabled=t.a=c),t},{e:void 0,t:void 0,a:void 0}),l})()]},list:{panel:()=>o(T,{}),overlay:()=>o(T,{})},get viewer(){return d()},get listOpen(){return e.listOpen()},get onToggleList(){return e.onToggleList},get splitWidth(){return e.splitWidth()},get onResizeMouseDown(){return e.onResizeMouseDown},get onResizeTouchStart(){return e.onResizeTouchStart},get isPhoneLayout(){return e.isPhoneLayout()},get overlayAriaLabel(){return e.t("instanceShell.rightPanel.tabs.files")}})})};Y(["input","click","keydown","mousedown"]);export{Te as default};