shennian 0.2.6 → 0.2.7

package/dist/src/agents/custom.js

@@ -0,0 +1,210 @@
+// @arch docs/architecture/cli/agent-adapters.md#custom-agents
+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;
+    mode;
+    proactive;
+    sessionId = null;
+    agentSessionId = null;
+    workDir = null;
+    runId = '';
+    seq = 0;
+    // stdio mode: single long-lived process
+    stdioProcess = null;
+    // spawn mode: current single-turn process
+    spawnProcess = null;
+    constructor(name, entry) {
+        super();
+        this.type = `custom:${name}`;
+        this.command = entry.command;
+        this.mode = entry.caps.mode;
+        this.proactive = entry.caps.proactive ?? false;
+    }
+    async start(sessionId, workDir, agentSessionId) {
+        this.sessionId = sessionId;
+        this.workDir = workDir;
+        this.seq = 0;
+        if (agentSessionId)
+            this.agentSessionId = agentSessionId;
+        if (this.mode === 'stdio') {
+            await this.startStdioProcess();
+        }
+    }
+    async send(text, modelId) {
+        this.runId = randomUUID();
+        this.seq = 0;
+        if (this.mode === 'stdio') {
+            await this.sendStdio(text, modelId);
+        }
+        else {
+            await this.runSpawn(text, modelId);
+        }
+    }
+    async resume(agentSessionId) {
+        if (this.mode === 'stdio') {
+            const msg = JSON.stringify({
+                method: 'resume',
+                id: randomUUID(),
+                params: { sessionId: this.sessionId, agentSessionId },
+            });
+            this.stdioProcess?.stdin?.write(msg + '\n');
+        }
+    }
+    async stop() {
+        if (this.mode === 'stdio') {
+            await this.stopStdioProcess();
+        }
+        else {
+            await this.killSpawnProcess();
+        }
+    }
+    // ─── Spawn mode ───────────────────────────────────────────────────────────
+    async runSpawn(text, modelId) {
+        await this.killSpawnProcess();
+        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 = spawnCommandString(this.command, args, {
+            cwd: this.workDir ?? undefined,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.spawnProcess = proc;
+        this.attachOutputHandlers(proc, () => {
+            if (this.spawnProcess === proc)
+                this.spawnProcess = null;
+        });
+        proc.stdin?.write(text);
+        proc.stdin?.end();
+    }
+    async killSpawnProcess() {
+        const proc = this.spawnProcess;
+        if (!proc)
+            return;
+        this.spawnProcess = null;
+        proc.kill('SIGTERM');
+        await new Promise((resolve) => {
+            proc.on('close', resolve);
+            setTimeout(() => { proc.kill('SIGKILL'); resolve(); }, 3000);
+        });
+    }
+    // ─── Stdio mode ───────────────────────────────────────────────────────────
+    async startStdioProcess() {
+        const proc = spawnCommandString(this.command, ['/start', '--workdir', this.workDir ?? process.cwd()], {
+            cwd: this.workDir ?? undefined,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+        });
+        this.stdioProcess = proc;
+        this.attachOutputHandlers(proc, () => {
+            if (this.stdioProcess === proc) {
+                this.stdioProcess = null;
+                this.emit('error', new Error('Custom agent process exited unexpectedly'));
+            }
+        });
+    }
+    async sendStdio(text, modelId) {
+        if (!this.stdioProcess) {
+            await this.startStdioProcess();
+        }
+        const msg = JSON.stringify({
+            method: 'send',
+            id: randomUUID(),
+            params: {
+                sessionId: this.sessionId,
+                text,
+                modelId,
+            },
+        });
+        this.stdioProcess?.stdin?.write(msg + '\n');
+    }
+    async stopStdioProcess() {
+        const proc = this.stdioProcess;
+        if (!proc)
+            return;
+        const stopMsg = JSON.stringify({ method: 'stop', id: randomUUID() });
+        proc.stdin?.write(stopMsg + '\n');
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                proc.kill('SIGTERM');
+                setTimeout(() => { proc.kill('SIGKILL'); resolve(); }, 3000);
+            }, 5000);
+            proc.on('close', () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+        this.stdioProcess = null;
+    }
+    // ─── Shared output parsing ────────────────────────────────────────────────
+    attachOutputHandlers(proc, onClose) {
+        const rl = createInterface({ input: proc.stdout });
+        rl.on('line', (line) => {
+            if (!line.trim())
+                return;
+            try {
+                const event = JSON.parse(line);
+                this.handleProtocolEvent(event);
+            }
+            catch {
+                // ignore malformed lines
+            }
+        });
+        let stderrBuf = '';
+        proc.stderr?.on('data', (chunk) => { stderrBuf += chunk.toString(); });
+        proc.on('close', (code) => {
+            onClose();
+            if (code !== 0 && code !== null) {
+                const msg = stderrBuf.trim() || `Agent exited with code ${code}`;
+                this.emitEvent({ state: 'error', message: msg });
+            }
+        });
+        proc.on('error', (err) => {
+            onClose();
+            this.emit('error', err);
+        });
+    }
+    handleProtocolEvent(event) {
+        const { state } = event;
+        if (!state)
+            return;
+        switch (state) {
+            case 'delta':
+                this.emitEvent({ state: 'delta', text: event.text ?? '', thinking: event.thinking });
+                break;
+            case 'final':
+                if (event.agentSessionId)
+                    this.agentSessionId = event.agentSessionId;
+                this.emitEvent({ state: 'final', usage: event.usage, agentSessionId: this.agentSessionId ?? undefined });
+                break;
+            case 'error':
+                this.emitEvent({ state: 'error', message: event.message ?? 'unknown error' });
+                break;
+            case 'tool-call':
+                this.emitEvent({ state: 'tool-call', name: event.name ?? '', args: event.args });
+                break;
+            case 'tool-result':
+                this.emitEvent({ state: 'tool-result', name: event.name ?? '', result: event.result ?? '' });
+                break;
+            case 'notify':
+                this.emitEvent({ state: 'notify', text: event.text ?? '', title: event.title, source: event.source });
+                break;
+        }
+    }
+    emitEvent(partial) {
+        const event = { ...partial, runId: this.runId, seq: this.seq++ };
+        this.emit('agentEvent', event);
+    }
+}
+export function registerCustomAgent(name, entry) {
+    const agentType = `custom:${name}`;
+    registerAgent(agentType, () => new CustomAgentAdapter(name, entry));
+}

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

@@ -0,0 +1,9 @@
+import { type AgentType, type ModelInfo } from '@shennian/wire';
+export type DetectedAgent = {
+    type: AgentType;
+    command: string;
+    args: string[];
+    version?: string;
+    models?: ModelInfo[];
+};
+export declare function detectAgents(): DetectedAgent[];

package/dist/src/agents/detect.js

@@ -0,0 +1,46 @@
+import { AVAILABLE_BUILTIN_AGENT_TYPES } from '@shennian/wire';
+import { loadConfig } from '../config/index.js';
+import { getCommandVersion, resolveBuiltinCommand } from './command-spec.js';
+const AGENTS = AVAILABLE_BUILTIN_AGENT_TYPES.filter((agent) => agent !== 'pi');
+function getCustomAgentModels(caps) {
+    const ids = caps.models?.length
+        ? caps.models
+        : caps.model
+            ? [caps.model]
+            : [];
+    const defaultModel = caps.defaultModel ?? caps.model;
+    return ids.map((id) => ({
+        id,
+        name: id,
+        isDefault: id === defaultModel,
+    }));
+}
+export function detectAgents() {
+    // Pi agent is always available (built-in, platform-powered)
+    const detected = [
+        { type: 'pi', command: 'shennian', args: [], version: undefined },
+    ];
+    for (const agent of AGENTS) {
+        const spec = resolveBuiltinCommand(agent);
+        if (!spec)
+            continue;
+        const version = getCommandVersion(spec);
+        detected.push({
+            type: agent,
+            command: spec.command,
+            args: spec.args,
+            version,
+        });
+    }
+    const config = loadConfig();
+    for (const [name, entry] of Object.entries(config.customAgents ?? {})) {
+        detected.push({
+            type: `custom:${name}`,
+            command: entry.command,
+            args: [],
+            version: entry.caps.version,
+            models: getCustomAgentModels(entry.caps),
+        });
+    }
+    return detected;
+}

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

@@ -0,0 +1,17 @@
+import { AgentAdapter } from './adapter.js';
+export declare class GeminiAdapter extends AgentAdapter {
+    readonly type: "gemini";
+    private process;
+    private agentSessionId;
+    private workDir;
+    private seq;
+    private runId;
+    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 emitEvent;
+    private killProcess;
+}

package/dist/src/agents/gemini.js

@@ -0,0 +1,172 @@
+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;
+}
+function usageFromStats(stats) {
+    if (!stats)
+        return undefined;
+    const input = num(stats.input_tokens) ??
+        num(stats.prompt_tokens) ??
+        num(stats.inputTokens) ??
+        num(stats.promptTokenCount);
+    const output = num(stats.output_tokens) ??
+        num(stats.completion_tokens) ??
+        num(stats.outputTokens) ??
+        num(stats.candidatesTokenCount) ??
+        num(stats.responseTokenCount);
+    if (input === undefined && output === undefined)
+        return undefined;
+    return {
+        inputTokens: input ?? 0,
+        outputTokens: output ?? 0,
+    };
+}
+export class GeminiAdapter extends AgentAdapter {
+    type = 'gemini';
+    process = null;
+    agentSessionId = null;
+    workDir = null;
+    seq = 0;
+    runId = '';
+    async start(_sessionId, workDir, agentSessionId) {
+        this.workDir = workDir;
+        this.seq = 0;
+        if (agentSessionId)
+            this.agentSessionId = agentSessionId;
+    }
+    async send(text, modelId) {
+        await this.killProcess();
+        this.runId = randomUUID();
+        this.seq = 0;
+        const args = ['-p', text, '--output-format', 'stream-json'];
+        if (modelId) {
+            args.push('-m', 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.seq = 0;
+        this.spawnAndParse([
+            '--resume', agentSessionId,
+            '--output-format', 'stream-json',
+        ]);
+    }
+    async stop() {
+        await this.killProcess();
+    }
+    spawnAndParse(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 },
+        });
+        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 {
+                this.emitEvent({ state: 'delta', text: line });
+            }
+        });
+        let stderrBuf = '';
+        proc.stderr?.on('data', (chunk) => {
+            stderrBuf += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (code !== 0 && code !== null) {
+                const msg = stderrBuf.trim() || `gemini exited with code ${code}`;
+                this.emitEvent({ state: 'error', message: msg });
+            }
+        });
+        proc.on('error', (err) => {
+            if (this.process !== proc)
+                return;
+            this.process = null;
+            if (err.code === 'ENOENT') {
+                this.emit('error', new Error('Command "gemini" not found. Is Gemini CLI installed?'));
+            }
+            else {
+                this.emit('error', err);
+            }
+        });
+    }
+    handleStreamEvent(obj) {
+        switch (obj.type) {
+            case 'init': {
+                if (obj.session_id) {
+                    this.agentSessionId = obj.session_id;
+                }
+                break;
+            }
+            case 'message': {
+                if (obj.role === 'assistant' && obj.content) {
+                    this.emitEvent({ state: 'delta', text: obj.content });
+                }
+                break;
+            }
+            case 'result': {
+                if (obj.status === 'success') {
+                    this.emitEvent({
+                        state: 'final',
+                        agentSessionId: this.agentSessionId ?? undefined,
+                        usage: usageFromStats(obj.stats),
+                    });
+                }
+                else if (obj.status === 'error') {
+                    const msg = (typeof obj.error === 'string' && obj.error) ||
+                        (typeof obj.message === 'string' && obj.message) ||
+                        'gemini result error';
+                    this.emitEvent({ state: 'error', message: msg });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    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('gemini', () => new GeminiAdapter());

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

@@ -0,0 +1,4 @@
+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;

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

@@ -0,0 +1,37 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+import fs from 'node:fs';
+import path from 'node:path';
+import { CACHE_TTL_MS, CACHE_VERSION, MODEL_CACHE_PATH } from './types.js';
+function ensureDirExists() {
+    fs.mkdirSync(path.dirname(MODEL_CACHE_PATH), { recursive: true });
+}
+export function readCache() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(MODEL_CACHE_PATH, 'utf-8'));
+        if (parsed.version === CACHE_VERSION && parsed.agents && typeof parsed.agents === 'object') {
+            return parsed;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return { version: CACHE_VERSION, agents: {} };
+}
+export function writeCache(cache) {
+    try {
+        ensureDirExists();
+        fs.writeFileSync(MODEL_CACHE_PATH, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // Cache is best-effort. Discovery should still succeed when local
+        // filesystem writes are unavailable (e.g. restricted sandboxes).
+    }
+}
+export function isCacheFresh(entry, version) {
+    if (!entry)
+        return false;
+    if (entry.version !== version)
+        return false;
+    return Date.now() - entry.refreshedAt < CACHE_TTL_MS;
+}

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

@@ -0,0 +1,4 @@
+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[]>;

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

@@ -0,0 +1,166 @@
+// @arch docs/architecture/cli/model-discovery.md
+// @test src/__tests__/model-switching.test.ts
+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 runResolvedCommand(spec, ['--list-models']);
+    return parseCursorModels(result.stdout);
+}
+async function discoverOpenClawModels() {
+    const spec = resolveBuiltinCommand('openclaw');
+    if (!spec)
+        return [];
+    const result = await runResolvedCommand(spec, ['models', 'list', '--json']);
+    return parseOpenClawModels(result.stdout);
+}
+async function discoverClaudeModels() {
+    if (!resolveBuiltinCommand('claude'))
+        return [];
+    return fallbackClaudeAliasModels();
+}
+async function discoverCodexModels() {
+    const spec = resolveBuiltinCommand('codex');
+    if (!spec)
+        return [];
+    const appServerModels = await discoverCodexModelsViaAppServer(spec).catch(() => []);
+    return appServerModels;
+}
+async function discoverGeminiModels() {
+    if (!resolveBuiltinCommand('gemini'))
+        return [];
+    return fallbackGeminiModels();
+}
+const fallbackPiModels = [
+    { id: 'qwen3.6-plus', name: 'Qwen 3.6 Plus', provider: 'dashscope', isDefault: true },
+    { id: 'qwen3.6-flash', name: 'Qwen 3.6 Flash', provider: 'dashscope' },
+];
+async function discoverPiModels(context) {
+    if (!context.serverUrl || !context.authToken)
+        return fallbackPiModels;
+    try {
+        const response = await fetch(`${context.serverUrl.replace(/\/$/, '')}/api/models`, {
+            headers: {
+                Authorization: `Bearer ${context.authToken}`,
+            },
+        });
+        if (!response.ok)
+            return fallbackPiModels;
+        const data = (await response.json());
+        const models = (data.models ?? []).map((model) => ({
+            id: model.id,
+            name: model.name?.trim() || model.id,
+            provider: model.provider,
+            isDefault: model.id === data.default,
+        }));
+        return models.length > 0 ? models : fallbackPiModels;
+    }
+    catch {
+        return fallbackPiModels;
+    }
+}
+async function discoverBuiltinModels(type, context) {
+    switch (type) {
+        case 'claude':
+            return discoverClaudeModels();
+        case 'codex':
+            return discoverCodexModels();
+        case 'gemini':
+            return discoverGeminiModels();
+        case 'cursor':
+            return discoverCursorModels();
+        case 'openclaw':
+            return discoverOpenClawModels();
+        case 'pi':
+            return discoverPiModels(context);
+    }
+}
+export async function discoverModelsForAgent(agent, context) {
+    if (agent.type.startsWith('custom:')) {
+        return agent.models ?? [];
+    }
+    return discoverBuiltinModels(agent.type, context);
+}

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

@@ -0,0 +1,11 @@
+import type { ModelInfo } from '@shennian/wire';
+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[];
+export declare function fallbackGeminiModels(): ModelInfo[];