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

package/README.md

@@ -217,3 +217,15 @@ When running as a server CodeNomad can also be installed as a PWA from any suppo
 
 - **Config**: `~/.config/codenomad/config.json`
 - **Instance Data**: `~/.config/codenomad/instances` (chat history, etc.)
+
+### Provider Plan Usage
+
+The Status panel automatically displays quota information for the provider used by the active session. CodeNomad reads existing OpenCode credentials and never returns provider secrets through its API.
+
+Some optional usage integrations require credentials that OpenCode does not expose. They can be enabled without UI configuration through these environment variables:
+
+- Google token refresh: `GOOGLE_OAUTH_CLIENT_ID` and `GOOGLE_OAUTH_CLIENT_SECRET`
+- Antigravity token refresh: `ANTIGRAVITY_OAUTH_CLIENT_ID` and `ANTIGRAVITY_OAUTH_CLIENT_SECRET`
+- Cursor: `CURSOR_ACCESS_TOKEN` or `CURSOR_TOKEN`, with optional `CURSOR_REFRESH_TOKEN`
+- Ollama Cloud: `OLLAMA_CLOUD_COOKIE`
+- OpenCode Go: `OPENCODE_GO_WORKSPACE_ID` and `OPENCODE_GO_AUTH_COOKIE`

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,26 @@
+# Third-Party Notices
+
+The provider usage adapters are derived from OpenChamber:
+https://github.com/openchamber/openchamber
+
+MIT License
+
+Copyright (c) 2025 Bohdan Triapitsyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/events/bus.js

@@ -3,8 +3,19 @@ export class EventBus extends EventEmitter {
     constructor(logger) {
         super();
         this.logger = logger;
+        this.instanceStatuses = new Map();
     }
     publish(event) {
+        if (event.type === "instance.eventStatus") {
+            const terminal = event.status === "disconnected"
+                && (event.reason === "workspace stopped" || event.reason === "workspace error");
+            if (terminal) {
+                this.instanceStatuses.delete(event.instanceId);
+            }
+            else {
+                this.instanceStatuses.set(event.instanceId, event);
+            }
+        }
         if (event.type !== "instance.event" && event.type !== "instance.eventStatus") {
             this.logger?.debug({ type: event.type }, "Publishing workspace event");
             if (this.logger?.isLevelEnabled("trace")) {
@@ -29,6 +40,8 @@ export class EventBus extends EventEmitter {
         this.on("instance.eventStatus", handler);
         this.on("yolo.stateChanged", handler);
         this.on("yolo.autoAccepted", handler);
+        for (const status of this.instanceStatuses.values())
+            listener(status);
         return () => {
             this.off("workspace.created", handler);
             this.off("workspace.started", handler);

package/dist/events/bus.test.js

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { EventBus } from "./bus";
+describe("event bus instance status replay", () => {
+    it("replays the latest instance status to a late subscriber", () => {
+        const bus = new EventBus();
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connecting" });
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" });
+        const received = [];
+        bus.onEvent((event) => received.push(event));
+        assert.deepEqual(received, [
+            { type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" },
+        ]);
+    });
+    it("delivers terminal disconnects live without replaying stopped workspaces", () => {
+        const bus = new EventBus();
+        bus.publish({ type: "instance.eventStatus", instanceId: "workspace-1", status: "connected" });
+        const live = [];
+        bus.onEvent((event) => live.push(event));
+        live.length = 0;
+        bus.publish({
+            type: "instance.eventStatus",
+            instanceId: "workspace-1",
+            status: "disconnected",
+            reason: "workspace stopped",
+        });
+        assert.deepEqual(live, [{
+                type: "instance.eventStatus",
+                instanceId: "workspace-1",
+                status: "disconnected",
+                reason: "workspace stopped",
+            }]);
+        const replayed = [];
+        bus.onEvent((event) => replayed.push(event));
+        assert.deepEqual(replayed, []);
+    });
+});

package/dist/index.js

@@ -31,6 +31,7 @@ import { ClientConnectionManager } from "./clients/connection-manager";
 import { PluginChannelManager } from "./plugins/channel";
 import { VoiceModeManager } from "./plugins/voice-mode";
 import { runCliUpgrade } from "./cli-upgrade";
+import { createServerShutdownHandler, orchestrateServerShutdown } from "./shutdown";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const __filename = fileURLToPath(import.meta.url);
@@ -40,6 +41,10 @@ const DEFAULT_HOST = "127.0.0.1";
 const DEFAULT_CONFIG_PATH = "~/.config/codenomad/config.json";
 const DEFAULT_HTTPS_PORT = 9898;
 const DEFAULT_HTTP_PORT = 9899;
+export function installShutdownSignalHandlers(source, shutdown) {
+    source.on("SIGINT", () => void shutdown("SIGINT"));
+    source.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
 function parseCliOptions(argv) {
     const program = new Command()
         .name("codenomad")
@@ -424,61 +429,33 @@ async function main() {
     if (options.launch) {
         await launchInBrowser(serverMeta.localUrl, logger.child({ component: "launcher" }));
     }
-    let shuttingDown = false;
-    const shutdown = async () => {
-        if (shuttingDown) {
-            logger.info("Shutdown already in progress, ignoring signal");
-            return;
-        }
-        shuttingDown = true;
-        logger.info("Received shutdown signal, stopping workspaces and server");
-        const shutdownWorkspaces = (async () => {
-            try {
-                instanceEventBridge.shutdown();
-            }
-            catch (error) {
-                logger.warn({ err: error }, "Instance event bridge shutdown failed");
-            }
-            try {
-                await sidecarManager.shutdown();
-            }
-            catch (error) {
-                logger.error({ err: error }, "SideCar manager shutdown failed");
-            }
-            try {
-                clientConnectionManager.shutdown();
-            }
-            catch (error) {
-                logger.warn({ err: error }, "Client connection manager shutdown failed");
-            }
-            try {
-                await workspaceManager.shutdown();
-                logger.info("Workspace manager shutdown complete");
-            }
-            catch (error) {
-                logger.error({ err: error }, "Workspace manager shutdown failed");
-            }
-        })();
-        const shutdownHttp = (async () => {
-            try {
-                await Promise.allSettled(servers.map((srv) => srv.stop()));
+    const shutdown = createServerShutdownHandler({
+        logger,
+        shutdown: () => orchestrateServerShutdown({
+            stopInstanceEventBridge: () => instanceEventBridge.shutdown(),
+            stopSidecars: () => sidecarManager.shutdown(),
+            stopClientConnections: () => clientConnectionManager.shutdown(),
+            stopRemoteProxySessions: () => remoteProxySessionManager.shutdown(),
+            stopWorkspaces: () => workspaceManager.shutdown(),
+            stopHttpServers: async () => {
+                const results = await Promise.allSettled(servers.map((srv) => srv.stop()));
+                const failures = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
+                if (failures.length > 0) {
+                    const error = new Error("One or more HTTP servers failed to stop");
+                    error.failures = failures;
+                    throw error;
+                }
                 logger.info("HTTP server(s) stopped");
-            }
-            catch (error) {
-                logger.error({ err: error }, "Failed to stop HTTP server");
-            }
-        })();
-        await Promise.allSettled([shutdownWorkspaces, shutdownHttp]);
-        // no-op: remote UI manifest replaces GitHub release monitor
-        devReleaseMonitor?.stop();
-        logger.info("Exiting process");
-        process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+            },
+            stopReleaseMonitor: () => devReleaseMonitor?.stop(),
+        }, logger),
+    });
+    installShutdownSignalHandlers(process, shutdown);
+}
+if (path.resolve(process.argv[1] ?? "") === __filename) {
+    main().catch((error) => {
+        const logger = createLogger({ component: "app" });
+        logger.error({ err: error }, "CLI server crashed");
+        process.exit(1);
+    });
 }
-main().catch((error) => {
-    const logger = createLogger({ component: "app" });
-    logger.error({ err: error }, "CLI server crashed");
-    process.exit(1);
-});

package/dist/index.test.js

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { installShutdownSignalHandlers } from "./index";
+import { createServerShutdownHandler } from "./shutdown";
+describe("CLI shutdown signal registration", () => {
+    it("routes a second process signal to forced nonzero escalation", async () => {
+        const listeners = new Map();
+        let finishCleanup;
+        const cleanup = new Promise((resolve) => {
+            finishCleanup = resolve;
+        });
+        const exits = [];
+        const shutdown = createServerShutdownHandler({
+            shutdown: () => cleanup,
+            logger: {
+                info: () => undefined,
+                warn: () => undefined,
+                error: () => undefined,
+            },
+            forceExit: (code) => exits.push(code),
+            setExitCode: () => undefined,
+        });
+        installShutdownSignalHandlers({
+            on: (signal, listener) => listeners.set(signal, listener),
+        }, shutdown);
+        listeners.get("SIGINT")?.();
+        listeners.get("SIGTERM")?.();
+        assert.deepEqual(exits, [1]);
+        finishCleanup();
+        await cleanup;
+    });
+});

package/dist/server/__tests__/remote-proxy.test.js

@@ -125,18 +125,118 @@ describe("RemoteProxySessionManager", () => {
             res.end("ok");
         });
     });
+    it("closes every session listener during shutdown", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const first = await createSession(manager, `${upstreamBaseUrl}/base`);
+            await createSession(manager, `${upstreamBaseUrl}/other`);
+            await manager.shutdown();
+            assert.equal(manager.sessions.size, 0);
+            await assert.rejects(proxyFetch(`${first.proxyOrigin}/status`));
+        }, (_req, res) => {
+            res.writeHead(200).end("ok");
+        });
+    });
+    it("waits for in-flight idle cleanup during shutdown", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager({ disposalTimeoutMs: 1000 });
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            const internalSession = manager.sessions.get(session.sessionId);
+            const closeGate = deferred();
+            const originalClose = internalSession.app.close.bind(internalSession.app);
+            internalSession.app.close = async () => {
+                await closeGate.promise;
+                return originalClose();
+            };
+            internalSession.lastAccessAt = Date.now() - 31 * 60000;
+            const cleanup = manager.cleanupExpiredSessions();
+            assert.equal(manager.pendingDisposals.size, 1);
+            let shutdownSettled = false;
+            const shutdown = manager.shutdown().then(() => {
+                shutdownSettled = true;
+            });
+            await new Promise((resolve) => setImmediate(resolve));
+            assert.equal(shutdownSettled, false);
+            closeGate.resolve();
+            await cleanup;
+            await shutdown;
+            assert.equal(manager.pendingDisposals.size, 0);
+        }, (_req, res) => {
+            res.writeHead(200).end("ok");
+        });
+    });
+    it("aborts a stalled event stream during bounded shutdown", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager({ disposalTimeoutMs: 100 });
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            await activateSession(session);
+            const response = await proxyFetch(`${session.proxyOrigin}/events`);
+            assert.equal(response.status, 200);
+            await Promise.race([
+                manager.shutdown(),
+                new Promise((_resolve, reject) => setTimeout(() => reject(new Error("shutdown stalled")), 500)),
+            ]);
+            assert.equal(manager.sessions.size, 0);
+            assert.equal(manager.pendingDisposals.size, 0);
+        }, (req, res) => {
+            if (req.url === "/base/events") {
+                res.writeHead(200, { "content-type": "text/event-stream" });
+                res.write("data: connected\n\n");
+                return;
+            }
+            res.writeHead(200).end("ok");
+        });
+    });
+    it("surfaces listener disposal failures", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const session = await createSession(manager, `${upstreamBaseUrl}/base`);
+            const internalSession = manager.sessions.get(session.sessionId);
+            const originalClose = internalSession.app.close.bind(internalSession.app);
+            internalSession.app.close = async () => {
+                await originalClose();
+                throw new Error("close failed");
+            };
+            await assert.rejects(manager.deleteSession(session.sessionId), /Remote proxy disposal failed/);
+            await assert.rejects(manager.shutdown(), /Remote proxy shutdown failed/);
+        }, (_req, res) => {
+            res.writeHead(200).end("ok");
+        });
+    });
+    it("waits for in-flight creation and rejects sessions that cross shutdown", async () => {
+        await withUpstreamServer(async (upstreamBaseUrl) => {
+            const manager = createSessionManager();
+            const creation = manager.createSession(`${upstreamBaseUrl}/base`, false);
+            const shutdown = manager.shutdown();
+            await assert.rejects(creation, /shutting down/);
+            await shutdown;
+            assert.equal(manager.pendingCreations.size, 0);
+            assert.equal(manager.sessions.size, 0);
+            await assert.rejects(manager.createSession(`${upstreamBaseUrl}/base`, false), /shutting down/);
+        }, (_req, res) => {
+            res.writeHead(200).end("ok");
+        });
+    });
 });
-function createSessionManager() {
+function createSessionManager(options = {}) {
     const manager = new RemoteProxySessionManager({
         authManager: {
             isLoopbackRequest: () => true,
         },
         logger: createStubLogger(),
         httpsOptions: sharedHttpsOptions,
+        ...options,
     });
     managers.add(manager);
     return manager;
 }
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
 async function createSession(manager, baseUrl) {
     const created = await manager.createSession(baseUrl, false);
     const windowUrl = new URL(created.windowUrl);
@@ -171,11 +271,7 @@ async function proxyFetch(url, init) {
     return fetch(url, { dispatcher: httpsDispatcher, ...init });
 }
 async function disposeManager(manager) {
-    const sessions = Array.from(manager.sessions.keys());
-    for (const sessionId of sessions) {
-        await manager.deleteSession(sessionId);
-    }
-    clearInterval(manager.cleanupTimer);
+    await manager.shutdown().catch(() => undefined);
 }
 async function withUpstreamServer(callback, handler) {
     const server = http.createServer(handler);

package/dist/server/http-server.js

@@ -23,6 +23,7 @@ import { registerRemoteServerRoutes } from "./routes/remote-servers";
 import { registerRemoteProxyRoutes } from "./routes/remote-proxy";
 import { registerSideCarRoutes } from "./routes/sidecars";
 import { registerPreviewRoutes } from "./routes/previews";
+import { registerUsageRoutes } from "./routes/usage";
 import { BackgroundProcessManager } from "../background-processes/manager";
 import { AutoAcceptManager } from "../permissions/auto-accept-manager";
 import { createOpencodePermissionReplier } from "../permissions/opencode-replier";
@@ -224,6 +225,7 @@ export function createHttpServer(deps) {
     registerSpeechRoutes(app, { speechService: deps.speechService });
     registerSideCarRoutes(app, { sidecarManager: deps.sidecarManager });
     registerPreviewRoutes(app, { previewManager: deps.previewManager });
+    registerUsageRoutes(app);
     registerSideCarProxyRoutes(app, { sidecarManager: deps.sidecarManager, logger: proxyLogger });
     registerPreviewProxyRoutes(app, { previewManager: deps.previewManager, logger: proxyLogger });
     setupSideCarWebSocketProxy(app, {

package/dist/server/remote-proxy.js

@@ -7,24 +7,46 @@ const LOOPBACK_HOST = "127.0.0.1";
 const BOOTSTRAP_PAGE_PATH = "/__codenomad/auth/token";
 const BOOTSTRAP_EXCHANGE_PATH = "/__codenomad/api/auth/token";
 const SESSION_IDLE_TTL_MS = 30 * 60000;
+const SESSION_DISPOSAL_TIMEOUT_MS = 5000;
 export class RemoteProxySessionManager {
     constructor(options) {
         this.options = options;
         this.sessions = new Map();
+        this.pendingCreations = new Set();
+        this.pendingDisposals = new Set();
+        this.disposalFailures = [];
+        this.shuttingDown = false;
+        this.disposalTimeoutMs = Math.max(1, options.disposalTimeoutMs ?? SESSION_DISPOSAL_TIMEOUT_MS);
         this.cleanupTimer = setInterval(() => {
-            void this.cleanupExpiredSessions();
+            void this.cleanupExpiredSessions().catch((error) => {
+                this.options.logger.error({ err: error }, "Failed to dispose expired remote proxy session");
+            });
         }, 60000);
         this.cleanupTimer.unref();
     }
     async createSession(baseUrl, skipTlsVerify) {
+        if (this.shuttingDown) {
+            throw new Error("Remote proxy session manager is shutting down");
+        }
+        const creation = this.createSessionInternal(baseUrl, skipTlsVerify);
+        this.pendingCreations.add(creation);
+        try {
+            return await creation;
+        }
+        finally {
+            this.pendingCreations.delete(creation);
+        }
+    }
+    async createSessionInternal(baseUrl, skipTlsVerify) {
         if (!this.options.httpsOptions) {
             throw new Error("Local HTTPS is required for remote proxy sessions");
         }
         const targetBaseUrl = normalizeBaseUrl(baseUrl);
         const sessionId = randomUUID();
         const bootstrapToken = randomBytes(32).toString("base64url");
-        const dispatcher = skipTlsVerify ? new Agent({ connect: { rejectUnauthorized: false } }) : undefined;
-        const app = Fastify({ logger: false, https: this.options.httpsOptions });
+        const dispatcher = new Agent(skipTlsVerify ? { connect: { rejectUnauthorized: false } } : {});
+        const abortController = new AbortController();
+        const app = Fastify({ logger: false, https: this.options.httpsOptions, forceCloseConnections: true });
         let session = null;
         app.removeAllContentTypeParsers();
         // Preserve raw request bodies for proxying while still letting token JSON parse from Buffer.
@@ -82,6 +104,17 @@ export class RemoteProxySessionManager {
             await proxyRequest({ request, reply, session, logger: this.options.logger });
         });
         const addressInfo = await app.listen({ host: LOOPBACK_HOST, port: 0 });
+        if (this.shuttingDown) {
+            abortController.abort();
+            try {
+                await this.disposeResources(app, dispatcher);
+            }
+            catch (error) {
+                this.disposalFailures.push(error);
+                throw error;
+            }
+            throw new Error("Remote proxy session manager is shutting down");
+        }
         const address = new URL(addressInfo);
         const localBaseUrl = new URL(`https://${LOOPBACK_HOST}:${address.port}`);
         const entryUrl = new URL(targetBaseUrl.pathname || "/", localBaseUrl);
@@ -98,6 +131,7 @@ export class RemoteProxySessionManager {
             cookiePrefix: `cnrp_${randomBytes(6).toString("hex")}_`,
             app,
             dispatcher,
+            abortController,
             createdAt: Date.now(),
             lastAccessAt: Date.now(),
         };
@@ -108,6 +142,27 @@ export class RemoteProxySessionManager {
     async deleteSession(sessionId) {
         return this.disposeSession(sessionId);
     }
+    async shutdown() {
+        this.shuttingDown = true;
+        clearInterval(this.cleanupTimer);
+        const disposals = new Set(this.pendingDisposals);
+        await Promise.allSettled(Array.from(this.pendingCreations));
+        for (const sessionId of this.sessions.keys())
+            disposals.add(this.disposeSession(sessionId));
+        while (this.pendingDisposals.size > 0) {
+            const pending = Array.from(this.pendingDisposals);
+            for (const disposal of pending)
+                disposals.add(disposal);
+            await Promise.allSettled(pending);
+        }
+        const results = await Promise.allSettled(disposals);
+        const failures = [
+            ...this.disposalFailures,
+            ...results.flatMap((result) => result.status === "rejected" ? [result.reason] : []),
+        ];
+        if (failures.length > 0)
+            throw createDisposalError("Remote proxy shutdown failed", failures);
+    }
     async cleanupExpiredSessions() {
         const now = Date.now();
         for (const session of Array.from(this.sessions.values())) {
@@ -117,17 +172,48 @@ export class RemoteProxySessionManager {
             await this.disposeSession(session.id);
         }
     }
-    async disposeSession(sessionId) {
+    disposeSession(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session) {
-            return false;
+            return Promise.resolve(false);
         }
         this.sessions.delete(sessionId);
-        session.dispatcher?.close().catch(() => { });
-        await session.app.close().catch(() => { });
-        this.options.logger.info({ sessionId }, "Disposed remote proxy session");
-        return true;
+        session.abortController.abort();
+        const disposal = this.disposeResources(session.app, session.dispatcher)
+            .then(() => {
+            this.options.logger.info({ sessionId }, "Disposed remote proxy session");
+            return true;
+        })
+            .catch((error) => {
+            this.disposalFailures.push(error);
+            throw error;
+        });
+        this.pendingDisposals.add(disposal);
+        void disposal.then(() => this.pendingDisposals.delete(disposal), () => this.pendingDisposals.delete(disposal));
+        return disposal;
     }
+    async disposeResources(app, dispatcher) {
+        app.server.closeAllConnections?.();
+        const disposal = Promise.allSettled([app.close(), dispatcher.destroy()]);
+        let timeout;
+        const deadline = new Promise((_resolve, reject) => {
+            timeout = setTimeout(() => reject(new Error(`Remote proxy disposal timed out after ${this.disposalTimeoutMs}ms`)), this.disposalTimeoutMs);
+            timeout.unref();
+        });
+        try {
+            const results = await Promise.race([disposal, deadline]);
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length > 0)
+                throw createDisposalError("Remote proxy disposal failed", failures);
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+}
+function createDisposalError(message, failures) {
+    return Object.assign(new Error(message), { failures });
 }
 function normalizeBaseUrl(input) {
     const parsed = new URL(input.trim());
@@ -253,6 +339,7 @@ async function proxyRequest(args) {
         method: request.method,
         headers,
         dispatcher: session.dispatcher,
+        signal: session.abortController.signal,
         redirect: "manual",
     };
     if (request.method !== "GET" && request.method !== "HEAD") {

package/dist/server/routes/usage.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { getProviderUsage } from "../../usage/service";
+const UsageParamsSchema = z.object({ providerId: z.string().trim().min(1) });
+const UsageQuerySchema = z.object({ modelId: z.string().trim().optional() });
+export function registerUsageRoutes(app) {
+    app.get("/api/usage/:providerId", async (request, reply) => {
+        try {
+            const params = UsageParamsSchema.parse(request.params);
+            const query = UsageQuerySchema.parse(request.query ?? {});
+            return await getProviderUsage(params.providerId, { modelId: query.modelId });
+        }
+        catch (error) {
+            request.log.error({ err: error }, "Failed to fetch provider usage");
+            reply.code(400);
+            return { error: error instanceof Error ? error.message : "Failed to fetch provider usage" };
+        }
+    });
+}

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

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import Fastify from "fastify";
+import { registerUsageRoutes } from "./usage";
+test("returns a typed unsupported result without exposing server details", async () => {
+    const app = Fastify();
+    registerUsageRoutes(app);
+    try {
+        const response = await app.inject({ method: "GET", url: "/api/usage/unknown-provider?modelId=test-model" });
+        assert.equal(response.statusCode, 200);
+        assert.deepEqual(response.json(), {
+            requestedProviderId: "unknown-provider",
+            providerId: null,
+            providerName: "unknown-provider",
+            modelId: "test-model",
+            supported: false,
+            configured: false,
+            ok: false,
+            windows: {},
+            fetchedAt: response.json().fetchedAt,
+        });
+    }
+    finally {
+        await app.close();
+    }
+});