@neuralnomads/codenomad-dev 0.19.0-dev-20260827-14586cb3 → 0.19.0-dev-20260829-56156827

package/dist/releases/dev-release-monitor.js

@@ -1,6 +1,10 @@
 import { fetch } from "undici";
 import { compareVersionStrings, stripTagPrefix } from "./release-monitor";
 const DEFAULT_POLL_INTERVAL_MS = 15 * 60 * 1000;
+export function matchesDevReleaseChannel(tag, currentVersion) {
+    const v2 = "-dev-v2-";
+    return currentVersion.includes(v2) ? tag.includes(v2) : tag.includes("-dev-") && !tag.includes(v2);
+}
 export function startDevReleaseMonitor(options) {
     let stopped = false;
     let timer = null;
@@ -49,7 +53,10 @@ async function fetchLatestPrerelease(args) {
         throw new Error(`GitHub releases API responded with ${response.status}`);
     }
     const list = (await response.json());
-    const latest = list.find((r) => r && r.prerelease === true && r.draft !== true);
+    const latest = list.find((release) => {
+        const tag = release?.tag_name || release?.name || "";
+        return release?.prerelease === true && release.draft !== true && matchesDevReleaseChannel(tag, args.currentVersion);
+    });
     if (!latest) {
         return null;
     }

package/dist/releases/dev-release-monitor.test.js

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { matchesDevReleaseChannel } from "./dev-release-monitor";
+test("dev prereleases stay within their V1 or V2 channel", () => {
+    const v1 = "v0.19.0-dev-20260825-12345678";
+    const v2 = "v0.20.0-dev-v2-20260825-abcdef12";
+    assert.equal(matchesDevReleaseChannel(v1, v1), true);
+    assert.equal(matchesDevReleaseChannel(v2, v1), false);
+    assert.equal(matchesDevReleaseChannel(v2, v2), true);
+    assert.equal(matchesDevReleaseChannel(v1, v2), false);
+});

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

@@ -96,6 +96,12 @@ const openRouter = {
         });
     },
 };
+const CREDIT_LIMIT_TYPE = "CREDIT_LIMIT";
+const UNIT_SECONDS = { 3: 3_600, 6: 604_800 };
+function unitWindowSeconds(unit, count) {
+    const unitSeconds = typeof unit === "number" ? UNIT_SECONDS[unit] : undefined;
+    return unitSeconds !== undefined && count !== null ? unitSeconds * count : null;
+}
 function createTokenLimitProvider(input) {
     return {
         id: input.id,
@@ -109,16 +115,29 @@ function createTokenLimitProvider(input) {
                 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 * 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),
-                        windowSeconds: seconds,
-                        resetAt: toTimestamp(limit.nextResetTime),
-                    });
+                    const number = toNumber(limit?.number);
+                    if (limit && (limit.type === "TOKENS_LIMIT" || limit.type === "TIME_LIMIT")) {
+                        const seconds = limit.type === "TIME_LIMIT" ? 30 * 86_400 : unitWindowSeconds(limit.unit, number);
+                        const label = limit.type === "TIME_LIMIT" ? "mcp-tools" : resolveWindowLabel(seconds);
+                        windows[label] = toUsageWindow({
+                            usedPercent: toNumber(limit.percentage),
+                            windowSeconds: seconds,
+                            resetAt: toTimestamp(limit.nextResetTime),
+                        });
+                    }
+                    else if (limit && limit.type === CREDIT_LIMIT_TYPE) {
+                        const usedPercent = toNumber(limit.percentage);
+                        const remaining = toNumber(limit.remaining);
+                        const allowance = toNumber(limit.usage);
+                        if (usedPercent === null && (remaining === null || allowance === null))
+                            continue;
+                        const seconds = unitWindowSeconds(limit.unit, number);
+                        windows[resolveWindowLabel(seconds)] = toUsageWindow({
+                            usedPercent: usedPercent ?? (allowance !== null && allowance > 0 && remaining !== null ? ((allowance - remaining) / allowance) * 100 : null),
+                            windowSeconds: seconds,
+                            resetAt: toTimestamp(limit.nextResetTime),
+                        });
+                    }
                 }
                 return { windows };
             });

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

@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { apiKeyProviders } from "./api-key";
+const originalAuthFile = process.env.OPENCODE_AUTH_FILE;
+const createdAuthDirs = [];
+test.before(() => {
+    const authDir = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-usage-auth-"));
+    createdAuthDirs.push(authDir);
+    fs.writeFileSync(path.join(authDir, "auth.json"), JSON.stringify({ "zai-coding-plan": { type: "api", key: "test-zai-key" }, "zhipuai-coding-plan": { type: "api", key: "test-zhipu-key" } }));
+    process.env.OPENCODE_AUTH_FILE = path.join(authDir, "auth.json");
+});
+test.after(() => {
+    if (originalAuthFile === undefined)
+        delete process.env.OPENCODE_AUTH_FILE;
+    else
+        process.env.OPENCODE_AUTH_FILE = originalAuthFile;
+    const tmpRoot = fs.realpathSync(os.tmpdir());
+    for (const dir of createdAuthDirs) {
+        // Containment guard: never recurse outside the temp root we created.
+        if (fs.realpathSync(path.dirname(dir)) === tmpRoot && path.basename(dir).startsWith("codenomad-usage-auth-")) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+});
+const CREDIT_RESET_AT = 1787849891189;
+const TOKENS_RESET_AT = 1787950772998;
+function respondWith(payload) {
+    return new Response(JSON.stringify(payload), { status: 200, headers: { "Content-Type": "application/json" } });
+}
+async function withFetchStub(payload, run) {
+    const original = globalThis.fetch;
+    let requestUrl;
+    globalThis.fetch = (async (input) => {
+        requestUrl = String(input);
+        return respondWith(payload);
+    });
+    try {
+        return { result: await run(), requestUrl };
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+}
+const zai = apiKeyProviders.find((provider) => provider.id === "zai-coding-plan");
+const zhipu = apiKeyProviders.find((provider) => provider.id === "zhipuai-coding-plan");
+test("parses credit-based limits into usage windows", async () => {
+    const { result } = await withFetchStub({
+        code: 200,
+        msg: "Operation successful",
+        success: true,
+        data: {
+            level: "lite",
+            limits: [
+                { type: "CREDIT_LIMIT", unit: 3, number: 5, usage: 2000, currentValue: 157, remaining: 1842, percentage: 7, nextResetTime: CREDIT_RESET_AT },
+                { type: "CREDIT_LIMIT", unit: 6, number: 1, usage: 10000, currentValue: 157, remaining: 9843, percentage: 1, nextResetTime: TOKENS_RESET_AT },
+            ],
+        },
+    }, () => zai.fetchQuota());
+    assert.equal(result.ok, true);
+    const windows = result.usage.windows;
+    assert.equal(windows["5h"]?.usedPercent, 7);
+    assert.equal(windows["5h"]?.windowSeconds, 18_000);
+    assert.equal(windows["5h"]?.resetAt, CREDIT_RESET_AT);
+    assert.equal(windows["weekly"]?.usedPercent, 1);
+    assert.equal(windows["weekly"]?.windowSeconds, 604_800);
+    assert.equal("valueLabel" in (windows["weekly"] ?? {}), false);
+});
+test("derives usedPercent when the credit payload omits percentage", async () => {
+    const { result } = await withFetchStub({
+        data: { limits: [{ type: "CREDIT_LIMIT", unit: 6, number: 1, usage: 2000, currentValue: 158, remaining: 1842, nextResetTime: CREDIT_RESET_AT }] },
+    }, () => zai.fetchQuota());
+    const window = result.usage.windows["weekly"];
+    // (2000 - 1842) / 2000
+    assert.ok(Math.abs((window?.usedPercent ?? 0) - 7.9) < 0.001);
+    assert.equal(window?.windowSeconds, 604_800);
+});
+test("coerces string quota fields and skips unusable or unknown entries without throwing", async () => {
+    const { result } = await withFetchStub({
+        data: {
+            limits: [
+                null,
+                { type: "UNKNOWN_LIMIT" },
+                { type: "PROMO_LIMIT", percentage: 55, remaining: 10, usage: 20 },
+                { type: "CREDIT_LIMIT", unit: 6, number: 1, usage: "10000", remaining: "9800", percentage: "2", nextResetTime: TOKENS_RESET_AT },
+            ],
+        },
+    }, () => zai.fetchQuota());
+    assert.equal(result.ok, true);
+    const windows = result.usage.windows;
+    assert.equal(Object.keys(windows).length, 1);
+    assert.equal(windows["weekly"]?.usedPercent, 2);
+});
+test("keeps legacy token and time windows intact for the bigmodel endpoint", async () => {
+    const { result, requestUrl } = await withFetchStub({
+        data: {
+            limits: [
+                { type: "TOKENS_LIMIT", unit: 3, number: 1, percentage: 42, nextResetTime: TOKENS_RESET_AT },
+                { type: "TIME_LIMIT", number: 1, percentage: 11 },
+            ],
+        },
+    }, () => zhipu.fetchQuota());
+    assert.equal(requestUrl, "https://open.bigmodel.cn/api/monitor/usage/quota/limit");
+    assert.equal(result.ok, true);
+    const windows = result.usage.windows;
+    assert.equal(windows["1h"]?.usedPercent, 42);
+    assert.equal(windows["mcp-tools"]?.usedPercent, 11);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuralnomads/codenomad-dev",
-  "version": "0.19.0-dev-20260827-14586cb3",
+  "version": "0.19.0-dev-20260829-56156827",
   "description": "CodeNomad Server",
   "license": "MIT",
   "author": {