shennian 0.2.6 → 0.2.8

package/dist/bin/shennian.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js';

package/dist/bin/shennian.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js';

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

@@ -0,0 +1,35 @@
+import { EventEmitter } from 'node:events';
+import type { AgentType } from '@shennian/wire';
+export type AgentEvent = {
+    state: string;
+    runId: string;
+    seq: number;
+    text?: string;
+    thinking?: boolean;
+    name?: string;
+    args?: Record<string, unknown>;
+    result?: string;
+    message?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    title?: string;
+    source?: string;
+    agentSessionId?: string;
+};
+export interface AgentAdapterEvents {
+    agentEvent: [event: AgentEvent];
+    error: [error: Error];
+}
+export declare abstract class AgentAdapter extends EventEmitter<AgentAdapterEvents> {
+    abstract readonly type: AgentType;
+    abstract start(sessionId: string, workDir: string, agentSessionId?: string | null): Promise<void>;
+    abstract send(text: string, modelId?: string): Promise<void>;
+    abstract resume(agentSessionId: string): Promise<void>;
+    abstract stop(): Promise<void>;
+}
+export declare function registerAgent(type: AgentType, factory: () => AgentAdapter): void;
+export declare function unregisterAgent(type: AgentType): void;
+export declare function createAgent(type: AgentType): AgentAdapter | null;
+export declare function getRegisteredAgents(): AgentType[];

package/dist/src/agents/adapter.js

@@ -0,0 +1,19 @@
+// @arch docs/architecture/cli/agent-adapters.md
+// @test src/__tests__/agents-e2e.ts
+import { EventEmitter } from 'node:events';
+export class AgentAdapter extends EventEmitter {
+}
+const registry = new Map();
+export function registerAgent(type, factory) {
+    registry.set(type, factory);
+}
+export function unregisterAgent(type) {
+    registry.delete(type);
+}
+export function createAgent(type) {
+    const factory = registry.get(type);
+    return factory ? factory() : null;
+}
+export function getRegisteredAgents() {
+    return [...registry.keys()];
+}

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

@@ -0,0 +1,25 @@
+import { AgentAdapter } from './adapter.js';
+export declare function normalizeClaudeModelId(modelId?: string | null): string;
+export declare class ClaudeAdapter extends AgentAdapter {
+    readonly type: "claude";
+    private process;
+    private agentSessionId;
+    private sessionId;
+    private workDir;
+    private seq;
+    private runId;
+    private hasEmittedText;
+    private terminalState;
+    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 spawnAndParse;
+    private handleStreamEvent;
+    private handleProcessClose;
+    private emitFinalIfOpen;
+    private emitErrorIfOpen;
+    private resetRunState;
+    private emitEvent;
+    private killProcess;
+}

package/dist/src/agents/claude.js

@@ -0,0 +1,234 @@
+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;
+    agentSessionId = null;
+    sessionId = null;
+    workDir = null;
+    seq = 0;
+    runId = '';
+    hasEmittedText = false;
+    terminalState = 'open';
+    async start(sessionId, workDir, agentSessionId) {
+        this.sessionId = sessionId;
+        this.workDir = workDir;
+        this.seq = 0;
+        if (agentSessionId)
+            this.agentSessionId = agentSessionId;
+    }
+    async send(text, modelId) {
+        await this.killProcess();
+        this.runId = randomUUID();
+        this.resetRunState();
+        const args = ['-p', text, '--output-format', 'stream-json', '--verbose'];
+        if (process.getuid?.() !== 0) {
+            args.push('--dangerously-skip-permissions');
+        }
+        args.push('--model', normalizeClaudeModelId(modelId));
+        if (this.agentSessionId) {
+            args.push('--resume', this.agentSessionId);
+        }
+        this.spawnAndParse(args);
+    }
+    async resume(agentSessionId) {
+        await this.killProcess();
+        this.agentSessionId = agentSessionId;
+        this.runId = randomUUID();
+        this.resetRunState();
+        const resumeArgs = ['--resume', agentSessionId, '--output-format', 'stream-json', '--verbose'];
+        if (process.getuid?.() !== 0) {
+            resumeArgs.push('--dangerously-skip-permissions');
+        }
+        this.spawnAndParse(resumeArgs);
+    }
+    async stop() {
+        await this.killProcess();
+    }
+    spawnAndParse(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 },
+        });
+        this.process = proc;
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const obj = JSON.parse(line);
+                this.handleStreamEvent(obj);
+            }
+            catch {
+                // skip malformed lines
+            }
+        });
+        let stderrBuf = '';
+        proc.stderr?.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderrBuf += text;
+            if (this.terminalState !== 'open')
+                return;
+            // Stream stderr lines in real-time so the app shows errors/retries immediately
+            for (const line of text.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    this.emitEvent({ state: 'delta', text: trimmed + '\n' });
+                }
+            }
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            this.handleProcessClose(code, stderrBuf);
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "claude" not found. Is Claude Code CLI installed?'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    handleStreamEvent(obj) {
+        if (obj.type === 'system' && obj.subtype === 'init' && obj.session_id) {
+            this.agentSessionId = obj.session_id;
+            this.emitEvent({ state: 'start', agentSessionId: this.agentSessionId });
+            return;
+        }
+        if (obj.type === 'system' &&
+            obj.subtype === 'api_retry' &&
+            obj.error === 'authentication_failed') {
+            this.emitErrorIfOpen({
+                state: 'error',
+                message: 'Claude authentication failed. Run "claude auth login" and retry.',
+            });
+            return;
+        }
+        if (obj.type === 'assistant') {
+            // New format (claude >= 2.1): content is in message.content[]
+            if (obj.message?.content) {
+                for (const block of obj.message.content) {
+                    if (block.type === 'text' && block.text) {
+                        const prefix = this.hasEmittedText ? '\n\n' : '';
+                        this.emitEvent({ state: 'delta', text: prefix + block.text });
+                        this.hasEmittedText = true;
+                    }
+                    else if (block.type === 'thinking' && block.thinking) {
+                        this.emitEvent({ state: 'delta', text: block.thinking, thinking: true });
+                    }
+                    else if (block.type === 'tool_use') {
+                        this.emitEvent({ state: 'tool-call', name: block.name, args: block.input });
+                    }
+                }
+                return;
+            }
+            // Legacy flat format (pre-2.1)
+            if (obj.subtype === 'text' && obj.text) {
+                const prefix = this.hasEmittedText ? '\n\n' : '';
+                this.emitEvent({ state: 'delta', text: prefix + obj.text });
+                this.hasEmittedText = true;
+            }
+            else if (obj.subtype === 'thinking' && obj.thinking) {
+                this.emitEvent({ state: 'delta', text: obj.thinking, thinking: true });
+            }
+            else if (obj.subtype === 'tool_use') {
+                this.emitEvent({ state: 'tool-call', name: obj.name, args: obj.input });
+            }
+            return;
+        }
+        if (obj.type === 'result') {
+            if (obj.subtype === 'tool_result') {
+                const content = typeof obj.content === 'string' ? obj.content : JSON.stringify(obj.content);
+                this.emitEvent({ state: 'tool-result', name: obj.name, result: content });
+            }
+            else if (obj.subtype === 'success') {
+                if (obj.session_id) {
+                    this.agentSessionId = obj.session_id;
+                }
+                const usage = obj.usage ?? obj.message?.usage;
+                this.emitFinalIfOpen({
+                    state: 'final',
+                    agentSessionId: this.agentSessionId ?? undefined,
+                    usage: usage
+                        ? { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens }
+                        : undefined,
+                });
+            }
+            else if (obj.subtype === 'error') {
+                this.emitErrorIfOpen({
+                    state: 'error',
+                    message: obj.error ?? obj.result ?? 'unknown error',
+                });
+            }
+        }
+    }
+    handleProcessClose(code, stderrBuf) {
+        if (code !== 0 && code !== null) {
+            const msg = stderrBuf.trim() || `claude exited with code ${code}`;
+            this.emitErrorIfOpen({ state: 'error', message: msg });
+            return;
+        }
+        this.emitFinalIfOpen({
+            state: 'final',
+            agentSessionId: this.agentSessionId ?? undefined,
+        });
+    }
+    emitFinalIfOpen(partial) {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'final';
+        this.emitEvent(partial);
+    }
+    emitErrorIfOpen(partial) {
+        if (this.terminalState !== 'open')
+            return;
+        this.terminalState = 'error';
+        this.emitEvent(partial);
+    }
+    resetRunState() {
+        this.seq = 0;
+        this.hasEmittedText = false;
+        this.terminalState = 'open';
+    }
+    emitEvent(partial) {
+        const event = {
+            ...partial,
+            runId: this.runId,
+            seq: this.seq++,
+        };
+        this.emit('agentEvent', event);
+    }
+    async killProcess() {
+        const proc = this.process;
+        if (!proc)
+            return;
+        this.process = null;
+        proc.kill('SIGTERM');
+        await new Promise((resolve) => {
+            proc.on('close', resolve);
+            setTimeout(() => {
+                proc.kill('SIGKILL');
+                resolve();
+            }, 3000);
+        });
+    }
+}
+registerAgent('claude', () => new ClaudeAdapter());

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

@@ -0,0 +1,52 @@
+import { AgentAdapter } from './adapter.js';
+export declare class CodexAdapter extends AgentAdapter {
+    readonly type: "codex";
+    private process;
+    private workDir;
+    private seq;
+    private runId;
+    private pendingUsage;
+    private agentSessionId;
+    private hasEmittedText;
+    private textTail;
+    private terminalState;
+    private forceCloseTimer;
+    private stderrBuf;
+    private rpcSeq;
+    private pendingRequests;
+    private appServerReady;
+    private appServerStartupError;
+    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 handleAppServerNonJsonStdout;
+    private failAppServerStartup;
+    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;
+}
+export declare function normalizeCodexModelId(modelId?: string | null): string | undefined;