lark-remote 0.1.0

package/dist/router/order-exec-dispatch.d.ts

@@ -0,0 +1,30 @@
+import type { CommandRouter } from './index.js';
+import type { Bridge } from '../bridge/index.js';
+/** Context shared by all card-action dispatch paths (file-local; callers pass it structurally). */
+interface DispatchContext {
+    userId: string;
+    chatId: string;
+    messageId: string;
+}
+/**
+ * Dispatch an `order.exec` card action as an equivalent queued user message
+ * (Plan A): resolve the order text at the enqueue boundary, then enqueue it
+ * through `router.handle(orderText)` — the same path a hand-typed message
+ * takes. The real text flows as the queue `messagePreview` (→ queue card
+ * display + edit default_value) and as the forwarded content; a unique
+ * internal key is used as the queue dedup key instead of the Feishu card
+ * messageId (one order card is clickable N times, so the card messageId is
+ * 1:N with enqueue actions and must not be reused).
+ *
+ * Extracted from `src/index.ts` so the enqueue-time contract is unit-testable
+ * without wiring up the full `main()` graph. Returns a short status string
+ * for the caller to log; performs its own error feedback via `bridge.sendResult`.
+ */
+export declare function dispatchOrderExecForQueue(args: {
+    router: CommandRouter;
+    bridge: Bridge;
+    workspace: string;
+    orderId: string | undefined;
+    ctx: DispatchContext;
+}): Promise<'enqueued' | 'missing-id' | 'not-found'>;
+export {};

package/dist/router/order-exec-dispatch.js

@@ -0,0 +1,48 @@
+/**
+ * Dispatch an `order.exec` card action as an equivalent queued user message
+ * (Plan A): resolve the order text at the enqueue boundary, then enqueue it
+ * through `router.handle(orderText)` — the same path a hand-typed message
+ * takes. The real text flows as the queue `messagePreview` (→ queue card
+ * display + edit default_value) and as the forwarded content; a unique
+ * internal key is used as the queue dedup key instead of the Feishu card
+ * messageId (one order card is clickable N times, so the card messageId is
+ * 1:N with enqueue actions and must not be reused).
+ *
+ * Extracted from `src/index.ts` so the enqueue-time contract is unit-testable
+ * without wiring up the full `main()` graph. Returns a short status string
+ * for the caller to log; performs its own error feedback via `bridge.sendResult`.
+ */
+export async function dispatchOrderExecForQueue(args) {
+    const { router, bridge, workspace, orderId, ctx } = args;
+    if (!orderId) {
+        await bridge.sendResult({ text: '卡片 payload 缺少必要信息' }, ctx);
+        return 'missing-id';
+    }
+    const resolved = router.resolveOrderExecForQueue(orderId);
+    if (!resolved) {
+        await bridge.sendResult({ text: '指令不存在或已被删除' }, ctx);
+        return 'not-found';
+    }
+    // Step4/D4: 入队时刻（T0）快照 agent+session，随任务闭包带到 T1 执行时刻，
+    // 避免排队期间 /new、/config 改写 live 状态导致语义漂移。唯一捕获点
+    // Bridge.currentBinding。
+    const binding = bridge.currentBinding(ctx.userId);
+    bridge.enqueue(workspace, async () => {
+        await router.handle(resolved.orderText, ctx, { cwdOverride: workspace, binding });
+    }, {
+        taskMeta: {
+            userId: ctx.userId,
+            chatId: ctx.chatId,
+            messageId: resolved.internalKey,
+            messagePreview: resolved.orderText.slice(0, 3000),
+            // The internal key is NOT a valid Feishu message id, so the queue
+            // status card must reply to the real Feishu card message id instead.
+            feishuReplyTo: ctx.messageId,
+            // D3/Step4：binding 随 taskMeta 存进 QueuedTask，供替换闭包
+            // （queue.edit/queue.immediate）复用，不重新快照。
+            binding,
+        },
+    });
+    return 'enqueued';
+}
+//# sourceMappingURL=order-exec-dispatch.js.map

package/dist/router/utils.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Pure utility functions extracted from router/index.ts.
+ * Path-safety helpers, display formatting, and validation — no Router state.
+ */
+import type { ActiveRunSnapshot } from '../bridge/index.js';
+export interface SessionDisplayUsage {
+    contextLength?: number;
+    compactCount?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+}
+export declare function activeRunUsage(activeRun: ActiveRunSnapshot | undefined): SessionDisplayUsage | undefined;
+/**
+ * Format usage stats (context length, compact count, cache tokens) into a display string.
+ * Each stat on its own line with blank lines between sections.
+ * @param usage - Usage stats object
+ * @param options - Optional display options (showResult adds result line)
+ */
+export declare function formatUsageStats(usage?: {
+    contextLength?: number;
+    compactCount?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    /** Agent-declared total; when present the display uses max(total, sum of parts). */
+    totalTokens?: number;
+    /** Real input tokens from the agent's result event. When present, used
+     *  directly for the "Input token" line instead of contextLength+cache. */
+    inputTokens?: number;
+    /** Real output tokens from the agent's result event. When present, used
+     *  directly instead of the 10% estimate. */
+    outputTokens?: number;
+    /** Session-cumulative total/input/output (all runs), from session jsonl. When
+     *  present, appended as "· 累计 X" on the Total/Input/Output lines. */
+    cumulativeTotalTokens?: number;
+    cumulativeInputTokens?: number;
+    cumulativeOutputTokens?: number;
+    /** Session-cumulative cache read tokens (all runs). */
+    cumulativeCacheReadTokens?: number;
+    /** Session-cumulative cache creation tokens (all runs). */
+    cumulativeCacheCreationTokens?: number;
+}, options?: {
+    showResult?: boolean;
+    result?: string;
+}): string;

package/dist/router/utils.js

@@ -0,0 +1,116 @@
+/**
+ * Pure utility functions extracted from router/index.ts.
+ * Path-safety helpers, display formatting, and validation — no Router state.
+ */
+export function activeRunUsage(activeRun) {
+    if (!activeRun || activeRun.contextLength === undefined)
+        return undefined;
+    return {
+        contextLength: activeRun.contextLength,
+        compactCount: activeRun.compactCount,
+        cacheReadTokens: activeRun.cacheReadTokens,
+        cacheCreationTokens: activeRun.cacheCreationTokens,
+    };
+}
+// --- Extracted helpers for refactoring ---
+/**
+ * Format number to K unit string, rounding to the nearest integer K
+ * (e.g., 120000 → 120K, 1500 → 2K, 1950 → 2K). Values < 1000 are returned as-is.
+ */
+function formatTokenK(n) {
+    if (n >= 1000) {
+        const k = Math.round(n / 1000);
+        return `${k}K`;
+    }
+    return n.toString();
+}
+/**
+ * Format usage stats (context length, compact count, cache tokens) into a display string.
+ * Each stat on its own line with blank lines between sections.
+ * @param usage - Usage stats object
+ * @param options - Optional display options (showResult adds result line)
+ */
+export function formatUsageStats(usage, options) {
+    const lines = [];
+    // 1. Success 状态（通用格式，无具体结果值）
+    lines.push('✅ 已完成');
+    // 1.5. 可选的结果行（showResult 为 true 时显示）
+    if (options?.showResult && options?.result) {
+        lines.push(`结果 - ${options.result}`);
+    }
+    // 2. Context 长度
+    if (usage?.contextLength !== undefined) {
+        lines.push(`Context - ${formatTokenK(usage.contextLength)}`);
+    }
+    // 3. Compact 次数
+    if (usage?.compactCount) {
+        lines.push(`Compact - ${usage.compactCount}次`);
+    }
+    // 4-7. Token 统计
+    const cacheRead = usage?.cacheReadTokens ?? 0;
+    const cacheCreation = usage?.cacheCreationTokens ?? 0;
+    const realInput = usage?.inputTokens;
+    const realOutput = usage?.outputTokens;
+    // Cumulative suffix (session-wide totals), appended to Input/Output lines.
+    const cumInputSuffix = usage?.cumulativeInputTokens !== undefined
+        ? ` · 累计 ${formatTokenK(usage.cumulativeInputTokens)}`
+        : '';
+    const cumOutputSuffix = usage?.cumulativeOutputTokens !== undefined
+        ? ` · 累计 ${formatTokenK(usage.cumulativeOutputTokens)}`
+        : '';
+    const cumTotalSuffix = usage?.cumulativeTotalTokens !== undefined
+        ? ` · 累计 ${formatTokenK(usage.cumulativeTotalTokens)}`
+        : '';
+    // 计算累计 cache 命中率
+    const cumInput = usage?.cumulativeInputTokens;
+    const cumCacheRead = usage?.cumulativeCacheReadTokens;
+    const cumCachePercent = cumInput !== undefined && cumCacheRead !== undefined && cumInput + cumCacheRead > 0
+        ? Math.round((cumCacheRead / (cumInput + cumCacheRead)) * 100)
+        : null;
+    // 构建累计 suffix
+    const cumCacheReadSuffix = cumCacheRead !== undefined
+        ? ` · 累计 ${formatTokenK(cumCacheRead)}` +
+            (cumCachePercent !== null ? ` (${cumCachePercent}%)` : '')
+        : '';
+    const cumCacheCreateSuffix = usage?.cumulativeCacheCreationTokens !== undefined
+        ? ` · 累计 ${formatTokenK(usage.cumulativeCacheCreationTokens)}`
+        : '';
+    if (realInput !== undefined && realOutput !== undefined) {
+        // Unified ccusage-aligned formula:
+        //   total = max(total_tokens, input + output + cacheRead + cacheCreation)
+        //   cache% = cacheRead / (input + cacheRead)
+        // cacheRead/cacheCreation are never double-counted; total_tokens folds in any
+        // extra (e.g. opencode reasoning, which is separate from output) via max().
+        const promptTokens = realInput + cacheRead;
+        const cachePercent = promptTokens > 0 ? Math.round((cacheRead / promptTokens) * 100) : 0;
+        const sumParts = realInput + realOutput + cacheRead + cacheCreation;
+        const totalTokens = usage?.totalTokens != null ? Math.max(usage.totalTokens, sumParts) : sumParts;
+        lines.push(`Input token - ${formatTokenK(realInput)}${cumInputSuffix}`);
+        lines.push(`Output token - ${formatTokenK(realOutput)}${cumOutputSuffix}`);
+        if (cacheCreation > 0) {
+            lines.push(`Cache create - ${formatTokenK(cacheCreation)}${cumCacheCreateSuffix}`);
+        }
+        lines.push(`Cached token - ${formatTokenK(cacheRead)} (${cachePercent}%)${cumCacheReadSuffix}`);
+        lines.push(`Total token - ${formatTokenK(totalTokens)}${cumTotalSuffix}`);
+    }
+    else {
+        // Estimate path: when real input/output are absent,
+        // fall back to the 10% estimate based on contextLength.
+        const inputRef = usage?.contextLength ?? cacheRead;
+        if (inputRef > 0 || cacheRead > 0 || cacheCreation > 0) {
+            const totalInput = inputRef + cacheRead;
+            const outputEst = inputRef > 0 ? Math.round(inputRef * 0.1) : 0;
+            const cachePercent = totalInput > 0 ? Math.round((cacheRead / totalInput) * 100) : 0;
+            const totalTokens = totalInput + outputEst + cacheCreation;
+            lines.push(`Input token - ${formatTokenK(totalInput)}${cumInputSuffix}`);
+            lines.push(`Output token - ${formatTokenK(outputEst)}${cumOutputSuffix}`);
+            if (cacheCreation > 0) {
+                lines.push(`Cache create - ${formatTokenK(cacheCreation)}${cumCacheCreateSuffix}`);
+            }
+            lines.push(`Cached token - ${formatTokenK(cacheRead)} (${cachePercent}%)${cumCacheReadSuffix}`);
+            lines.push(`Total token - ${formatTokenK(totalTokens)}${cumTotalSuffix}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=utils.js.map

package/dist/runner/bash/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Bash Runner 模块入口
+ */
+export { BashProcessRunner, type BashRunner } from './runner.js';

package/dist/runner/bash/index.js

@@ -0,0 +1,5 @@
+/**
+ * Bash Runner 模块入口
+ */
+export { BashProcessRunner } from './runner.js';
+//# sourceMappingURL=index.js.map

package/dist/runner/bash/runner.d.ts

@@ -0,0 +1,55 @@
+interface BashOutputEvent {
+    type: 'stdout' | 'stderr' | 'exit';
+    content: string;
+    exitCode?: number;
+}
+export interface BashRunner {
+    run(command: string, opts: {
+        cwd: string;
+    }): AsyncGenerator<BashOutputEvent>;
+    stop(opts?: {
+        immediate?: boolean;
+    }): Promise<void>;
+    get isRunning(): boolean;
+}
+/**
+ * Lightweight bash executor for `!` commands.
+ * Spawns `bash -c "<command>"` and yields stdout/stderr/exit as events.
+ *
+ * Output streaming is event-driven: the run loop races the next stdout/stderr
+ * `data` event against process `exit`/`error`, so it wakes instantly on either
+ * (no `setTimeout` busy-wait polling). This drops exit latency from ~100ms
+ * (the previous poll granularity) to ~0 and avoids periodic CPU wakeups while
+ * a long command produces no output. Each stream has a single `data` handler
+ * that logs, enqueues, and wakes the loop.
+ */
+export declare class BashProcessRunner implements BashRunner {
+    private currentProcess;
+    /**
+     * 背压高水位/低水位（P1-4 层④，参照 jsonl-stream.ts 的 pauseThreshold/
+     * resumeThreshold）。stdout/stderr 队列超过高水位时 pause 流（内存有界），
+     * 消费者 drain 到低水位后 resume。构造可注入以便测试用小水位。
+     */
+    private readonly queueHighWater;
+    private readonly queueLowWater;
+    private stopper;
+    constructor(opts?: {
+        stopGraceMs?: number;
+        queueHighWater?: number;
+        queueLowWater?: number;
+    });
+    get isRunning(): boolean;
+    run(command: string, opts: {
+        cwd: string;
+    }): AsyncGenerator<BashOutputEvent>;
+    /**
+     * P1-22: called by the process-level exit dispatcher on SIGINT/SIGTERM/exit.
+     * Kills the whole process group (leader + background children) via
+     * ProcessStopper, matching agent-runner cleanupOnExit semantics.
+     */
+    cleanupOnExit(): void;
+    stop(opts?: {
+        immediate?: boolean;
+    }): Promise<void>;
+}
+export {};

package/dist/runner/bash/runner.js

@@ -0,0 +1,213 @@
+import { spawn } from 'node:child_process';
+import { getLogger } from '../../logger/index.js';
+import { ProcessStopper } from '../common/process-stopper.js';
+import { registerExitCleanup, unregisterExitCleanup } from '../common/spawning-runner.js';
+/**
+ * Lightweight bash executor for `!` commands.
+ * Spawns `bash -c "<command>"` and yields stdout/stderr/exit as events.
+ *
+ * Output streaming is event-driven: the run loop races the next stdout/stderr
+ * `data` event against process `exit`/`error`, so it wakes instantly on either
+ * (no `setTimeout` busy-wait polling). This drops exit latency from ~100ms
+ * (the previous poll granularity) to ~0 and avoids periodic CPU wakeups while
+ * a long command produces no output. Each stream has a single `data` handler
+ * that logs, enqueues, and wakes the loop.
+ */
+export class BashProcessRunner {
+    currentProcess = null;
+    /**
+     * 背压高水位/低水位（P1-4 层④，参照 jsonl-stream.ts 的 pauseThreshold/
+     * resumeThreshold）。stdout/stderr 队列超过高水位时 pause 流（内存有界），
+     * 消费者 drain 到低水位后 resume。构造可注入以便测试用小水位。
+     */
+    queueHighWater;
+    queueLowWater;
+    stopper;
+    constructor(opts) {
+        const stopGraceMs = opts?.stopGraceMs ?? 1000;
+        this.queueHighWater = opts?.queueHighWater ?? 32;
+        this.queueLowWater = opts?.queueLowWater ?? 16;
+        if (this.queueLowWater > this.queueHighWater) {
+            this.queueLowWater = this.queueHighWater;
+        }
+        this.stopper = new ProcessStopper({ graceMs: stopGraceMs });
+    }
+    get isRunning() {
+        return (this.currentProcess !== null &&
+            this.currentProcess.exitCode === null &&
+            this.currentProcess.signalCode === null);
+    }
+    async *run(command, opts) {
+        if (this.isRunning) {
+            getLogger().warn('[bash-runner] run() called while already running');
+            throw new Error('bash process already running');
+        }
+        getLogger().debug(`[bash-runner] spawning command="${command}" cwd=${opts.cwd}`);
+        const proc = spawn('bash', ['-c', command], {
+            cwd: opts.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // Spawn in new process group so we can kill the entire group
+            detached: true,
+        });
+        this.currentProcess = proc;
+        getLogger().info(`[bash-runner] spawn pid=${proc.pid} command="${command.slice(0, 50)}..." cwd=${opts.cwd}`);
+        // P1-22: register with the process-level exit dispatcher while the process
+        // is alive — bridge exit/restart (SIGINT/SIGTERM/exit) then kills the whole
+        // group via cleanupOnExit instead of orphaning `!` processes.
+        registerExitCleanup(this);
+        // Single handler per stream: log + enqueue + wake the run loop. The
+        // previous implementation registered two `data` listeners per stream (one
+        // for logging, one for queueing) -- both fired on the same chunk.
+        const stdoutQueue = [];
+        const stderrQueue = [];
+        // 背压状态（P1-4 层④）：队列超高水位 → pause 对应流；drain 到低水位 → resume。
+        let stdoutPaused = false;
+        let stderrPaused = false;
+        const maybePauseStdout = () => {
+            if (!stdoutPaused && stdoutQueue.length > this.queueHighWater) {
+                stdoutPaused = true;
+                proc.stdout.pause();
+            }
+        };
+        const maybeResumeStdout = () => {
+            if (stdoutPaused && stdoutQueue.length <= this.queueLowWater) {
+                stdoutPaused = false;
+                proc.stdout.resume();
+            }
+        };
+        const maybePauseStderr = () => {
+            if (!stderrPaused && stderrQueue.length > this.queueHighWater) {
+                stderrPaused = true;
+                proc.stderr.pause();
+            }
+        };
+        const maybeResumeStderr = () => {
+            if (stderrPaused && stderrQueue.length <= this.queueLowWater) {
+                stderrPaused = false;
+                proc.stderr.resume();
+            }
+        };
+        // Resolved by a `data` event to signal "more output may be available,
+        // re-check the queues". Held as a field so either stream's handler can
+        // resolve the single in-flight waiter. Cleared on resolve and on loop exit.
+        let dataWaiter = null;
+        const notifyData = () => {
+            if (dataWaiter) {
+                const resolve = dataWaiter;
+                dataWaiter = null;
+                resolve();
+            }
+        };
+        proc.stdout?.on('data', (chunk) => {
+            const text = chunk.toString('utf-8');
+            getLogger().debug(`[bash-runner] stdout: ${text.slice(0, 100)}`);
+            stdoutQueue.push(text);
+            maybePauseStdout();
+            notifyData();
+        });
+        proc.stderr?.on('data', (chunk) => {
+            const text = chunk.toString('utf-8');
+            getLogger().debug(`[bash-runner] stderr: ${text.slice(0, 100)}`);
+            stderrQueue.push(text);
+            maybePauseStderr();
+            notifyData();
+        });
+        // Use the `exit` event (not `close`): `close` waits for ALL child processes
+        // including background daemons (`nohup &`), which can take forever. `exit`
+        // fires as soon as bash itself exits. A SIGKILL from /stop sets `signal`
+        // while `code` stays null, so callers distinguish signal-kill from exit.
+        // A spawn failure (e.g. bash missing) emits `error` and never `exit`;
+        // resolving completion with code=1 here lets the loop terminate instead of
+        // spinning forever on a permanently-null exitCode check (the old poll loop
+        // had the same latent hang on a missing bash binary).
+        let completionResult = null;
+        const completion = new Promise((resolve) => {
+            proc.once('exit', (code, signal) => {
+                completionResult = { code, signal };
+                resolve();
+            });
+            proc.once('error', (err) => {
+                getLogger().error('[bash-runner] process error:', err.message);
+                completionResult = { code: 1, signal: null };
+                resolve();
+            });
+        });
+        try {
+            while (completionResult === null) {
+                // Drain queued chunks before waiting, so output is streamed
+                // incrementally rather than batched at exit.
+                while (stdoutQueue.length > 0) {
+                    yield { type: 'stdout', content: stdoutQueue.shift() };
+                    maybeResumeStdout();
+                }
+                while (stderrQueue.length > 0) {
+                    yield { type: 'stderr', content: stderrQueue.shift() };
+                    maybeResumeStderr();
+                }
+                if (completionResult === null) {
+                    // Wait for the next chunk OR process exit/error -- no fixed-interval
+                    // polling. Racing `completion` guarantees the loop wakes on exit even
+                    // when the command produces no output (e.g. `true`, `nohup &`), which
+                    // the previous setTimeout(100) poll only caught after a full tick.
+                    const nextData = new Promise((resolve) => {
+                        dataWaiter = resolve;
+                    });
+                    await Promise.race([nextData, completion]);
+                    dataWaiter = null;
+                }
+            }
+            // Drain any chunks that arrived between the last drain and exit. (Data
+            // emitted after the exit yield is not delivered -- matching the prior
+            // contract; the bridge accumulates output/stderr from pre-exit events.)
+            while (stdoutQueue.length > 0) {
+                yield { type: 'stdout', content: stdoutQueue.shift() };
+                maybeResumeStdout();
+            }
+            while (stderrQueue.length > 0) {
+                yield { type: 'stderr', content: stderrQueue.shift() };
+                maybeResumeStderr();
+            }
+            const { code, signal } = completionResult;
+            getLogger().info(`[bash-runner] process exited with code=${code} signal=${signal}`);
+            // A SIGKILL'd process (e.g. from /stop) has exitCode=null and a signal
+            // set. Reporting `code ?? 0` would falsely claim success; use -1 to
+            // signal abnormal termination by signal.
+            yield { type: 'exit', content: '', exitCode: code ?? (signal ? -1 : 0) };
+        }
+        finally {
+            dataWaiter = null;
+            this.currentProcess = null;
+            // Run finished — remove from the exit dispatcher so dead runners are not
+            // retained (mirror agent-runner slot eviction; keeps the Set bounded to
+            // active bash runs only).
+            unregisterExitCleanup(this);
+        }
+    }
+    /**
+     * P1-22: called by the process-level exit dispatcher on SIGINT/SIGTERM/exit.
+     * Kills the whole process group (leader + background children) via
+     * ProcessStopper, matching agent-runner cleanupOnExit semantics.
+     */
+    cleanupOnExit() {
+        const proc = this.currentProcess;
+        if (!proc || proc.exitCode !== null || proc.signalCode !== null)
+            return;
+        try {
+            void this.stopper.stop(proc, { immediate: true });
+        }
+        catch {
+            // fire-and-forget: nothing else to do at process exit
+        }
+    }
+    async stop(opts) {
+        const proc = this.currentProcess;
+        if (!proc || proc.exitCode !== null || proc.signalCode !== null) {
+            this.currentProcess = null;
+            return;
+        }
+        // Delegate to ProcessStopper for unified stop semantics
+        await this.stopper.stop(proc, { immediate: opts?.immediate });
+        this.currentProcess = null;
+    }
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner/claude/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Claude Runner 模块入口
+ */
+export { ClaudeRunner } from './runner.js';

package/dist/runner/claude/index.js

@@ -0,0 +1,5 @@
+/**
+ * Claude Runner 模块入口
+ */
+export { ClaudeRunner } from './runner.js';
+//# sourceMappingURL=index.js.map

package/dist/runner/claude/runner.d.ts

@@ -0,0 +1,29 @@
+import { type AgentEvent, type SpawnOptions, type AgentSessionReader, type AgentRunner as IAgentRunner, type AgentStatusInfo } from '../types.js';
+import { SpawningRunner } from '../common/spawning-runner.js';
+/**
+ * Claude Agent Runner
+ *
+ * 使用 Claude Code CLI (claude) 作为后端 AI 代理
+ */
+export declare class ClaudeRunner extends SpawningRunner implements IAgentRunner {
+    readonly kind: "claude";
+    readonly sessionReader: AgentSessionReader;
+    private defaultModel;
+    private defaultEffort;
+    private defaultSettings?;
+    constructor(opts: {
+        binary?: string;
+        model?: string;
+        effort?: string;
+        settings?: string;
+        stopGraceMs?: number;
+        pidDir?: string;
+        workspace: string;
+        spawnHeartbeatMs?: number;
+        sessionReader?: AgentSessionReader;
+    });
+    get pid(): number | undefined;
+    getStatusInfo(): AgentStatusInfo;
+    protected buildArgv(opts: SpawnOptions): string[];
+    protected translate(rawEvent: unknown, _ctx: unknown): AgentEvent | AgentEvent[] | null;
+}

package/dist/runner/claude/runner.js

@@ -0,0 +1,83 @@
+/**
+ * Claude Runner 实现
+ *
+ * 从 runner/index.ts 提取的 ClaudeRunner 类
+ */
+import { ClaudeSessionReader } from '../../session/claude/index.js';
+import { SpawningRunner } from '../common/spawning-runner.js';
+import { MODEL_ID_TO_ALIAS } from '../../config/index.js';
+/**
+ * Claude Agent Runner
+ *
+ * 使用 Claude Code CLI (claude) 作为后端 AI 代理
+ */
+export class ClaudeRunner extends SpawningRunner {
+    kind = 'claude';
+    sessionReader;
+    defaultModel;
+    defaultEffort;
+    defaultSettings;
+    constructor(opts) {
+        super({
+            binary: opts.binary ?? 'claude',
+            pidDir: opts.pidDir,
+            workspace: opts.workspace,
+            stopGraceMs: opts.stopGraceMs,
+            spawnHeartbeatMs: opts.spawnHeartbeatMs,
+            pidFilePrefix: 'claude',
+            logTag: 'claude-runner',
+        });
+        this.defaultModel = opts.model ?? 'claude-opus-4-8';
+        this.defaultEffort = opts.effort ?? 'medium';
+        this.defaultSettings = opts.settings;
+        this.sessionReader = opts.sessionReader ?? new ClaudeSessionReader();
+    }
+    get pid() {
+        return this.currentProcess?.pid;
+    }
+    getStatusInfo() {
+        const alias = MODEL_ID_TO_ALIAS[this.defaultModel] ?? this.defaultModel;
+        const isHaiku = this.defaultModel.includes('haiku');
+        return {
+            kind: 'claude',
+            model: alias,
+            reasoning: isHaiku ? 'off' : this.defaultEffort,
+        };
+    }
+    buildArgv(opts) {
+        const args = [
+            '-p',
+            this.currentMessage,
+            '--output-format',
+            'stream-json',
+            '--verbose',
+            // Hardcoded: Feishu chat doesn't support interactive approval.
+            '--permission-mode',
+            'bypassPermissions',
+        ];
+        if (opts.sessionId) {
+            args.push('--resume', opts.sessionId);
+        }
+        if (opts.model) {
+            args.push('--model', opts.model);
+        }
+        const effort = opts.effort ?? this.defaultEffort;
+        if (effort) {
+            args.push('--effort', effort);
+        }
+        const settings = opts.settings ?? this.defaultSettings;
+        if (settings) {
+            args.push('--settings', settings);
+        }
+        return args;
+    }
+    translate(rawEvent, _ctx) {
+        const event = rawEvent;
+        // 统一方案：所有 runner 自己生成 timestamp
+        if (!event.timestamp) {
+            event.timestamp = new Date().toISOString();
+        }
+        return event;
+    }
+}
+//# sourceMappingURL=runner.js.map