@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

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

@@ -72,4 +72,42 @@ describe("workspace routes", () => {
         assert.equal(calls.length, 2);
         await app.close();
     });
+    it("rejects release after cancellation wins while deletion is still pending", async () => {
+        const app = Fastify({ logger: false });
+        let state = "active";
+        let cancellationStarted;
+        let finishDeletion;
+        const started = new Promise((resolve) => { cancellationStarted = resolve; });
+        const deletion = new Promise((resolve) => { finishDeletion = resolve; });
+        const workspaceManager = {
+            cancelCreationRequest: async () => {
+                state = "cancelled";
+                cancellationStarted();
+                await deletion;
+            },
+            releaseCreationRequest: () => {
+                if (state === "cancelled")
+                    return false;
+                state = "released";
+                return true;
+            },
+        };
+        registerWorkspaceRoutes(app, { workspaceManager });
+        const cancellation = app.inject({
+            method: "POST",
+            url: "/api/workspaces/creation/cancel",
+            payload: { requestId: "restore-request" },
+        });
+        await started;
+        const release = await app.inject({
+            method: "POST",
+            url: "/api/workspaces/workspace/creation/release",
+            payload: { requestId: "restore-request" },
+        });
+        assert.equal(release.statusCode, 404);
+        assert.equal(release.body, "Workspace creation request not found");
+        finishDeletion();
+        assert.equal((await cancellation).statusCode, 204);
+        await app.close();
+    });
 });

package/dist/server/routes/worktrees.js

@@ -10,7 +10,26 @@ const WorktreeCreateSchema = z.object({
     slug: z.string().trim().min(1),
     branch: z.string().trim().min(1).optional(),
 });
+const WorktreeSessionSchema = z.object({ worktreeSlug: z.string().trim().refine(isValidWorktreeSlug) });
 export function registerWorktreeRoutes(app, deps) {
+    app.put("/api/workspaces/:id/worktrees/sessions/:sessionId", async (request, reply) => {
+        if (!deps.workspaceManager.get(request.params.id)) {
+            reply.code(404);
+            return { error: "Workspace not found" };
+        }
+        try {
+            const body = WorktreeSessionSchema.parse(request.body);
+            if (!await deps.sessionMetadataPersistence.hasProjectSession(request.params.id, request.params.sessionId)) {
+                reply.code(404);
+                return { error: "Session not found" };
+            }
+            const metadata = await deps.sessionMetadataPersistence.setWorktreeSlug(request.params.id, request.params.sessionId, body.worktreeSlug);
+            return { metadata };
+        }
+        catch (error) {
+            return handleError(error, reply);
+        }
+    });
     app.get("/api/workspaces/:id/worktrees", async (request, reply) => {
         const workspace = deps.workspaceManager.get(request.params.id);
         if (!workspace) {

package/dist/server/routes/yolo.js

@@ -1,11 +1,12 @@
 export function registerYoloRoutes(app, deps) {
     app.get("/workspaces/:id/yolo/sessions/:sessionId", async (request) => {
         const { id, sessionId } = request.params;
+        await deps.yoloManager.hydrateInstance(id);
         return { enabled: deps.yoloManager.isEnabled(id, sessionId) };
     });
     app.post("/workspaces/:id/yolo/sessions/:sessionId/toggle", async (request, reply) => {
         const { id, sessionId } = request.params;
-        const enabled = deps.yoloManager.toggle(id, sessionId);
+        const enabled = await deps.yoloManager.toggle(id, sessionId);
         reply.code(200);
         return { enabled };
     });

package/dist/server/tls.js

@@ -115,7 +115,7 @@ function generateCaCertificate() {
     cert.publicKey = keys.publicKey;
     cert.serialNumber = crypto.randomBytes(16).toString("hex");
     const now = new Date();
-    const notBefore = new Date(now.getTime() - 60000);
+    const notBefore = new Date(now.getTime() - 60_000);
     const notAfter = new Date(now.getTime() + CA_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
     cert.validity.notBefore = notBefore;
     cert.validity.notAfter = notAfter;
@@ -142,7 +142,7 @@ function generateServerCertificate(args) {
     cert.publicKey = keys.publicKey;
     cert.serialNumber = crypto.randomBytes(16).toString("hex");
     const now = new Date();
-    const notBefore = new Date(now.getTime() - 60000);
+    const notBefore = new Date(now.getTime() - 60_000);
     const notAfter = new Date(now.getTime() + LEAF_VALIDITY_DAYS * 24 * 60 * 60 * 1000);
     cert.validity.notBefore = notBefore;
     cert.validity.notAfter = notAfter;

package/dist/settings/binaries.test.js

@@ -7,18 +7,13 @@ describe("BinaryResolver", () => {
             getOwner(scope, owner) {
                 if (scope === "config" && owner === "server")
                     return { opencodeBinary: "default-opencode" };
-                if (scope === "state" && owner === "ui") {
+                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.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

@@ -1,75 +1,83 @@
-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 const SERVER_SHUTDOWN_COMPLETE = "CODENOMAD_SHUTDOWN_STATUS:complete";
+export const SERVER_SHUTDOWN_INCOMPLETE = "CODENOMAD_SHUTDOWN_STATUS:incomplete";
 export function createServerShutdownHandler(options) {
-    const forceExit = options.forceExit ?? ((code) => process.exit(code));
-    const setExitCode = options.setExitCode ?? ((code) => {
-        process.exitCode = code;
-    });
-    let shutdownPromise;
+    const forceExit = options.forceExit ?? process.exit;
+    const setExitCode = options.setExitCode ?? ((code) => { process.exitCode = code; });
+    const reportStatus = options.reportStatus ?? ((status) => console.log(status));
+    let pending;
     return (signal) => {
-        if (shutdownPromise) {
+        if (pending) {
             options.logger.error({ signal }, "Additional shutdown signal received; forcing nonzero exit");
             forceExit(1);
-            return shutdownPromise;
+            return pending;
         }
         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);
+        pending = Promise.resolve().then(options.shutdown).then(() => {
+            options.logger.info({}, "Shutdown complete");
+            reportStatus(SERVER_SHUTDOWN_COMPLETE);
+            setExitCode(0);
+        }, async (error) => {
+            options.logger.error({ err: error }, "Server shutdown incomplete; retrying cleanup");
+            const retryAttempts = Math.max(0, Math.floor(options.retryAttempts ?? 3));
+            for (let attempt = 1; attempt <= retryAttempts; attempt += 1) {
+                await new Promise((resolve) => setTimeout(resolve, options.retryDelayMs ?? 250));
+                try {
+                    await options.shutdown();
+                    options.logger.info({}, "Shutdown cleanup retry completed");
+                    reportStatus(SERVER_SHUTDOWN_COMPLETE);
+                    setExitCode(0);
+                    return;
+                }
+                catch (retryError) {
+                    options.logger.warn({ err: retryError, attempt, attempts: retryAttempts }, "Shutdown cleanup retry remains incomplete");
+                }
             }
-        })();
-        return shutdownPromise;
+            options.logger.error({ attempts: retryAttempts }, "Shutdown cleanup retries exhausted; preserving process-tree containment");
+            reportStatus(SERVER_SHUTDOWN_INCOMPLETE);
+            setExitCode(1);
+            if (options.holdAfterFailure)
+                await options.holdAfterFailure();
+        });
+        return pending;
     };
 }
 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`);
+    const errors = [];
+    const namedError = (name, cause) => Object.assign(new Error(`${name} failed: ${cause instanceof Error ? cause.message : String(cause)}`), { cause });
+    const settle = async (pending) => {
+        const results = await Promise.allSettled(pending.map(([, run]) => Promise.resolve().then(run)));
+        for (let index = 0; index < results.length; index += 1) {
+            const result = results[index];
+            if (result.status !== "rejected")
+                continue;
+            const error = namedError(pending[index][0], result.reason);
+            errors.push(error);
+            logger.error({ err: error }, "Server 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;
+    const workspaceShutdown = (async () => {
+        const attempts = Math.max(1, Math.floor(workspaceAttempts));
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+            const [result] = await Promise.allSettled([Promise.resolve().then(operations.stopWorkspaces)]);
+            if (result.status === "fulfilled")
+                break;
             if (attempt < attempts) {
-                logger.warn({ err: error, attempt, attempts }, "Workspace manager shutdown failed; retrying cleanup");
+                logger.warn({ err: result.reason, attempt, attempts }, "Workspace manager shutdown failed; retrying cleanup");
+                continue;
             }
+            const error = namedError("stopWorkspaces", result.reason);
+            errors.push(error);
+            logger.error({ err: error, attempts }, "Workspace manager shutdown failed");
         }
-    }
-    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);
-    }
+    })();
+    await Promise.all([
+        settle([
+            ["stopInstanceEventBridge", operations.stopInstanceEventBridge], ["stopSidecars", operations.stopSidecars],
+            ["stopClientConnections", operations.stopClientConnections], ["stopRemoteProxySessions", operations.stopRemoteProxySessions],
+        ]),
+        workspaceShutdown,
+    ]);
+    await settle([["stopHttpServers", operations.stopHttpServers], ["stopReleaseMonitor", operations.stopReleaseMonitor]]);
+    if (errors.length)
+        throw new AggregateError(errors, "Server shutdown failed");
 }

package/dist/shutdown.test.js

@@ -1,110 +1,147 @@
 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,
-    };
-}
+import { createServerShutdownHandler, orchestrateServerShutdown, SERVER_SHUTDOWN_COMPLETE, SERVER_SHUTDOWN_INCOMPLETE, } from "./shutdown";
+const logger = { info() { }, warn() { }, error() { } };
+const operations = (overrides = {}) => ({
+    stopInstanceEventBridge() { }, stopSidecars() { }, stopClientConnections() { },
+    stopRemoteProxySessions() { }, stopWorkspaces() { }, stopHttpServers() { }, stopReleaseMonitor() { },
+    ...overrides,
+});
 describe("server shutdown orchestration", () => {
-    it("retries workspace cleanup before reporting success", async () => {
+    it("retries workspace cleanup and preserves shutdown order", async () => {
+        const calls = [];
         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"); },
+            stopRemoteProxySessions: () => { calls.push("remote-proxy"); },
+            stopWorkspaces: () => { calls.push(`workspaces-${++attempts}`); if (attempts === 1)
+                throw new Error("still alive"); },
+            stopHttpServers: () => { calls.push("http"); },
         }), logger);
-        assert.deepEqual(closed, ["remote-proxy", "workspaces", "http"]);
+        assert.deepEqual(calls, ["workspaces-1", "remote-proxy", "workspaces-2", "http"]);
     });
-    it("closes other resources and rejects with the concrete workspace failure", async () => {
+    it("closes remaining resources and aggregates the concrete current error", async () => {
+        const failure = new Error("workspace abc POSIX process group is still alive");
         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");
-            },
+            stopWorkspaces: () => { attempts++; throw failure; },
+            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);
+            assert.ok(error instanceof AggregateError);
+            assert.equal(error.errors.length, 1);
+            assert.match(error.errors[0].message, /^stopWorkspaces failed:/);
+            assert.strictEqual(error.errors[0].cause, failure);
             return true;
         });
-        assert.equal(attempts, 2);
-        assert.deepEqual(closed, ["http", "release-monitor"]);
+        assert.deepEqual([attempts, closed], [2, ["http", "release-monitor"]]);
+    });
+    it("starts workspace cleanup without waiting for preliminary shutdown", async () => {
+        let releasePreliminary;
+        const preliminary = new Promise((resolve) => { releasePreliminary = resolve; });
+        let workspaceStarted = false;
+        const shutdown = orchestrateServerShutdown(operations({
+            stopRemoteProxySessions: () => preliminary,
+            stopWorkspaces: () => { workspaceStarted = true; },
+        }), logger);
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.equal(workspaceStarted, true);
+        releasePreliminary();
+        await shutdown;
     });
 });
 describe("server shutdown signal boundary", () => {
-    it("forces a nonzero exit after failed bounded cleanup returns", async () => {
+    it("reports incomplete cleanup and holds for final tree enforcement", async () => {
         const calls = [];
         const exits = [];
+        const statuses = [];
+        let releaseHold;
+        const hold = new Promise((resolve) => { releaseHold = resolve; });
         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);
-            },
+            shutdown: async () => { calls.push("cleanup"); throw new Error("retained child survived"); },
+            logger: { info: () => calls.push("info"), warn() { }, error: () => calls.push("error") },
+            forceExit: (code) => { calls.push("force-exit"); exits.push(code); },
+            setExitCode: () => undefined,
+            reportStatus: (status) => statuses.push(status),
+            holdAfterFailure: () => hold,
+            retryAttempts: 0,
         });
-        await handler("SIGTERM");
+        const pending = handler("SIGTERM");
+        await new Promise((resolve) => setImmediate(resolve));
+        assert.deepEqual([exits, statuses, calls], [[], [SERVER_SHUTDOWN_INCOMPLETE], ["info", "cleanup", "error", "error"]]);
+        handler("SIGTERM");
         assert.deepEqual(exits, [1]);
-        assert.deepEqual(calls, ["info", "cleanup", "error", "force-exit"]);
+        releaseHold();
+        await pending;
     });
-    it("escalates a second signal while shutdown is still pending", async () => {
-        let finishCleanup;
-        const cleanup = new Promise((resolve) => {
-            finishCleanup = resolve;
+    it("reports complete cleanup before allowing natural exit", async () => {
+        const statuses = [], exitCodes = [];
+        const handler = createServerShutdownHandler({
+            shutdown: async () => undefined,
+            logger,
+            reportStatus: (status) => statuses.push(status),
+            setExitCode: (code) => exitCodes.push(code),
         });
-        const exits = [];
-        const exitCodes = [];
+        await handler("stdin");
+        assert.deepEqual(statuses, [SERVER_SHUTDOWN_COMPLETE]);
+        assert.deepEqual(exitCodes, [0]);
+    });
+    it("keeps retrying identity-aware cleanup during the final enforcement budget", async () => {
+        let attempts = 0;
+        const statuses = [], exitCodes = [];
+        const handler = createServerShutdownHandler({
+            shutdown: async () => {
+                attempts++;
+                if (attempts === 1)
+                    throw new Error("detached group still alive");
+            },
+            logger,
+            reportStatus: (status) => statuses.push(status),
+            setExitCode: (code) => exitCodes.push(code),
+            retryDelayMs: 0,
+        });
+        await handler("stdin");
+        assert.equal(attempts, 2);
+        assert.deepEqual(statuses, [SERVER_SHUTDOWN_COMPLETE]);
+        assert.deepEqual(exitCodes, [0]);
+    });
+    it("preserves containment after the standalone cleanup retry budget", async () => {
+        let attempts = 0;
+        const statuses = [], exitCodes = [], forcedExits = [];
+        let releaseHold;
+        const hold = new Promise((resolve) => { releaseHold = resolve; });
         const handler = createServerShutdownHandler({
-            shutdown: () => cleanup,
+            shutdown: async () => { attempts++; throw new Error("process tree remains alive"); },
             logger,
-            forceExit: (code) => exits.push(code),
+            reportStatus: (status) => statuses.push(status),
             setExitCode: (code) => exitCodes.push(code),
+            forceExit: (code) => forcedExits.push(code),
+            holdAfterFailure: () => hold,
+            retryDelayMs: 0,
+            retryAttempts: 2,
         });
-        const first = handler("SIGINT");
-        const second = handler("SIGTERM");
+        const pending = handler("stdin");
+        while (attempts < 3)
+            await new Promise((resolve) => setTimeout(resolve, 0));
+        assert.equal(attempts, 3);
+        assert.deepEqual(statuses, [SERVER_SHUTDOWN_INCOMPLETE]);
+        assert.deepEqual(exitCodes, [1]);
+        assert.deepEqual(forcedExits, []);
+        handler("SIGTERM");
+        assert.deepEqual(forcedExits, [1]);
+        releaseHold();
+        await pending;
+    });
+    it("escalates a second signal while sharing first-signal cleanup", async () => {
+        let finish;
+        const cleanup = new Promise((resolve) => { finish = resolve; });
+        const exits = [], exitCodes = [];
+        const handler = createServerShutdownHandler({ shutdown: () => cleanup, logger,
+            forceExit: (code) => exits.push(code), setExitCode: (code) => exitCodes.push(code), reportStatus: () => undefined });
+        const first = handler("SIGINT"), second = handler("SIGTERM");
         assert.strictEqual(first, second);
         assert.deepEqual(exits, [1]);
-        finishCleanup();
+        finish();
         await first;
         assert.deepEqual(exitCodes, [0]);
     });

package/dist/ui/remote-ui.js

@@ -7,8 +7,8 @@ import { Readable } from "stream";
 import { fetch } from "undici";
 import yauzl from "yauzl";
 const DEFAULT_MANIFEST_URL = "https://ui.codenomad.neuralnomads.ai/version.json";
-const MANIFEST_TIMEOUT_MS = 5000;
-const ZIP_TIMEOUT_MS = 30000;
+const MANIFEST_TIMEOUT_MS = 5_000;
+const ZIP_TIMEOUT_MS = 30_000;
 export async function resolveUi(options) {
     const manifestUrl = options.manifestUrl ?? DEFAULT_MANIFEST_URL;
     if (options.uiDevServerUrl) {

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

@@ -25,7 +25,7 @@ const kimi = {
             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 multiplier = unit === "TIME_UNIT_MINUTE" ? 60 : unit === "TIME_UNIT_HOUR" ? 3600 : unit === "TIME_UNIT_DAY" ? 86_400 : null;
                 const seconds = duration !== null && multiplier ? duration * multiplier : null;
                 const limit = toNumber(item?.detail?.limit);
                 const remaining = toNumber(item?.detail?.remaining);
@@ -61,7 +61,7 @@ const nanoGpt = {
                 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,
+                    windowSeconds: label === "daily" ? 86_400 : null,
                     resetAt: toTimestamp(source.resetAt ?? payload?.period?.currentPeriodEnd),
                 });
             }
@@ -112,7 +112,7 @@ function createTokenLimitProvider(input) {
                     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 seconds = limit.type === "TIME_LIMIT" ? 30 * 86_400 : limit.unit === 3 && duration ? duration * 3600 : null;
                     const label = limit.type === "TIME_LIMIT" ? "mcp-tools" : resolveWindowLabel(seconds);
                     windows[label] = toUsageWindow({
                         usedPercent: toNumber(limit.percentage),

package/dist/usage/providers/google.js

@@ -92,7 +92,7 @@ function transformModel(sourceId, modelId, data) {
             windows: {
                 [label]: toUsageWindow({
                     usedPercent: fraction === null ? null : 100 - fraction * 100,
-                    windowSeconds: label === "daily" ? 86400 : 5 * 3600,
+                    windowSeconds: label === "daily" ? 86_400 : 5 * 3600,
                     resetAt,
                 }),
             },

package/dist/usage/providers/oauth.js

@@ -1,32 +1,4 @@
 import { fetchJson, getAuthEntry, getCredential, notConfigured, resolveWindowLabel, safeFetch, toNumber, toTimestamp, toUsageWindow, } from "../shared";
-const claudeAliases = ["anthropic", "claude"];
-const claude = {
-    id: "claude",
-    name: "Claude",
-    aliases: claudeAliases,
-    async fetchQuota() {
-        const token = getCredential(claudeAliases, ["access", "token"]);
-        if (!token)
-            return notConfigured(this.id, this.name);
-        return safeFetch(this.id, this.name, async () => {
-            const payload = await fetchJson("https://api.anthropic.com/api/oauth/usage", {
-                headers: { Authorization: `Bearer ${token}`, "anthropic-beta": "oauth-2025-04-20" },
-            });
-            const windows = {};
-            for (const [key, source] of [
-                ["5h", payload?.five_hour],
-                ["7d", payload?.seven_day],
-                ["7d-sonnet", payload?.seven_day_sonnet],
-                ["7d-opus", payload?.seven_day_opus],
-            ]) {
-                if (!source)
-                    continue;
-                windows[key] = toUsageWindow({ usedPercent: toNumber(source.utilization), resetAt: toTimestamp(source.resets_at) });
-            }
-            return { windows };
-        });
-    },
-};
 const codexAliases = ["openai", "codex", "chatgpt"];
 const codex = {
     id: "codex",
@@ -57,13 +29,6 @@ const codex = {
                     resetAt: toTimestamp(source.reset_at),
                 });
             }
-            const balance = toNumber(payload?.credits?.balance);
-            if (payload?.credits?.unlimited || balance !== null) {
-                windows.credits_balance = toUsageWindow({
-                    usedPercent: null,
-                    valueLabel: payload?.credits?.unlimited ? "∞" : `$${balance.toFixed(2)}`,
-                });
-            }
             return { windows };
         });
     },
@@ -108,4 +73,4 @@ const copilot = {
         });
     },
 };
-export const oauthProviders = [claude, codex, copilot];
+export const oauthProviders = [codex, copilot];

package/dist/usage/providers/special.js

@@ -15,7 +15,7 @@ async function resolveCursorToken() {
     const accessToken = getString(process.env.CURSOR_ACCESS_TOKEN) ?? getString(process.env.CURSOR_TOKEN);
     const refreshToken = getString(process.env.CURSOR_REFRESH_TOKEN);
     const expiresAt = accessToken ? decodeJwtExpiration(accessToken) : null;
-    if (accessToken && (!expiresAt || expiresAt > Date.now() + 5 * 60000))
+    if (accessToken && (!expiresAt || expiresAt > Date.now() + 5 * 60_000))
         return accessToken;
     if (!refreshToken)
         return accessToken;
@@ -94,7 +94,7 @@ const ollamaCloud = {
             const response = await fetch("https://ollama.com/settings", {
                 headers: { Cookie: cookie, "User-Agent": "CodeNomad usage provider" },
                 redirect: "manual",
-                signal: AbortSignal.timeout(15000),
+                signal: AbortSignal.timeout(15_000),
             });
             if (!response.ok)
                 throw new Error(`Provider returned HTTP ${response.status}`);
@@ -134,7 +134,7 @@ const openCodeGo = {
             const response = await fetch(`https://opencode.ai/workspace/${encodeURIComponent(workspaceId)}/go`, {
                 headers: { Cookie: `auth=${authCookie.replace(/^auth=/, "")}`, "User-Agent": "CodeNomad usage provider" },
                 redirect: "manual",
-                signal: AbortSignal.timeout(15000),
+                signal: AbortSignal.timeout(15_000),
             });
             if (!response.ok)
                 throw new Error(`Provider returned HTTP ${response.status}`);

package/dist/usage/service.js

@@ -3,7 +3,7 @@ import { googleProviders } from "./providers/google";
 import { miniMaxProviders } from "./providers/minimax";
 import { oauthProviders } from "./providers/oauth";
 import { specialProviders } from "./providers/special";
-const CACHE_TTL_MS = 60000;
+const CACHE_TTL_MS = 60_000;
 const providers = [...oauthProviders, ...apiKeyProviders, ...miniMaxProviders, ...googleProviders, ...specialProviders];
 const registry = new Map();
 for (const provider of providers) {