shennian 0.2.0 → 0.2.5

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

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

@@ -1,75 +1,118 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
-import { resolveBuiltinCommand } from '../command-spec.js';
-import { parseClaudeModels, parseCodexModels, parseCursorModels, parseGeminiModels, parseOpenClawModels } from './parsers.js';
-import { runCommand, runPtyCommand } from './runner.js';
+import { createInterface } from 'node:readline';
+import { resolveBuiltinCommand, spawnResolvedCommand } from '../command-spec.js';
+import { fallbackClaudeAliasModels, fallbackGeminiModels, parseCodexAppServerModels, parseCursorModels, parseOpenClawModels, } from './parsers.js';
+import { runResolvedCommand } from './runner.js';
 import { DISCOVERY_WORKDIR } from './types.js';
+function sendAppServerRpc(proc, pending, id, method, params, timeoutMs) {
+    if (!proc.stdin)
+        return Promise.reject(new Error('codex app-server stdin unavailable'));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(id);
+            reject(new Error(`codex app-server request timed out: ${method}`));
+        }, timeoutMs);
+        pending.set(id, { resolve, reject, timer });
+        proc.stdin.write(`${JSON.stringify({ id, method, params })}\n`, (error) => {
+            if (!error)
+                return;
+            clearTimeout(timer);
+            pending.delete(id);
+            reject(error);
+        });
+    });
+}
+async function discoverCodexModelsViaAppServer(spec) {
+    const proc = spawnResolvedCommand(spec, ['app-server', '--listen', 'stdio://'], {
+        cwd: DISCOVERY_WORKDIR,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, NO_COLOR: '1' },
+    });
+    const pending = new Map();
+    let seq = 1;
+    const rl = createInterface({ input: proc.stdout });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (msg.id == null)
+            return;
+        const request = pending.get(msg.id);
+        if (!request)
+            return;
+        clearTimeout(request.timer);
+        pending.delete(msg.id);
+        if (msg.error) {
+            request.reject(new Error(msg.error.message || `codex app-server error ${msg.error.code ?? ''}`.trim()));
+        }
+        else {
+            request.resolve(msg.result);
+        }
+    });
+    try {
+        await sendAppServerRpc(proc, pending, seq++, 'initialize', {
+            clientInfo: { name: 'shennian', title: 'Shennian', version: '0.0.0' },
+            capabilities: { experimentalApi: true },
+        }, 10_000);
+        const [modelList, configRead] = await Promise.all([
+            sendAppServerRpc(proc, pending, seq++, 'model/list', {}, 15_000),
+            sendAppServerRpc(proc, pending, seq++, 'config/read', {}, 15_000).catch(() => null),
+        ]);
+        const config = typeof configRead === 'object' && configRead !== null && 'config' in configRead
+            ? configRead.config
+            : undefined;
+        return parseCodexAppServerModels({
+            ...(typeof modelList === 'object' && modelList !== null ? modelList : {}),
+            config,
+        });
+    }
+    finally {
+        for (const [id, request] of pending) {
+            clearTimeout(request.timer);
+            request.reject(new Error('codex app-server stopped'));
+            pending.delete(id);
+        }
+        proc.kill('SIGTERM');
+        setTimeout(() => proc.kill('SIGKILL'), 1000).unref();
+    }
+}
 async function discoverCursorModels() {
     const spec = resolveBuiltinCommand('cursor');
     if (!spec)
         return [];
-    const result = await runCommand(spec.command, [...spec.args, '--list-models']);
+    const result = await runResolvedCommand(spec, ['--list-models']);
     return parseCursorModels(result.stdout);
 }
 async function discoverOpenClawModels() {
     const spec = resolveBuiltinCommand('openclaw');
     if (!spec)
         return [];
-    const result = await runCommand(spec.command, [...spec.args, 'models', 'list', '--json']);
+    const result = await runResolvedCommand(spec, ['models', 'list', '--json']);
     return parseOpenClawModels(result.stdout);
 }
 async function discoverClaudeModels() {
-    const spec = resolveBuiltinCommand('claude');
-    if (!spec)
+    if (!resolveBuiltinCommand('claude'))
         return [];
-    const runDiscovery = async (startupArgs) => runPtyCommand(spec, {
-        startupArgs,
-        readyPatterns: [/[>❯]/, /claude/i],
-        closePatterns: [/esc/i, /confirm/i, /default/i],
-        timeoutMs: 12_000,
-    });
-    const primaryRaw = await runDiscovery(['--bare', '--dangerously-skip-permissions']);
-    const primaryModels = parseClaudeModels(primaryRaw);
-    if (primaryModels.length > 0)
-        return primaryModels;
-    const clean = primaryRaw.toLowerCase();
-    const bareUnsupported = clean.includes('--bare') &&
-        (clean.includes('unknown option') ||
-            clean.includes('unknown argument') ||
-            clean.includes('unexpected argument') ||
-            clean.includes('unrecognized option'));
-    if (!bareUnsupported)
-        return primaryModels;
-    const fallbackRaw = await runDiscovery(['--dangerously-skip-permissions']);
-    return parseClaudeModels(fallbackRaw);
+    return fallbackClaudeAliasModels();
 }
 async function discoverCodexModels() {
     const spec = resolveBuiltinCommand('codex');
     if (!spec)
         return [];
-    const raw = await runPtyCommand(spec, {
-        startupArgs: ['--no-alt-screen', '-C', DISCOVERY_WORKDIR],
-        preOpenPromptPatterns: [/update available!/i, /skip until next version/i, /release notes:/i],
-        preOpenPromptInput: '\u001b[B\r',
-        readyPatterns: [/(?:^|\s)\/model\b/i, /codex/i],
-        closePatterns: [/enter to select/i, /dismiss/i, /select model/i],
-        timeoutMs: 45_000,
-        scrollAfterOpenMs: 2500,
-        scrollCount: 15,
-        scrollIntervalMs: 500,
-    });
-    return parseCodexModels(raw);
+    const appServerModels = await discoverCodexModelsViaAppServer(spec).catch(() => []);
+    return appServerModels;
 }
 async function discoverGeminiModels() {
-    const spec = resolveBuiltinCommand('gemini');
-    if (!spec)
+    if (!resolveBuiltinCommand('gemini'))
         return [];
-    const raw = await runPtyCommand(spec, {
-        readyPatterns: [/[>❯]/, /gemini/i],
-        closePatterns: [/enter to select/i, /select model/i, /\besc\b/i],
-        timeoutMs: 16_000,
-    });
-    return parseGeminiModels(raw);
+    return fallbackGeminiModels();
 }
 async function discoverPiModels(context) {
     if (!context.serverUrl || !context.authToken)
@@ -116,4 +159,3 @@ export async function discoverModelsForAgent(agent, context) {
     }
     return discoverBuiltinModels(agent.type, context);
 }
-//# sourceMappingURL=discovery.js.map

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

@@ -3,6 +3,9 @@ export declare function stripAnsi(text: string): string;
 export declare function parseCursorModels(raw: string): ModelInfo[];
 export declare function parseOpenClawModels(raw: string): ModelInfo[];
 export declare function parseClaudeModels(raw: string): ModelInfo[];
+export declare function parseClaudeBinaryModels(raw: string): ModelInfo[];
+export declare function fallbackClaudeAliasModels(): ModelInfo[];
 export declare function parseCodexModels(raw: string): ModelInfo[];
+export declare function parseCodexAppServerModels(raw: unknown): ModelInfo[];
 export declare function parseGeminiModels(raw: string): ModelInfo[];
-//# sourceMappingURL=parsers.d.ts.map
+export declare function fallbackGeminiModels(): ModelInfo[];