shennian 0.2.4 → 0.2.5

package/dist/bin/shennian.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 import '../src/index.js';
-//# sourceMappingURL=shennian.d.ts.map

package/dist/bin/shennian.js

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 import '../src/index.js';
-//# sourceMappingURL=shennian.js.map

package/dist/src/agents/adapter.d.ts

@@ -33,4 +33,3 @@ export declare function registerAgent(type: AgentType, factory: () => AgentAdapt
 export declare function unregisterAgent(type: AgentType): void;
 export declare function createAgent(type: AgentType): AgentAdapter | null;
 export declare function getRegisteredAgents(): AgentType[];
-//# sourceMappingURL=adapter.d.ts.map

package/dist/src/agents/adapter.js

@@ -17,4 +17,3 @@ export function createAgent(type) {
 export function getRegisteredAgents() {
     return [...registry.keys()];
 }
-//# sourceMappingURL=adapter.js.map

package/dist/src/agents/claude.d.ts

@@ -1,4 +1,5 @@
 import { AgentAdapter } from './adapter.js';
+export declare function normalizeClaudeModelId(modelId?: string | null): string;
 export declare class ClaudeAdapter extends AgentAdapter {
     readonly type: "claude";
     private process;
@@ -22,4 +23,3 @@ export declare class ClaudeAdapter extends AgentAdapter {
     private emitEvent;
     private killProcess;
 }
-//# sourceMappingURL=claude.d.ts.map

package/dist/src/agents/claude.js

@@ -1,7 +1,11 @@
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
+export function normalizeClaudeModelId(modelId) {
+    const trimmed = modelId?.trim();
+    return trimmed || 'default';
+}
 export class ClaudeAdapter extends AgentAdapter {
     type = 'claude';
     process = null;
@@ -27,9 +31,7 @@ export class ClaudeAdapter extends AgentAdapter {
         if (process.getuid?.() !== 0) {
             args.push('--dangerously-skip-permissions');
         }
-        if (modelId) {
-            args.push('--model', modelId);
-        }
+        args.push('--model', normalizeClaudeModelId(modelId));
         if (this.agentSessionId) {
             args.push('--resume', this.agentSessionId);
         }
@@ -50,7 +52,12 @@ export class ClaudeAdapter extends AgentAdapter {
         await this.killProcess();
     }
     spawnAndParse(args) {
-        const proc = spawn('claude', args, {
+        const spec = resolveBuiltinCommand('claude');
+        if (!spec) {
+            this.emit('error', new Error('Command "claude" not found. Is Claude Code CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -225,4 +232,3 @@ export class ClaudeAdapter extends AgentAdapter {
     }
 }
 registerAgent('claude', () => new ClaudeAdapter());
-//# sourceMappingURL=claude.js.map

package/dist/src/agents/codex.d.ts

@@ -47,4 +47,3 @@ export declare class CodexAdapter extends AgentAdapter {
     private clearForceCloseTimer;
 }
 export declare function normalizeCodexModelId(modelId?: string | null): string | undefined;
-//# sourceMappingURL=codex.d.ts.map

package/dist/src/agents/codex.js

@@ -1,9 +1,9 @@
 // @arch docs/architecture/cli/agent-adapters.md
 // @test src/__tests__/codex-adapter.test.ts
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 export class CodexAdapter extends AgentAdapter {
     type = 'codex';
     process = null;
@@ -69,7 +69,12 @@ export class CodexAdapter extends AgentAdapter {
         await this.killProcess();
     }
     spawnCodex(args) {
-        const proc = spawn('codex', args, {
+        const spec = resolveBuiltinCommand('codex');
+        if (!spec) {
+            this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -111,7 +116,12 @@ export class CodexAdapter extends AgentAdapter {
         });
     }
     spawnAppServer() {
-        const proc = spawn('codex', ['app-server', '--listen', 'stdio://'], {
+        const spec = resolveBuiltinCommand('codex');
+        if (!spec) {
+            this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, ['app-server', '--listen', 'stdio://'], {
             cwd: this.workDir ?? undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env, NO_COLOR: '1' },
@@ -782,4 +792,3 @@ function looksLikeFatalCodexStderr(stderr) {
     ].some((pattern) => pattern.test(stderr));
 }
 registerAgent('codex', () => new CodexAdapter());
-//# sourceMappingURL=codex.js.map

package/dist/src/agents/command-spec.d.ts

@@ -1,11 +1,36 @@
+import { type ChildProcess, type SpawnOptions, type SpawnSyncOptions } from 'node:child_process';
 import type { BuiltinAgentType } from '@shennian/wire';
 export type CommandSpec = {
     command: string;
     args: string[];
     display: string;
 };
+export type ResolvedCommandKind = 'native' | 'cmd-shim' | 'wsl-bridge';
+export type ResolvedCommandSpec = CommandSpec & {
+    kind: ResolvedCommandKind;
+    path: string;
+};
+type LaunchSpec = {
+    command: string;
+    args: string[];
+    cwd?: string;
+};
 export declare function resetCommandSpecCache(): void;
+export declare function getProcessPlatform(): NodeJS.Platform;
+export declare function windowsPathToWsl(input: string): string | undefined;
 export declare function commandExists(command: string): boolean;
-export declare function resolveBuiltinCommand(type: BuiltinAgentType): CommandSpec | null;
-export declare function getCommandVersion(spec: CommandSpec, flag?: string): string | undefined;
-//# sourceMappingURL=command-spec.d.ts.map
+export declare function resolveBuiltinCommand(type: BuiltinAgentType): ResolvedCommandSpec | null;
+export declare function buildLaunchSpec(spec: ResolvedCommandSpec, runtimeArgs: string[], cwd?: string): LaunchSpec;
+export declare function spawnResolvedCommand(spec: ResolvedCommandSpec, runtimeArgs: string[], options?: Omit<SpawnOptions, 'cwd'> & {
+    cwd?: string;
+}): ChildProcess;
+export declare function spawnResolvedCommandSync(spec: ResolvedCommandSpec, runtimeArgs: string[], options?: Omit<SpawnSyncOptions, 'cwd'> & {
+    cwd?: string;
+}): import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+export declare function parseCommandString(command: string): string[];
+export declare function buildCommandStringLaunchSpec(commandString: string, runtimeArgs: string[], cwd?: string): LaunchSpec;
+export declare function spawnCommandString(commandString: string, runtimeArgs: string[], options?: Omit<SpawnOptions, 'cwd'> & {
+    cwd?: string;
+}): ChildProcess;
+export declare function getCommandVersion(spec: ResolvedCommandSpec, flag?: string): string | undefined;
+export {};

package/dist/src/agents/command-spec.js

@@ -1,4 +1,7 @@
-import { spawnSync } from 'node:child_process';
+// @arch docs/architecture/cli/windows-agent-launch.md
+// @test src/__tests__/command-spec.test.ts
+import { spawn, spawnSync } from 'node:child_process';
+import path from 'node:path';
 const BUILTIN_COMMANDS = {
     claude: [
         { command: 'claude', args: [], display: 'claude' },
@@ -22,33 +25,272 @@ const BUILTIN_COMMANDS = {
 };
 const availabilityCache = new Map();
 const resolvedCache = new Map();
+const pathLookupCache = new Map();
+const wslAvailabilityCache = new Map();
 export function resetCommandSpecCache() {
     availabilityCache.clear();
     resolvedCache.clear();
+    pathLookupCache.clear();
+    wslAvailabilityCache.clear();
 }
-export function commandExists(command) {
-    if (availabilityCache.has(command)) {
-        return availabilityCache.get(command) ?? false;
+export function getProcessPlatform() {
+    return process.platform;
+}
+function splitLines(text) {
+    return text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function lookupCommandPaths(command) {
+    if (pathLookupCache.has(command)) {
+        return pathLookupCache.get(command) ?? [];
     }
-    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    const lookup = getProcessPlatform() === 'win32' ? 'where' : 'which';
     const result = spawnSync(lookup, [command], {
-        stdio: 'ignore',
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
         timeout: 3000,
     });
-    const exists = result.status === 0;
+    const paths = result.status === 0 ? splitLines(result.stdout ?? '') : [];
+    pathLookupCache.set(command, paths);
+    return paths;
+}
+function getWindowsShellPath() {
+    return process.env.ComSpec || 'cmd.exe';
+}
+function isWindowsNativeBinary(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.exe' || ext === '.com';
+}
+function isWindowsCmdShim(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return ext === '.cmd' || ext === '.bat';
+}
+function quoteCmdArg(text) {
+    return `"${text.replace(/"/g, '""')}"`;
+}
+function quotePosixArg(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+export function windowsPathToWsl(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.replace(/\//g, '\\');
+    const driveMatch = normalized.match(/^([A-Za-z]):\\(.*)$/);
+    if (driveMatch) {
+        const [, drive, rest] = driveMatch;
+        const suffix = rest.replace(/\\/g, '/');
+        return `/mnt/${drive.toLowerCase()}/${suffix}`;
+    }
+    if (normalized.startsWith('\\\\wsl$\\')) {
+        const remainder = normalized.replace(/^\\\\wsl\$\\[^\\]+\\?/, '');
+        return `/${remainder.replace(/\\/g, '/')}`;
+    }
+    if (input.startsWith('/'))
+        return input;
+    return undefined;
+}
+function resolveArbitraryWindowsCommand(command) {
+    const normalized = command.trim();
+    if (!normalized) {
+        throw new Error('Command string is empty');
+    }
+    const hasExplicitPath = /[\\/]/.test(normalized) || /^[A-Za-z]:/.test(normalized);
+    if (hasExplicitPath) {
+        if (isWindowsCmdShim(normalized))
+            return { kind: 'cmd-shim', path: normalized };
+        return { kind: 'direct', path: normalized };
+    }
+    const paths = lookupCommandPaths(normalized);
+    const native = paths.find(isWindowsNativeBinary);
+    if (native)
+        return { kind: 'direct', path: native };
+    const shim = paths.find(isWindowsCmdShim);
+    if (shim)
+        return { kind: 'cmd-shim', path: shim };
+    return { kind: 'direct', path: normalized };
+}
+function canUseWslBridge(command) {
+    if (wslAvailabilityCache.has(command)) {
+        return wslAvailabilityCache.get(command) ?? false;
+    }
+    const wslPath = lookupCommandPaths('wsl.exe')[0] ?? lookupCommandPaths('wsl')[0];
+    if (!wslPath) {
+        wslAvailabilityCache.set(command, false);
+        return false;
+    }
+    const result = spawnSync(wslPath, ['-e', 'sh', '-lc', `command -v ${quotePosixArg(command)} >/dev/null 2>&1`], {
+        stdio: 'ignore',
+        timeout: 5000,
+    });
+    const ok = result.status === 0;
+    wslAvailabilityCache.set(command, ok);
+    return ok;
+}
+export function commandExists(command) {
+    if (availabilityCache.has(command)) {
+        return availabilityCache.get(command) ?? false;
+    }
+    const exists = lookupCommandPaths(command).length > 0 || (getProcessPlatform() === 'win32' && canUseWslBridge(command));
     availabilityCache.set(command, exists);
     return exists;
 }
+function resolveWindowsBuiltinCommand(candidate) {
+    const paths = lookupCommandPaths(candidate.command);
+    const native = paths.find(isWindowsNativeBinary);
+    if (native) {
+        return { ...candidate, kind: 'native', path: native };
+    }
+    const shim = paths.find(isWindowsCmdShim);
+    if (shim) {
+        return { ...candidate, kind: 'cmd-shim', path: shim };
+    }
+    if (canUseWslBridge(candidate.command)) {
+        const wslPath = lookupCommandPaths('wsl.exe')[0] ?? lookupCommandPaths('wsl')[0];
+        if (wslPath) {
+            return { ...candidate, kind: 'wsl-bridge', path: wslPath };
+        }
+    }
+    return null;
+}
 export function resolveBuiltinCommand(type) {
     if (resolvedCache.has(type)) {
         return resolvedCache.get(type) ?? null;
     }
-    const resolved = BUILTIN_COMMANDS[type].find((candidate) => commandExists(candidate.command)) ?? null;
+    const resolved = BUILTIN_COMMANDS[type]
+        .map((candidate) => {
+        if (getProcessPlatform() === 'win32') {
+            return resolveWindowsBuiltinCommand(candidate);
+        }
+        const commandPath = lookupCommandPaths(candidate.command)[0];
+        return commandPath ? { ...candidate, kind: 'native', path: commandPath } : null;
+    })
+        .find(Boolean) ?? null;
     resolvedCache.set(type, resolved);
     return resolved;
 }
+export function buildLaunchSpec(spec, runtimeArgs, cwd) {
+    if (spec.kind === 'native') {
+        return {
+            command: spec.path,
+            args: [...spec.args, ...runtimeArgs],
+            cwd,
+        };
+    }
+    if (spec.kind === 'cmd-shim') {
+        const commandLine = [spec.path, ...spec.args, ...runtimeArgs].map(quoteCmdArg).join(' ');
+        return {
+            command: getWindowsShellPath(),
+            args: ['/d', '/s', '/c', `"${commandLine}"`],
+            cwd,
+        };
+    }
+    const wslCwd = cwd ? windowsPathToWsl(cwd) : undefined;
+    if (cwd && !wslCwd) {
+        throw new Error(`Cannot map Windows path to WSL workDir: ${cwd}`);
+    }
+    const shellCommand = [
+        wslCwd ? `cd ${quotePosixArg(wslCwd)}` : '',
+        `exec ${[spec.command, ...spec.args, ...runtimeArgs].map(quotePosixArg).join(' ')}`,
+    ].filter(Boolean).join(' && ');
+    return {
+        command: spec.path,
+        args: ['-e', 'sh', '-lc', shellCommand],
+        cwd: undefined,
+    };
+}
+export function spawnResolvedCommand(spec, runtimeArgs, options = {}) {
+    const launch = buildLaunchSpec(spec, runtimeArgs, options.cwd);
+    return spawn(launch.command, launch.args, {
+        ...options,
+        cwd: launch.cwd,
+        ...(getProcessPlatform() === 'win32' && spec.kind === 'cmd-shim'
+            ? { windowsVerbatimArguments: true }
+            : {}),
+    });
+}
+export function spawnResolvedCommandSync(spec, runtimeArgs, options = {}) {
+    const launch = buildLaunchSpec(spec, runtimeArgs, options.cwd);
+    return spawnSync(launch.command, launch.args, {
+        ...options,
+        cwd: launch.cwd,
+        ...(getProcessPlatform() === 'win32' && spec.kind === 'cmd-shim'
+            ? { windowsVerbatimArguments: true }
+            : {}),
+    });
+}
+export function parseCommandString(command) {
+    const args = [];
+    let current = '';
+    let inSingle = false;
+    let inDouble = false;
+    for (const ch of command) {
+        if (ch === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (ch === ' ' && !inSingle && !inDouble) {
+            if (current) {
+                args.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (current)
+        args.push(current);
+    return args;
+}
+export function buildCommandStringLaunchSpec(commandString, runtimeArgs, cwd) {
+    const parts = parseCommandString(commandString);
+    const bin = parts[0];
+    if (!bin) {
+        throw new Error('Command string is empty');
+    }
+    const baseArgs = parts.slice(1);
+    if (getProcessPlatform() !== 'win32') {
+        return {
+            command: bin,
+            args: [...baseArgs, ...runtimeArgs],
+            cwd,
+        };
+    }
+    const invocation = resolveArbitraryWindowsCommand(bin);
+    if (invocation.kind === 'cmd-shim') {
+        return {
+            command: getWindowsShellPath(),
+            args: ['/d', '/s', '/c', `"${[invocation.path, ...baseArgs, ...runtimeArgs].map(quoteCmdArg).join(' ')}"`],
+            cwd,
+        };
+    }
+    return {
+        command: invocation.path,
+        args: [...baseArgs, ...runtimeArgs],
+        cwd,
+    };
+}
+export function spawnCommandString(commandString, runtimeArgs, options = {}) {
+    const launch = buildCommandStringLaunchSpec(commandString, runtimeArgs, options.cwd);
+    const parts = parseCommandString(commandString);
+    const invocation = getProcessPlatform() === 'win32' && parts[0]
+        ? resolveArbitraryWindowsCommand(parts[0])
+        : null;
+    return spawn(launch.command, launch.args, {
+        ...options,
+        cwd: launch.cwd,
+        ...(getProcessPlatform() === 'win32' && invocation?.kind === 'cmd-shim'
+            ? { windowsVerbatimArguments: true }
+            : {}),
+    });
+}
 export function getCommandVersion(spec, flag = '--version') {
-    const result = spawnSync(spec.command, [...spec.args, flag], {
+    const result = spawnResolvedCommandSync(spec, [flag], {
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'pipe'],
         timeout: 5000,
@@ -59,4 +301,3 @@ export function getCommandVersion(spec, flag = '--version') {
     const match = text.match(/\d+\.\d+[\w.-]*/);
     return match?.[0];
 }
-//# sourceMappingURL=command-spec.js.map

package/dist/src/agents/cursor.d.ts

@@ -20,4 +20,3 @@ export declare class CursorAdapter extends AgentAdapter {
     private emitTextDelta;
     private emitFinalResultDelta;
 }
-//# sourceMappingURL=cursor.d.ts.map

package/dist/src/agents/cursor.js

@@ -1,10 +1,9 @@
 // @arch docs/architecture/cli/agent-adapters.md
 // @test src/__tests__/cursor-adapter.test.ts
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
-import { resolveBuiltinCommand } from './command-spec.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 export class CursorAdapter extends AgentAdapter {
     type = 'cursor';
     process = null;
@@ -58,7 +57,7 @@ export class CursorAdapter extends AgentAdapter {
             this.emit('error', new Error('Cursor Agent CLI not found. Expected "agent" or "cursor agent".'));
             return;
         }
-        const proc = spawn(spec.command, [...spec.args, ...args], {
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -247,4 +246,3 @@ export class CursorAdapter extends AgentAdapter {
     }
 }
 registerAgent('cursor', () => new CursorAdapter());
-//# sourceMappingURL=cursor.js.map

package/dist/src/agents/custom.d.ts

@@ -26,11 +26,5 @@ export declare class CustomAgentAdapter extends AgentAdapter {
     private attachOutputHandlers;
     private handleProtocolEvent;
     private emitEvent;
-    /**
-     * Splits `this.command` into argv, supporting quoted strings.
-     * e.g. `python /path/to/agent.py` → ['python', '/path/to/agent.py']
-     */
-    private buildCommandArgs;
 }
 export declare function registerCustomAgent(name: string, entry: CustomAgentEntry): void;
-//# sourceMappingURL=custom.d.ts.map

package/dist/src/agents/custom.js

@@ -1,8 +1,8 @@
 // @arch docs/architecture/cli/agent-adapters.md#custom-agents
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { spawnCommandString } from './command-spec.js';
 export class CustomAgentAdapter extends AgentAdapter {
     type;
     command;
@@ -65,15 +65,14 @@ export class CustomAgentAdapter extends AgentAdapter {
     // ─── Spawn mode ───────────────────────────────────────────────────────────
     async runSpawn(text, modelId) {
         await this.killSpawnProcess();
-        const args = this.buildCommandArgs();
-        args.push('/run', '--workdir', this.workDir ?? process.cwd());
+        const args = ['/run', '--workdir', this.workDir ?? process.cwd()];
         if (this.sessionId)
             args.push('--session', this.sessionId);
         if (this.agentSessionId)
             args.push('--resume', this.agentSessionId);
         if (modelId)
             args.push('--model', modelId);
-        const proc = spawn(args[0], args.slice(1), {
+        const proc = spawnCommandString(this.command, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -99,9 +98,7 @@ export class CustomAgentAdapter extends AgentAdapter {
     }
     // ─── Stdio mode ───────────────────────────────────────────────────────────
     async startStdioProcess() {
-        const args = this.buildCommandArgs();
-        args.push('/start', '--workdir', this.workDir ?? process.cwd());
-        const proc = spawn(args[0], args.slice(1), {
+        const proc = spawnCommandString(this.command, ['/start', '--workdir', this.workDir ?? process.cwd()], {
             cwd: this.workDir ?? undefined,
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -206,41 +203,8 @@ export class CustomAgentAdapter extends AgentAdapter {
         const event = { ...partial, runId: this.runId, seq: this.seq++ };
         this.emit('agentEvent', event);
     }
-    // ─── Helpers ──────────────────────────────────────────────────────────────
-    /**
-     * Splits `this.command` into argv, supporting quoted strings.
-     * e.g. `python /path/to/agent.py` → ['python', '/path/to/agent.py']
-     */
-    buildCommandArgs() {
-        const args = [];
-        let current = '';
-        let inSingle = false;
-        let inDouble = false;
-        for (const ch of this.command) {
-            if (ch === "'" && !inDouble) {
-                inSingle = !inSingle;
-                continue;
-            }
-            if (ch === '"' && !inSingle) {
-                inDouble = !inDouble;
-                continue;
-            }
-            if (ch === ' ' && !inSingle && !inDouble) {
-                if (current) {
-                    args.push(current);
-                    current = '';
-                }
-                continue;
-            }
-            current += ch;
-        }
-        if (current)
-            args.push(current);
-        return args;
-    }
 }
 export function registerCustomAgent(name, entry) {
     const agentType = `custom:${name}`;
     registerAgent(agentType, () => new CustomAgentAdapter(name, entry));
 }
-//# sourceMappingURL=custom.js.map

package/dist/src/agents/detect.d.ts

@@ -7,4 +7,3 @@ export type DetectedAgent = {
     models?: ModelInfo[];
 };
 export declare function detectAgents(): DetectedAgent[];
-//# sourceMappingURL=detect.d.ts.map

package/dist/src/agents/detect.js

@@ -44,4 +44,3 @@ export function detectAgents() {
     }
     return detected;
 }
-//# sourceMappingURL=detect.js.map

package/dist/src/agents/gemini.d.ts

@@ -15,4 +15,3 @@ export declare class GeminiAdapter extends AgentAdapter {
     private emitEvent;
     private killProcess;
 }
-//# sourceMappingURL=gemini.d.ts.map

package/dist/src/agents/gemini.js

@@ -1,7 +1,7 @@
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 function num(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
@@ -64,7 +64,12 @@ export class GeminiAdapter extends AgentAdapter {
         await this.killProcess();
     }
     spawnAndParse(args) {
-        const proc = spawn('gemini', args, {
+        const spec = resolveBuiltinCommand('gemini');
+        if (!spec) {
+            this.emit('error', new Error('Command "gemini" not found. Is Gemini CLI installed?'));
+            return;
+        }
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -165,4 +170,3 @@ export class GeminiAdapter extends AgentAdapter {
     }
 }
 registerAgent('gemini', () => new GeminiAdapter());
-//# sourceMappingURL=gemini.js.map

package/dist/src/agents/model-registry/cache.d.ts

@@ -2,4 +2,3 @@ import { type CacheEntry, type CacheFile } from './types.js';
 export declare function readCache(): CacheFile;
 export declare function writeCache(cache: CacheFile): void;
 export declare function isCacheFresh(entry: CacheEntry | undefined, version?: string): boolean;
-//# sourceMappingURL=cache.d.ts.map

package/dist/src/agents/model-registry/cache.js

@@ -35,4 +35,3 @@ export function isCacheFresh(entry, version) {
         return false;
     return Date.now() - entry.refreshedAt < CACHE_TTL_MS;
 }
-//# sourceMappingURL=cache.js.map

package/dist/src/agents/model-registry/discovery.d.ts

@@ -2,4 +2,3 @@ import type { ModelInfo } from '@shennian/wire';
 import type { DetectedAgent } from '../detect.js';
 import { type DiscoveryContext } from './types.js';
 export declare function discoverModelsForAgent(agent: DetectedAgent, context: DiscoveryContext): Promise<ModelInfo[]>;
-//# sourceMappingURL=discovery.d.ts.map