lark-remote 0.1.6 → 0.1.8

package/dist/runner/opencode/jsonl.js

@@ -1,295 +0,0 @@
-/**
- * Translates opencode `run --format json` ndjson output into lark-remote `AgentEvent`s.
- *
- * Key design decisions:
- * - opencode uses step-level events (step_start/step_finish), not turn-level like codex.
- * - Tool is a single-part state machine: state.status evolves pending→running→completed/error,
- *   input and output are in the same part.
- * - Fail-fast: unknown types and missing fields return [] (no event emitted),
- *   never throw, never write back to opencode (root cause ② tolerance).
- * - Stream ending before a terminal event records a terminal error via `finish()`
- *   (root cause ③ fail-fast); the runner's `buildResultEvent` emits the result.
- * - Each `run()` must create a new translator instance (stateful: sessionId/terminal/startedTools).
- *
- * Terminal state (sessionId, lastUsage, terminalErrorMessage) is stored on
- * the instance and exposed via getters; `OpencodeExecRunner.run()` folds
- * this state into `SpawningRunner.buildResultEvent(...)` so result-event
- * semantics are uniform across all 5 agents.
- *
- * Event mapping:
- * | opencode ndjson          | lark-remote AgentEvent                              |
- * |--------------------------|------------------------------------------------------|
- * | step_start               | SystemInitEvent (first event only)                 |
- * | text                     | AssistantEvent(text)                               |
- * | reasoning                | AssistantEvent(thinking)                          |
- * | tool/tool_use (first)    | AssistantEvent(tool_use)                          |
- * | tool (status=completed)  | UserEvent(tool_result, is_error=false)            |
- * | tool (status=error)      | UserEvent(tool_result, is_error=true)             |
- * | patch                    | FileChangeEvent                                    |
- * | step_finish(reason=stop) | [] (terminal — usage stashed for runner)          |
- * | step_finish(reason=*)    | [] (non-terminal, continues)                      |
- * | error                    | [] (terminal - error message stashed for runner)  |
- * | unknown type             | [] (no event)                                     |
- */
-import { getLogger } from '../../logger/index.js';
-import { recordValue, stringValue, numberValue, extractErrorMessage } from '../../common/guards.js';
-import { ExecTranslator } from '../common/exec-translator.js';
-export class OpencodeExecTranslator extends ExecTranslator {
-    cwd;
-    /** Accumulate usage across all steps (not just terminal step). */
-    accumulatedUsage = {
-        input_tokens: 0,
-        output_tokens: 0,
-        cache_read_tokens: 0,
-        cache_creation_tokens: 0,
-    };
-    /** Track which tool results have already been emitted (idempotency). */
-    emittedResults = new Set();
-    logTag = '[opencode-exec-translator]';
-    streamEndedMessage() {
-        return 'opencode stream ended before a terminal step';
-    }
-    /**
-     * @param opts.cwd The session's real directory. Emitted on the synthesized
-     * SystemInitEvent so the bridge persists the correct cwd (was hardcoded '').
-     * Post-PWD-sync-fix this equals the runner's opts.cwd == opencode's directory.
-     */
-    constructor(opts = {}) {
-        super();
-        this.cwd = opts.cwd ?? '';
-    }
-    /** Get accumulated usage across all steps (for diagnostics). */
-    getAccumulatedUsage() {
-        return { ...this.accumulatedUsage };
-    }
-    // --- translateEvent: opencode-specific dispatch ---
-    translateEvent(raw) {
-        // Stash sessionId from the very first event (every event carries it)
-        const sid = stringValue(raw.sessionID ?? raw.sessionId);
-        if (sid && !this.sessionId) {
-            this.sessionId = sid;
-        }
-        switch (raw.type) {
-            case 'step_start':
-                return this.onStepStart(raw);
-            case 'text':
-                return this.onText(raw);
-            case 'reasoning':
-                return this.onReasoning(raw);
-            case 'tool':
-            case 'tool_use':
-            case 'tool_output':
-                return this.onTool(raw);
-            case 'patch':
-                return this.onPatch(raw);
-            case 'step_finish':
-                return this.onStepFinish(raw);
-            case 'error':
-                return this.onError(raw);
-            default:
-                return this.recordUnknownEvent(raw.type);
-        }
-    }
-    // --- Private handlers ---
-    /** SystemInitEvent: synthesize from first event with sessionId. */
-    synthesizeInit() {
-        return {
-            type: 'system',
-            subtype: 'init',
-            session_id: this.sessionId ?? '',
-            cwd: this.cwd,
-            model: '',
-            timestamp: new Date().toISOString(),
-        };
-    }
-    onStepStart(_raw) {
-        // Internal marker, no lark-remote event
-        // But this is the first event, so synthesize SystemInitEvent
-        return this.sessionId && !this.terminal ? [this.synthesizeInit()] : [];
-    }
-    onText(raw) {
-        const part = recordValue(raw.part);
-        if (!part) {
-            return [];
-        }
-        const text = stringValue(part.text);
-        if (!text) {
-            return [];
-        }
-        return [
-            {
-                type: 'assistant',
-                message: {
-                    content: [{ type: 'text', text }],
-                },
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-    onReasoning(raw) {
-        const part = recordValue(raw.part);
-        if (!part) {
-            return [];
-        }
-        const text = stringValue(part.text);
-        if (!text) {
-            return [];
-        }
-        return [
-            {
-                type: 'assistant',
-                message: {
-                    content: [{ type: 'thinking', thinking: text }],
-                },
-                timestamp: new Date().toISOString(),
-            },
-        ];
-    }
-    onTool(raw) {
-        const part = recordValue(raw.part);
-        if (!part) {
-            return [];
-        }
-        const tool = stringValue(part.tool);
-        const callId = stringValue(part.callID ?? part.callId);
-        const state = recordValue(part.state);
-        if (!callId) {
-            return [];
-        }
-        const events = [];
-        // First time seeing this tool call: emit tool_use
-        if (!this.startedTools.has(callId)) {
-            this.startedTools.add(callId);
-            const input = state ? recordValue(state.input) : undefined;
-            const toolUseContent = {
-                type: 'tool_use',
-                id: callId,
-                name: tool ?? '',
-                input: input ?? {},
-            };
-            events.push({
-                type: 'assistant',
-                message: {
-                    content: [toolUseContent],
-                },
-                timestamp: new Date().toISOString(),
-            });
-        }
-        // Check for completion or error status
-        if (state) {
-            const status = stringValue(state.status);
-            // completed: emit tool_result with output
-            if (status === 'completed' && !this.emittedResults.has(callId)) {
-                this.emittedResults.add(callId);
-                const output = stringValue(state.output) ?? '';
-                events.push({
-                    type: 'user',
-                    message: {
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: callId,
-                                content: output,
-                                is_error: false,
-                            },
-                        ],
-                    },
-                    timestamp: new Date().toISOString(),
-                });
-            }
-            // error: emit tool_result with error
-            if (status === 'error' && !this.emittedResults.has(callId)) {
-                this.emittedResults.add(callId);
-                const error = stringValue(state.error) ?? stringValue(state.output) ?? 'unknown error';
-                events.push({
-                    type: 'user',
-                    message: {
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: callId,
-                                content: error,
-                                is_error: true,
-                            },
-                        ],
-                    },
-                    timestamp: new Date().toISOString(),
-                });
-            }
-        }
-        return events;
-    }
-    onPatch(raw) {
-        const part = recordValue(raw.part);
-        if (!part) {
-            return [];
-        }
-        const files = part.files;
-        if (!Array.isArray(files) || files.length === 0) {
-            return [];
-        }
-        // Emit a FileChangeEvent for each file
-        const events = [];
-        for (const file of files) {
-            const path = stringValue(file.path ?? file.file_path);
-            if (!path)
-                continue;
-            events.push({
-                type: 'file_change',
-                path,
-                operation: 'edit', // patch implies edit
-                timestamp: new Date().toISOString(),
-            });
-        }
-        return events;
-    }
-    onStepFinish(raw) {
-        const part = recordValue(raw.part);
-        if (!part) {
-            return [];
-        }
-        const reason = stringValue(part.reason);
-        // Extract tokens from this step (both terminal and non-terminal steps contribute usage).
-        const tokens = recordValue(part.tokens);
-        if (tokens) {
-            const cache = recordValue(tokens.cache);
-            // Accumulate usage across ALL steps (not just terminal step).
-            // This fixes the systematic undercount for multi-step runs.
-            this.accumulatedUsage.input_tokens += numberValue(tokens.input) ?? 0;
-            this.accumulatedUsage.output_tokens += numberValue(tokens.output) ?? 0;
-            this.accumulatedUsage.cache_read_tokens += cache ? (numberValue(cache.read) ?? 0) : 0;
-            this.accumulatedUsage.cache_creation_tokens += cache ? (numberValue(cache.write) ?? 0) : 0;
-            // Only reason='stop' is terminal
-            if (reason === 'stop') {
-                // Mark terminal and stash accumulated usage; the runner emits the result event
-                // via buildResultEvent({...usage}) so success/error is uniform across agents.
-                this.terminal = true;
-                // Use accumulated usage (all steps) for the final result
-                const total = numberValue(tokens.total);
-                this.lastUsage = {
-                    input_tokens: this.accumulatedUsage.input_tokens,
-                    output_tokens: this.accumulatedUsage.output_tokens,
-                    cache_read_tokens: this.accumulatedUsage.cache_read_tokens,
-                    cache_creation_tokens: this.accumulatedUsage.cache_creation_tokens,
-                    ...(total !== undefined ? { total_tokens: total } : {}),
-                };
-            }
-        }
-        return [];
-    }
-    onError(raw) {
-        // opencode error events are terminal in practice: opencode exits with
-        // code=1 immediately after emitting one, without a step_finish(reason=stop).
-        // Mark terminal so the real error message reaches the user via
-        // buildResultEvent({translatorError}) instead of the generic
-        // "opencode exited code=1" fallback.
-        const message = extractErrorMessage(raw, 'opencode error');
-        getLogger().warn(`[opencode-exec-translator] error: ${message.slice(0, 500)}`);
-        getLogger().warn(`[opencode-exec-translator] RAW ERROR EVENT: ${JSON.stringify(raw).slice(0, 2000)}`);
-        this.terminal = true;
-        this.terminalErrorFromAgent = true;
-        this.terminalErrorMessage = message;
-        return [];
-    }
-}
-//# sourceMappingURL=jsonl.js.map

package/dist/runner/opencode/runner.d.ts

@@ -1,61 +0,0 @@
-/**
- * OpencodeExecRunner: spawn-per-message runner using `opencode run --format json --auto`.
- *
- * Architecture:
- * - Each `run()` spawns a fresh `opencode run` process, writes prompt to stdin,
- *   reads ndjson from stdout, translates to AgentEvent via OpencodeExecTranslator.
- * - No singleton, no long-lived process, no HTTP server, no approval handshake.
- * - Structurally identical to other exec runners (spawn-per-message + ProcessStopper + SpawnHeartbeat).
- *
- * The entire spawn + completion + cleanup orchestration is inherited
- * from SpawningRunner. This subclass overrides only the 5 hooks:
- *   - getStdio()              → ['pipe','pipe','pipe'] (writes prompt to stdin)
- *   - getSpawnEnv(opts)       → sync PWD=opts.cwd (opencode reads PWD, not cwd)
- *   - setupStdin(proc, msg)   → proc.stdin.end(msg, 'utf-8')
- *   - handleBadStreamLine()   → empty override (silently skip non-JSON lines)
- *   - createTranslator(opts)  → new OpencodeExecTranslator({ cwd: opts.cwd })
- *
- * Key invariants:
- * 1. argv includes `--auto` (root cause ①).
- * 2. stdin is written once via `stdin.end(prompt)` and never written again (root cause ②).
- * 3. Translator parse failures → return [] (no event), never throw, never write back (root cause ②).
- * 4. Stream ending early → finish() yields terminal event, never leaves consumer waiting (root cause ③).
- *
- * Verified (2026-07-13): opencode run reads prompt from stdin.
- * Command: `echo 'msg' | opencode run --format json --auto`
- * Result: stdout outputs ndjson with step_start → text → step_finish
- */
-import type { ChildProcess } from 'node:child_process';
-import type { AgentKind, AgentSessionReader, AgentRunner, AgentStatusInfo } from '../types.js';
-import type { SpawnOptions } from '../types.js';
-import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
-interface OpencodeExecRunnerOptions {
-    /** Model override in provider/model format (e.g. 'anthropic/claude-sonnet-4-20250514'). Omitted → opencode config default. */
-    model?: string;
-    /** Grace period (ms) for SIGTERM→SIGKILL. Default: 5000. */
-    stopGraceMs?: number;
-    /** Directory for pid files. Default: `~/.lark-remote`. */
-    pidDir?: string;
-    /** Workspace identifier, scoped into the pid file name so concurrent
-     *  workspaces do not share one `<prefix>.pid` (P1-9). */
-    workspace: string;
-    /** Spawn heartbeat interval (ms). Default: 30_000. */
-    spawnHeartbeatMs?: number;
-    /** Injected session reader (CLI-based OpencodeSessionReader). */
-    sessionReader: AgentSessionReader;
-}
-export declare class OpencodeExecRunner extends SpawningRunner implements AgentRunner {
-    readonly kind: AgentKind;
-    readonly sessionReader: AgentSessionReader;
-    private readonly defaultModel?;
-    constructor(opts: OpencodeExecRunnerOptions);
-    getStatusInfo(): AgentStatusInfo;
-    protected buildArgv(opts: SpawnOptions): string[];
-    protected getStdio(): ('ignore' | 'pipe')[];
-    protected getSpawnEnv(opts: SpawnOptions): NodeJS.ProcessEnv;
-    protected setupStdin(proc: ChildProcess, message: string): void;
-    /** Silently skip non-JSON lines from opencode stdout (e.g. warnings). */
-    protected handleBadStreamLine(_line: string): void;
-    protected createTranslator(opts: SpawnOptions): RunnerTranslator;
-}
-export {};

package/dist/runner/opencode/runner.js

@@ -1,93 +0,0 @@
-/**
- * OpencodeExecRunner: spawn-per-message runner using `opencode run --format json --auto`.
- *
- * Architecture:
- * - Each `run()` spawns a fresh `opencode run` process, writes prompt to stdin,
- *   reads ndjson from stdout, translates to AgentEvent via OpencodeExecTranslator.
- * - No singleton, no long-lived process, no HTTP server, no approval handshake.
- * - Structurally identical to other exec runners (spawn-per-message + ProcessStopper + SpawnHeartbeat).
- *
- * The entire spawn + completion + cleanup orchestration is inherited
- * from SpawningRunner. This subclass overrides only the 5 hooks:
- *   - getStdio()              → ['pipe','pipe','pipe'] (writes prompt to stdin)
- *   - getSpawnEnv(opts)       → sync PWD=opts.cwd (opencode reads PWD, not cwd)
- *   - setupStdin(proc, msg)   → proc.stdin.end(msg, 'utf-8')
- *   - handleBadStreamLine()   → empty override (silently skip non-JSON lines)
- *   - createTranslator(opts)  → new OpencodeExecTranslator({ cwd: opts.cwd })
- *
- * Key invariants:
- * 1. argv includes `--auto` (root cause ①).
- * 2. stdin is written once via `stdin.end(prompt)` and never written again (root cause ②).
- * 3. Translator parse failures → return [] (no event), never throw, never write back (root cause ②).
- * 4. Stream ending early → finish() yields terminal event, never leaves consumer waiting (root cause ③).
- *
- * Verified (2026-07-13): opencode run reads prompt from stdin.
- * Command: `echo 'msg' | opencode run --format json --auto`
- * Result: stdout outputs ndjson with step_start → text → step_finish
- */
-import { SpawningRunner } from '../common/spawning-runner.js';
-import { pipeAllStdio, endStdinWithPrompt } from '../common/runner-utils.js';
-import { buildOpencodeRunArgs } from './argv.js';
-import { OpencodeExecTranslator } from './jsonl.js';
-export class OpencodeExecRunner extends SpawningRunner {
-    kind = 'opencode';
-    sessionReader;
-    defaultModel;
-    constructor(opts) {
-        super({
-            pidDir: opts.pidDir,
-            workspace: opts.workspace,
-            stopGraceMs: opts.stopGraceMs,
-            spawnHeartbeatMs: opts.spawnHeartbeatMs,
-            pidFilePrefix: 'opencode',
-            logTag: 'opencode-exec-runner',
-        });
-        this.binary = 'opencode';
-        this.defaultModel = opts.model;
-        this.sessionReader = opts.sessionReader;
-    }
-    getStatusInfo() {
-        return {
-            kind: 'opencode',
-            model: this.defaultModel ?? '(未配置)',
-            provider: this.defaultModel?.split('/')[0],
-        };
-    }
-    buildArgv(opts) {
-        const model = opts.model ?? this.defaultModel;
-        return buildOpencodeRunArgs({
-            model,
-            sessionId: opts.sessionId,
-        });
-    }
-    // --- Hooks ---
-    getStdio() {
-        // ['pipe','pipe','pipe'] so we can write the prompt to stdin via setupStdin.
-        return pipeAllStdio();
-    }
-    getSpawnEnv(opts) {
-        // Sync PWD env to opts.cwd: Node spawn's `cwd` option only chdir's the
-        // child, it does NOT update the PWD env var (a shell convention).
-        // opencode `run` reads PWD (not process.cwd()) for project/directory
-        // detection in its 2nd instance phase, so an inherited PWD (e.g. bridge
-        // started from "/") would orphan sessions under directory="/" /
-        // project=global, making /resume unable to find them.
-        const spawnEnv = { ...process.env };
-        if (opts.cwd)
-            spawnEnv.PWD = opts.cwd;
-        return spawnEnv;
-    }
-    setupStdin(proc, message) {
-        // Write prompt once and close (invariant: write once, never again).
-        endStdinWithPrompt(proc, message);
-    }
-    /** Silently skip non-JSON lines from opencode stdout (e.g. warnings). */
-    handleBadStreamLine(_line) { }
-    createTranslator(opts) {
-        // Fresh translator per run. Pass opts.cwd so the synthesized
-        // SystemInitEvent carries the session's real directory (the bridge
-        // persists this into last-session.json).
-        return new OpencodeExecTranslator({ cwd: opts.cwd });
-    }
-}
-//# sourceMappingURL=runner.js.map

package/dist/runner/pi/jsonl.d.ts

@@ -1,128 +0,0 @@
-import type { RunnerTranslator } from '../common/spawning-runner.js';
-import type { AgentEvent } from '../types.js';
-interface PiSessionEvent {
-    type: 'session';
-    id: string;
-    cwd: string;
-    model?: string;
-}
-interface PiMessageStartEvent {
-    type: 'message_start';
-    message: {
-        role: 'user' | 'assistant' | 'toolResult';
-        content?: unknown[];
-        model?: string;
-        usage?: PiUsage;
-    };
-}
-interface PiMessageUpdateEvent {
-    type: 'message_update';
-    assistantMessageEvent: {
-        type: 'text_start' | 'text_delta' | 'text_end' | 'thinking_start' | 'thinking_delta' | 'thinking_end' | 'toolcall_start' | 'toolcall_delta' | 'toolcall_end';
-        contentIndex?: number;
-        delta?: string;
-        content?: string;
-        toolCall?: {
-            id: string;
-            name: string;
-            arguments: Record<string, unknown>;
-        };
-    };
-}
-interface PiMessageEndEvent {
-    type: 'message_end';
-    message: {
-        role: 'user' | 'assistant' | 'toolResult';
-        content?: unknown[];
-        usage?: PiUsage;
-        toolCallId?: string;
-        toolName?: string;
-        isError?: boolean;
-        /** pi reports provider/LLM failures via stopReason="error" + errorMessage
-         * (content empty, usage zeros). e.g. "Connection error." on transient
-         * provider outage. */
-        stopReason?: string;
-        errorMessage?: string;
-    };
-}
-interface PiTurnEndEvent {
-    type: 'turn_end';
-    message?: {
-        usage?: PiUsage;
-    };
-}
-interface PiAgentEndEvent {
-    type: 'agent_end';
-    messages?: unknown[];
-}
-interface PiUsage {
-    input?: number;
-    output?: number;
-    cacheRead?: number;
-    cacheWrite?: number;
-    totalTokens?: number;
-    /** Reasoning tokens (display-only, not added to total). */
-    reasoning?: number;
-}
-type PiEvent = PiSessionEvent | PiMessageStartEvent | PiMessageUpdateEvent | PiMessageEndEvent | PiTurnEndEvent | PiAgentEndEvent | {
-    type: string;
-};
-/** ccusage-aligned usage: pi's `input` is non-cached; cacheRead/cacheWrite map to cache read/creation. */
-type PiResultUsage = {
-    input_tokens: number;
-    output_tokens: number;
-    cache_read_tokens: number;
-    cache_creation_tokens: number;
-    total_tokens?: number;
-};
-/**
- * Accumulates pi's incremental message_update events and emits normalized
- * AgentEvents. Content mapping: text→TextContent, thinking→ThinkingContent,
- * toolCall→ToolUseContent (input:arguments), toolResult→ToolResultContent.
- *
- * Implements RunnerTranslator so the base SpawningRunner can drive it
- * uniformly. pi has no agent-reported terminal error (no equivalent of codex
- * `turn.failed`), so isTerminal/finish/getTerminalError/hasAgentTerminalError
- * are no-ops — pi relies entirely on the base class's signal/code-based
- * result event classification.
- */
-export declare class PiEventAccumulator implements RunnerTranslator {
-    private content;
-    private currentContentIndex;
-    private sessionId;
-    /**
-     * Accumulated (summed) token usage across all assistant messages in this run.
-     * pi emits per-message (non-cumulative) usage on each assistant `message_end`;
-     * summing yields the run's total consumption, aligned with ccusage (which sums
-     * per-message entries).
-     * `totalTokens` is NOT summed: it tracks the last message's total as the
-     * context-length water level (summing would overcount - design.md §usage:
-     * "N turn 累加得 N×context 虚假巨值").
-     */
-    private accInput;
-    private accOutput;
-    private accCacheRead;
-    private accCacheCreation;
-    private lastTotalTokens;
-    /** stopReason of the most recent assistant message_end. "error" indicates a
-     * provider/LLM failure (pi retries internally; a later message_end may
-     * overwrite this with "stop" on eventual success). */
-    private lastAssistantStopReason;
-    /** errorMessage paired with the last assistant message_end whose
-     * stopReason==="error". Surfaces the provider's failure text (e.g.
-     * "Connection error.") to the user via the result event. */
-    private lastAssistantErrorMessage;
-    translate(raw: unknown): AgentEvent | null;
-    isTerminal(): boolean;
-    finish(_reason: 'failed' | 'interrupted' | 'timeout'): void;
-    getTerminalError(): string | undefined;
-    hasAgentTerminalError(): boolean;
-    getSessionId(): string;
-    getLastUsage(): PiResultUsage | undefined;
-    /** Accumulate a per-message usage record into the run's cumulative totals. */
-    private addUsage;
-    normalize(raw: PiEvent): AgentEvent | null;
-    private applyUpdate;
-    private normalizeToolResult;
-}
-export {};