@neuralnomads/codenomad-dev 0.18.0-dev-20260727-269cff64 → 0.18.0-dev-20260731-1d4f7786

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/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 = "";
@@ -606,7 +607,7 @@ 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;
@@ -656,7 +657,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/package.json

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