glm-coding-router 0.5.0 → 1.1.0

package/dist/core/errors.js

@@ -1,3 +1,15 @@
+/*
+ * This module deliberately does NOT import platform.ts: platform.ts imports
+ * Errors, so the dependency would be circular. The couple of platform checks
+ * below read process.platform directly (specs/cross-platform.md).
+ */
+const onWindows = () => process.platform === "win32";
+/** Config dir as the user's own platform spells it. */
+function configPathHint() {
+    return onWindows()
+        ? "%USERPROFILE%\\.glm-coding-router\\config.json"
+        : "~/.glm-coding-router/config.json";
+}
 /** Standard exit codes (spec §35). */
 export const ExitCode = {
     Success: 0,
@@ -29,17 +41,26 @@ export const Errors = {
     zaiKeyMissing: () => new GlmRouterError({
         name: "ZAI_KEY_MISSING",
         message: "ZAI_API_KEY was not found.",
-        hint: ["Run:", "", "  glm-router key set"],
+        // On platforms without a persistent store `key set` can only print
+        // guidance, so the export line is shown here too — otherwise this hint
+        // points at a command that cannot finish the job.
+        hint: onWindows()
+            ? ["Run:", "", "  glm-router key set"]
+            : [
+                "Run:",
+                "",
+                "  glm-router key set",
+                "",
+                "or set it in this shell and your shell profile:",
+                "",
+                '  export ZAI_API_KEY="<your-key>"',
+            ],
         exitCode: ExitCode.ZaiKeyMissing,
     }),
     configInvalid: (detail) => new GlmRouterError({
         name: "CONFIG_INVALID",
         message: `Configuration is invalid: ${detail}`,
-        hint: [
-            "Fix or remove the config file:",
-            "",
-            "  %USERPROFILE%\\.glm-coding-router\\config.json",
-        ],
+        hint: ["Fix or remove the config file:", "", `  ${configPathHint()}`],
         exitCode: ExitCode.ConfigInvalid,
     }),
     claudeNotFound: (detail) => new GlmRouterError({
@@ -49,11 +70,13 @@ export const Errors = {
         hint: [
             "Expected:",
             "",
-            "  claude.exe",
+            onWindows() ? "  claude.exe" : "  claude",
             "",
             "Install Claude Code or set an override:",
             "",
-            "  glm-router config set claudePath C:\\path\\to\\claude.exe",
+            onWindows()
+                ? "  glm-router config set claudePath C:\\path\\to\\claude.exe"
+                : "  glm-router config set claudePath /path/to/claude",
         ],
         exitCode: ExitCode.ClaudeNotFound,
     }),
@@ -81,8 +104,8 @@ export const Errors = {
     }),
     unsupportedPlatform: (platform) => new GlmRouterError({
         name: "UNSUPPORTED_PLATFORM",
-        message: `This command requires Windows (detected: ${platform}).`,
-        hint: ["Linux and macOS support is planned for v0.2."],
+        message: `This platform is not supported (detected: ${platform}).`,
+        hint: ["Supported: Windows, Linux. macOS is experimental."],
         exitCode: ExitCode.UnsupportedPlatform,
     }),
     promptRequired: (command = "glm-worker") => new GlmRouterError({

package/dist/core/platform.js

@@ -3,18 +3,47 @@ import { Errors } from "./errors.js";
 export function isWindows() {
     return process.platform === "win32";
 }
-/** Human-readable Windows version from os.release() ("10.0.26200" → "Windows 11"). */
-export function windowsVersionName() {
-    if (!isWindows()) {
-        return process.platform;
+/**
+ * Support level per platform:
+ *   win32  — verified through the registry-verification ritual
+ *   linux  — verified 2026-09-20 on Ubuntu 24.04
+ *   darwin — designed but never executed; no Mac has run the suite
+ */
+export function platformSupport(platform = process.platform) {
+    if (platform === "win32" || platform === "linux")
+        return "supported";
+    if (platform === "darwin")
+        return "experimental";
+    return "unsupported";
+}
+export function isSupportedPlatform(platform = process.platform) {
+    return platformSupport(platform) !== "unsupported";
+}
+/** Human-readable platform name for doctor/status. */
+export function platformName(platform = process.platform, release = os.release()) {
+    if (platform === "win32") {
+        const build = Number.parseInt(release.split(".")[2] ?? "0", 10);
+        return build >= 22000 ? "Windows 11" : "Windows 10";
     }
-    const release = os.release();
-    const build = Number.parseInt(release.split(".")[2] ?? "0", 10);
-    return build >= 22000 ? "Windows 11" : "Windows 10";
+    if (platform === "darwin")
+        return `macOS (darwin ${release.split(".")[0] ?? "?"})`;
+    if (platform === "linux")
+        return `Linux ${release.split("-")[0] ?? release}`;
+    return `Platform ${platform}`;
 }
-/** Guard for commands that require Windows-specific machinery (PowerShell user env, etc.). */
+/** @deprecated use platformName(); kept so existing callers keep compiling. */
+export function windowsVersionName() {
+    return platformName();
+}
+/** Guard for the few code paths that are genuinely Windows-only. */
 export function assertWindows() {
     if (!isWindows()) {
         throw Errors.unsupportedPlatform(process.platform);
     }
 }
+/** Guard for commands that need a platform this package supports at all. */
+export function assertSupportedPlatform() {
+    if (!isSupportedPlatform()) {
+        throw Errors.unsupportedPlatform(process.platform);
+    }
+}

package/dist/core/profile.js

@@ -51,7 +51,12 @@ export function applyProfile(config, name) {
             main: profile.main ?? config.models.main,
             fast: profile.fast ?? config.models.fast,
         },
-        worker: { maxTurns: profile.workerMaxTurns ?? config.worker.maxTurns },
+        worker: {
+            maxTurns: profile.workerMaxTurns ?? config.worker.maxTurns,
+            // Profiles tune models and turn budgets, never the Bash allowlist —
+            // that is a security setting, not a performance knob.
+            allowedBash: config.worker.allowedBash,
+        },
         review: { maxTurns: profile.reviewMaxTurns ?? config.review.maxTurns },
     };
 }

package/dist/core/user-env.js

@@ -0,0 +1,181 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/** Keychain/libsecret service name; the variable name is the account. */
+export const KEY_STORE_SERVICE = "glm-coding-router";
+/** Only well-formed variable names may reach a child process (spec §38). */
+function assertEnvVarName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Invalid environment variable name: ${name}`);
+    }
+}
+function defaultRun(file, args, options) {
+    const result = execFileSync(file, [...args], {
+        encoding: "utf8",
+        windowsHide: true,
+        input: options.input,
+        stdio: options.input === undefined
+            ? ["ignore", options.capture ? "pipe" : "ignore", "ignore"]
+            : ["pipe", options.capture ? "pipe" : "ignore", "ignore"],
+    });
+    return typeof result === "string" ? result : "";
+}
+/** Is `name` an executable file somewhere on PATH? */
+function defaultHasCommand(name, env = process.env) {
+    const dirs = (env.PATH ?? "").split(path.delimiter).filter((d) => d.length > 0);
+    return dirs.some((dir) => {
+        try {
+            return fs.statSync(path.join(dir, name)).isFile();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/**
+ * Which store this machine has. `libsecret` requires `secret-tool` on PATH —
+ * it is NOT installed by default on Ubuntu, so "none" is a normal Linux
+ * outcome, not an error (specs/cross-platform.md).
+ */
+export function detectUserEnvStore(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const env = deps.env ?? process.env;
+    const hasCommand = deps.hasCommand ?? ((name) => defaultHasCommand(name, env));
+    if (platform === "win32")
+        return "windows-user-env";
+    if (platform === "darwin")
+        return hasCommand("security") ? "macos-keychain" : "none";
+    if (platform === "linux")
+        return hasCommand("secret-tool") ? "libsecret" : "none";
+    return "none";
+}
+/** Human wording for the store, used by key/doctor/uninstall messages. */
+export function describeKeyStore(store) {
+    switch (store) {
+        case "windows-user-env":
+            return "Windows User Environment";
+        case "macos-keychain":
+            return "macOS login keychain";
+        case "libsecret":
+            return "the system keyring (libsecret)";
+        case "none":
+            return "no persistent store";
+    }
+}
+/**
+ * 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 = {}) {
+    assertEnvVarName(name);
+    const store = detectUserEnvStore(deps);
+    const run = deps.run ?? defaultRun;
+    try {
+        let value;
+        switch (store) {
+            case "windows-user-env":
+                value = run("powershell.exe", [
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    `[Environment]::GetEnvironmentVariable('${name}','User')`,
+                ], { capture: true });
+                break;
+            case "macos-keychain":
+                value = run("security", ["find-generic-password", "-s", KEY_STORE_SERVICE, "-a", name, "-w"], { capture: true });
+                break;
+            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;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write a variable to the per-user store. Throws when there is no store —
+ * callers print platform-appropriate guidance instead.
+ *
+ * The value never goes through a shell. On Windows and Linux it is passed via
+ * a child environment variable / stdin respectively, so it never appears in
+ * any process's argv. The macOS backend has no stdin form, so the value is in
+ * `security`'s argv for the duration of that call — a known limitation of the
+ * experimental darwin support (specs/cross-platform.md).
+ */
+export function writeUserEnv(name, value, deps = {}) {
+    assertEnvVarName(name);
+    const store = detectUserEnvStore(deps);
+    const run = deps.run ?? defaultRun;
+    switch (store) {
+        case "windows-user-env":
+            execFileSync("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `[Environment]::SetEnvironmentVariable('${name}', $env:GLM_ROUTER_VALUE, 'User')`,
+            ], {
+                windowsHide: true,
+                stdio: ["ignore", "ignore", "pipe"],
+                env: { ...process.env, GLM_ROUTER_VALUE: value },
+            });
+            return;
+        case "macos-keychain":
+            run("security", ["add-generic-password", "-U", "-s", KEY_STORE_SERVICE, "-a", name, "-w", value], { capture: false });
+            return;
+        case "libsecret":
+            run("secret-tool", ["store", "--label", `${KEY_STORE_SERVICE} ${name}`, "service", KEY_STORE_SERVICE, "account", name], { input: value, capture: false });
+            return;
+        case "none":
+            throw new Error("no persistent secret store is available on this platform");
+    }
+}
+/** Remove the variable from the per-user store. No store → nothing to do. */
+export function deleteUserEnv(name, deps = {}) {
+    assertEnvVarName(name);
+    const store = detectUserEnvStore(deps);
+    const run = deps.run ?? defaultRun;
+    switch (store) {
+        case "windows-user-env":
+            run("powershell.exe", [
+                "-NoProfile",
+                "-NonInteractive",
+                "-Command",
+                `[Environment]::SetEnvironmentVariable('${name}', $null, 'User')`,
+            ], { capture: false });
+            return;
+        case "macos-keychain":
+            run("security", ["delete-generic-password", "-s", KEY_STORE_SERVICE, "-a", name], { capture: false });
+            return;
+        case "libsecret":
+            run("secret-tool", ["clear", "service", KEY_STORE_SERVICE, "account", name], {
+                capture: false,
+            });
+            return;
+        case "none":
+            return;
+    }
+}
+/**
+ * The shell line a user must add when there is no store, plus the profile file
+ * to put it in. Chosen from $SHELL, preferring a file that already exists.
+ */
+export function describeShellExport(name, deps = {}) {
+    const env = deps.env ?? process.env;
+    const home = deps.home ?? env.HOME ?? "~";
+    const exists = deps.exists ?? ((file) => fs.existsSync(file));
+    const shell = path.basename(env.SHELL ?? "bash");
+    const candidates = shell === "zsh"
+        ? [".zshrc", ".zprofile", ".profile"]
+        : shell === "fish"
+            ? [".config/fish/config.fish"]
+            : [".bashrc", ".bash_profile", ".profile"];
+    const found = candidates.find((rel) => exists(path.join(home, rel)));
+    const profile = path.join(home, found ?? candidates[0]);
+    const line = shell === "fish" ? `set -gx ${name} <your-key>` : `export ${name}="<your-key>"`;
+    return { line, profile };
+}

package/dist/core/zai-key.js

@@ -1,69 +1,25 @@
-import { execFileSync } from "node:child_process";
+import { deleteUserEnv, detectUserEnvStore, readUserEnv as readUserEnvStore, writeUserEnv, } from "./user-env.js";
 export const ZAI_API_KEY_ENV = "ZAI_API_KEY";
-/** Only well-formed variable names may reach powershell.exe (spec §38). */
-function assertEnvVarName(name) {
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
-        throw new Error(`Invalid environment variable name: ${name}`);
-    }
-}
 /**
- * Read a variable from the Windows User Environment via PowerShell (spec §10).
- * Returns undefined on any failure — callers fall back or fail with their own error.
+ * Read the variable from this platform's per-user store (spec §10).
+ * The Windows implementation is unchanged; it now lives in user-env.ts.
  */
-export function readWindowsUserEnv(name) {
-    assertEnvVarName(name);
-    try {
-        const result = execFileSync("powershell.exe", [
-            "-NoProfile",
-            "-NonInteractive",
-            "-Command",
-            `[Environment]::GetEnvironmentVariable('${name}','User')`,
-        ], {
-            encoding: "utf8",
-            windowsHide: true,
-            stdio: ["ignore", "pipe", "ignore"],
-        });
-        const value = result.trim();
-        return value || undefined;
-    }
-    catch {
-        return undefined;
-    }
+export function readWindowsUserEnv(name, deps = {}) {
+    return readUserEnvStore(name, deps);
 }
-/**
- * Write a variable to the Windows User Environment (spec §11).
- * The value is passed through a child-process env var so it never needs
- * PowerShell string escaping (spec §38: no unescaped user data in commands).
- */
-export function setWindowsUserEnv(name, value) {
-    assertEnvVarName(name);
-    execFileSync("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `[Environment]::SetEnvironmentVariable('${name}', $env:GLM_ROUTER_VALUE, 'User')`,
-    ], {
-        windowsHide: true,
-        stdio: ["ignore", "ignore", "pipe"],
-        env: { ...process.env, GLM_ROUTER_VALUE: value },
-    });
+/** Write the variable to this platform's per-user store (spec §11). */
+export function setWindowsUserEnv(name, value, deps = {}) {
+    writeUserEnv(name, value, deps);
 }
-export function deleteWindowsUserEnv(name) {
-    assertEnvVarName(name);
-    execFileSync("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `[Environment]::SetEnvironmentVariable('${name}', $null, 'User')`,
-    ], {
-        windowsHide: true,
-        stdio: ["ignore", "ignore", "pipe"],
-    });
+export function deleteWindowsUserEnv(name, deps = {}) {
+    deleteUserEnv(name, deps);
 }
+/** Re-exported so callers do not need two imports. */
+export { detectUserEnvStore };
 /**
  * Resolve the Z.ai key with the mandatory fallback order (spec §10):
  *   1. process.env.ZAI_API_KEY
- *   2. Windows User Environment
+ *   2. this platform's per-user store
  *   3. fail (undefined)
  *
  * The fallback exists because Orca terminals snapshot a stale environment and
@@ -71,14 +27,14 @@ export function deleteWindowsUserEnv(name) {
  */
 export function resolveZaiApiKey(options = {}) {
     const env = options.env ?? process.env;
-    const readUserEnv = options.readUserEnv ?? readWindowsUserEnv;
+    const readUserEnv = options.readUserEnv ?? ((name) => readUserEnvStore(name));
     const fromProcess = env[ZAI_API_KEY_ENV];
     if (fromProcess && fromProcess.trim()) {
         return { key: fromProcess.trim(), source: "process-env" };
     }
     const fromUserEnv = readUserEnv(ZAI_API_KEY_ENV);
     if (fromUserEnv && fromUserEnv.trim()) {
-        return { key: fromUserEnv.trim(), source: "windows-user-env" };
+        return { key: fromUserEnv.trim(), source: "user-store" };
     }
     return undefined;
 }

package/dist/integrations/skill.js

@@ -3,33 +3,52 @@ import path from "node:path";
 import { atomicWriteFile } from "../project/atomic-write.js";
 import { GLM_DELEGATION_SKILL_MD, GLM_DELEGATION_SKILL_NAME, } from "../templates/glm-delegation-skill.js";
 /**
- * Installs SKILL.md-based skills into the Codex home (~/.codex/skills).
- * Detection is conservative: if ~/.codex does not exist there is no
- * supported Codex installation to enhance — return null and let callers warn+skip.
+ * Shared SKILL.md-folder mechanics; subclasses only pick the agent home dir
+ * (specs/v1-architecture.md). Detection stays conservative: a missing home
+ * means no supported installation to enhance — return null, callers warn+skip.
  */
-export class CodexSkillInstaller {
-    codexHome;
-    constructor(home) {
-        this.codexHome = path.join(home, ".codex");
+class HomeDirSkillInstaller {
+    agentHome;
+    constructor(agentHome) {
+        this.agentHome = agentHome;
     }
     detect() {
-        if (!fs.existsSync(this.codexHome)) {
+        if (!fs.existsSync(this.agentHome)) {
             return null;
         }
-        return { skillsDir: path.join(this.codexHome, "skills") };
+        return { skillsDir: path.join(this.agentHome, "skills") };
     }
     install(skill) {
-        const skillDir = path.join(this.codexHome, "skills", skill.name);
+        const skillDir = path.join(this.agentHome, "skills", skill.name);
         atomicWriteFile(path.join(skillDir, "SKILL.md"), skill.content);
     }
     remove(name) {
-        const skillDir = path.join(this.codexHome, "skills", name);
+        const skillDir = path.join(this.agentHome, "skills", name);
         fs.rmSync(skillDir, { recursive: true, force: true });
     }
     isInstalled(name) {
-        return fs.existsSync(path.join(this.codexHome, "skills", name, "SKILL.md"));
+        return fs.existsSync(path.join(this.agentHome, "skills", name, "SKILL.md"));
+    }
+}
+/** Installs skills into the Codex home (~/.codex/skills). */
+export class CodexSkillInstaller extends HomeDirSkillInstaller {
+    constructor(home) {
+        super(path.join(home, ".codex"));
     }
 }
+/** Installs skills into the Claude Code home (~/.claude/skills, specs/v1-architecture.md). */
+export class ClaudeSkillInstaller extends HomeDirSkillInstaller {
+    constructor(home) {
+        super(path.join(home, ".claude"));
+    }
+}
+/** Every agent the delegation skill supports, in stable display order. */
+export function skillTargets(home) {
+    return [
+        { agent: "Claude", installer: new ClaudeSkillInstaller(home) },
+        { agent: "Codex", installer: new CodexSkillInstaller(home) },
+    ];
+}
 export function glmDelegationSkill() {
     return { name: GLM_DELEGATION_SKILL_NAME, content: GLM_DELEGATION_SKILL_MD };
 }