glm-coding-router 1.1.2 → 2.1.0

package/dist/commands/doctor-command.js

@@ -1,36 +1,13 @@
 import { runDoctorChecks, doctorHasFailures } from "./doctor.js";
 import { emitJson } from "./context.js";
 import { logger } from "../core/logging.js";
-const SYMBOL = {
-    ok: "✓",
-    warn: "⚠",
-    fail: "✗",
-};
-function renderText(results, networkResult) {
-    const lines = ["GLM Coding Router Doctor", ""];
-    let currentSection = "";
-    for (const result of results) {
-        if (result.section !== currentSection) {
-            currentSection = result.section;
-            lines.push(currentSection);
-        }
-        lines.push(`  ${SYMBOL[result.status]} ${result.name}`);
-        if (result.detail) {
-            lines.push(`      ${result.detail}`);
-        }
-        if (result.note) {
-            lines.push(`      ${result.note}`);
-        }
-    }
-    if (networkResult) {
-        lines.push("Network");
-        lines.push(`  ${networkResult === "reachable" ? "✓" : "⚠"} Z.ai endpoint ${networkResult}`);
-    }
-    const failures = doctorHasFailures(results);
-    lines.push("");
-    lines.push(`Status: ${failures ? "ISSUES DETECTED" : "HEALTHY"}`);
-    return lines.join("\n");
-}
+import { Errors } from "../core/errors.js";
+import { inspectZaiKey } from "../core/key-inspector.js";
+import { authenticateZaiKey, authenticationCheckStatus, deriveDoctorVerdict, } from "./doctor-auth.js";
+import { describeKeyStore, detectUserEnvStore } from "../core/user-env.js";
+import { createWriter } from "../tui/render.js";
+import { createCommandUi } from "../tui/command-ui.js";
+import { version } from "../core/version.js";
 /** Lightweight endpoint reachability probe (spec §42). Never consumes coding quota. */
 export async function probeEndpoint(baseUrl, fetchImpl = fetch) {
     try {
@@ -45,24 +22,177 @@ export async function probeEndpoint(baseUrl, fetchImpl = fetch) {
         return "not reachable";
     }
 }
+function shellUnsetLines(platform) {
+    if (platform === "win32") {
+        return ["PowerShell:  Remove-Item Env:ZAI_API_KEY", "CMD:         set ZAI_API_KEY="];
+    }
+    return ["POSIX shell: unset ZAI_API_KEY"];
+}
+function describeComparisonRow(inspection) {
+    switch (inspection.comparison) {
+        case "match":
+            return { status: "ok", value: "Matches the saved key" };
+        case "different":
+            return { status: "warn", value: "Different from the saved key" };
+        case "unavailable":
+            return { status: "warn", value: `Could not read ${describeKeyStore(inspection.store)} to compare` };
+        case "not-comparable":
+            if (inspection.store === "none") {
+                return { status: "info", value: "No persistent store on this platform" };
+            }
+            if (inspection.effectiveSource === "process-env") {
+                return { status: "info", value: "No saved key to compare against" };
+            }
+            if (inspection.effectiveSource === "user-store") {
+                return { status: "info", value: "No process override" };
+            }
+            return { status: "info", value: "Not applicable" };
+    }
+}
+/** Ordered, actionable "next step" lines. Empty when the verdict is HEALTHY. */
+function buildNextSteps(input) {
+    const { authentication, comparison, store, platform, networkProbeFailed, verdictStatus } = input;
+    if (verdictStatus === "HEALTHY") {
+        return [];
+    }
+    const lines = [];
+    if (comparison === "different") {
+        lines.push("This terminal's key takes priority over the saved key (process environment wins).", "Restart the terminal's hosting app to refresh its environment,", "or if this is an intentional process override, update that override instead.", ...shellUnsetLines(platform));
+    }
+    else if (comparison === "unavailable") {
+        lines.push(`Could not read ${describeKeyStore(store)} to compare against the process key.`);
+    }
+    switch (authentication.reason) {
+        case "missing-key":
+            lines.push("No ZAI_API_KEY was found.", platform === "win32" ? "Run: glm-router key set" : 'Run: glm-router key set, or export ZAI_API_KEY="<your-key>"');
+            break;
+        case "http-401":
+            lines.push("The selected key was rejected. To replace it: glm-router key set");
+            break;
+        case "http-403":
+            lines.push("Access was denied for the selected key. Check the key's account permissions — not necessarily expiry.");
+            break;
+        case "rate-limited":
+            lines.push("The Z.ai monitor endpoint is rate-limiting this key. Retry in a moment.");
+            break;
+        case "http-error":
+        case "network-error":
+        case "timeout":
+            lines.push("Could not reach the Z.ai monitor endpoint. Check network/proxy connectivity and retry.");
+            break;
+        case "invalid-response":
+        case "provider-error":
+            lines.push("The Z.ai monitor endpoint returned an unexpected response — this is not proof the key is invalid.");
+            break;
+        case "offline":
+            lines.push("Authentication was not checked (--offline). Run without --offline to verify the key online.");
+            break;
+        case "accepted":
+            break;
+    }
+    if (networkProbeFailed) {
+        lines.push("The configured Anthropic endpoint reachability probe did not succeed (separate from key authentication).");
+    }
+    if (lines.length > 0 && authentication.reason !== "offline") {
+        lines.push("Then run: glm-router doctor");
+    }
+    return lines;
+}
 export async function doctorCommand(options, deps = {}) {
-    const report = runDoctorChecks({ home: deps.home, env: deps.env, readUserEnv: deps.readUserEnv });
+    if (options.offline && options.network) {
+        throw Errors.invalidArgs("--offline and --network cannot be used together.", [
+            "Use --offline for local-only checks, or --network for the extra reachability probe.",
+        ]);
+    }
+    const env = deps.env ?? process.env;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const offline = options.offline ?? false;
+    const platform = deps.platform ?? process.platform;
+    const store = deps.store ?? detectUserEnvStore({ platform, env });
+    const report = runDoctorChecks({ home: deps.home, env, readUserEnv: deps.readUserEnv, store });
+    const inspection = inspectZaiKey({ env, readUserEnvDiagnostic: deps.readUserEnvDiagnostic, store });
+    const [authentication, networkResult] = await Promise.all([
+        authenticateZaiKey(inspection.effectiveKey, fetchImpl, offline),
+        options.network ? probeEndpoint(report.config.provider.anthropicBaseUrl, fetchImpl) : Promise.resolve(undefined),
+    ]);
+    const localFailure = doctorHasFailures(report.results);
+    const networkProbeFailed = networkResult !== undefined && networkResult !== "reachable";
+    const verdict = deriveDoctorVerdict({
+        localFailure,
+        authentication,
+        keyComparison: inspection.comparison,
+        offline,
+        networkProbeFailed,
+    });
     if (options.json) {
-        const networkResult = options.network
-            ? await probeEndpoint(report.config.provider.anthropicBaseUrl, deps.fetchImpl)
-            : undefined;
         emitJson({
-            status: doctorHasFailures(report.results) ? "ISSUES" : "HEALTHY",
+            status: verdict.status,
             checks: report.results,
             keySource: report.keySource,
             network: networkResult,
+            authentication,
+            keyComparison: inspection.comparison,
+            keyMismatch: inspection.keyMismatch,
         });
-        return doctorHasFailures(report.results) ? 1 : 0;
+        return verdict.exitCode;
     }
-    const networkResult = options.network
-        ? await probeEndpoint(report.config.provider.anthropicBaseUrl, deps.fetchImpl)
-        : undefined;
-    process.stdout.write(renderText(report.results, networkResult) + "\n");
+    const stream = deps.stdout ?? process.stdout;
+    const writer = createWriter(stream);
+    const ui = createCommandUi(writer, { quiet: options.quiet });
+    writer.line(renderText(ui, report.results, inspection, authentication, networkResult, verdict, platform));
     logger.debug(`anthropic base url: ${report.config.provider.anthropicBaseUrl}`);
-    return doctorHasFailures(report.results) ? 1 : 0;
+    return verdict.exitCode;
+}
+function renderText(ui, results, inspection, authentication, networkResult, verdict, platform) {
+    const blocks = [];
+    const header = ui.header(`GLM CODING ROUTER  v${version}  /  DOCTOR`, "Runtime and credential diagnostics");
+    if (header)
+        blocks.push(header);
+    let currentSection = "";
+    const localRows = [];
+    for (const result of results) {
+        if (result.section !== currentSection) {
+            currentSection = result.section;
+            localRows.push(ui.section(currentSection.toUpperCase()));
+        }
+        const status = result.status === "ok" ? "ok" : result.status === "warn" ? "warn" : "fail";
+        localRows.push(ui.row(result.name, result.detail ?? "", status));
+        if (result.note)
+            localRows.push(ui.detail(result.note));
+    }
+    blocks.push(localRows.join("\n"));
+    const credentialRows = [ui.section("CREDENTIALS")];
+    credentialRows.push(ui.row("Selected source", inspection.effectiveSource === "process-env" ? "Process environment" : inspection.effectiveSource === "user-store" ? describeKeyStore(inspection.store) : "none", "info"));
+    const comparisonRow = describeComparisonRow(inspection);
+    credentialRows.push(ui.row("Saved key comparison", comparisonRow.value, comparisonRow.status));
+    credentialRows.push(ui.row("Monitor authentication", authentication.detail, authenticationCheckStatus(authentication.state)));
+    blocks.push(credentialRows.join("\n"));
+    if (networkResult !== undefined) {
+        const networkRows = [
+            ui.section("NETWORK"),
+            ui.row("Z.ai endpoint reachability", networkResult, networkResult === "reachable" ? "ok" : "warn"),
+        ];
+        blocks.push(networkRows.join("\n"));
+    }
+    const nextSteps = buildNextSteps({
+        authentication,
+        comparison: inspection.comparison,
+        store: inspection.store,
+        platform,
+        networkProbeFailed: networkResult !== undefined && networkResult !== "reachable",
+        verdictStatus: verdict.status,
+    });
+    if (nextSteps.length > 0) {
+        const footer = ui.footer(nextSteps.join("\n"));
+        if (footer)
+            blocks.push([ui.section("NEXT STEP"), footer].join("\n"));
+    }
+    const resultLabel = {
+        HEALTHY: "HEALTHY",
+        ATTENTION: "ATTENTION",
+        UNVERIFIED: "UNVERIFIED",
+        ISSUES: "ISSUES DETECTED",
+    };
+    blocks.push(`RESULT  ${resultLabel[verdict.status]}`);
+    return blocks.join("\n\n");
 }

package/dist/commands/landing.js

@@ -0,0 +1,47 @@
+/**
+ * `glm-router` with no subcommand (specs/terminal-ui-doctor.md §B.1). Purely
+ * static: no provider request, no key/config read, no side effects. Exists
+ * so a first-time user sees "what do I run" instead of nothing.
+ */
+import { Errors } from "../core/errors.js";
+import { version } from "../core/version.js";
+import { createCommandUi } from "../tui/command-ui.js";
+import { createWriter } from "../tui/render.js";
+export function landingCommand(options, deps = {}) {
+    if (options.json) {
+        // Root --json has no data to emit — a data-producing command must be named.
+        throw Errors.invalidArgs("--json requires a command that produces data.", [
+            "Try:", "", "  glm-router status --json", "  glm-router doctor --json", "  glm-router usage --json",
+        ]);
+    }
+    const stream = deps.stdout ?? process.stdout;
+    const writer = createWriter(stream);
+    const ui = createCommandUi(writer, { quiet: options.quiet });
+    const blocks = [];
+    const header = ui.header(`GLM CODING ROUTER  v${version}`, "Coding Plan workers for Claude Code and Codex");
+    if (header)
+        blocks.push(header);
+    blocks.push([
+        ui.section("CHECK & MONITOR"),
+        ui.row("glm-router doctor", "Check setup and verify API key"),
+        ui.row("glm-router status", "Quick offline overview"),
+        ui.row("glm-router usage", "Coding Plan quota and reset times"),
+        ui.row("glm-router dashboard", "Live quota and worker activity"),
+    ].join("\n"));
+    blocks.push([
+        ui.section("WORK"),
+        ui.row('glm-worker "<task>"', "Run an implementation task"),
+        ui.row('glm-review "<task>"', "Run a read-only review"),
+        ui.row("glm-router runs", "Inspect recorded runs"),
+    ].join("\n"));
+    blocks.push([
+        ui.section("SETUP"),
+        ui.row("glm-router init", "Guided setup"),
+        ui.row("glm-router key set", "Save a replacement API key"),
+    ].join("\n"));
+    const footer = ui.footer("Start with: glm-router doctor\nAll commands: glm-router --help");
+    if (footer)
+        blocks.push(footer);
+    writer.line(blocks.join("\n\n"));
+    return 0;
+}