@cjhyy/code-shell-capability-coding 0.9.5 → 0.9.7

package/dist/external-runtimes/codex/app-server-client.d.ts

@@ -61,6 +61,6 @@ export declare class CodexAppServerClient {
     private write;
     private failAll;
     get isClosed(): boolean;
-    /** Graceful stop: stdin EOF (the Rust app-server exits on it), SIGTERM after. */
+    /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
     close(): Promise<void>;
 }

package/dist/external-runtimes/codex/app-server-client.js

@@ -219,12 +219,14 @@ export class CodexAppServerClient {
     get isClosed() {
         return this.closed;
     }
-    /** Graceful stop: stdin EOF (the Rust app-server exits on it), SIGTERM after. */
+    /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
     async close() {
         const child = this.child;
         this.failAll("app-server client closed");
         this.lines?.close();
-        if (!child)
+        // Failed spawns have no pid and never emit `exit`. A process already killed
+        // by a signal likewise has no numeric exitCode and will not emit it again.
+        if (!child || !child.pid || child.exitCode !== null || child.signalCode !== null)
             return;
         try {
             child.stdin.end();
@@ -237,8 +239,20 @@ export class CodexAppServerClient {
                 return resolve();
             child.once("exit", () => resolve());
         });
-        const timer = setTimeout(() => child.kill("SIGTERM"), 2_000);
-        await exited;
-        clearTimeout(timer);
+        let killTimer;
+        const terminateTimer = setTimeout(() => {
+            child.kill("SIGTERM");
+            // Cleanup must finish even when an unresponsive server ignores SIGTERM.
+            // Keep awaiting its actual exit so callers never leave an orphan behind.
+            killTimer = setTimeout(() => child.kill("SIGKILL"), 500);
+        }, 2_000);
+        try {
+            await exited;
+        }
+        finally {
+            clearTimeout(terminateTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+        }
     }
 }

package/dist/external-runtimes/codex/model-discovery.d.ts

@@ -0,0 +1,14 @@
+import { type AppServerClientOptions } from "./app-server-client.js";
+export interface CodexDiscoveredModel {
+    model: string;
+    displayName: string;
+    isDefault: boolean;
+}
+/**
+ * Read the installed Codex CLI's available models without starting a thread or
+ * turn. The deadline covers initialization and every page together. Callers own
+ * caching and fallback policy; a valid empty catalog is distinct from failure.
+ */
+export declare function discoverCodexModels(options?: AppServerClientOptions & {
+    timeoutMs?: number;
+}): Promise<CodexDiscoveredModel[]>;

package/dist/external-runtimes/codex/model-discovery.js

@@ -0,0 +1,76 @@
+import { CodexAppServerClient } from "./app-server-client.js";
+import { buildRuntimeSpawnEnv } from "../shared/spawn-env.js";
+const DEFAULT_TIMEOUT_MS = 8_000;
+const MAX_PAGES = 100;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonemptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/**
+ * Read the installed Codex CLI's available models without starting a thread or
+ * turn. The deadline covers initialization and every page together. Callers own
+ * caching and fallback policy; a valid empty catalog is distinct from failure.
+ */
+export async function discoverCodexModels(options = {}) {
+    const { timeoutMs = DEFAULT_TIMEOUT_MS, ...clientOptions } = options;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("Codex model discovery requires a positive timeout");
+    }
+    const deadline = performance.now() + timeoutMs;
+    const remainingMs = () => {
+        const remaining = deadline - performance.now();
+        if (remaining <= 0)
+            throw new Error("Codex model discovery timed out");
+        return Math.ceil(remaining);
+    };
+    const client = new CodexAppServerClient({
+        ...clientOptions,
+        env: buildRuntimeSpawnEnv({ base: options.env }),
+    });
+    client.onNotification(() => { });
+    client.onServerRequest(() => undefined);
+    try {
+        client.start();
+        await client.request("initialize", { clientInfo: { name: "codeshell", title: "CodeShell", version: "1" } }, remainingMs());
+        client.notify("initialized");
+        const models = new Map();
+        const cursors = new Set();
+        let cursor;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const result = await client.request("model/list", { includeHidden: false, limit: 100, ...(cursor ? { cursor } : {}) }, remainingMs());
+            if (!isRecord(result) || !Array.isArray(result.data)) {
+                throw new Error("Invalid Codex model/list response");
+            }
+            for (const entry of result.data) {
+                if (!isRecord(entry) ||
+                    !nonemptyString(entry.model) ||
+                    !nonemptyString(entry.displayName) ||
+                    (entry.isDefault !== undefined && typeof entry.isDefault !== "boolean") ||
+                    (entry.hidden !== undefined && typeof entry.hidden !== "boolean")) {
+                    throw new Error("Invalid Codex model/list entry");
+                }
+                if (entry.hidden === true || models.has(entry.model))
+                    continue;
+                models.set(entry.model, {
+                    model: entry.model,
+                    displayName: entry.displayName,
+                    isDefault: entry.isDefault === true,
+                });
+            }
+            if (result.nextCursor === null || result.nextCursor === undefined) {
+                return [...models.values()];
+            }
+            if (!nonemptyString(result.nextCursor) || cursors.has(result.nextCursor)) {
+                throw new Error("Invalid Codex model/list pagination cursor");
+            }
+            cursor = result.nextCursor;
+            cursors.add(cursor);
+        }
+        throw new Error("Codex model/list exceeded the pagination limit");
+    }
+    finally {
+        await client.close();
+    }
+}

package/dist/external-runtimes/index.d.ts

@@ -25,6 +25,8 @@ export type { ExternalRuntimeAttachment, ExternalRuntimeTurnInput } from "./turn
 export { CodexEventTranslator } from "./codex/event-translator.js";
 export { CodexAppServerClient } from "./codex/app-server-client.js";
 export type { AppServerClientOptions } from "./codex/app-server-client.js";
+export { discoverCodexModels } from "./codex/model-discovery.js";
+export type { CodexDiscoveredModel } from "./codex/model-discovery.js";
 export { CodexRuntime } from "./codex/runtime.js";
 export type { CodexRuntimeOptions, CodexRuntimeHooks, CodexTurnHandle, NativeApprovalDecision, } from "./codex/runtime.js";
 export { buildClaudeMcpConfig, claudeAllowedToolNames, claudeBridgeArgs, CLAUDE_MCP_SERVER_NAME, } from "./claude-code/mcp-config.js";

package/dist/external-runtimes/index.js

@@ -20,6 +20,7 @@ export { buildRuntimeSpawnEnv } from "./shared/spawn-env.js";
 export { textWithAttachmentReferences } from "./turn-input.js";
 export { CodexEventTranslator } from "./codex/event-translator.js";
 export { CodexAppServerClient } from "./codex/app-server-client.js";
+export { discoverCodexModels } from "./codex/model-discovery.js";
 export { CodexRuntime } from "./codex/runtime.js";
 export { buildClaudeMcpConfig, claudeAllowedToolNames, claudeBridgeArgs, CLAUDE_MCP_SERVER_NAME, } from "./claude-code/mcp-config.js";
 export { writeClaudeMcpConfigFile } from "./claude-code/mcp-config.js";

package/dist/quota/index.d.ts

@@ -6,14 +6,16 @@
  *            rate_limit.{primary_window,secondary_window}.{used_percent,reset_at}.
  *            Zero cost (no message sent).
  *   - Claude: POST /v1/messages (max_tokens:1) → response headers
- *            anthropic-ratelimit-unified-{5h,7d}-{utilization,reset}.
- *            Costs ~1 output token (Claude exposes quota only via response
- *            headers — there is no standalone usage endpoint).
+ *            anthropic-ratelimit-unified-<window>-{utilization,reset}, where
+ *            <window> is discovered from the headers (5h / 7d / overage / …)
+ *            rather than assumed — see parseClaudeWindows (re-verified
+ *            2026-09-06). Costs ~1 output token (Claude exposes quota only via
+ *            response headers — there is no standalone usage endpoint).
  *
  * The `fetch` and credentials are injected so this is unit-testable offline and
  * so the host owns secret resolution (see types.ts boundary note).
  */
-import type { ProviderQuota, QuotaCredentials, QuotaResult } from "./types.js";
+import type { ProviderQuota, QuotaCredentials, QuotaResult, QuotaWindow } from "./types.js";
 type FetchLike = typeof fetch;
 export interface CheckQuotaOptions {
     creds: QuotaCredentials;
@@ -29,6 +31,20 @@ export interface CheckQuotaOptions {
 export declare function queryCodexQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
 /** Claude: POST a 1-token probe and read the unified rate-limit headers. */
 export declare function queryClaudeQuota(creds: QuotaCredentials, fetchImpl: FetchLike, signal: AbortSignal): Promise<ProviderQuota>;
+/**
+ * Discover every rate-limit window from the unified headers.
+ *
+ * Windows are found by PREFIX, not from a hardcoded list, because which ones
+ * the API sends depends on the account. A normal subscription reports 5h + 7d;
+ * an account on overage reports `overage` and omits 5h/7d entirely. Matching a
+ * fixed list is what silently broke this lookup before (see types.ts).
+ *
+ * Each window contributes `<prefix><name>-utilization` (0–1) and an optional
+ * `<prefix><name>-reset` (epoch seconds). Bare `<prefix>reset` / `<prefix>status`
+ * are envelope fields, not windows, so anything without a `-utilization` suffix
+ * is skipped.
+ */
+export declare function parseClaudeWindows(h: Headers): QuotaWindow[];
 /** Query both providers (or the subset requested), concurrently. */
 export declare function checkQuota(opts: CheckQuotaOptions): Promise<QuotaResult>;
 /** Render a QuotaResult as a compact human/agent-readable summary. */

package/dist/quota/index.js

@@ -101,21 +101,68 @@ export async function queryClaudeQuota(creds, fetchImpl, signal) {
             error: `HTTP ${resp.status}${resp.status === 401 ? " (token 可能已过期)" : ""}`,
         };
     }
-    const h = resp.headers;
+    const windows = parseClaudeWindows(resp.headers);
+    if (windows.length === 0)
+        return { provider: "claude", error: "响应头无 rate-limit 字段" };
+    return { provider: "claude", windows };
+}
+const UNIFIED_PREFIX = "anthropic-ratelimit-unified-";
+/**
+ * Map `representative-claim` values onto the window names used in the headers.
+ * The claim spells a window out ("five_hour"); the window headers abbreviate it
+ * ("5h"). An unlisted claim value falls through to an exact `kind` match, which
+ * is how "overage" already lines up.
+ */
+const CLAIM_TO_KIND = {
+    five_hour: "5h",
+    seven_day: "7d",
+    seven_day_sonnet: "7d_sonnet",
+};
+/**
+ * Discover every rate-limit window from the unified headers.
+ *
+ * Windows are found by PREFIX, not from a hardcoded list, because which ones
+ * the API sends depends on the account. A normal subscription reports 5h + 7d;
+ * an account on overage reports `overage` and omits 5h/7d entirely. Matching a
+ * fixed list is what silently broke this lookup before (see types.ts).
+ *
+ * Each window contributes `<prefix><name>-utilization` (0–1) and an optional
+ * `<prefix><name>-reset` (epoch seconds). Bare `<prefix>reset` / `<prefix>status`
+ * are envelope fields, not windows, so anything without a `-utilization` suffix
+ * is skipped.
+ */
+export function parseClaudeWindows(h) {
     const windows = [];
-    const map = [
-        ["anthropic-ratelimit-unified-5h-utilization", "anthropic-ratelimit-unified-5h-reset", "5h"],
-        ["anthropic-ratelimit-unified-7d-utilization", "anthropic-ratelimit-unified-7d-reset", "7d"],
-    ];
-    for (const [utilKey, resetKey, kind] of map) {
-        const util = num(h.get(utilKey)); // 0–1
+    for (const [rawKey, rawVal] of h.entries()) {
+        const key = rawKey.toLowerCase();
+        if (!key.startsWith(UNIFIED_PREFIX) || !key.endsWith("-utilization"))
+            continue;
+        const kind = key.slice(UNIFIED_PREFIX.length, -"-utilization".length);
+        if (!kind)
+            continue; // guard a bare `<prefix>utilization`
+        const util = num(rawVal); // 0–1
         if (util == null)
             continue;
-        windows.push({ kind, usedPercent: util * 100, resetsAt: num(h.get(resetKey)) });
+        windows.push({
+            // Round to 4dp: `0.07 * 100` is 7.000000000000001 in binary float, which
+            // leaks into equality checks and any raw (unformatted) display.
+            kind,
+            usedPercent: Math.round(util * 100 * 1e4) / 1e4,
+            resetsAt: num(h.get(`${UNIFIED_PREFIX}${kind}-reset`)),
+        });
     }
-    if (windows.length === 0)
-        return { provider: "claude", error: "响应头无 rate-limit 字段" };
-    return { provider: "claude", windows };
+    // Stable order so output does not shuffle between identical probes.
+    windows.sort((a, b) => a.kind.localeCompare(b.kind));
+    // Flag the binding window. A request is throttled on this one, so it is what
+    // an orchestrator should plan against when windows disagree.
+    const claim = h.get(`${UNIFIED_PREFIX}representative-claim`)?.trim().toLowerCase();
+    if (claim) {
+        const want = CLAIM_TO_KIND[claim] ?? claim;
+        const hit = windows.find((w) => w.kind === want);
+        if (hit)
+            hit.representative = true;
+    }
+    return windows;
 }
 /** Query both providers (or the subset requested), concurrently. */
 export async function checkQuota(opts) {
@@ -145,17 +192,28 @@ export function formatQuota(result, nowSec) {
         const plan = pq.planType ? ` [${pq.planType}]` : "";
         const parts = pq.windows.map((w) => {
             const reset = w.resetsAt != null ? ` (重置 ${formatReset(w.resetsAt - nowSec)})` : "";
-            return `${w.kind} 用了 ${w.usedPercent.toFixed(0)}%${reset}`;
+            // Star the binding window so a reader/agent knows which one throttles.
+            const star = w.representative ? "*" : "";
+            return `${w.kind}${star} 用了 ${w.usedPercent.toFixed(0)}%${reset}`;
         });
         lines.push(`${name}${plan}: ${parts.join("，")}`);
     }
     return lines.length ? lines.join("\n") : "(无可用额度信息)";
 }
-/** "2h13m" / "45m" / "已重置" from a seconds delta. */
+/**
+ * "3d2h" / "2h13m" / "45m" / "已重置" from a seconds delta.
+ *
+ * The day unit matters: this only ever had to render 5h/7d windows, but an
+ * overage window can reset weeks out, and "606h0m 后" is not a readable way to
+ * say 25 days.
+ */
 function formatReset(deltaSec) {
     if (deltaSec <= 0)
         return "已重置";
-    const h = Math.floor(deltaSec / 3600);
+    const d = Math.floor(deltaSec / 86400);
+    const h = Math.floor((deltaSec % 86400) / 3600);
     const m = Math.floor((deltaSec % 3600) / 60);
+    if (d > 0)
+        return `${d}d${h}h 后`;
     return h > 0 ? `${h}h${m}m 后` : `${m}m 后`;
 }

package/dist/quota/types.d.ts

@@ -10,14 +10,30 @@
  * it from the rest of core. Nothing outside this module should know about
  * Keychain / wham endpoints / `anthropic-ratelimit-*` header names.
  */
-/** A single rolling limit window (e.g. the 5-hour or 7-day window). */
+/**
+ * A single rolling limit window.
+ *
+ * `kind` is NOT a closed set. Claude reports whichever windows apply to the
+ * account: usually "5h" and "7d", but an account running on overage reports an
+ * "overage" window INSTEAD of those (verified 2026-09-06 against a team /
+ * default_claude_max_5x account). New window names appear without notice, so
+ * the parser discovers them from the header prefix rather than matching a
+ * hardcoded list. Renderers must treat `kind` as an opaque label.
+ */
 export interface QuotaWindow {
-    /** Which window this is. */
-    kind: "5h" | "7d";
+    /** Which window this is: "5h" | "7d" | "overage" | any future name. */
+    kind: string;
     /** Percent of the window's limit already used, 0–100. */
     usedPercent: number;
     /** Unix epoch seconds when this window resets, or null if unknown. */
     resetsAt: number | null;
+    /**
+     * True for the window the API named as the binding constraint via
+     * `anthropic-ratelimit-unified-representative-claim`. Claude only; a request
+     * is throttled on THIS window, so it is the one to act on when several
+     * windows disagree.
+     */
+    representative?: boolean;
 }
 /** Quota for one provider (claude | codex). */
 export interface ProviderQuota {

package/dist/tools/check-quota.js

@@ -3,9 +3,11 @@ import { resolveQuotaCredentials } from "../quota/credentials.js";
 export const checkQuotaToolDef = {
     name: "CheckQuota",
     description: "Check remaining usage/rate-limit quota for the external coding-agent CLIs (Claude Code and/or " +
-        "Codex) — the same 5h/7d subscription windows their status lines show. Use before or during " +
+        "Codex) — the same subscription windows their status lines show. Use before or during " +
         "orchestration (DriveAgent) to plan how much work to hand off, whether to wait for a reset, or " +
-        "which provider to use. Returns each provider's 5h/7d used-% and reset time. " +
+        "which provider to use. Returns each window's used-% and reset time. Codex reports 5h/7d; " +
+        "Claude reports whichever windows apply to the account (5h/7d normally, 'overage' when the " +
+        "account is running on overage), and marks the currently binding window with '*'. " +
         "COST: 'codex' is free (reads a usage endpoint). 'claude' costs ~1 token (Anthropic exposes " +
         "quota only via a response header, so this sends a 1-token probe). Pass `provider` to query " +
         "just one and avoid the other's cost/latency.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.5"
+    "@cjhyy/code-shell-core": "0.9.7"
   },
   "engines": {
     "node": ">=20.10"