@neuralnomads/codenomad-dev 0.18.0-dev-20260715-07e8ce68 → 0.18.0-dev-20260716-40cee071

package/dist/server/routes/workspaces.js

@@ -7,6 +7,8 @@ import { resolveWorktreeDirectory } from "../../workspaces/worktree-directory";
 const WorkspaceCreateSchema = z.object({
     path: z.string(),
     name: z.string().optional(),
+    binaryPath: z.string().trim().min(1).max(4096).optional(),
+    requestId: z.string().trim().min(1).max(128).optional(),
     forceNew: z.boolean().optional(),
 });
 const WorkspaceCloneSchema = z.object({
@@ -14,6 +16,9 @@ const WorkspaceCloneSchema = z.object({
     destinationPath: z.string().trim().min(1, "Destination path is required"),
     cleanup: z.boolean().optional(),
 });
+const WorkspaceCreationReleaseSchema = z.object({
+    requestId: z.string().trim().min(1).max(128),
+});
 const WorkspaceFilesQuerySchema = z.object({
     path: z.string().optional(),
 });
@@ -52,7 +57,11 @@ export function registerWorkspaceRoutes(app, deps) {
     app.post("/api/workspaces", async (request, reply) => {
         try {
             const body = WorkspaceCreateSchema.parse(request.body ?? {});
-            const result = await deps.workspaceManager.create(body.path, body.name, { forceNew: body.forceNew });
+            const result = await deps.workspaceManager.create(body.path, body.name, {
+                binaryPath: body.binaryPath,
+                requestId: body.requestId,
+                forceNew: body.forceNew,
+            });
             reply.code(201);
             return result.created ? result.workspace : { ...result.workspace, reused: true };
         }
@@ -85,6 +94,28 @@ export function registerWorkspaceRoutes(app, deps) {
         await deps.workspaceManager.delete(request.params.id);
         reply.code(204);
     });
+    app.post("/api/workspaces/creation/cancel", async (request, reply) => {
+        const parsed = WorkspaceCreationReleaseSchema.safeParse(request.body ?? {});
+        if (!parsed.success) {
+            reply.code(400).type("text/plain").send("Invalid workspace creation request");
+            return;
+        }
+        await deps.workspaceManager.cancelCreationRequest(parsed.data.requestId);
+        reply.code(204);
+    });
+    app.post("/api/workspaces/:id/creation/release", async (request, reply) => {
+        const parsed = WorkspaceCreationReleaseSchema.safeParse(request.body ?? {});
+        if (!parsed.success) {
+            reply.code(400).type("text/plain").send("Invalid workspace creation request");
+            return;
+        }
+        const body = parsed.data;
+        if (!deps.workspaceManager.releaseCreationRequest(request.params.id, body.requestId)) {
+            reply.code(404).type("text/plain").send("Workspace creation request not found");
+            return;
+        }
+        reply.code(204);
+    });
     app.get("/api/workspaces/:id/files", async (request, reply) => {
         try {
             const query = WorkspaceFilesQuerySchema.parse(request.query ?? {});

package/dist/server/routes/workspaces.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import Fastify from "fastify";
+import { registerWorkspaceRoutes } from "./workspaces";
+describe("workspace routes", () => {
+    it("forwards a validated explicit binary path when creating a workspace", async () => {
+        const calls = [];
+        const app = Fastify({ logger: false });
+        const descriptor = {
+            id: "workspace",
+            path: "C:/work",
+            status: "ready",
+            proxyPath: "/workspaces/workspace/instance",
+            binaryId: "C:/tools/opencode.exe",
+            binaryLabel: "opencode.exe",
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+        };
+        const workspaceManager = {
+            create: async (...args) => {
+                calls.push(args);
+                return { workspace: descriptor, created: true };
+            },
+            releaseCreationRequest: (workspaceId, requestId) => workspaceId === descriptor.id && requestId === "restore-request",
+            cancelCreationRequest: async (requestId) => {
+                calls.push(["cancel", requestId]);
+            },
+        };
+        registerWorkspaceRoutes(app, { workspaceManager });
+        const response = await app.inject({
+            method: "POST",
+            url: "/api/workspaces",
+            payload: {
+                path: "C:/work",
+                name: "Work",
+                binaryPath: " C:/tools/opencode.exe ",
+                requestId: " restore-request ",
+                forceNew: true,
+            },
+        });
+        assert.equal(response.statusCode, 201);
+        assert.deepEqual(calls, [["C:/work", "Work", {
+                    binaryPath: "C:/tools/opencode.exe",
+                    requestId: "restore-request",
+                    forceNew: true,
+                }]]);
+        const released = await app.inject({
+            method: "POST",
+            url: "/api/workspaces/workspace/creation/release",
+            payload: { requestId: "restore-request" },
+        });
+        assert.equal(released.statusCode, 204);
+        const wrongRelease = await app.inject({
+            method: "POST",
+            url: "/api/workspaces/workspace/creation/release",
+            payload: { requestId: "other-request" },
+        });
+        assert.equal(wrongRelease.statusCode, 404);
+        const cancelled = await app.inject({
+            method: "POST",
+            url: "/api/workspaces/creation/cancel",
+            payload: { requestId: "restore-request" },
+        });
+        assert.equal(cancelled.statusCode, 204);
+        assert.deepEqual(calls.at(-1), ["cancel", "restore-request"]);
+        const invalid = await app.inject({
+            method: "POST",
+            url: "/api/workspaces",
+            payload: { path: "C:/work", binaryPath: "x".repeat(4097) },
+        });
+        assert.equal(invalid.statusCode, 400);
+        assert.equal(calls.length, 2);
+        await app.close();
+    });
+});

package/dist/settings/binaries.js

@@ -23,10 +23,13 @@ export class BinaryResolver {
         return readUiBinaries(this.settings);
     }
     resolveDefault() {
+        return this.resolve();
+    }
+    resolve(explicitPath) {
         const binaries = this.list();
         const configuredDefault = readDefaultBinaryPath(this.settings);
         const fallback = binaries[0]?.path;
-        const path = configuredDefault ?? fallback ?? "opencode";
+        const path = explicitPath?.trim() || configuredDefault || fallback || "opencode";
         const entry = binaries.find((b) => b.path === path);
         return {
             path,

package/dist/settings/binaries.test.js

@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { BinaryResolver } from "./binaries";
+describe("BinaryResolver", () => {
+    it("uses an explicit workspace binary without changing the configured default", () => {
+        const settings = {
+            getOwner(scope, owner) {
+                if (scope === "config" && owner === "server")
+                    return { opencodeBinary: "default-opencode" };
+                if (scope === "state" && owner === "ui") {
+                    return { opencodeBinaries: [{ path: "saved-opencode", label: "Saved", version: "1.2.3" }] };
+                }
+                return {};
+            },
+        };
+        const resolver = new BinaryResolver(settings);
+        assert.deepEqual(resolver.resolve("saved-opencode"), {
+            path: "saved-opencode",
+            label: "Saved",
+            version: "1.2.3",
+        });
+        assert.equal(resolver.resolveDefault().path, "default-opencode");
+    });
+});

package/dist/shutdown.js

@@ -0,0 +1,75 @@
+export class ServerShutdownError extends Error {
+    constructor(failures) {
+        super(`Server shutdown failed while stopping: ${failures.map((failure) => failure.resource).join(", ")}`);
+        this.name = "ServerShutdownError";
+        this.failures = failures;
+    }
+}
+export function createServerShutdownHandler(options) {
+    const forceExit = options.forceExit ?? ((code) => process.exit(code));
+    const setExitCode = options.setExitCode ?? ((code) => {
+        process.exitCode = code;
+    });
+    let shutdownPromise;
+    return (signal) => {
+        if (shutdownPromise) {
+            options.logger.error({ signal }, "Additional shutdown signal received; forcing nonzero exit");
+            forceExit(1);
+            return shutdownPromise;
+        }
+        options.logger.info({ signal }, "Received shutdown signal, stopping workspaces and server");
+        shutdownPromise = (async () => {
+            try {
+                await options.shutdown();
+                options.logger.info({}, "Shutdown complete");
+                setExitCode(0);
+            }
+            catch (error) {
+                options.logger.error({ err: error }, "Server shutdown incomplete; forcing nonzero exit");
+                forceExit(1);
+            }
+        })();
+        return shutdownPromise;
+    };
+}
+export async function orchestrateServerShutdown(operations, logger, workspaceAttempts = 2) {
+    const failures = [];
+    const run = async (resource, operation) => {
+        try {
+            await operation();
+        }
+        catch (error) {
+            failures.push({ resource, error });
+            logger.error({ err: error, resource }, `${resource} shutdown failed`);
+        }
+    };
+    await run("Instance event bridge", operations.stopInstanceEventBridge);
+    await run("SideCar manager", operations.stopSidecars);
+    await run("Client connection manager", operations.stopClientConnections);
+    await run("Remote proxy session manager", operations.stopRemoteProxySessions);
+    const attempts = Math.max(1, Math.floor(workspaceAttempts));
+    let workspaceFailure;
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            await operations.stopWorkspaces();
+            workspaceFailure = undefined;
+            logger.info({ attempt }, "Workspace manager shutdown complete");
+            break;
+        }
+        catch (error) {
+            workspaceFailure = error;
+            if (attempt < attempts) {
+                logger.warn({ err: error, attempt, attempts }, "Workspace manager shutdown failed; retrying cleanup");
+            }
+        }
+    }
+    if (workspaceFailure !== undefined) {
+        failures.push({ resource: "Workspace manager", error: workspaceFailure });
+        logger.error({ err: workspaceFailure, attempts }, "Workspace manager shutdown failed");
+    }
+    await run("HTTP servers", operations.stopHttpServers);
+    await run("Release monitor", operations.stopReleaseMonitor);
+    if (failures.length > 0) {
+        throw new ServerShutdownError(failures);
+    }
+}

package/dist/shutdown.test.js

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createServerShutdownHandler, orchestrateServerShutdown, ServerShutdownError, } from "./shutdown";
+const logger = {
+    info: () => undefined,
+    warn: () => undefined,
+    error: () => undefined,
+};
+function operations(overrides = {}) {
+    return {
+        stopInstanceEventBridge: () => undefined,
+        stopSidecars: () => undefined,
+        stopClientConnections: () => undefined,
+        stopRemoteProxySessions: () => undefined,
+        stopWorkspaces: () => undefined,
+        stopHttpServers: () => undefined,
+        stopReleaseMonitor: () => undefined,
+        ...overrides,
+    };
+}
+describe("server shutdown orchestration", () => {
+    it("retries workspace cleanup before reporting success", async () => {
+        let attempts = 0;
+        await orchestrateServerShutdown(operations({
+            stopWorkspaces: () => {
+                attempts += 1;
+                if (attempts === 1)
+                    throw new Error("detached process still alive");
+            },
+        }), logger);
+        assert.equal(attempts, 2);
+    });
+    it("stops remote proxy sessions before workspace and HTTP shutdown", async () => {
+        const closed = [];
+        await orchestrateServerShutdown(operations({
+            stopRemoteProxySessions: () => { closed.push("remote-proxy"); },
+            stopWorkspaces: () => { closed.push("workspaces"); },
+            stopHttpServers: () => { closed.push("http"); },
+        }), logger);
+        assert.deepEqual(closed, ["remote-proxy", "workspaces", "http"]);
+    });
+    it("closes other resources and rejects with the concrete workspace failure", async () => {
+        const closed = [];
+        const cleanupFailure = new Error("workspace abc POSIX process group is still alive");
+        let attempts = 0;
+        await assert.rejects(orchestrateServerShutdown(operations({
+            stopWorkspaces: () => {
+                attempts += 1;
+                throw cleanupFailure;
+            },
+            stopHttpServers: () => {
+                closed.push("http");
+            },
+            stopReleaseMonitor: () => {
+                closed.push("release-monitor");
+            },
+        }), logger), (error) => {
+            assert.ok(error instanceof ServerShutdownError);
+            assert.equal(error.failures[0]?.resource, "Workspace manager");
+            assert.strictEqual(error.failures[0]?.error, cleanupFailure);
+            return true;
+        });
+        assert.equal(attempts, 2);
+        assert.deepEqual(closed, ["http", "release-monitor"]);
+    });
+});
+describe("server shutdown signal boundary", () => {
+    it("forces a nonzero exit after failed bounded cleanup returns", async () => {
+        const calls = [];
+        const exits = [];
+        const handler = createServerShutdownHandler({
+            shutdown: async () => {
+                calls.push("cleanup");
+                throw new Error("retained child survived");
+            },
+            logger: {
+                info: () => calls.push("info"),
+                warn: () => undefined,
+                error: () => calls.push("error"),
+            },
+            forceExit: (code) => {
+                calls.push("force-exit");
+                exits.push(code);
+            },
+        });
+        await handler("SIGTERM");
+        assert.deepEqual(exits, [1]);
+        assert.deepEqual(calls, ["info", "cleanup", "error", "force-exit"]);
+    });
+    it("escalates a second signal while shutdown is still pending", async () => {
+        let finishCleanup;
+        const cleanup = new Promise((resolve) => {
+            finishCleanup = resolve;
+        });
+        const exits = [];
+        const exitCodes = [];
+        const handler = createServerShutdownHandler({
+            shutdown: () => cleanup,
+            logger,
+            forceExit: (code) => exits.push(code),
+            setExitCode: (code) => exitCodes.push(code),
+        });
+        const first = handler("SIGINT");
+        const second = handler("SIGTERM");
+        assert.strictEqual(first, second);
+        assert.deepEqual(exits, [1]);
+        finishCleanup();
+        await first;
+        assert.deepEqual(exitCodes, [0]);
+    });
+});

package/dist/usage/providers/api-key.js

@@ -0,0 +1,171 @@
+import { fetchJson, getCredential, notConfigured, resolveWindowLabel, safeFetch, toNumber, toTimestamp, toUsageWindow, } from "../shared";
+const kimiAliases = ["kimi-for-coding", "kimi"];
+const kimi = {
+    id: "kimi-for-coding",
+    name: "Kimi for Coding",
+    aliases: kimiAliases,
+    async fetchQuota() {
+        const key = getCredential(kimiAliases, ["key", "token"]);
+        if (!key)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://api.kimi.com/coding/v1/usages", {
+                headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            });
+            const windows = {};
+            const usage = payload?.usage;
+            if (usage) {
+                const limit = toNumber(usage.limit);
+                const remaining = toNumber(usage.remaining);
+                windows.weekly = toUsageWindow({
+                    usedPercent: limit && remaining !== null ? 100 - (remaining / limit) * 100 : null,
+                    resetAt: toTimestamp(usage.resetTime),
+                });
+            }
+            for (const item of Array.isArray(payload?.limits) ? payload.limits : []) {
+                const duration = toNumber(item?.window?.duration);
+                const unit = item?.window?.timeUnit;
+                const multiplier = unit === "TIME_UNIT_MINUTE" ? 60 : unit === "TIME_UNIT_HOUR" ? 3600 : unit === "TIME_UNIT_DAY" ? 86400 : null;
+                const seconds = duration !== null && multiplier ? duration * multiplier : null;
+                const limit = toNumber(item?.detail?.limit);
+                const remaining = toNumber(item?.detail?.remaining);
+                windows[resolveWindowLabel(seconds)] = toUsageWindow({
+                    usedPercent: limit && remaining !== null ? 100 - (remaining / limit) * 100 : null,
+                    windowSeconds: seconds,
+                    resetAt: toTimestamp(item?.detail?.resetTime),
+                });
+            }
+            return { windows };
+        });
+    },
+};
+const nanoAliases = ["nano-gpt", "nanogpt", "nano_gpt"];
+const nanoGpt = {
+    id: "nano-gpt",
+    name: "NanoGPT",
+    aliases: nanoAliases,
+    async fetchQuota() {
+        const key = getCredential(nanoAliases, ["key", "token"]);
+        if (!key)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://nano-gpt.com/api/subscription/v1/usage", {
+                headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            });
+            const windows = {};
+            for (const [label, source] of [["daily", payload?.daily], ["monthly", payload?.monthly]]) {
+                if (!source)
+                    continue;
+                const fraction = toNumber(source.percentUsed);
+                const used = toNumber(source.used);
+                const limit = toNumber(source.limit ?? source.limits?.[label]);
+                windows[label] = toUsageWindow({
+                    usedPercent: fraction !== null ? fraction * 100 : used !== null && limit ? (used / limit) * 100 : null,
+                    windowSeconds: label === "daily" ? 86400 : null,
+                    resetAt: toTimestamp(source.resetAt ?? payload?.period?.currentPeriodEnd),
+                });
+            }
+            return { windows };
+        });
+    },
+};
+const openRouterAliases = ["openrouter"];
+const openRouter = {
+    id: "openrouter",
+    name: "OpenRouter",
+    aliases: openRouterAliases,
+    async fetchQuota() {
+        const key = getCredential(openRouterAliases, ["key", "token"]);
+        if (!key)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://openrouter.ai/api/v1/credits", {
+                headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            });
+            const total = toNumber(payload?.data?.total_credits);
+            const used = toNumber(payload?.data?.total_usage);
+            const remaining = total !== null && used !== null ? Math.max(0, total - used) : null;
+            return {
+                windows: {
+                    credits: toUsageWindow({
+                        usedPercent: total && used !== null ? (used / total) * 100 : null,
+                        valueLabel: remaining !== null && total !== null ? `$${remaining.toFixed(2)} / $${total.toFixed(2)}` : null,
+                    }),
+                },
+            };
+        });
+    },
+};
+function createTokenLimitProvider(input) {
+    return {
+        id: input.id,
+        name: input.name,
+        aliases: input.aliases,
+        async fetchQuota() {
+            const key = getCredential(input.aliases, ["key", "token"]);
+            if (!key)
+                return notConfigured(this.id, this.name);
+            return safeFetch(this.id, this.name, async () => {
+                const payload = await fetchJson(input.url, { headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" } });
+                const windows = {};
+                for (const limit of Array.isArray(payload?.data?.limits) ? payload.data.limits : []) {
+                    if (limit?.type !== "TOKENS_LIMIT" && limit?.type !== "TIME_LIMIT")
+                        continue;
+                    const duration = toNumber(limit.number);
+                    const seconds = limit.type === "TIME_LIMIT" ? 30 * 86400 : limit.unit === 3 && duration ? duration * 3600 : null;
+                    const label = limit.type === "TIME_LIMIT" ? "mcp-tools" : resolveWindowLabel(seconds);
+                    windows[label] = toUsageWindow({
+                        usedPercent: toNumber(limit.percentage),
+                        windowSeconds: seconds,
+                        resetAt: toTimestamp(limit.nextResetTime),
+                    });
+                }
+                return { windows };
+            });
+        },
+    };
+}
+const zai = createTokenLimitProvider({
+    id: "zai-coding-plan",
+    name: "z.ai",
+    aliases: ["zai-coding-plan", "zai", "z.ai"],
+    url: "https://api.z.ai/api/monitor/usage/quota/limit",
+});
+const zhipu = createTokenLimitProvider({
+    id: "zhipuai-coding-plan",
+    name: "Zhipu AI Coding Plan",
+    aliases: ["zhipuai-coding-plan", "zhipuai", "zhipu"],
+    url: "https://open.bigmodel.cn/api/monitor/usage/quota/limit",
+});
+const waferAliases = ["wafer", "wafer-ai", "wafer_ai", "wafer.ai"];
+const wafer = {
+    id: "wafer",
+    name: "Wafer.ai",
+    aliases: waferAliases,
+    async fetchQuota() {
+        const key = getCredential(waferAliases, ["key", "token"]);
+        if (!key)
+            return notConfigured(this.id, this.name);
+        return safeFetch(this.id, this.name, async () => {
+            const payload = await fetchJson("https://pass.wafer.ai/v1/inference/quota", {
+                headers: { Authorization: `Bearer ${key}`, "Accept-Encoding": "identity" },
+            });
+            const remaining = toNumber(payload?.remaining_included_requests);
+            const limit = toNumber(payload?.included_request_limit);
+            const startAt = toTimestamp(payload?.window_start);
+            const resetAt = toTimestamp(payload?.window_end);
+            const seconds = startAt !== null && resetAt !== null ? Math.round((resetAt - startAt) / 1000) : 5 * 3600;
+            return {
+                windows: {
+                    [resolveWindowLabel(seconds)]: toUsageWindow({
+                        usedPercent: toNumber(payload?.current_period_used_percent),
+                        windowSeconds: seconds,
+                        resetAt,
+                        valueLabel: remaining !== null && limit !== null ? `${remaining} / ${limit}` : null,
+                    }),
+                },
+            };
+        });
+    },
+};
+export const apiKeyProviders = [kimi, nanoGpt, openRouter, zai, zhipu, wafer];