shennian 0.2.0 → 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

@@ -11,22 +11,39 @@ export declare class CodexAdapter extends AgentAdapter {
     private textTail;
     private terminalState;
     private forceCloseTimer;
+    private stderrBuf;
+    private rpcSeq;
+    private pendingRequests;
+    private appServerReady;
+    private activeTurnId;
+    private namedThread;
+    private deltaItemIds;
+    private lastTransientStatus;
     start(_sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
     send(text: string, modelId?: string): Promise<void>;
     resume(agentSessionId: string): Promise<void>;
     stop(): Promise<void>;
     private spawnCodex;
+    private spawnAppServer;
+    private ensureAppServer;
+    private initializeAppServer;
+    private sendRpc;
+    private handleAppServerMessage;
+    private handleAppServerCompletedItem;
+    private handleAppServerUsage;
     private handleCodexItemLine;
     private handleStreamEvent;
     private emitEvent;
     private killProcess;
+    private rejectAllPending;
     private handleProcessClose;
     private emitFinalIfOpen;
     private emitErrorIfOpen;
     private resetRunState;
+    private emitTransientStatus;
     private resetTextState;
     private emitText;
     private scheduleProcessClose;
     private clearForceCloseTimer;
 }
-//# sourceMappingURL=codex.d.ts.map
+export declare function normalizeCodexModelId(modelId?: string | null): string | undefined;

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;
@@ -16,6 +16,14 @@ export class CodexAdapter extends AgentAdapter {
     textTail = '';
     terminalState = 'open';
     forceCloseTimer = null;
+    stderrBuf = '';
+    rpcSeq = 1;
+    pendingRequests = new Map();
+    appServerReady = null;
+    activeTurnId = null;
+    namedThread = false;
+    deltaItemIds = new Set();
+    lastTransientStatus = '';
     async start(_sessionId, workDir, agentSessionId) {
         this.workDir = workDir;
         this.seq = 0;
@@ -23,27 +31,50 @@ export class CodexAdapter extends AgentAdapter {
             this.agentSessionId = agentSessionId;
     }
     async send(text, modelId) {
-        await this.killProcess();
+        if (this.activeTurnId) {
+            await this.killProcess();
+        }
+        const codexModelId = normalizeCodexModelId(modelId);
         this.runId = randomUUID();
         this.seq = 0;
         this.resetRunState();
-        const modelArgs = modelId ? ['-m', modelId] : [];
-        if (this.agentSessionId) {
-            this.spawnCodex([...modelArgs, '--dangerously-bypass-approvals-and-sandbox', 'exec', 'resume', this.agentSessionId, '--json', '--skip-git-repo-check', text]);
-        }
-        else {
-            this.spawnCodex([...modelArgs, '--dangerously-bypass-approvals-and-sandbox', 'exec', '--json', '--skip-git-repo-check', text]);
+        await this.ensureAppServer(codexModelId);
+        const threadId = this.agentSessionId;
+        if (!threadId)
+            throw new Error('codex app-server did not create a thread');
+        this.emitEvent({ state: 'start', agentSessionId: threadId });
+        if (!this.namedThread) {
+            await this.sendRpc('thread/name/set', {
+                threadId,
+                name: makeThreadTitle(text),
+            }).catch(() => { });
+            this.namedThread = true;
         }
+        const response = await this.sendRpc('turn/start', {
+            threadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+            approvalPolicy: 'never',
+            sandboxPolicy: { type: 'dangerFullAccess' },
+            ...(codexModelId ? { model: codexModelId } : {}),
+        });
+        this.activeTurnId = response.turn?.id ?? null;
     }
     async resume(agentSessionId) {
+        await this.killProcess();
         this.agentSessionId = agentSessionId;
+        this.namedThread = true;
         this.resetTextState();
     }
     async stop() {
         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 },
@@ -84,6 +115,263 @@ export class CodexAdapter extends AgentAdapter {
             }
         });
     }
+    spawnAppServer() {
+        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' },
+        });
+        this.process = proc;
+        this.stderrBuf = '';
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            this.handleAppServerMessage(msg);
+        });
+        proc.stderr?.on('data', (chunk) => {
+            this.stderrBuf += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            const hadActiveTurn = this.activeTurnId != null;
+            this.process = null;
+            this.appServerReady = null;
+            this.activeTurnId = null;
+            this.rejectAllPending(new Error(normalizeCodexStderr(this.stderrBuf) || `codex app-server exited with code ${code}`));
+            if (this.terminalState === 'open' && hadActiveTurn) {
+                this.handleProcessClose(code, this.stderrBuf);
+            }
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.rejectAllPending(err);
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "codex" not found. Is OpenAI Codex CLI installed?'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    async ensureAppServer(modelId) {
+        if (this.appServerReady)
+            return this.appServerReady;
+        this.spawnAppServer();
+        this.appServerReady = this.initializeAppServer(modelId).catch(async (error) => {
+            this.appServerReady = null;
+            await this.killProcess();
+            throw error;
+        });
+        return this.appServerReady;
+    }
+    async initializeAppServer(modelId) {
+        const codexModelId = normalizeCodexModelId(modelId);
+        await this.sendRpc('initialize', {
+            clientInfo: { name: 'shennian', title: 'Shennian', version: '0.0.0' },
+            capabilities: { experimentalApi: true },
+        });
+        if (this.agentSessionId) {
+            const response = await this.sendRpc('thread/resume', {
+                threadId: this.agentSessionId,
+                cwd: this.workDir,
+                approvalPolicy: 'never',
+                sandbox: 'danger-full-access',
+                persistExtendedHistory: true,
+                ...(codexModelId ? { model: codexModelId } : {}),
+            });
+            this.agentSessionId = response.thread?.id ?? this.agentSessionId;
+            this.namedThread = !!response.thread?.name;
+            return;
+        }
+        const response = await this.sendRpc('thread/start', {
+            cwd: this.workDir,
+            approvalPolicy: 'never',
+            sandbox: 'danger-full-access',
+            serviceName: 'Shennian',
+            experimentalRawEvents: false,
+            persistExtendedHistory: true,
+            ...(codexModelId ? { model: codexModelId } : {}),
+        });
+        const threadId = response.thread?.id;
+        if (!threadId)
+            throw new Error('codex app-server thread/start returned no thread id');
+        this.agentSessionId = threadId;
+        this.namedThread = !!response.thread?.name;
+    }
+    sendRpc(method, params, timeoutMs = 60_000) {
+        const proc = this.process;
+        if (!proc?.stdin)
+            return Promise.reject(new Error('codex app-server is not running'));
+        const id = this.rpcSeq++;
+        const payload = JSON.stringify({ id, method, params });
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`codex app-server request timed out: ${method}`));
+            }, timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timer });
+            proc.stdin.write(`${payload}\n`, (error) => {
+                if (!error)
+                    return;
+                clearTimeout(timer);
+                this.pendingRequests.delete(id);
+                reject(error);
+            });
+        });
+    }
+    handleAppServerMessage(msg) {
+        if (msg.id != null) {
+            const pending = this.pendingRequests.get(msg.id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pendingRequests.delete(msg.id);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message || `codex app-server error ${msg.error.code ?? ''}`.trim()));
+                }
+                else {
+                    pending.resolve(msg.result);
+                }
+            }
+        }
+        if (!msg.method)
+            return;
+        const params = msg.params ?? {};
+        switch (msg.method) {
+            case 'item/agentMessage/delta': {
+                const itemId = typeof params.itemId === 'string' ? params.itemId : '';
+                if (itemId)
+                    this.deltaItemIds.add(itemId);
+                if (typeof params.delta === 'string')
+                    this.emitText(params.delta);
+                break;
+            }
+            case 'item/completed':
+                this.handleAppServerCompletedItem(params);
+                break;
+            case 'thread/tokenUsage/updated':
+                this.handleAppServerUsage(params);
+                break;
+            case 'turn/completed': {
+                const turn = typeof params.turn === 'object' && params.turn !== null
+                    ? params.turn
+                    : null;
+                const turnId = typeof turn?.id === 'string' ? turn.id : null;
+                if (!this.activeTurnId || turnId === this.activeTurnId) {
+                    this.activeTurnId = null;
+                    this.emitFinalIfOpen();
+                }
+                break;
+            }
+            case 'error': {
+                const message = extractAppServerErrorMessage(params);
+                if (isTransientCodexErrorMessage(message)) {
+                    this.emitTransientStatus(message);
+                    return;
+                }
+                this.emitErrorIfOpen(message);
+                break;
+            }
+        }
+    }
+    handleAppServerCompletedItem(params) {
+        const item = typeof params.item === 'object' && params.item !== null
+            ? params.item
+            : null;
+        if (!item || typeof item.type !== 'string')
+            return;
+        switch (item.type) {
+            case 'agentMessage': {
+                const id = typeof item.id === 'string' ? item.id : '';
+                if (id && this.deltaItemIds.has(id))
+                    return;
+                if (typeof item.text === 'string')
+                    this.emitText(item.text, 'block');
+                break;
+            }
+            case 'commandExecution': {
+                const command = typeof item.command === 'string' ? item.command : '';
+                const output = typeof item.aggregatedOutput === 'string' ? item.aggregatedOutput : '';
+                if (command) {
+                    this.emitEvent({ state: 'tool-call', name: 'command_execution', args: { command } });
+                }
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: 'command_execution',
+                    result: [output, item.exitCode != null ? `\n(exit ${item.exitCode})` : ''].join('').trim(),
+                });
+                break;
+            }
+            case 'mcpToolCall':
+            case 'dynamicToolCall': {
+                const tool = typeof item.tool === 'string' ? item.tool : item.type;
+                const args = typeof item.arguments === 'object' && item.arguments !== null
+                    ? item.arguments
+                    : {};
+                this.emitEvent({ state: 'tool-call', name: tool, args });
+                this.emitEvent({
+                    state: 'tool-result',
+                    name: tool,
+                    result: safeStringify(item.error ?? item.result ?? item.contentItems ?? ''),
+                });
+                break;
+            }
+            case 'fileChange': {
+                const changes = Array.isArray(item.changes) ? item.changes : [];
+                const summary = changes
+                    .map((change) => {
+                    if (typeof change !== 'object' || change === null)
+                        return '';
+                    const c = change;
+                    const path = typeof c.path === 'string' ? c.path : typeof c.file === 'string' ? c.file : '';
+                    const kind = typeof c.kind === 'string' ? c.kind : typeof c.type === 'string' ? c.type : 'change';
+                    return path ? `${kind}: ${path}` : '';
+                })
+                    .filter(Boolean)
+                    .join('\n');
+                if (summary)
+                    this.emitText(summary, 'block');
+                break;
+            }
+        }
+    }
+    handleAppServerUsage(params) {
+        const tokenUsage = typeof params.tokenUsage === 'object' && params.tokenUsage !== null
+            ? params.tokenUsage
+            : null;
+        const last = typeof tokenUsage?.last === 'object' && tokenUsage.last !== null
+            ? tokenUsage.last
+            : null;
+        const total = typeof tokenUsage?.total === 'object' && tokenUsage.total !== null
+            ? tokenUsage.total
+            : null;
+        const usage = last ?? total;
+        if (!usage)
+            return;
+        const input = typeof usage.inputTokens === 'number' ? usage.inputTokens : undefined;
+        const output = typeof usage.outputTokens === 'number' ? usage.outputTokens : undefined;
+        if (input != null || output != null) {
+            this.pendingUsage = {
+                inputTokens: input ?? 0,
+                outputTokens: output ?? 0,
+            };
+        }
+    }
     handleCodexItemLine(obj) {
         const item = obj.item;
         if (!item?.type)
@@ -273,8 +561,12 @@ export class CodexAdapter extends AgentAdapter {
     }
     async killProcess() {
         const proc = this.process;
-        if (!proc)
+        this.appServerReady = null;
+        this.activeTurnId = null;
+        if (!proc) {
+            this.rejectAllPending(new Error('codex app-server stopped'));
             return;
+        }
         this.process = null;
         this.clearForceCloseTimer();
         proc.kill('SIGTERM');
@@ -285,6 +577,14 @@ export class CodexAdapter extends AgentAdapter {
                 resolve();
             }, 3000);
         });
+        this.rejectAllPending(new Error('codex app-server stopped'));
+    }
+    rejectAllPending(error) {
+        for (const [id, pending] of this.pendingRequests.entries()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+            this.pendingRequests.delete(id);
+        }
     }
     handleProcessClose(code, stderrBuf) {
         const stderr = normalizeCodexStderr(stderrBuf);
@@ -311,21 +611,29 @@ export class CodexAdapter extends AgentAdapter {
             usage: this.pendingUsage,
             agentSessionId: this.agentSessionId ?? undefined,
         });
-        this.scheduleProcessClose();
     }
     emitErrorIfOpen(message) {
         if (this.terminalState !== 'open')
             return;
         this.terminalState = 'error';
-        this.emitEvent({ state: 'error', message });
+        this.emitEvent({ state: 'error', message: formatCodexErrorMessage(message) });
         this.scheduleProcessClose();
     }
     resetRunState() {
         this.pendingUsage = undefined;
         this.terminalState = 'open';
+        this.deltaItemIds.clear();
+        this.lastTransientStatus = '';
         this.clearForceCloseTimer();
         this.resetTextState();
     }
+    emitTransientStatus(message) {
+        const formatted = formatTransientCodexStatus(message);
+        if (!formatted || formatted === this.lastTransientStatus || this.terminalState !== 'open')
+            return;
+        this.lastTransientStatus = formatted;
+        this.emitEvent({ state: 'delta', text: `${formatted}\n`, thinking: true });
+    }
     resetTextState() {
         this.hasEmittedText = false;
         this.textTail = '';
@@ -371,6 +679,58 @@ export class CodexAdapter extends AgentAdapter {
         this.forceCloseTimer = null;
     }
 }
+function makeThreadTitle(text) {
+    const firstLine = normalizeTitleText(text).split('\n').find((line) => line.trim()) ?? 'Shennian';
+    const title = firstLine.trim().slice(0, 80);
+    return title || 'Shennian';
+}
+function normalizeTitleText(text) {
+    return text
+        .replace(/!\[[^\]]*]\([^)]+\)/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function normalizeCodexModelId(modelId) {
+    const trimmed = modelId?.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.toLowerCase() === 'openai' ? undefined : trimmed;
+}
+function extractAppServerErrorMessage(params) {
+    if (typeof params.message === 'string' && params.message.trim())
+        return params.message.trim();
+    const error = params.error;
+    if (typeof error === 'string' && error.trim())
+        return error.trim();
+    if (typeof error === 'object' && error !== null) {
+        const message = error.message;
+        if (typeof message === 'string' && message.trim())
+            return message.trim();
+    }
+    return 'codex app-server error';
+}
+function isTransientCodexErrorMessage(message) {
+    return /\bReconnecting\.\.\.\s*\d+\/\d+/i.test(message);
+}
+function formatTransientCodexStatus(message) {
+    const match = message.match(/\bReconnecting\.\.\.\s*(\d+\/\d+)/i);
+    if (!match)
+        return '';
+    return `Codex API 暂时不可用，正在重试 ${match[1]}...`;
+}
+function formatCodexErrorMessage(message) {
+    const statusMatch = message.match(/unexpected status\s+(\d+)\s+([^:,]+)(?::\s*([^,]+))?(?:,\s*url:\s*([^,\s]+))?(?:,\s*request id:\s*([^\s,]+))?/i);
+    if (!statusMatch)
+        return message;
+    const [, status, statusText, detail, url, requestId] = statusMatch;
+    const parts = [
+        `Codex API 返回 ${status} ${statusText.trim()}`,
+        detail?.trim() ? `：${detail.trim()}` : '',
+        url ? `\n上游地址：${url}` : '',
+        requestId ? `\nrequest id：${requestId}` : '',
+    ];
+    return parts.join('');
+}
 const GIT_DIRECTIVE_LINE_RE = /^\s*::git-[a-z-]+\{[^\n]*\}\s*$/gm;
 function stripGitDirectiveArtifacts(text) {
     if (!text)
@@ -432,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 {};