shennian 0.2.4 → 0.2.5

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

@@ -1,10 +1,9 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
-import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
-import { resolveBuiltinCommand } from '../command-spec.js';
-import { parseClaudeModels, parseCodexAppServerModels, parseCodexModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, } from './parsers.js';
-import { runCommand, runPtyCommand } from './runner.js';
+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)
@@ -24,8 +23,8 @@ function sendAppServerRpc(proc, pending, id, method, params, timeoutMs) {
         });
     });
 }
-async function discoverCodexModelsViaAppServer() {
-    const proc = spawn('codex', ['app-server', '--listen', 'stdio://'], {
+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' },
@@ -88,71 +87,32 @@ 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 appServerModels = await discoverCodexModelsViaAppServer().catch(() => []);
-    if (appServerModels.length > 0)
-        return appServerModels;
-    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)
@@ -199,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,7 +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[];

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

@@ -138,6 +138,78 @@ export function parseClaudeModels(raw) {
     }
     return uniqueModels(fallback);
 }
+function compareVersionNumbers(a, b) {
+    const length = Math.max(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        const left = a[index] ?? -1;
+        const right = b[index] ?? -1;
+        if (left === right)
+            continue;
+        return left - right;
+    }
+    return 0;
+}
+function extractClaudeFamilyVersion(id, family) {
+    const match = id.match(new RegExp(`^claude-${family}-([0-9]+(?:-[0-9]+)*)$`, 'i'));
+    if (!match?.[1])
+        return null;
+    const parts = match[1]
+        .split('-')
+        .map((part) => Number.parseInt(part, 10))
+        .filter((part) => Number.isFinite(part));
+    if (parts.length === 0 || parts.length > 2)
+        return null;
+    return parts;
+}
+function formatClaudeVersion(version) {
+    if (!version?.length)
+        return undefined;
+    return `v${version.join('.')}`;
+}
+export function parseClaudeBinaryModels(raw) {
+    const clean = stripAnsi(raw);
+    const aliasMap = {
+        default: 'Default (recommended)',
+        sonnet: 'Sonnet',
+        opus: 'Opus',
+        haiku: 'Haiku',
+    };
+    const familyVersions = new Map();
+    for (const family of ['sonnet', 'opus', 'haiku']) {
+        for (const match of clean.matchAll(new RegExp(`\\bclaude-${family}-[0-9.-]+\\b`, 'gi'))) {
+            const normalized = match[0].trim().toLowerCase().replace(/\./g, '-').replace(/-+$/g, '');
+            const version = extractClaudeFamilyVersion(normalized, family);
+            if (!version)
+                continue;
+            const current = familyVersions.get(family);
+            if (!current || compareVersionNumbers(current, version) < 0) {
+                familyVersions.set(family, version);
+            }
+        }
+    }
+    const models = [];
+    for (const alias of ['default', 'sonnet', 'opus', 'haiku']) {
+        if (!new RegExp(`\\b${alias}\\b`, 'i').test(clean))
+            continue;
+        const version = (alias === 'default' ? familyVersions.get('sonnet') : familyVersions.get(alias)) ?? null;
+        models.push({
+            id: alias,
+            name: aliasMap[alias],
+            description: formatClaudeVersion(version),
+            provider: 'anthropic',
+            isDefault: alias === 'default',
+        });
+    }
+    return uniqueModels(models);
+}
+export function fallbackClaudeAliasModels() {
+    return [
+        { id: 'default', name: 'Default (recommended)', provider: 'anthropic', isDefault: true },
+        { id: 'sonnet', name: 'Sonnet', provider: 'anthropic' },
+        { id: 'opus', name: 'Opus', provider: 'anthropic' },
+        { id: 'haiku', name: 'Haiku', provider: 'anthropic' },
+    ];
+}
 export function parseCodexModels(raw) {
     const clean = stripAnsi(raw);
     const models = [];
@@ -162,6 +234,9 @@ export function parseCodexAppServerModels(raw) {
         ? raw
         : {};
     const currentModel = typeof data.config?.model === 'string' ? data.config.model : undefined;
+    const currentReasoningEffort = typeof data.config?.model_reasoning_effort === 'string'
+        ? data.config.model_reasoning_effort
+        : undefined;
     const models = [];
     for (const entry of data.data ?? []) {
         if (typeof entry !== 'object' || entry === null)
@@ -212,12 +287,21 @@ export function parseCodexAppServerModels(raw) {
             name: displayName || prettifyCodexModel(id),
             description,
             provider: 'openai',
-            isDefault: item.isDefault === true || currentModel === id,
+            isDefault: currentModel ? currentModel === id : item.isDefault === true,
             supportedReasoningEfforts,
             defaultReasoningEffort,
             additionalSpeedTiers,
         });
     }
+    if (currentModel && !models.some((model) => model.id === currentModel)) {
+        models.unshift({
+            id: currentModel,
+            name: prettifyCodexModel(currentModel),
+            provider: 'openai',
+            isDefault: true,
+            defaultReasoningEffort: currentReasoningEffort,
+        });
+    }
     return uniqueModels(models);
 }
 export function parseGeminiModels(raw) {
@@ -256,4 +340,10 @@ export function parseGeminiModels(raw) {
     }
     return uniqueModels(models);
 }
-//# sourceMappingURL=parsers.js.map
+export function fallbackGeminiModels() {
+    return [
+        { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', provider: 'google', isDefault: true },
+        { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', provider: 'google' },
+        { id: 'auto-gemini-2.5', name: 'Auto Gemini 2.5', provider: 'google' },
+    ];
+}

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

@@ -1,11 +1,6 @@
-import { type PtyOptions } from './types.js';
-export declare function runCommand(command: string, args: string[], timeoutMs?: number): Promise<{
+import type { ResolvedCommandSpec } from '../command-spec.js';
+export declare function runResolvedCommand(spec: ResolvedCommandSpec, args: string[], timeoutMs?: number): Promise<{
     stdout: string;
     stderr: string;
     exitCode: number | null;
 }>;
-export declare function runPtyCommand(spec: {
-    command: string;
-    args: string[];
-}, options: PtyOptions): Promise<string>;
-//# sourceMappingURL=runner.d.ts.map

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

@@ -1,11 +1,10 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
-import { spawn as spawnProcess } from 'node:child_process';
-import { stripAnsi } from './parsers.js';
+import { spawnResolvedCommand } from '../command-spec.js';
 import { DISCOVERY_WORKDIR } from './types.js';
-export function runCommand(command, args, timeoutMs = 15_000) {
+export function runResolvedCommand(spec, args, timeoutMs = 15_000) {
     return new Promise((resolve, reject) => {
-        const proc = spawnProcess(command, args, {
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: DISCOVERY_WORKDIR,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env, NO_COLOR: '1' },
@@ -28,133 +27,3 @@ export function runCommand(command, args, timeoutMs = 15_000) {
         });
     });
 }
-// Lazy-load node-pty so platforms where native compilation fails still work
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let ptySpawnRef;
-async function loadPtySpawn() {
-    if (ptySpawnRef)
-        return ptySpawnRef;
-    try {
-        const pty = await import('@homebridge/node-pty-prebuilt-multiarch');
-        ptySpawnRef = pty.spawn;
-        return ptySpawnRef;
-    }
-    catch {
-        return undefined;
-    }
-}
-export async function runPtyCommand(spec, options) {
-    const ptySpawn = await loadPtySpawn();
-    if (!ptySpawn)
-        return '';
-    const initialDelayMs = options.initialDelayMs ?? 2500;
-    const timeoutMs = options.timeoutMs ?? 20_000;
-    const scrollCount = options.scrollCount ?? 0;
-    const scrollIntervalMs = options.scrollIntervalMs ?? 400;
-    const scrollAfterOpenMs = options.scrollAfterOpenMs ?? 2000;
-    const preOpenPromptPatterns = options.preOpenPromptPatterns ?? [];
-    const preOpenPromptInput = options.preOpenPromptInput ?? '';
-    return new Promise((resolve) => {
-        const proc = ptySpawn(spec.command, [...spec.args, ...(options.startupArgs ?? [])], {
-            name: 'xterm-256color',
-            cols: 200,
-            rows: 120,
-            cwd: DISCOVERY_WORKDIR,
-            env: {
-                ...process.env,
-                TERM: 'xterm-256color',
-                COLUMNS: '200',
-                LINES: '120',
-                NO_COLOR: '1',
-            },
-        });
-        let output = '';
-        let opened = false;
-        let scrolling = false;
-        let closing = false;
-        let finished = false;
-        let handledPreOpenPrompt = false;
-        const cleanup = () => {
-            if (finished)
-                return;
-            finished = true;
-            clearTimeout(forceOpenTimer);
-            clearTimeout(forceCloseTimer);
-            resolve(output);
-        };
-        const doClose = () => {
-            if (closing)
-                return;
-            closing = true;
-            proc.write('\u001b');
-            setTimeout(() => {
-                proc.write('\u0003');
-                proc.kill();
-            }, 300);
-        };
-        const doScroll = () => {
-            if (scrollCount <= 0)
-                return;
-            scrolling = true;
-            let remaining = scrollCount;
-            const tick = () => {
-                if (remaining <= 0 || closing || finished) {
-                    scrolling = false;
-                    setTimeout(doClose, 500);
-                    return;
-                }
-                proc.write('\u001b[B');
-                remaining--;
-                setTimeout(tick, scrollIntervalMs);
-            };
-            tick();
-        };
-        const afterOpen = () => {
-            if (scrollCount > 0) {
-                setTimeout(doScroll, scrollAfterOpenMs);
-            }
-        };
-        const forceOpenTimer = setTimeout(() => {
-            if (!opened) {
-                opened = true;
-                proc.write('/model\r');
-                afterOpen();
-            }
-        }, initialDelayMs);
-        const forceCloseTimer = setTimeout(doClose, timeoutMs);
-        const maybeOpen = () => {
-            const clean = stripAnsi(output);
-            if (!handledPreOpenPrompt && preOpenPromptPatterns.some((pattern) => pattern.test(clean))) {
-                handledPreOpenPrompt = true;
-                if (preOpenPromptInput) {
-                    proc.write(preOpenPromptInput);
-                }
-                return;
-            }
-            if (opened)
-                return;
-            if (options.readyPatterns.some((pattern) => pattern.test(clean))) {
-                opened = true;
-                proc.write('/model\r');
-                afterOpen();
-            }
-        };
-        const maybeClose = () => {
-            if (!opened || closing || scrolling || scrollCount > 0)
-                return;
-            const clean = stripAnsi(output);
-            if (options.closePatterns.some((pattern) => pattern.test(clean))) {
-                doClose();
-            }
-        };
-        proc.onData((chunk) => {
-            output += chunk;
-            if (!finished) {
-                maybeOpen();
-                maybeClose();
-            }
-        });
-        proc.onExit(cleanup);
-    });
-}
-//# sourceMappingURL=runner.js.map

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

@@ -4,4 +4,3 @@ import type { DiscoveryContext } from './types.js';
 export declare function getCachedAgentInfos(detectedAgents: DetectedAgent[]): AgentInfo[];
 export declare function refreshAgentInfos(detectedAgents: DetectedAgent[], context: DiscoveryContext): Promise<AgentInfo[]>;
 export declare function resolveAgentInfos(detectedAgents: DetectedAgent[], context: DiscoveryContext): Promise<AgentInfo[]>;
-//# sourceMappingURL=service.d.ts.map

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

@@ -39,21 +39,24 @@ export async function resolveAgentInfos(detectedAgents, context) {
             models = cached.models;
         }
         else {
+            let discovered = null;
             try {
-                const discovered = uniqueModels(await discoverModelsForAgent(agent, context));
+                discovered = uniqueModels(await discoverModelsForAgent(agent, context));
                 models = discovered.length > 0 ? discovered : cached?.models ?? agent.models ?? [];
             }
             catch {
                 models = cached?.models ?? agent.models ?? [];
             }
-            const nextEntry = {
-                version: agent.version,
-                refreshedAt: Date.now(),
-                models,
-            };
-            if (JSON.stringify(cached) !== JSON.stringify(nextEntry)) {
-                cache.agents[agent.type] = nextEntry;
-                changed = true;
+            if (discovered && discovered.length > 0) {
+                const nextEntry = {
+                    version: agent.version,
+                    refreshedAt: Date.now(),
+                    models,
+                };
+                if (JSON.stringify(cached) !== JSON.stringify(nextEntry)) {
+                    cache.agents[agent.type] = nextEntry;
+                    changed = true;
+                }
             }
         }
         infos.push({
@@ -66,4 +69,3 @@ export async function resolveAgentInfos(detectedAgents, context) {
     }
     return infos;
 }
-//# sourceMappingURL=service.js.map

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

@@ -28,4 +28,3 @@ export type PtyOptions = {
     scrollCount?: number;
     scrollIntervalMs?: number;
 };
-//# sourceMappingURL=types.d.ts.map

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

@@ -6,4 +6,3 @@ export const CACHE_VERSION = 1;
 export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 export const MODEL_CACHE_PATH = resolveShennianPath('model-cache.json');
 export const DISCOVERY_WORKDIR = os.tmpdir();
-//# sourceMappingURL=types.js.map

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

@@ -1,7 +1,8 @@
 export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos } from './model-registry/service.js';
-import { parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi } from './model-registry/parsers.js';
+import { parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi } from './model-registry/parsers.js';
 /** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
 export declare const modelSwitchingTestExports: {
+    readonly parseClaudeBinaryModels: typeof parseClaudeBinaryModels;
     readonly parseClaudeModels: typeof parseClaudeModels;
     readonly parseCodexModels: typeof parseCodexModels;
     readonly parseCodexAppServerModels: typeof parseCodexAppServerModels;
@@ -10,4 +11,3 @@ export declare const modelSwitchingTestExports: {
     readonly parseGeminiModels: typeof parseGeminiModels;
     readonly stripAnsi: typeof stripAnsi;
 };
-//# sourceMappingURL=model-registry.d.ts.map

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

@@ -1,9 +1,10 @@
 // @arch docs/architecture/cli/model-discovery.md
 // @test src/__tests__/model-switching.test.ts
 export { getCachedAgentInfos, refreshAgentInfos, resolveAgentInfos } from './model-registry/service.js';
-import { parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi, } from './model-registry/parsers.js';
+import { parseClaudeBinaryModels, parseClaudeModels, parseCodexModels, parseCodexAppServerModels, parseCursorModels, parseGeminiModels, parseOpenClawModels, stripAnsi, } from './model-registry/parsers.js';
 /** Used by Vitest / `model-switching-e2e.ts` — not a stable public API. */
 export const modelSwitchingTestExports = {
+    parseClaudeBinaryModels,
     parseClaudeModels,
     parseCodexModels,
     parseCodexAppServerModels,
@@ -12,4 +13,3 @@ export const modelSwitchingTestExports = {
     parseGeminiModels,
     stripAnsi,
 };
-//# sourceMappingURL=model-registry.js.map

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

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

package/dist/src/agents/openclaw.js

@@ -1,6 +1,6 @@
-import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { AgentAdapter, registerAgent } from './adapter.js';
+import { resolveBuiltinCommand, spawnResolvedCommand } from './command-spec.js';
 /** Best-effort parse of `openclaw agent --json` stdout; shape may vary by version. */
 function extractResponseText(parsed) {
     if (parsed == null)
@@ -116,8 +116,13 @@ export class OpenClawAdapter extends AgentAdapter {
         await this.killProcess();
     }
     spawnAgent(extraArgs) {
+        const spec = resolveBuiltinCommand('openclaw');
+        if (!spec) {
+            this.emit('error', new Error('Command "openclaw" not found. Is OpenClaw CLI installed?'));
+            return;
+        }
         const args = ['agent', '--local', '--json', ...extraArgs];
-        const proc = spawn('openclaw', args, {
+        const proc = spawnResolvedCommand(spec, args, {
             cwd: this.workDir ?? undefined,
             stdio: ['ignore', 'pipe', 'pipe'],
             env: { ...process.env },
@@ -190,8 +195,13 @@ export class OpenClawAdapter extends AgentAdapter {
     }
     async runAgentCommand(extraArgs) {
         return new Promise((resolve) => {
+            const spec = resolveBuiltinCommand('openclaw');
+            if (!spec) {
+                resolve({ ok: false, error: 'Command "openclaw" not found. Is OpenClaw CLI installed?' });
+                return;
+            }
             const args = ['agent', '--local', '--json', ...extraArgs];
-            const proc = spawn('openclaw', args, {
+            const proc = spawnResolvedCommand(spec, args, {
                 cwd: this.workDir ?? undefined,
                 stdio: ['ignore', 'pipe', 'pipe'],
                 env: { ...process.env },
@@ -261,4 +271,3 @@ export class OpenClawAdapter extends AgentAdapter {
     }
 }
 registerAgent('openclaw', () => new OpenClawAdapter());
-//# sourceMappingURL=openclaw.js.map

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

@@ -49,4 +49,3 @@ export declare class PiAdapter extends AgentAdapter {
     private resolvePendingSendStart;
     private rejectPendingSendStart;
 }
-//# sourceMappingURL=pi.d.ts.map

package/dist/src/agents/pi.js

@@ -791,4 +791,3 @@ export class PiAdapter extends AgentAdapter {
     }
 }
 registerAgent('pi', () => new PiAdapter());
-//# sourceMappingURL=pi.js.map

package/dist/src/commands/agent.d.ts

@@ -1,3 +1,2 @@
 import type { Command } from 'commander';
 export declare function registerAgentCommand(program: Command): void;
-//# sourceMappingURL=agent.d.ts.map

package/dist/src/commands/agent.js

@@ -1,6 +1,6 @@
-import { spawn } from 'node:child_process';
 import chalk from 'chalk';
 import { loadConfig, saveConfig } from '../config/index.js';
+import { spawnCommandString } from '../agents/command-spec.js';
 function getCapsModels(caps) {
     if (caps.models?.length)
         return caps.models;
@@ -12,11 +12,8 @@ function getCapsModels(caps) {
  * Runs `<command> /caps` and returns the parsed caps JSON.
  */
 async function probeCaps(command) {
-    const parts = splitCommand(command);
-    const bin = parts[0];
-    const args = [...parts.slice(1), '/caps'];
     return new Promise((resolve, reject) => {
-        const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        const proc = spawnCommandString(command, ['/caps'], { stdio: ['ignore', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
         proc.stdout?.on('data', (d) => { stdout += d.toString(); });
@@ -54,33 +51,6 @@ async function probeCaps(command) {
         }, 5000);
     });
 }
-function splitCommand(cmd) {
-    const args = [];
-    let current = '';
-    let inSingle = false;
-    let inDouble = false;
-    for (const ch of cmd) {
-        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 registerAgentCommand(program) {
     const agent = program
         .command('agent')
@@ -159,4 +129,3 @@ export function registerAgentCommand(program) {
         console.log(chalk.yellow('  Refresh Agents in the app to hot-reload this daemon, or restart the daemon as a fallback.'));
     });
 }
-//# sourceMappingURL=agent.js.map

package/dist/src/commands/daemon.d.ts

@@ -14,6 +14,12 @@ export declare function resolveServiceLaunchSpec(input: {
 }): ServiceLaunchSpec;
 export declare function buildWindowsLauncherCommand(spec: ServiceLaunchSpec, logFile: string): string;
 export declare function buildWindowsStartupVbs(cmdPath: string): string;
+export declare function buildWindowsScheduledTaskXml(input: {
+    userId: string;
+    command: string;
+    arguments: string[];
+}): string;
+export declare function captureEnvForService(): Record<string, string>;
 /**
  * Save current env vars so the daemon can load them at startup.
  * This is critical for launchd/systemd which start with minimal env.
@@ -27,4 +33,3 @@ export declare function startDaemonProcess(): void;
 export declare function installService(): boolean;
 export declare function registerDaemonCommand(program: Command): void;
 export {};
-//# sourceMappingURL=daemon.d.ts.map