glm-coding-router 1.1.2 → 2.1.0

package/dist/core/process.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { Errors } from "./errors.js";
+import { logger } from "./logging.js";
 /**
  * Spawn a child agent process (spec §18, §32, §39):
  * - argument array, never a shell string
@@ -64,6 +65,88 @@ export function spawnAgentCapture(binPath, options) {
         });
     });
 }
+/**
+ * Like spawnAgentCapture, but delivers every complete stdout/stderr line the
+ * moment it arrives (v2 spec Phase D) instead of buffering the whole output
+ * until exit — that buffering is exactly what makes live progress impossible.
+ * Same no-shell argv rule and signal forwarding. A chunk boundary can fall
+ * inside a JSON object, so each stream carries its own partial-line buffer;
+ * blank lines are dropped, and a trailing line without a newline is flushed
+ * before the promise resolves — a crashed agent's last line is still evidence.
+ * A throwing callback is reported at debug level and never kills the run.
+ */
+export function spawnAgentStream(binPath, options) {
+    const { args, cwd, env, onStdoutLine, onStderrLine, onSpawn } = options;
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            windowsHide: false,
+        });
+        if (onSpawn) {
+            try {
+                onSpawn(child);
+            }
+            catch (error) {
+                logger.debug(`spawnAgentStream: onSpawn callback failed: ${errorMessage(error)}`);
+            }
+        }
+        const stdout = createLineSplitter(onStdoutLine);
+        const stderr = createLineSplitter(onStderrLine);
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => stdout.push(chunk));
+        child.stderr?.on("data", (chunk) => stderr.push(chunk));
+        const handlers = forwardSignals(child);
+        child.on("error", (error) => {
+            removeSignals(handlers);
+            reject(Errors.childAgentFailed(errorMessage(error)));
+        });
+        // "close", not "exit": it fires once the stdio streams are drained, so the
+        // trailing-line flush below cannot race data still sitting in the pipe.
+        child.on("close", (code) => {
+            removeSignals(handlers);
+            stdout.flush();
+            stderr.flush();
+            resolve({ code: code ?? 1 });
+        });
+    });
+}
+/** Per-stream line buffer for spawnAgentStream: emits each complete line (\n or \r\n) as it arrives. */
+function createLineSplitter(deliver) {
+    let buffer = "";
+    const emit = (line) => {
+        if (line.length === 0)
+            return;
+        try {
+            deliver(line);
+        }
+        catch (error) {
+            logger.debug(`spawnAgentStream: line callback failed: ${errorMessage(error)}`);
+        }
+    };
+    return {
+        push(chunk) {
+            buffer += chunk;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                emit(line.endsWith("\r") ? line.slice(0, -1) : line);
+                newline = buffer.indexOf("\n");
+            }
+        },
+        flush() {
+            if (buffer.length > 0) {
+                const line = buffer;
+                buffer = "";
+                emit(line);
+            }
+        },
+    };
+}
 /** Install SIGINT/SIGTERM forwarding; returns the handlers for cleanup. */
 function forwardSignals(child) {
     const handlers = new Map();

package/dist/core/prompt.js

@@ -17,16 +17,29 @@ export function readStdin() {
 }
 /**
  * Resolve the task prompt (spec §15, §40):
- *   stdin text → joined arguments → error
+ *   arguments → stdin text → error
+ *
+ * Arguments are checked FIRST, and when they carry a prompt stdin is never
+ * awaited. The original order was stdin-first, which hangs forever whenever
+ * stdin is an open pipe that never reaches EOF — the normal shape under an
+ * agent harness, a CI runner or `nohup`. Measured on Windows: with stdin held
+ * open, `glm-worker "Reply exactly with X"` did nothing at all — no run
+ * directory, no API call, no output — until the pipe closed 25 s later, then
+ * completed in 7 s. A prompt in argv is an explicit instruction and must not
+ * wait on a stream that may never close.
+ *
+ * Piping a task packet still works exactly as before: with no arguments,
+ * blocking until EOF is the correct thing to do, because there is nothing
+ * else to run.
  */
 export async function resolvePrompt(argv, readStdinFn = readStdin, command = "glm-worker") {
-    const stdinText = await readStdinFn();
-    if (stdinText !== undefined && stdinText.trim().length > 0) {
-        return stdinText;
-    }
     const argText = argv.join(" ").trim();
     if (argText.length > 0) {
         return argText;
     }
+    const stdinText = await readStdinFn();
+    if (stdinText !== undefined && stdinText.trim().length > 0) {
+        return stdinText;
+    }
     throw Errors.promptRequired(command);
 }

package/dist/core/routing-flags.js

@@ -0,0 +1,59 @@
+import { Errors } from "./errors.js";
+/** The only two values `--model` takes; the router routes between config slots, not model names. */
+const MODEL_SLOTS = ["main", "fast"];
+/**
+ * Remove the router's Phase E flags from argv (specs/v2-architecture.md).
+ *
+ * Every occurrence is consumed, including repeats, because whatever is left in
+ * `rest` becomes the PROMPT — `resolvePrompt` joins it — so a flag that
+ * survives this function does not reach Claude as a flag, it silently becomes
+ * task text. That is why an unknown `--model` value is an error rather than a
+ * pass-through: quietly appending "--model gpt-4" to someone's prompt is worse
+ * than telling them the flag takes main or fast.
+ *
+ * Like `--profile` (specs/glm-fast-profiles.md), our `--model` deliberately
+ * shadows Claude Code's own flag of that name inside these binaries; callers
+ * who need Claude's version can call `claude` directly.
+ */
+export function extractRoutingFlags(argv) {
+    const rest = [];
+    let model;
+    let force = false;
+    let refreshQuota = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--refresh-quota") {
+            refreshQuota = true;
+            continue;
+        }
+        if (arg === "--model") {
+            // The first occurrence wins, but later ones are still consumed so they
+            // cannot leak into the prompt.
+            model ??= parseSlot(argv[i + 1]);
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            model ??= parseSlot(arg.slice("--model=".length));
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, model, force, refreshQuota };
+}
+function parseSlot(value) {
+    if (value === undefined || !MODEL_SLOTS.includes(value)) {
+        throw Errors.invalidArgs(`--model expects "main" or "fast"${value === undefined ? "" : `, got "${value}"`}.`, [
+            "Pick the configured slot, not a model name:",
+            "",
+            "  glm-worker --model fast \"<task>\"",
+            "",
+            "The names behind the slots come from models.main / models.fast in config.",
+        ]);
+    }
+    return value;
+}

package/dist/core/user-env.js

@@ -63,12 +63,17 @@ export function describeKeyStore(store) {
     }
 }
 /**
- * Read a variable from the per-user store. Returns undefined on any failure —
- * callers fall back or raise their own error.
+ * Read a variable from the per-user store, distinguishing "no store" / "not
+ * set" (readable: true, value: undefined) from "the read itself failed"
+ * (readable: false). `readUserEnv` below is a thin wrapper that collapses
+ * both to `undefined` for existing callers.
  */
-export function readUserEnv(name, deps = {}) {
+export function readUserEnvDiagnostic(name, deps = {}) {
     assertEnvVarName(name);
     const store = detectUserEnvStore(deps);
+    if (store === "none") {
+        return { readable: true, value: undefined };
+    }
     const run = deps.run ?? defaultRun;
     try {
         let value;
@@ -87,16 +92,21 @@ export function readUserEnv(name, deps = {}) {
             case "libsecret":
                 value = run("secret-tool", ["lookup", "service", KEY_STORE_SERVICE, "account", name], { capture: true });
                 break;
-            case "none":
-                return undefined;
         }
         const trimmed = value.trim();
-        return trimmed || undefined;
+        return { readable: true, value: trimmed || undefined };
     }
     catch {
-        return undefined;
+        return { readable: false, value: undefined };
     }
 }
+/**
+ * Read a variable from the per-user store. Returns undefined on any failure —
+ * callers fall back or raise their own error.
+ */
+export function readUserEnv(name, deps = {}) {
+    return readUserEnvDiagnostic(name, deps).value;
+}
 /**
  * Write a variable to the per-user store. Throws when there is no store —
  * callers print platform-appropriate guidance instead.

package/dist/core/zai-quota.js

@@ -0,0 +1,148 @@
+/**
+ * The Z.ai monitor endpoint lives in core because four readers need it —
+ * usage, dashboard, the MCP server and the Phase E budget manager — and a
+ * budget module must not import from a command module: commands sit on top
+ * of core, never underneath it.
+ */
+/** Z.ai monitor API used by their own dashboard (specs/usage.md). */
+export const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+/** Window labels for the observed enum values (specs/usage.md); unknown values stay generic. */
+export function describeWindow(limit) {
+    if (limit.unit === 3 && typeof limit.number === "number") {
+        return `${limit.number}-hour window`;
+    }
+    if (limit.unit === 6 && limit.number === 1) {
+        return "weekly";
+    }
+    return `window unit=${String(limit.unit)} x ${String(limit.number)}`;
+}
+/**
+ * Thrown by `fetchZaiQuota` instead of a plain `Error`. `message` is always a
+ * safe, locally-constructed string — it never contains the raw response body,
+ * a provider `msg`, headers, or a URL with credentials (spec §D "Security").
+ */
+export class ZaiQuotaError extends Error {
+    kind;
+    httpStatus;
+    /** Only meaningful when kind === "network": distinguishes a timeout from any other network failure. */
+    timeout;
+    constructor(kind, message, options = {}) {
+        super(message);
+        this.name = "ZaiQuotaError";
+        this.kind = kind;
+        this.httpStatus = options.httpStatus;
+        this.timeout = options.timeout ?? false;
+    }
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumberOrAbsent(value) {
+    return value === undefined || (typeof value === "number" && Number.isFinite(value));
+}
+/** Every quota field is optional, but any field that IS present must be well-typed. */
+function isValidLimit(entry) {
+    if (!isPlainObject(entry))
+        return false;
+    if (entry.type !== undefined && typeof entry.type !== "string")
+        return false;
+    return (isFiniteNumberOrAbsent(entry.unit) &&
+        isFiniteNumberOrAbsent(entry.number) &&
+        isFiniteNumberOrAbsent(entry.usage) &&
+        isFiniteNumberOrAbsent(entry.currentValue) &&
+        isFiniteNumberOrAbsent(entry.remaining) &&
+        isFiniteNumberOrAbsent(entry.percentage) &&
+        isFiniteNumberOrAbsent(entry.nextResetTime));
+}
+/**
+ * Validate the monitor response shape (spec §D "Success validation"). Empty
+ * `limits` is a valid, fully-authenticated response meaning "no windows
+ * reported" — never treated as zero quota. A missing or wrong-type `limits`
+ * field means the schema did not match, which is unverified, not rejected.
+ */
+function parseQuotaBody(body) {
+    if (!isPlainObject(body)) {
+        return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint returned an unexpected response shape." };
+    }
+    if (typeof body.code !== "number") {
+        return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint response is missing a status code." };
+    }
+    if (body.code !== 200) {
+        return { ok: false, kind: "provider", message: `Z.ai monitor endpoint rejected the request (code ${body.code}).` };
+    }
+    if (body.success !== undefined && body.success !== true) {
+        return { ok: false, kind: "provider", message: "Z.ai monitor endpoint reported an unsuccessful request." };
+    }
+    if (!isPlainObject(body.data)) {
+        return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint response is missing usage data." };
+    }
+    const data = body.data;
+    if (data.level !== undefined && typeof data.level !== "string") {
+        return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint response has an invalid level field." };
+    }
+    if (!Array.isArray(data.limits)) {
+        return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint response is missing usage limits." };
+    }
+    for (const entry of data.limits) {
+        if (!isValidLimit(entry)) {
+            return { ok: false, kind: "invalid-response", message: "Z.ai monitor endpoint response contains a malformed limit entry." };
+        }
+    }
+    return {
+        ok: true,
+        data: { level: data.level, limits: data.limits },
+    };
+}
+/**
+ * Fetch and validate the Z.ai quota snapshot. Never logs the Authorization
+ * header. Throws `ZaiQuotaError` on any failure — callers branch on `.kind`.
+ * `redirect: "error"` refuses to forward the bearer token to a redirect
+ * target (spec §D "Security").
+ */
+export async function fetchZaiQuota(key, fetchImpl) {
+    let response;
+    try {
+        response = await fetchImpl(ZAI_QUOTA_URL, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            signal: AbortSignal.timeout(10_000),
+            redirect: "error",
+        });
+    }
+    catch (error) {
+        const isTimeout = error instanceof Error && error.name === "TimeoutError";
+        throw new ZaiQuotaError("network", isTimeout ? "Z.ai monitor endpoint timed out." : "Z.ai monitor endpoint was unreachable.", { timeout: isTimeout });
+    }
+    if (response.status === 401) {
+        throw new ZaiQuotaError("unauthorized", "Z.ai monitor endpoint rejected the key (HTTP 401).", {
+            httpStatus: 401,
+        });
+    }
+    if (response.status === 403) {
+        throw new ZaiQuotaError("forbidden", "Z.ai monitor endpoint denied access (HTTP 403).", {
+            httpStatus: 403,
+        });
+    }
+    if (response.status === 429) {
+        throw new ZaiQuotaError("rate-limited", "Z.ai monitor endpoint is rate-limiting this key (HTTP 429).", {
+            httpStatus: 429,
+        });
+    }
+    if (!response.ok) {
+        throw new ZaiQuotaError("http", `Z.ai monitor endpoint returned HTTP ${response.status}.`, {
+            httpStatus: response.status,
+        });
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        throw new ZaiQuotaError("invalid-response", "Z.ai monitor endpoint returned a non-JSON body.");
+    }
+    const parsed = parseQuotaBody(body);
+    if (!parsed.ok) {
+        throw new ZaiQuotaError(parsed.kind, parsed.message);
+    }
+    return parsed.data;
+}

package/dist/events/bus.js

@@ -0,0 +1,64 @@
+import { logger } from "../core/logging.js";
+/**
+ * Not a `createEventBus` parameter: v2 has exactly one provider, and a
+ * parameter would invite a wrong value into the persisted history (H2).
+ */
+const PROVIDER = "zai.zcode";
+/**
+ * Build a bus for one run. `taskId` defaults to the `runId` while there is no
+ * task graph (hedge H1); `role` defaults to `"worker"`. `deps.now` exists so
+ * tests can pin `ts` deterministically; production omits it and gets the real
+ * clock.
+ */
+export function createEventBus(runId, deps) {
+    const taskId = deps?.taskId ?? runId;
+    const role = deps?.role ?? "worker";
+    const now = deps?.now;
+    const listeners = new Set();
+    let seq = 0;
+    let closed = false;
+    return {
+        runId,
+        taskId,
+        emit(event) {
+            const stamped = {
+                ...event,
+                runId,
+                taskId,
+                provider: PROVIDER,
+                role,
+                seq: ++seq,
+                ts: (now?.() ?? new Date()).toISOString(),
+            };
+            if (!closed) {
+                for (const listener of listeners) {
+                    try {
+                        listener(stamped);
+                    }
+                    catch (error) {
+                        // A broken renderer must never kill a run (specs/v2-architecture.md,
+                        // Phase A): swallow, keep dispatching, leave a debug trace.
+                        logger.debug(`event subscriber threw on ${stamped.type} seq ${stamped.seq}: ${errorMessage(error)}`);
+                    }
+                }
+            }
+            return stamped;
+        },
+        subscribe(listener) {
+            if (closed) {
+                return () => { };
+            }
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        close() {
+            closed = true;
+            listeners.clear();
+        },
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}