glm-coding-router 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,93 @@
+import os from "node:os";
+import { execFileSync } from "node:child_process";
+import { defaultConfig, loadConfig } from "../core/config.js";
+import { locateClaude, locateCodex, searchPathFor } from "../core/claude.js";
+import { isWindows, windowsVersionName } from "../core/platform.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { configPath } from "../core/paths.js";
+import fs from "node:fs";
+import { CodexSkillInstaller } from "../integrations/skill.js";
+import { GLM_DELEGATION_SKILL_NAME } from "../templates/glm-delegation-skill.js";
+function check(section, name, status, detail, note) {
+    return { section, name, status, detail, note };
+}
+function nodeVersionMajor() {
+    return Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+}
+function gitFound() {
+    try {
+        execFileSync("git", ["--version"], { windowsHide: true, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** All doctor checks (spec §9). Read-only; never exposes the key value. */
+export function runDoctorChecks(options = {}) {
+    const results = [];
+    const home = options.home ?? os.homedir();
+    // --- System ---
+    results.push(check("System", isWindows() ? windowsVersionName() : `Platform ${process.platform}`, isWindows() ? "ok" : "fail", undefined, isWindows() ? undefined : "v0.1 targets Windows only."));
+    const nodeMajor = nodeVersionMajor();
+    results.push(check("System", `Node.js ${process.versions.node}`, nodeMajor >= 20 ? "ok" : "fail", undefined, nodeMajor >= 20 ? undefined : "glm-coding-router requires Node.js >= 20."));
+    results.push(check("System", "Git", gitFound() ? "ok" : "warn"));
+    // --- Z.ai / config ---
+    let config = defaultConfig();
+    const configFile = configPath(home);
+    const configExists = fs.existsSync(configFile);
+    if (!configExists) {
+        results.push(check("Z.ai", "Configuration", "ok", "defaults (config.json not created yet)"));
+    }
+    else {
+        try {
+            config = loadConfig(home);
+            results.push(check("Z.ai", "Configuration", "ok", configFile));
+        }
+        catch (error) {
+            results.push(check("Z.ai", "Configuration", "fail", error instanceof Error ? error.message : String(error)));
+        }
+    }
+    // --- Agents ---
+    try {
+        const claudePath = locateClaude(config);
+        results.push(check("Agents", "Claude Code", "ok", claudePath));
+    }
+    catch (error) {
+        results.push(check("Agents", "Claude Code", "fail", error instanceof Error ? error.message : String(error)));
+    }
+    const codexPath = locateCodex(config);
+    results.push(check("Agents", "Codex", codexPath ? "ok" : "warn", codexPath, codexPath ? undefined : "Optional — Claude-only setups are supported."));
+    // --- Z.ai key ---
+    const resolved = resolveZaiApiKey();
+    results.push(check("Z.ai", "ZAI_API_KEY", resolved ? "ok" : "fail", resolved ? `configured (${resolved.source})` : "not found", resolved ? undefined : "Run: glm-router key set"));
+    results.push(check("Z.ai", "Anthropic endpoint", "ok", config.provider.anthropicBaseUrl));
+    // --- Commands (PATH shims; a dev checkout warns instead of failing) ---
+    for (const command of ["glm-chat", "glm-worker", "glm-review"]) {
+        const found = searchPathFor(command);
+        results.push(check("Commands", command, found ? "ok" : "warn", found, found ? undefined : "Not on PATH — install globally (npm install -g glm-coding-router) or use npm run dev."));
+    }
+    // --- Claude / Codex integrations ---
+    results.push(check("Claude", "Integration", config.integrations.claude ? "ok" : "warn", config.integrations.claude ? "enabled" : "disabled in config"));
+    results.push(check("Codex", "AGENTS.md integration", config.integrations.codex ? "ok" : "warn", config.integrations.codex ? "enabled" : "disabled in config"));
+    const skillInstaller = new CodexSkillInstaller(home);
+    const skillDetected = skillInstaller.detect() !== null;
+    const skillInstalled = skillDetected && skillInstaller.isInstalled(GLM_DELEGATION_SKILL_NAME);
+    results.push(check("Codex", "Delegation skill", skillInstalled ? "ok" : "warn", skillInstalled
+        ? "installed"
+        : skillDetected
+            ? "not installed (optional)"
+            : "Codex home not detected — skill skipped (optional)"));
+    // --- Environment: the Orca stale-env case (spec §9, §10) ---
+    const hasProcessKey = Boolean(process.env.ZAI_API_KEY && process.env.ZAI_API_KEY.trim());
+    if (hasProcessKey) {
+        results.push(check("Environment", "Process environment", "ok", "ZAI_API_KEY visible in current process"));
+    }
+    else if (resolved) {
+        results.push(check("Environment", "Process environment", "warn", "Current process does not contain ZAI_API_KEY", "This is safe. GLM workers reload the key automatically from the Windows User Environment."));
+    }
+    return { results, config, keySource: resolved?.source };
+}
+export function doctorHasFailures(results) {
+    return results.some((result) => result.status === "fail");
+}

package/dist/commands/init.js

@@ -0,0 +1,123 @@
+import prompts from "prompts";
+import fs from "node:fs";
+import os from "node:os";
+import { loadConfig, saveConfig } from "../core/config.js";
+import { configPath } from "../core/paths.js";
+import { runDoctorChecks } from "./doctor.js";
+import { setWindowsUserEnv, ZAI_API_KEY_ENV } from "../core/zai-key.js";
+import { isWindows } from "../core/platform.js";
+import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
+import { version } from "../core/version.js";
+function renderEnvironment(results) {
+    const lines = [];
+    for (const result of results) {
+        const symbol = result.status === "ok" ? "✓" : result.status === "warn" ? "⚠" : "✗";
+        lines.push(`${symbol} ${result.name}`);
+    }
+    return lines.join("\n");
+}
+async function askChoices(existingKey, options) {
+    if (options.yes) {
+        return { configureKey: !existingKey, claude: true, codex: true, codexSkill: true };
+    }
+    if (!process.stdin.isTTY) {
+        process.stdout.write("Non-interactive terminal detected. Re-run with --yes to accept defaults.\n");
+        process.exit(2);
+    }
+    const response = await prompts([
+        {
+            type: existingKey ? null : "confirm",
+            name: "configureKey",
+            message: "Configure Z.ai Coding Plan key?",
+            initial: true,
+        },
+        { type: "confirm", name: "claude", message: "Install Claude integration?", initial: true },
+        { type: "confirm", name: "codex", message: "Install Codex integration?", initial: true },
+        { type: "confirm", name: "codexSkill", message: "Install Codex delegation skill?", initial: true },
+    ]);
+    if (response.claude === undefined) {
+        process.stdout.write("Cancelled.\n");
+        process.exit(1);
+    }
+    return {
+        configureKey: existingKey ? true : Boolean(response.configureKey),
+        claude: Boolean(response.claude),
+        codex: Boolean(response.codex),
+        codexSkill: Boolean(response.codexSkill),
+    };
+}
+/** glm-router init (spec §7): environment report, key setup, config, skill. Idempotent. */
+export async function initCommand(options) {
+    process.stdout.write(`GLM Coding Router v${version}\n\n`);
+    const report = runDoctorChecks();
+    process.stdout.write("Environment\n\n");
+    process.stdout.write(renderEnvironment(report.results) + "\n\n");
+    const existingKey = report.keySource !== undefined;
+    const choices = await askChoices(existingKey, options);
+    process.stdout.write("\nInstalling...\n\n");
+    const home = os.homedir();
+    const config = loadConfig();
+    const nextConfig = {
+        ...config,
+        integrations: {
+            claude: choices.claude,
+            codex: choices.codex,
+            codexSkill: choices.codexSkill,
+        },
+    };
+    // Z.ai key
+    if (existingKey) {
+        process.stdout.write(`✓ ${ZAI_API_KEY_ENV} already configured (${report.keySource})\n`);
+    }
+    else if (choices.configureKey) {
+        if (!isWindows()) {
+            process.stdout.write("⚠ Key storage requires Windows in v0.1 — skipped\n");
+        }
+        else {
+            const keyResponse = await prompts({
+                type: "password",
+                name: "key",
+                message: "Enter Z.ai Coding Plan API key:",
+                validate: (value) => (value.trim().length > 0 ? true : "Key cannot be empty"),
+            });
+            if (keyResponse.key === undefined) {
+                process.stderr.write("Cancelled.\n");
+                return 1;
+            }
+            setWindowsUserEnv(ZAI_API_KEY_ENV, String(keyResponse.key).trim());
+            process.stdout.write(`✓ ${ZAI_API_KEY_ENV} configured\n`);
+        }
+    }
+    else {
+        process.stdout.write(`⚠ Skipped — run "glm-router key set" later\n`);
+    }
+    // Config
+    const alreadyConfigured = fs.existsSync(configPath(home));
+    saveConfig(nextConfig, home);
+    process.stdout.write(alreadyConfigured
+        ? `✓ Configuration updated (${configPath(home)})\n`
+        : `✓ Configuration created (${configPath(home)})\n`);
+    // GLM commands
+    process.stdout.write(`✓ GLM commands available: glm-chat, glm-worker, glm-review\n`);
+    // Integrations
+    process.stdout.write(choices.claude ? "✓ Claude integration ready (CLAUDE.md managed block via: glm-router project init)\n"
+        : "⚠ Claude integration disabled\n");
+    process.stdout.write(choices.codex ? "✓ Codex integration ready (AGENTS.md managed block via: glm-router project init)\n"
+        : "⚠ Codex integration disabled\n");
+    // Skill
+    if (choices.codexSkill) {
+        const skillInstaller = new CodexSkillInstaller(home);
+        if (skillInstaller.detect()) {
+            skillInstaller.install(glmDelegationSkill());
+            process.stdout.write("✓ Codex skill installed\n");
+        }
+        else {
+            process.stdout.write("⚠ Codex home (~/.codex) not detected — skill skipped (optional). AGENTS.md integration is unaffected.\n");
+        }
+    }
+    else {
+        process.stdout.write("⚠ Codex skill skipped\n");
+    }
+    process.stdout.write("\nSetup complete.\n\nRun:\n\n  glm-router doctor\n");
+    return 0;
+}

package/dist/commands/key.js

@@ -0,0 +1,56 @@
+import prompts from "prompts";
+import { assertWindows } from "../core/platform.js";
+import { Errors } from "../core/errors.js";
+import { logger } from "../core/logging.js";
+import { ZAI_API_KEY_ENV, deleteWindowsUserEnv, resolveZaiApiKey, setWindowsUserEnv, } from "../core/zai-key.js";
+import { emitJson } from "./context.js";
+/** glm-router key set (spec §11): prompt, save to Windows User Environment. */
+export async function keySetCommand(_options) {
+    assertWindows();
+    const response = await prompts({
+        type: "password",
+        name: "key",
+        message: "Enter Z.ai Coding Plan API key:",
+        validate: (value) => (value.trim().length > 0 ? true : "Key cannot be empty"),
+    });
+    if (response.key === undefined) {
+        process.stderr.write("Cancelled.\n");
+        return 1;
+    }
+    const key = String(response.key).trim();
+    try {
+        setWindowsUserEnv(ZAI_API_KEY_ENV, key);
+    }
+    catch (error) {
+        logger.error(`Failed to write the Windows User Environment: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+    process.stdout.write(`\n✓ Saved to Windows User Environment:\n  ${ZAI_API_KEY_ENV}\n`);
+    process.stdout.write("\nOpen a NEW terminal (or restart your Orca terminal) so the current process picks it up.\n");
+    return 0;
+}
+/** glm-router key check (spec §11): report presence + source; never the value. */
+export function keyCheckCommand(options) {
+    const resolved = resolveZaiApiKey();
+    if (options.json) {
+        emitJson({
+            configured: Boolean(resolved),
+            source: resolved?.source ?? null,
+        });
+        return resolved ? 0 : 10;
+    }
+    if (!resolved) {
+        // Formatted per spec §36; exit 10 (spec §35).
+        const error = Errors.zaiKeyMissing();
+        process.stderr.write(`ERROR [${error.codeName}]\n\n${error.message}\n\nRun:\n\n  glm-router key set\n`);
+        return error.exitCode;
+    }
+    const sourceLabel = resolved.source === "process-env" ? "process environment" : "Windows User Environment";
+    process.stdout.write(`${ZAI_API_KEY_ENV}: configured\nSource: ${sourceLabel}\n`);
+    return 0;
+}
+/** Used by uninstall; keeps the key by default (spec §44). */
+export async function keyRemoveCommand() {
+    assertWindows();
+    deleteWindowsUserEnv(ZAI_API_KEY_ENV);
+}

package/dist/commands/project-init.js

@@ -0,0 +1,61 @@
+import { findProjectRoot } from "../project/project-root.js";
+import { installClaudeIntegration } from "../integrations/claude.js";
+import { installCodexIntegration } from "../integrations/codex.js";
+import { loadConfig } from "../core/config.js";
+/** Lines of the managed block region (markers included), for --dry-run previews (spec §45). */
+function managedLines(content) {
+    const start = content.indexOf("<!-- glm-coding-router:start -->");
+    if (start === -1)
+        return [];
+    const endMarker = "<!-- glm-coding-router:end -->";
+    const end = content.indexOf(endMarker);
+    const regionEnd = end === -1 ? content.length : end + endMarker.length;
+    return content.slice(start, regionEnd).split(/\r?\n/);
+}
+/** Unified-diff-style preview for --dry-run (spec §45). */
+export function renderChangeDiff(change) {
+    const lines = [];
+    lines.push(`--- ${change.file}${change.created ? " (new file)" : ""}`);
+    for (const line of managedLines(change.oldContent)) {
+        lines.push(`- ${line}`);
+    }
+    for (const line of managedLines(change.newContent)) {
+        lines.push(`+ ${line}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * glm-router project init (spec §19, §23): create/update the managed block in
+ * CLAUDE.md and AGENTS.md at the project root. Idempotent; never overwrites
+ * user content; supports --dry-run.
+ */
+export function projectInitCommand(options) {
+    const root = findProjectRoot();
+    const config = loadConfig();
+    const changes = [];
+    if (config.integrations.claude) {
+        changes.push(installClaudeIntegration(root, { dryRun: options.dryRun }));
+    }
+    if (config.integrations.codex) {
+        changes.push(installCodexIntegration(root, { dryRun: options.dryRun }));
+    }
+    if (changes.length === 0) {
+        process.stdout.write("All integrations are disabled in config — nothing to do.\n");
+        return 0;
+    }
+    for (const change of changes) {
+        if (options.dryRun) {
+            process.stdout.write(`[dry-run] would update ${change.file}:\n${renderChangeDiff(change)}\n`);
+        }
+        else if (!change.changed) {
+            process.stdout.write(`✓ ${change.file} — already up to date\n`);
+        }
+        else if (change.created) {
+            process.stdout.write(`✓ ${change.file} — created\n`);
+        }
+        else {
+            process.stdout.write(`✓ ${change.file} — managed block updated\n`);
+        }
+    }
+    return 0;
+}

package/dist/commands/project-remove.js

@@ -0,0 +1,36 @@
+import { findProjectRoot } from "../project/project-root.js";
+import { removeClaudeIntegration } from "../integrations/claude.js";
+import { removeCodexIntegration } from "../integrations/codex.js";
+/**
+ * glm-router project remove (spec §43): remove only the managed block,
+ * preserve all user content, and delete router-created files that become empty.
+ */
+export function projectRemoveCommand(options) {
+    const root = findProjectRoot();
+    const changes = [
+        removeClaudeIntegration(root, { dryRun: options.dryRun }),
+        removeCodexIntegration(root, { dryRun: options.dryRun }),
+    ];
+    for (const change of changes) {
+        if (options.dryRun) {
+            if (change.changed) {
+                const action = change.deleted ? "delete (router-created, now empty)" : "remove managed block from";
+                process.stdout.write(`[dry-run] would ${action}: ${change.file}\n`);
+            }
+            else {
+                process.stdout.write(`[dry-run] no managed block in ${change.file}\n`);
+            }
+            continue;
+        }
+        if (change.deleted) {
+            process.stdout.write(`✓ ${change.file} — deleted (was created by glm-coding-router)\n`);
+        }
+        else if (change.changed) {
+            process.stdout.write(`✓ ${change.file} — managed block removed\n`);
+        }
+        else {
+            process.stdout.write(`✓ ${change.file} — no managed block present\n`);
+        }
+    }
+    return 0;
+}

package/dist/commands/skill.js

@@ -0,0 +1,43 @@
+import os from "node:os";
+import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
+function installer() {
+    return new CodexSkillInstaller(os.homedir());
+}
+/** glm-router skill install (spec §27): optional enhancement; warn+skip when unsupported. */
+export function skillInstallCommand(options) {
+    const skillInstaller = installer();
+    const location = skillInstaller.detect();
+    if (!location) {
+        process.stdout.write("⚠ Codex skill directory not detected (~/.codex not found).\n" +
+            "  Skipping optional skill — AGENTS.md integration keeps working.\n");
+        return 0;
+    }
+    const skill = glmDelegationSkill();
+    if (skillInstaller.isInstalled(skill.name) && !options.force) {
+        process.stdout.write(`✓ Skill "${skill.name}" already installed\n`);
+        return 0;
+    }
+    if (options.dryRun) {
+        process.stdout.write(`[dry-run] would install skill "${skill.name}" to ${location.skillsDir}\n`);
+        return 0;
+    }
+    skillInstaller.install(skill);
+    process.stdout.write(`✓ Skill "${skill.name}" installed at ${location.skillsDir}\n`);
+    return 0;
+}
+/** glm-router skill remove. */
+export function skillRemoveCommand(options) {
+    const skillInstaller = installer();
+    const skill = glmDelegationSkill();
+    if (!skillInstaller.isInstalled(skill.name)) {
+        process.stdout.write(`✓ Skill "${skill.name}" is not installed\n`);
+        return 0;
+    }
+    if (options.dryRun) {
+        process.stdout.write(`[dry-run] would remove skill "${skill.name}"\n`);
+        return 0;
+    }
+    skillInstaller.remove(skill.name);
+    process.stdout.write(`✓ Skill "${skill.name}" removed\n`);
+    return 0;
+}

package/dist/commands/status.js

@@ -0,0 +1,57 @@
+import os from "node:os";
+import { loadConfig } from "../core/config.js";
+import { locateClaude, locateCodex } from "../core/claude.js";
+import { version } from "../core/version.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { CodexSkillInstaller } from "../integrations/skill.js";
+import { GLM_DELEGATION_SKILL_NAME } from "../templates/glm-delegation-skill.js";
+import { emitJson } from "./context.js";
+/** Fast, fully offline summary (spec §41) — no API requests, no key values. */
+export function statusCommand(options) {
+    const config = loadConfig();
+    const home = os.homedir();
+    const resolved = resolveZaiApiKey();
+    const claudeInstalled = (() => {
+        try {
+            locateClaude(config);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    })();
+    const codexInstalled = Boolean(locateCodex(config));
+    const skillInstaller = new CodexSkillInstaller(home);
+    const skillInstalled = skillInstaller.detect() !== null && skillInstaller.isInstalled(GLM_DELEGATION_SKILL_NAME);
+    if (options.json) {
+        emitJson({
+            version,
+            zaiKeyConfigured: Boolean(resolved),
+            claude: claudeInstalled ? "installed" : "missing",
+            codex: codexInstalled ? "installed" : "missing",
+            integrations: {
+                claude: config.integrations.claude,
+                codex: config.integrations.codex,
+                codexSkill: config.integrations.codexSkill && skillInstalled,
+            },
+            models: config.models,
+        });
+        return 0;
+    }
+    const lines = [
+        `GLM Coding Router v${version}`,
+        "",
+        `Z.ai key        ${resolved ? "configured" : "not configured"}`,
+        `Claude          ${claudeInstalled ? "installed" : "missing"}`,
+        `Codex           ${codexInstalled ? "installed" : "missing"}`,
+        "",
+        `Claude policy   ${config.integrations.claude ? "enabled" : "disabled"}`,
+        `Codex policy    ${config.integrations.codex ? "enabled" : "disabled"}`,
+        `Codex skill     ${skillInstalled ? "enabled" : "disabled"}`,
+        "",
+        `Main model      ${config.models.main}`,
+        `Fast model      ${config.models.fast}`,
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+    return 0;
+}

package/dist/commands/uninstall.js

@@ -0,0 +1,81 @@
+import prompts from "prompts";
+import fs from "node:fs";
+import os from "node:os";
+import { configDir } from "../core/paths.js";
+import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
+import { keyRemoveCommand } from "./key.js";
+import { removeClaudeIntegration, removeCodexIntegration } from "../integrations/index.js";
+async function askChoices(options) {
+    // Defaults per spec §44: keep ZAI_API_KEY; destructive credential removal
+    // requires explicit consent, so --yes never flips it.
+    const defaults = {
+        removeConfig: true,
+        removeSkill: true,
+        removeProjectIntegration: false,
+        removeKey: false,
+    };
+    if (options.yes || options.force) {
+        return options.force ? { ...defaults, removeProjectIntegration: true } : defaults;
+    }
+    if (!process.stdin.isTTY) {
+        process.stdout.write("Non-interactive terminal detected. Re-run with --yes for safe defaults.\n");
+        process.exit(2);
+    }
+    const response = await prompts([
+        { type: "confirm", name: "removeConfig", message: "Remove global configuration?", initial: true },
+        { type: "confirm", name: "removeSkill", message: "Remove Codex skill?", initial: true },
+        { type: "confirm", name: "removeProject", message: "Remove current project integration?", initial: false },
+        { type: "confirm", name: "removeKey", message: "Remove ZAI_API_KEY?", initial: false },
+    ]);
+    if (response.removeConfig === undefined) {
+        process.stdout.write("Cancelled.\n");
+        process.exit(1);
+    }
+    return {
+        removeConfig: Boolean(response.removeConfig),
+        removeSkill: Boolean(response.removeSkill),
+        removeProjectIntegration: Boolean(response.removeProject),
+        removeKey: Boolean(response.removeKey),
+    };
+}
+/** glm-router uninstall (spec §44): wizard with safe defaults. */
+export async function uninstallCommand(options) {
+    const choices = await askChoices(options);
+    const home = os.homedir();
+    if (choices.removeSkill) {
+        const skillInstaller = new CodexSkillInstaller(home);
+        const skill = glmDelegationSkill();
+        if (skillInstaller.isInstalled(skill.name)) {
+            skillInstaller.remove(skill.name);
+            process.stdout.write("✓ Codex skill removed\n");
+        }
+        else {
+            process.stdout.write("✓ Codex skill not installed\n");
+        }
+    }
+    if (choices.removeProjectIntegration) {
+        const root = process.cwd();
+        removeClaudeIntegration(root);
+        removeCodexIntegration(root);
+        process.stdout.write("✓ Project integration removed (CLAUDE.md / AGENTS.md managed blocks)\n");
+    }
+    if (choices.removeConfig) {
+        const dir = configDir(home);
+        if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true, force: true });
+            process.stdout.write(`✓ Global configuration removed (${dir})\n`);
+        }
+        else {
+            process.stdout.write("✓ Global configuration not present\n");
+        }
+    }
+    if (choices.removeKey) {
+        await keyRemoveCommand();
+        process.stdout.write("✓ ZAI_API_KEY removed from Windows User Environment\n");
+    }
+    else {
+        process.stdout.write("✓ ZAI_API_KEY kept\n");
+    }
+    process.stdout.write("\nUninstall complete. Run `npm uninstall -g glm-coding-router` to remove the binaries.\n");
+    return 0;
+}

package/dist/core/claude.js

@@ -0,0 +1,104 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { Errors } from "./errors.js";
+import { isWindows } from "./platform.js";
+function runWhere(name) {
+    const finder = isWindows() ? "where.exe" : "which";
+    try {
+        const output = execFileSync(finder, [name], {
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return output
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/** Manual PATH scan for candidate executables, preferring .exe over shims (spec §33). */
+export function searchPathFor(name, env = process.env) {
+    const pathValue = env.PATH ?? "";
+    const separators = isWindows() ? [".exe", ".cmd", ".bat", ""] : [""];
+    const dirs = pathValue.split(path.delimiter).filter((d) => d.length > 0);
+    const candidates = [];
+    for (const dir of dirs) {
+        for (const ext of separators) {
+            const candidate = path.join(dir, name + ext);
+            if (isExecutableFile(candidate)) {
+                candidates.push(candidate);
+            }
+        }
+    }
+    const exe = candidates.find((c) => c.toLowerCase().endsWith(".exe"));
+    return exe ?? candidates[0];
+}
+function isExecutableFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Prefer native executables; npm .cmd shims are a last resort (spec §33). */
+function preferNative(matches) {
+    return matches.find((m) => m.toLowerCase().endsWith(".exe")) ?? matches[0];
+}
+/**
+ * Locate claude.exe (spec §33):
+ *   1. where.exe claude
+ *   2. PATH search through Node
+ *   3. config override
+ *   4. error
+ */
+export function locateClaude(config) {
+    const matches = runWhere("claude");
+    const fromWhere = preferNative(matches);
+    if (fromWhere) {
+        return fromWhere;
+    }
+    const fromPath = searchPathFor("claude");
+    if (fromPath) {
+        return fromPath;
+    }
+    const override = config?.claudePath;
+    if (override && isExecutableFile(override)) {
+        return override;
+    }
+    const detail = override && !isExecutableFile(override)
+        ? `Configured claudePath override does not exist: ${override}`
+        : undefined;
+    throw Errors.claudeNotFound(detail);
+}
+/**
+ * Locate codex (spec §34). Absence is a WARN for doctor, not an error here —
+ * the tool must work with a Claude-only setup. `required` callers
+ * (glm commands that need codex) get a proper error.
+ */
+export function locateCodex(config) {
+    const matches = runWhere("codex");
+    if (matches.length > 0) {
+        return preferNative(matches);
+    }
+    const fromPath = searchPathFor("codex");
+    if (fromPath) {
+        return fromPath;
+    }
+    const override = config?.codexPath;
+    if (override && isExecutableFile(override)) {
+        return override;
+    }
+    return undefined;
+}
+export function codexRequired(config) {
+    const found = locateCodex(config);
+    if (!found) {
+        throw Errors.codexNotFound();
+    }
+    return found;
+}