lark-remote 0.1.6 → 0.1.8

package/dist/runner/common/exec-translator.js

@@ -1,105 +0,0 @@
-/**
- * Abstract base class for exec-stream translators (codex, opencode, pi, kimi).
- *
- * Encapsulates the shared state machine and guard logic that was duplicated
- * across every concrete translator:
- *   - Terminal-state tracking (idempotent `finish()`)
- *   - `translate()` guard (terminal → []; non-record / non-string-type → anomaly)
- *   - `recordUnknownEvent()` helper (warn-logs unknown event types)
- *   - Session / usage / error getters
- *
- * Subclasses provide:
- *   - `logTag` — prefix for warn logs
- *   - `streamEndedMessage()` — agent-specific "stream ended early" message
- *   - `translateEvent(raw)` — agent-specific event dispatch
- *
- * @see SpawningRunner for the runner that consumes translators
- */
-import { getLogger } from '../../logger/index.js';
-import { isRecord } from '../../common/guards.js';
-// ---------------------------------------------------------------------------
-// Abstract base class
-// ---------------------------------------------------------------------------
-export class ExecTranslator {
-    // --- Shared state ---
-    terminal = false;
-    lastError;
-    lastUsage;
-    terminalErrorMessage;
-    terminalErrorFromAgent = false;
-    sessionId;
-    startedTools = new Set();
-    // --- translate() guard (shared) ---
-    /** Translate a single parsed ndjson line into zero or more `AgentEvent`s.
-     *  P3-3: filter paths (terminal / non-record / non-string-type) return `null`
-     *  instead of `[]` to avoid a throwaway array allocation per non-emitting
-     *  event on codex/opencode hot paths. The consumer (SpawningRunner) already
-     *  handles `null` via `Array.isArray` + null guards. */
-    translate(raw) {
-        if (this.terminal)
-            return null;
-        if (!isRecord(raw) || typeof raw.type !== 'string') {
-            return null;
-        }
-        return this.translateEvent(raw);
-    }
-    // --- recordUnknownEvent helper ---
-    /** Warn-log an unknown event type and return `null` (P3-3: no throwaway []). */
-    recordUnknownEvent(type) {
-        getLogger().warn(`${this.logTag} unknown event type: ${type}`);
-        return null;
-    }
-    // --- finish() (shared, idempotent) ---
-    /**
-     * Called when the stream ends without a natural terminal event.
-     *
-     * - Marks the translator terminal (idempotent — second call returns `[]`).
-     * - For `reason='failed'`, stores `terminalErrorMessage` so the runner can
-     *   surface it via `buildResultEvent({translatorError})`.
-     * - Returns `[]` — the runner is responsible for emitting the result event.
-     */
-    finish(reason = 'failed') {
-        if (this.terminal)
-            return [];
-        this.terminal = true;
-        if (reason === 'failed') {
-            const detail = this.lastError ? `: ${this.lastError}` : '';
-            this.terminalErrorMessage = `${this.streamEndedMessage()}${detail}`;
-        }
-        // interrupted / timeout: no terminalErrorMessage — the runner's
-        // stoppedByUser flag (set by base class stop()) drives the result subtype.
-        return [];
-    }
-    // --- Getters (shared) ---
-    /** Whether a terminal event has already been seen. */
-    isTerminal() {
-        return this.terminal;
-    }
-    /** Session ID captured from the agent stream (for the result event). */
-    getSessionId() {
-        return this.sessionId;
-    }
-    /** Token usage captured from the terminal event (for the success result event). */
-    getLastUsage() {
-        return this.lastUsage;
-    }
-    /**
-     * Terminal error message captured from an agent-reported error or
-     * `finish('failed')`. Returns `undefined` if no terminal error occurred.
-     */
-    getTerminalError() {
-        return this.terminalErrorMessage;
-    }
-    /**
-     * True iff `getTerminalError()` was populated by an agent-reported terminal
-     * error (e.g. codex `turn.failed`). The runner uses this to pick the correct
-     * root cause for `buildResultEvent`: agent errors override signal/non-zero-code
-     * (the agent error is the root cause), but stream-ended-early errors
-     * (`finish('failed')`) yield to signal/non-zero-code (the signal is the root
-     * cause and the early stream-end is a symptom).
-     */
-    hasAgentTerminalError() {
-        return this.terminalErrorFromAgent;
-    }
-}
-//# sourceMappingURL=exec-translator.js.map

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

@@ -1,28 +0,0 @@
-import type { RunnerTranslator } from '../common/spawning-runner.js';
-import type { AgentEvent } from '../types.js';
-/**
- * Translates kimi `--output-format stream-json` ndjson into lark-remote
- * AgentEvents. Stateful: captures sessionId from the first meta event so
- * the synthesized SystemInitEvent carries the correct session_id.
- *
- * Implements RunnerTranslator so the base SpawningRunner can drive it
- * uniformly. kimi has no agent-reported terminal error (no equivalent of
- * codex `turn.failed`), so isTerminal/finish/getTerminalError/
- * hasAgentTerminalError are no-ops — kimi relies entirely on the base
- * class's signal/code-based result event classification.
- */
-export declare class KimiTranslator implements RunnerTranslator {
-    private readonly cwd;
-    private readonly model;
-    private sessionId;
-    constructor(opts: {
-        cwd: string;
-        model: string;
-    });
-    translate(raw: unknown): AgentEvent | AgentEvent[] | null;
-    isTerminal(): boolean;
-    finish(_reason: 'failed' | 'interrupted' | 'timeout'): void;
-    getTerminalError(): string | undefined;
-    hasAgentTerminalError(): boolean;
-    getSessionId(): string | undefined;
-}

package/dist/runner/kimi/jsonl.js

@@ -1,143 +0,0 @@
-// --- Tool name normalization (Kimi uses lowercase) ---
-const TOOL_NAME_MAP = {
-    read: 'Read',
-    write: 'Write',
-    edit: 'Edit',
-    grep: 'Grep',
-    glob: 'Glob',
-    bash: 'Bash',
-    websearch: 'WebSearch',
-    fetchurl: 'FetchURL',
-    skill: 'Skill',
-    tasklist: 'TaskList',
-    taskoutput: 'TaskOutput',
-    taskstop: 'TaskStop',
-    todolist: 'TodoList',
-    croncreate: 'CronCreate',
-    crondelete: 'CronDelete',
-    cronlist: 'CronList',
-    enterplanmode: 'EnterPlanMode',
-    exitplanmode: 'ExitPlanMode',
-    getgoal: 'GetGoal',
-    setgoalbudget: 'SetGoalBudget',
-    updategoal: 'UpdateGoal',
-    readmediafile: 'ReadMediaFile',
-};
-function normalizeToolName(name) {
-    return TOOL_NAME_MAP[name] || name.charAt(0).toUpperCase() + name.slice(1);
-}
-// --- KimiTranslator ---
-/**
- * Translates kimi `--output-format stream-json` ndjson into lark-remote
- * AgentEvents. Stateful: captures sessionId from the first meta event so
- * the synthesized SystemInitEvent carries the correct session_id.
- *
- * Implements RunnerTranslator so the base SpawningRunner can drive it
- * uniformly. kimi has no agent-reported terminal error (no equivalent of
- * codex `turn.failed`), so isTerminal/finish/getTerminalError/
- * hasAgentTerminalError are no-ops — kimi relies entirely on the base
- * class's signal/code-based result event classification.
- */
-export class KimiTranslator {
-    cwd;
-    model;
-    sessionId;
-    constructor(opts) {
-        this.cwd = opts.cwd;
-        this.model = opts.model;
-    }
-    translate(raw) {
-        const rawEvent = raw;
-        // Handle meta events (session.resume_hint) — emit system.init so the
-        // bridge can sync sessionStore with the new sessionId. Without this,
-        // the bridge never learns the sessionId and auto-resume silently fails.
-        if (rawEvent.role === 'meta' && rawEvent.type === 'session.resume_hint') {
-            const metaEvent = rawEvent;
-            this.sessionId = metaEvent.session_id;
-            return {
-                type: 'system',
-                subtype: 'init',
-                session_id: metaEvent.session_id,
-                cwd: this.cwd,
-                model: this.model,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        if (rawEvent.role === 'assistant') {
-            const assistantEvent = rawEvent;
-            const events = [];
-            // Text content - yield immediately (Kimi sends complete content per message)
-            if (assistantEvent.content) {
-                events.push({
-                    type: 'assistant',
-                    message: { content: [{ type: 'text', text: assistantEvent.content }] },
-                    timestamp: new Date().toISOString(),
-                });
-            }
-            // Tool calls - emit as separate events
-            if (assistantEvent.tool_calls && assistantEvent.tool_calls.length > 0) {
-                for (const tc of assistantEvent.tool_calls) {
-                    let argsObj = {};
-                    try {
-                        argsObj = JSON.parse(tc.function.arguments);
-                    }
-                    catch {
-                        // Use empty object if parse fails
-                    }
-                    events.push({
-                        type: 'assistant',
-                        message: {
-                            content: [
-                                {
-                                    type: 'tool_use',
-                                    id: tc.id,
-                                    name: normalizeToolName(tc.function.name),
-                                    input: argsObj,
-                                },
-                            ],
-                        },
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-            }
-            return events.length > 0 ? events : null;
-        }
-        if (rawEvent.role === 'tool') {
-            const toolEvent = rawEvent;
-            return {
-                type: 'user',
-                message: {
-                    content: [
-                        {
-                            type: 'tool_result',
-                            tool_use_id: toolEvent.tool_call_id,
-                            content: toolEvent.content,
-                            is_error: false,
-                        },
-                    ],
-                },
-                timestamp: new Date().toISOString(),
-            };
-        }
-        return null;
-    }
-    isTerminal() {
-        // kimi has no terminal event — the base class's result event is the terminal.
-        return false;
-    }
-    finish(_reason) {
-        // No-op: kimi has no stream-ended-early terminal error to record.
-    }
-    getTerminalError() {
-        // Always undefined — kimi has no agent-reported terminal error.
-        return undefined;
-    }
-    hasAgentTerminalError() {
-        // Always false — kimi has no agent-reported terminal error.
-        return false;
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-}
-//# sourceMappingURL=jsonl.js.map

package/dist/runner/kimi/runner.d.ts

@@ -1,49 +0,0 @@
-import type { ChildProcess } from 'node:child_process';
-import { SpawningRunner, type RunnerTranslator } from '../common/spawning-runner.js';
-import type { AgentRunner, AgentSessionReader, SpawnOptions, AgentStatusInfo } from '../types.js';
-interface KimiRunnerConfig {
-    model?: string;
-    thinkingEffort?: string;
-    stopGraceMs?: number;
-    pidDir?: string;
-    workspace: string;
-    spawnHeartbeatMs?: number;
-    sessionReader?: AgentSessionReader;
-    /** Completion timeout (ms). Default: 5000. Injectable for testing. */
-    completionTimeoutMs?: number;
-}
-/**
- * KimiRunner: spawn-per-message runner using `kimi -p <prompt> --output-format stream-json`.
- *
- * Inherits the spawn + completion + cleanup orchestration from SpawningRunner.
- * This subclass overrides only:
- *   - buildArgv(opts)         → kimi-specific flags (-p/--output-format/thinkingEffort)
- *   - createTranslator(opts)  → new KimiTranslator({ cwd: opts.cwd, model })
- *   - awaitCompletion(proc, p) → 5s timeout race + SIGKILL fallback (kimi hangs after
- *     stdout closes)
- *
- * The spawn-error 5s race lives in the base class (awaitSpawnError), shared by all
- * 5 runners — kimi no longer overrides it. The completion 5s race MUST remain here
- * (pinned by source-grep anchor tests/anchor/kimi/kimi-runner-stream-error.test.ts
- * which checks for `Promise.race` and `timeout` strings in this file).
- */
-export declare class KimiRunner extends SpawningRunner implements AgentRunner {
-    readonly kind: "kimi";
-    readonly sessionReader: AgentSessionReader;
-    private defaultModel;
-    private thinkingEffort;
-    private readonly completionTimeoutMs;
-    constructor(opts: KimiRunnerConfig);
-    get pid(): number | undefined;
-    getStatusInfo(): AgentStatusInfo;
-    protected buildArgv(opts: SpawnOptions): string[];
-    protected createTranslator(opts: SpawnOptions): RunnerTranslator;
-    protected awaitCompletion(proc: ChildProcess, completion: Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>): Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>;
-}
-export {};

package/dist/runner/kimi/runner.js

@@ -1,105 +0,0 @@
-import { getLogger } from '../../logger/index.js';
-import { SpawningRunner } from '../common/spawning-runner.js';
-import { KimiTranslator } from './jsonl.js';
-/**
- * Timeout (ms) for kimi's spawn-error race and completion race. Kimi's CLI
- * sometimes hangs after stdout closes or fails silently without an 'error'
- * event; both hooks race against this timeout to avoid blocking the runner
- * forever. Same value for both because they protect the same failure mode
- * (silent hang). Clean Code P3-1 (G25 Magic Numbers).
- */
-const KIMI_TIMEOUT_MS = 5000;
-/**
- * KimiRunner: spawn-per-message runner using `kimi -p <prompt> --output-format stream-json`.
- *
- * Inherits the spawn + completion + cleanup orchestration from SpawningRunner.
- * This subclass overrides only:
- *   - buildArgv(opts)         → kimi-specific flags (-p/--output-format/thinkingEffort)
- *   - createTranslator(opts)  → new KimiTranslator({ cwd: opts.cwd, model })
- *   - awaitCompletion(proc, p) → 5s timeout race + SIGKILL fallback (kimi hangs after
- *     stdout closes)
- *
- * The spawn-error 5s race lives in the base class (awaitSpawnError), shared by all
- * 5 runners — kimi no longer overrides it. The completion 5s race MUST remain here
- * (pinned by source-grep anchor tests/anchor/kimi/kimi-runner-stream-error.test.ts
- * which checks for `Promise.race` and `timeout` strings in this file).
- */
-export class KimiRunner extends SpawningRunner {
-    kind = 'kimi';
-    sessionReader;
-    defaultModel;
-    thinkingEffort;
-    completionTimeoutMs;
-    constructor(opts) {
-        super({
-            pidDir: opts.pidDir,
-            workspace: opts.workspace,
-            stopGraceMs: opts.stopGraceMs,
-            spawnHeartbeatMs: opts.spawnHeartbeatMs,
-            pidFilePrefix: 'kimi',
-            logTag: 'kimi-runner',
-        });
-        this.binary = 'kimi';
-        this.defaultModel = opts.model ?? 'kimi-code/k3';
-        this.thinkingEffort = opts.thinkingEffort ?? 'max';
-        this.completionTimeoutMs = opts.completionTimeoutMs ?? KIMI_TIMEOUT_MS;
-        this.sessionReader = opts.sessionReader ?? {
-            listSessions: () => ({ sessions: [], total: 0 }),
-            getNewestSession: () => null,
-            readSessionContent: () => ({ events: [] }),
-            isSessionActive: () => false,
-        };
-    }
-    get pid() {
-        return this.currentProcess?.pid;
-    }
-    getStatusInfo() {
-        return {
-            kind: 'kimi',
-            model: this.defaultModel,
-            reasoning: this.thinkingEffort,
-        };
-    }
-    buildArgv(opts) {
-        // kimi 0.26+ 的 -p 非交互模式与 --auto/--yolo 互斥，不能传权限 flag。
-        const args = ['-p', this.currentMessage, '--output-format', 'stream-json'];
-        if (opts.sessionId)
-            args.push('-r', opts.sessionId);
-        if (this.defaultModel)
-            args.push('-m', this.defaultModel);
-        return args;
-    }
-    // --- Hooks ---
-    createTranslator(opts) {
-        // Fresh translator per run. Pass opts.cwd and defaultModel so the
-        // synthesized SystemInitEvent carries the session's real directory
-        // and model name (the bridge persists these into last-session.json).
-        return new KimiTranslator({ cwd: opts.cwd, model: this.defaultModel });
-    }
-    async awaitCompletion(proc, completion) {
-        // kimi sometimes hangs after stdout closes — race completion against a
-        // 5s timeout, then force SIGKILL if still running. Pinned by source-grep
-        // anchor (tests/anchor/kimi/kimi-runner-stream-error.test.ts).
-        if (proc.exitCode !== null || proc.signalCode !== null) {
-            return { code: proc.exitCode, signal: proc.signalCode };
-        }
-        const result = await Promise.race([
-            completion,
-            new Promise((resolve) => setTimeout(() => resolve({ timeout: true }), this.completionTimeoutMs)),
-        ]);
-        if ('timeout' in result) {
-            getLogger().warn(`[kimi-runner] completion timeout, force stopping`);
-            // P1-12: 只杀组长会让组内子进程 reparent 成孤儿。复用 ProcessStopper 的
-            // immediate 组杀（与 exit/cleanup/killOrphan 语义一致）。
-            try {
-                await this.stopper.stop(proc, { immediate: true });
-            }
-            catch {
-                // Process may have already exited
-            }
-            return { code: null, signal: 'SIGKILL' };
-        }
-        return result;
-    }
-}
-//# sourceMappingURL=runner.js.map

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

@@ -1,32 +0,0 @@
-/**
- * Builds `opencode run` command-line arguments.
- *
- * Design:
- * - `--auto` eliminates approval handshake (root cause ①).
- * - `--format json` outputs ndjson event stream.
- * - Prompt goes via stdin (verified: opencode reads from stdin).
- * - cwd is set via spawn `cwd` option (not a flag).
- * - Model format: `provider/model` (e.g. 'anthropic/claude-sonnet-4-20250514').
- */
-interface BuildOpencodeRunArgsInput {
-    /** Model in provider/model format (maps to -m). Omitted → opencode config default. */
-    model?: string;
-    /** Session ID for resumption (maps to -s). */
-    sessionId?: string;
-}
-/**
- * Construct argv for `opencode run --format json --auto`.
- *
- * New session:
- *   opencode run --format json --auto -m <provider/model>
- *   (prompt via stdin)
- *
- * Resume session:
- *   opencode run --format json --auto -s <sessionID>
- *   (prompt via stdin)
- *
- * Note: prompt is sent via stdin, NOT argv position parameter.
- * The `--` separator is NOT needed because prompt goes via stdin.
- */
-export declare function buildOpencodeRunArgs(input: BuildOpencodeRunArgsInput): string[];
-export {};

package/dist/runner/opencode/argv.js

@@ -1,35 +0,0 @@
-/**
- * Builds `opencode run` command-line arguments.
- *
- * Design:
- * - `--auto` eliminates approval handshake (root cause ①).
- * - `--format json` outputs ndjson event stream.
- * - Prompt goes via stdin (verified: opencode reads from stdin).
- * - cwd is set via spawn `cwd` option (not a flag).
- * - Model format: `provider/model` (e.g. 'anthropic/claude-sonnet-4-20250514').
- */
-/**
- * Construct argv for `opencode run --format json --auto`.
- *
- * New session:
- *   opencode run --format json --auto -m <provider/model>
- *   (prompt via stdin)
- *
- * Resume session:
- *   opencode run --format json --auto -s <sessionID>
- *   (prompt via stdin)
- *
- * Note: prompt is sent via stdin, NOT argv position parameter.
- * The `--` separator is NOT needed because prompt goes via stdin.
- */
-export function buildOpencodeRunArgs(input) {
-    const args = ['run', '--format', 'json', '--auto'];
-    if (input.model) {
-        args.push('-m', input.model);
-    }
-    if (input.sessionId) {
-        args.push('-s', input.sessionId);
-    }
-    return args;
-}
-//# sourceMappingURL=argv.js.map

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

@@ -1,68 +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 type { AgentEvent, ResultEvent } from '../types.js';
-import { ExecTranslator } from '../common/exec-translator.js';
-type ResultUsage = NonNullable<ResultEvent['usage']>;
-export declare class OpencodeExecTranslator extends ExecTranslator {
-    private readonly cwd;
-    /** Accumulate usage across all steps (not just terminal step). */
-    private accumulatedUsage;
-    /** Track which tool results have already been emitted (idempotency). */
-    private readonly emittedResults;
-    protected readonly logTag = "[opencode-exec-translator]";
-    protected streamEndedMessage(): string;
-    /**
-     * @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?: {
-        cwd?: string;
-    });
-    /** Token usage captured from `step_finish(reason=stop)` (for the success result event). */
-    getLastUsage: () => ResultUsage | undefined;
-    /** Get accumulated usage across all steps (for diagnostics). */
-    getAccumulatedUsage(): Readonly<typeof this.accumulatedUsage>;
-    protected translateEvent(raw: Record<string, unknown>): AgentEvent[] | null;
-    /** SystemInitEvent: synthesize from first event with sessionId. */
-    private synthesizeInit;
-    private onStepStart;
-    private onText;
-    private onReasoning;
-    private onTool;
-    private onPatch;
-    private onStepFinish;
-    private onError;
-}
-export {};