lark-remote 0.1.6 → 0.1.8

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

@@ -0,0 +1,138 @@
+/**
+ * KimiAcpTranslator: translates ACP session/update notifications and
+ * session/request_permission server requests into AgentEvents.
+ *
+ * Per-turn stateful: accumulates text/thinking deltas, tracks tool calls,
+ * and produces turn_started events with operationKind.
+ *
+ * Wire envelope (R1, source: kimi-code packages/acp-server/src/events-map.ts,
+ * verified live 2026-08-15/16 against kimi 0.36.0):
+ *   session/update params = {sessionId, update: {sessionUpdate: '<kind>', ...}}
+ *   — the discriminator is `update.sessionUpdate`, NOT a nested `event.type`.
+ *
+ * Event mapping (design doc §4.2):
+ *   agent_message_chunk   → turn_diff text snapshot (content.text accumulation)
+ *   agent_thought_chunk   → turn_diff reasoning snapshot (content.text accumulation)
+ *   tool_call             → assistant/tool_use (rawInput object passthrough,
+ *                           string → JSON.parse fallback)
+ *   tool_call_update      → user/tool_result (status:'failed' → is_error:true)
+ *   plan / available_commands_update / session_info_update /
+ *   current_mode_update / config_option_update → discard
+ *   usage_update          → live context occupancy {used, size} →
+ *                           {total_tokens, context_limit}; NO input/output
+ *                           split exists on the wire — cumulative token stats
+ *                           fall back to wire.jsonl usage.record (dual path)
+ *   prompt stopReason:'end_turn'   → result success
+ *   prompt stopReason:'cancelled'  → result interrupted (独立终态)
+ *   prompt other stopReason/error  → result error
+ *   turn_started (self-produced)   → operationKind 'turn'/'compaction'
+ *   session/request_permission     → approval_requested
+ */
+import type { AgentEvent } from '../../types.js';
+import type { ApprovalRequestedEvent } from '../../types.js';
+/** Self-produced turn_started event (no wire equivalent — produced on prompt start). */
+export interface AcpTurnStartedEvent {
+    type: 'turn_started';
+    threadId: string;
+    turnId: string;
+    operationKind: 'turn' | 'compaction';
+    timestamp?: string;
+}
+/**
+ * Live usage snapshot from usage_update. The wire only carries context
+ * occupancy (`used`) and the model context window (`size`) — there is NO
+ * input/output token split (events-map.ts:505-516). input_tokens/output_tokens
+ * stay undefined so the bridge falls back to wire.jsonl usage.record for
+ * cumulative token stats (R1 dual path).
+ */
+export interface AcpLiveUsage {
+    total_tokens?: number;
+    context_limit?: number;
+    input_tokens?: number;
+    output_tokens?: number;
+}
+/** Usage update event for live token display. */
+export interface AcpUsageEvent {
+    type: 'usage';
+    usage: AcpLiveUsage;
+    timestamp?: string;
+}
+export type AcpTranslatorEvent = AgentEvent | AcpTurnStartedEvent | AcpUsageEvent | ApprovalRequestedEvent;
+export declare class KimiAcpTranslator {
+    /** Accumulated text per tool-call or message (keyed by a logical item id). */
+    private textByItem;
+    /** Accumulated thinking per item. */
+    private thinkingByItem;
+    /** Pending tool calls keyed by toolCallId (for matching tool_call_update). */
+    private pendingToolCalls;
+    /** Current operation kind (turn vs compact). */
+    private operationKind;
+    /** Live usage snapshot from usage_update events (context occupancy only). */
+    private liveUsage;
+    /** Whether any usage_update has been seen this turn (no update → no usage). */
+    private hasLiveUsage;
+    /** Current turn id, set by produceTurnStarted; carried on turn_diff events. */
+    private currentTurnId;
+    /**
+     * Handle a notification from the ACP server and return translated events.
+     */
+    handleNotification(method: string, params: unknown): AcpTranslatorEvent[];
+    /**
+     * Handle a server request (reverse RPC from the ACP server).
+     */
+    handleServerRequest(id: number | string, method: string, params: unknown): AcpTranslatorEvent[];
+    /**
+     * Kimi elicitation form：requestedSchema.properties 按顺序解析为 UserQuestion[]
+     * （type:array → 多选；oneOf/anyOf const → 选项 label；title → header??question）。
+     * 题面完整文本只在 form 级 message 里合并出现（逐字段 title 可能只是短 header），
+     * 因此 message 作为卡片概要行（view.intro）透传。
+     * form 会丢弃非声明选项值 → isOther=false（卡片隐藏自定义答案输入）。
+     */
+    private handleElicitationCreate;
+    /**
+     * Produce a turn_started event. Called by the runner when session/prompt
+     * is sent (no wire notification for this — self-produced).
+     */
+    produceTurnStarted(sessionId: string, turnId: string): AcpTurnStartedEvent;
+    /**
+     * Translate a prompt response into a result event. Carries the live usage
+     * snapshot only when a usage_update was seen (otherwise undefined, so the
+     * bridge falls back to wire.jsonl usage.record readback).
+     */
+    handlePromptResponse(sessionId: string, result: {
+        stopReason: string;
+    }): AgentEvent;
+    /**
+     * Produce an error result event (for JSON-RPC errors during prompt).
+     */
+    produceErrorResult(sessionId: string, errorMessage: string): AgentEvent;
+    /**
+     * Set the operation kind (turn vs compact).
+     */
+    setOperationKind(kind: 'turn' | 'compact'): void;
+    private handleAgentMessageChunk;
+    private handleAgentThoughtChunk;
+    private handleToolCall;
+    private handleToolCallUpdate;
+    private handleUsageUpdate;
+    private handleRequestPermission;
+    /**
+     * request_permission 兜底桥（elicitation/create 失败或旧版 kimi）：
+     * 选项为 q{n}_opt_{i}（allow_once，label 直取 name）+ q{n}_skip（reject_once，
+     * 跳过语义）。单题单选、无 Other（kimi 桥丢弃非声明值）。
+     */
+    private handlePermissionQuestion;
+    /**
+     * Derive the approval decision list from the server's offered options.
+     * accept/decline/cancel are universal; acceptForSession requires an
+     * always-class option (kimi `approve_always`, opencode `allow_always`).
+     */
+    private deriveAvailableDecisions;
+    /**
+     * ResultEvent.usage requires input_tokens/output_tokens: number, but the
+     * ACP wire has no such split — the live snapshot is context occupancy only.
+     * Cast is deliberate: consumers must tolerate undefined input/output (the
+     * bridge's kimi path already falls back to wire.jsonl readback).
+     */
+    private liveUsageSnapshot;
+}

package/dist/runner/kimi/acp/translator.js

@@ -0,0 +1,441 @@
+/**
+ * KimiAcpTranslator: translates ACP session/update notifications and
+ * session/request_permission server requests into AgentEvents.
+ *
+ * Per-turn stateful: accumulates text/thinking deltas, tracks tool calls,
+ * and produces turn_started events with operationKind.
+ *
+ * Wire envelope (R1, source: kimi-code packages/acp-server/src/events-map.ts,
+ * verified live 2026-08-15/16 against kimi 0.36.0):
+ *   session/update params = {sessionId, update: {sessionUpdate: '<kind>', ...}}
+ *   — the discriminator is `update.sessionUpdate`, NOT a nested `event.type`.
+ *
+ * Event mapping (design doc §4.2):
+ *   agent_message_chunk   → turn_diff text snapshot (content.text accumulation)
+ *   agent_thought_chunk   → turn_diff reasoning snapshot (content.text accumulation)
+ *   tool_call             → assistant/tool_use (rawInput object passthrough,
+ *                           string → JSON.parse fallback)
+ *   tool_call_update      → user/tool_result (status:'failed' → is_error:true)
+ *   plan / available_commands_update / session_info_update /
+ *   current_mode_update / config_option_update → discard
+ *   usage_update          → live context occupancy {used, size} →
+ *                           {total_tokens, context_limit}; NO input/output
+ *                           split exists on the wire — cumulative token stats
+ *                           fall back to wire.jsonl usage.record (dual path)
+ *   prompt stopReason:'end_turn'   → result success
+ *   prompt stopReason:'cancelled'  → result interrupted (独立终态)
+ *   prompt other stopReason/error  → result error
+ *   turn_started (self-produced)   → operationKind 'turn'/'compaction'
+ *   session/request_permission     → approval_requested
+ */
+import { makeQuestionApprovalEvent } from '../../question-common.js';
+import { NotificationMethod, ServerRequestMethod, SessionEventType, } from '../../common/acp/protocol-types.js';
+import { getLogger } from '../../../logger/index.js';
+/**
+ * Fixed snapshot item ids: ACP has exactly one text stream and one thinking
+ * stream per turn (no itemId on the wire), so turn_diff snapshots use these
+ * stable ids for in-place block replacement.
+ */
+const TEXT_ITEM_ID = 'text';
+const THINKING_ITEM_ID = 'thinking';
+// =============================================================================
+// Translator
+// =============================================================================
+export class KimiAcpTranslator {
+    /** Accumulated text per tool-call or message (keyed by a logical item id). */
+    textByItem = new Map();
+    /** Accumulated thinking per item. */
+    thinkingByItem = new Map();
+    /** Pending tool calls keyed by toolCallId (for matching tool_call_update). */
+    pendingToolCalls = new Map();
+    /** Current operation kind (turn vs compact). */
+    operationKind = 'turn';
+    /** Live usage snapshot from usage_update events (context occupancy only). */
+    liveUsage = {};
+    /** Whether any usage_update has been seen this turn (no update → no usage). */
+    hasLiveUsage = false;
+    /** Current turn id, set by produceTurnStarted; carried on turn_diff events. */
+    currentTurnId = '';
+    /**
+     * Handle a notification from the ACP server and return translated events.
+     */
+    handleNotification(method, params) {
+        if (method !== NotificationMethod.SESSION_UPDATE) {
+            return [];
+        }
+        // R1: real envelope is {sessionId, update: {sessionUpdate: ...}}.
+        const notif = params;
+        const update = notif.update;
+        switch (update.sessionUpdate) {
+            case SessionEventType.AGENT_MESSAGE_CHUNK:
+                return this.handleAgentMessageChunk(update, notif.sessionId);
+            case SessionEventType.AGENT_THOUGHT_CHUNK:
+                return this.handleAgentThoughtChunk(update, notif.sessionId);
+            case SessionEventType.TOOL_CALL:
+                return this.handleToolCall(update, notif.sessionId);
+            case SessionEventType.TOOL_CALL_UPDATE:
+                return this.handleToolCallUpdate(update, notif.sessionId);
+            case SessionEventType.PLAN:
+                getLogger().debug(`[kimi-acp-translator] discarding plan event`);
+                return [];
+            case SessionEventType.AVAILABLE_COMMANDS_UPDATE:
+            case SessionEventType.SESSION_INFO_UPDATE:
+            case SessionEventType.CURRENT_MODE_UPDATE:
+            case SessionEventType.CONFIG_OPTION_UPDATE:
+                // Control-plane noise (command list, mode/config echoes) — not content.
+                return [];
+            case SessionEventType.USAGE_UPDATE:
+                return this.handleUsageUpdate(update);
+            default:
+                return [];
+        }
+    }
+    /**
+     * Handle a server request (reverse RPC from the ACP server).
+     */
+    handleServerRequest(id, method, params) {
+        if (method === ServerRequestMethod.REQUEST_PERMISSION) {
+            return this.handleRequestPermission(id, params);
+        }
+        if (method === ServerRequestMethod.ELICITATION_CREATE) {
+            return this.handleElicitationCreate(id, params);
+        }
+        return [];
+    }
+    /**
+     * Kimi elicitation form：requestedSchema.properties 按顺序解析为 UserQuestion[]
+     * （type:array → 多选；oneOf/anyOf const → 选项 label；title → header??question）。
+     * 题面完整文本只在 form 级 message 里合并出现（逐字段 title 可能只是短 header），
+     * 因此 message 作为卡片概要行（view.intro）透传。
+     * form 会丢弃非声明选项值 → isOther=false（卡片隐藏自定义答案输入）。
+     */
+    handleElicitationCreate(requestId, params) {
+        const properties = params.requestedSchema?.properties ?? {};
+        const questions = [];
+        for (const [key, prop] of Object.entries(properties)) {
+            const q = elicitationPropertyToQuestion(prop);
+            if (!q) {
+                getLogger().warn(`[kimi-acp-translator] elicitation property skipped: key=${key}`);
+                continue;
+            }
+            questions.push(q);
+        }
+        if (questions.length === 0) {
+            // 无法解析 → 交还 runner 自动响应（不悬挂服务端）。
+            return [];
+        }
+        const message = params.message?.trim();
+        const single = questions.length === 1;
+        const intro = message && (!single || message !== questions[0].question) ? message : undefined;
+        const event = makeQuestionApprovalEvent(requestId, questions, params.sessionId);
+        if (intro)
+            event.view.intro = intro;
+        return [event];
+    }
+    /**
+     * Produce a turn_started event. Called by the runner when session/prompt
+     * is sent (no wire notification for this — self-produced).
+     */
+    produceTurnStarted(sessionId, turnId) {
+        this.currentTurnId = turnId;
+        return {
+            type: 'turn_started',
+            threadId: sessionId,
+            turnId,
+            operationKind: this.operationKind === 'compact' ? 'compaction' : 'turn',
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Translate a prompt response into a result event. Carries the live usage
+     * snapshot only when a usage_update was seen (otherwise undefined, so the
+     * bridge falls back to wire.jsonl usage.record readback).
+     */
+    handlePromptResponse(sessionId, result) {
+        // §4.2: cancelled is independent terminal state, must NOT merge into error
+        const subtype = result.stopReason === 'end_turn'
+            ? 'success'
+            : result.stopReason === 'cancelled'
+                ? 'interrupted'
+                : 'error';
+        return {
+            type: 'result',
+            subtype,
+            session_id: sessionId,
+            ...(this.hasLiveUsage ? { usage: this.liveUsageSnapshot() } : {}),
+            ...(subtype === 'error'
+                ? { errorMessage: `Prompt ended with stopReason: ${result.stopReason}` }
+                : {}),
+        };
+    }
+    /**
+     * Produce an error result event (for JSON-RPC errors during prompt).
+     */
+    produceErrorResult(sessionId, errorMessage) {
+        return {
+            type: 'result',
+            subtype: 'error',
+            session_id: sessionId,
+            errorMessage,
+            ...(this.hasLiveUsage ? { usage: this.liveUsageSnapshot() } : {}),
+        };
+    }
+    /**
+     * Set the operation kind (turn vs compact).
+     */
+    setOperationKind(kind) {
+        this.operationKind = kind;
+    }
+    // =========================================================================
+    // Private notification handlers
+    // =========================================================================
+    handleAgentMessageChunk(event, sessionId) {
+        // Use a stable key for the current text stream. Kimi ACP doesn't
+        // provide an itemId in agent_message_chunk; we use 'text' as the
+        // single logical text accumulator (one text stream per turn).
+        // R1: wire chunk text lives at content.text and is a DELTA
+        // (kimi-code events-map.ts assistantDeltaToSessionUpdate:
+        // content.text = event.delta), so we accumulate here into a full-text
+        // snapshot and emit it as turn_diff. The card reducer's turn_diff path
+        // REPLACES the block in place (snapshot semantics). Emitting the full
+        // text as assistant/text (delta semantics) made the reducer append the
+        // full text to itself on every chunk — duplicated card output
+        // (2026-08-17 live regression, reproduced with 3 chunks).
+        const key = 'text';
+        const prev = this.textByItem.get(key) ?? '';
+        const next = prev + event.content.text;
+        this.textByItem.set(key, next);
+        return [
+            {
+                type: 'turn_diff',
+                itemId: TEXT_ITEM_ID,
+                text: next,
+                threadId: sessionId,
+                turnId: this.currentTurnId,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleAgentThoughtChunk(event, sessionId) {
+        // Same delta→snapshot contract as handleAgentMessageChunk: accumulate
+        // wire deltas and emit a full reasoning snapshot via turn_diff so the
+        // reducer replaces the thinking block instead of appending.
+        const key = THINKING_ITEM_ID;
+        const prev = this.thinkingByItem.get(key) ?? '';
+        const next = prev + event.content.text;
+        this.thinkingByItem.set(key, next);
+        return [
+            {
+                type: 'turn_diff',
+                itemId: THINKING_ITEM_ID,
+                reasoning: next,
+                threadId: sessionId,
+                turnId: this.currentTurnId,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleToolCall(event, _sessionId) {
+        // rawInput arrives as an object on the wire; older kimi versions sent a
+        // JSON string — parse defensively in that case. The acp-server's
+        // lazy-create tool_call (first args delta, events-map.ts
+        // toolCallLazyCreateToSessionUpdate) carries NO rawInput field at all —
+        // normalize to an empty object so the card renders an empty args summary
+        // instead of crashing on undefined input (2026-08-17 live TypeError).
+        let input = event.rawInput ?? {};
+        if (typeof event.rawInput === 'string') {
+            try {
+                input = JSON.parse(event.rawInput);
+            }
+            catch {
+                // Keep raw string as-is
+            }
+        }
+        this.pendingToolCalls.set(event.toolCallId, {
+            id: event.toolCallId,
+            name: event.title,
+            input,
+        });
+        return [
+            {
+                type: 'assistant',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: event.toolCallId,
+                            name: event.title,
+                            input,
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleToolCallUpdate(event, _sessionId) {
+        // §4.2: status:'failed' → is_error:true (fixes CLI mode's is_error always false)
+        const isError = event.status === 'failed';
+        const content = event.rawOutput ?? '';
+        return [
+            {
+                type: 'user',
+                message: {
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: event.toolCallId,
+                            content,
+                            is_error: isError,
+                        },
+                    ],
+                },
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    handleUsageUpdate(event) {
+        // R1: usage_update is {sessionUpdate:'usage_update', used, size}
+        // (events-map.ts:505-516) — context occupancy, not cumulative tokens.
+        this.liveUsage = {
+            total_tokens: event.used,
+            context_limit: event.size,
+        };
+        this.hasLiveUsage = true;
+        return [];
+    }
+    // =========================================================================
+    // Private approval handlers
+    // =========================================================================
+    handleRequestPermission(requestId, params) {
+        // §5.4 升级：question elicitation 识别（isQuestion 标记 / AskUserQuestion
+        // toolCall 标题 / q{n}_opt_* 选项命名空间）→ 渲染为提问卡；无法解析的
+        // 退化形态（无 toolCall 也无选项）仍返回 [] 由 runner 自动响应 cancelled。
+        const toolCall = params.toolCall;
+        const questionMarker = params.isQuestion === true ||
+            toolCall?.title === 'AskUserQuestion' ||
+            optionIdsMatchQuestionNamespace(params.options);
+        if (questionMarker) {
+            return this.handlePermissionQuestion(requestId, params);
+        }
+        // §5.4：无 toolCall 且无提问标记 → 无法构成审批视图，返回 [] 由 runner
+        // 自动响应 cancelled（服务端不会悬挂）。
+        if (!toolCall) {
+            getLogger().info(`[kimi-acp-translator] permission request without toolCall, auto-responding cancelled (requestId=${requestId})`);
+            return [];
+        }
+        const view = {
+            requestId,
+            kind: 'command',
+            command: params.toolCall?.title ?? undefined,
+            reason: params.toolCall?.rawInput ? truncate(params.toolCall.rawInput, 200) : undefined,
+            // §P4: 从服务端 options kind 派生——带 approve_always（或 allow_always）
+            // 才提供「本会话总是允许」（acceptForSession）；否则与旧行为一致。
+            availableDecisions: this.deriveAvailableDecisions(params),
+        };
+        return [
+            {
+                type: 'approval_requested',
+                requestId,
+                kind: 'command',
+                threadId: params.sessionId,
+                turnId: '',
+                itemId: '',
+                view,
+                timestamp: new Date().toISOString(),
+            },
+        ];
+    }
+    /**
+     * request_permission 兜底桥（elicitation/create 失败或旧版 kimi）：
+     * 选项为 q{n}_opt_{i}（allow_once，label 直取 name）+ q{n}_skip（reject_once，
+     * 跳过语义）。单题单选、无 Other（kimi 桥丢弃非声明值）。
+     */
+    handlePermissionQuestion(requestId, params) {
+        const selectable = (params.options ?? []).filter((opt) => /^q\d+_opt_\d+$/.test(opt.optionId));
+        if (selectable.length === 0) {
+            getLogger().info(`[kimi-acp-translator] question elicitation unparseable, auto-responding cancelled (requestId=${requestId})`);
+            return [];
+        }
+        const questionText = extractQuestionText(params.toolCall);
+        const questions = [
+            {
+                question: questionText,
+                isOther: false,
+                options: selectable.map((opt) => ({ label: opt.name })),
+            },
+        ];
+        return [makeQuestionApprovalEvent(requestId, questions, params.sessionId)];
+    }
+    /**
+     * Derive the approval decision list from the server's offered options.
+     * accept/decline/cancel are universal; acceptForSession requires an
+     * always-class option (kimi `approve_always`, opencode `allow_always`).
+     */
+    deriveAvailableDecisions(params) {
+        const decisions = ['accept', 'decline', 'cancel'];
+        const hasAlwaysOption = (params.options ?? []).some((opt) => opt.kind === 'approve_always' || opt.kind === 'allow_always');
+        if (hasAlwaysOption) {
+            decisions.push('acceptForSession');
+        }
+        return decisions;
+    }
+    // =========================================================================
+    // Private helpers
+    // =========================================================================
+    /**
+     * ResultEvent.usage requires input_tokens/output_tokens: number, but the
+     * ACP wire has no such split — the live snapshot is context occupancy only.
+     * Cast is deliberate: consumers must tolerate undefined input/output (the
+     * bridge's kimi path already falls back to wire.jsonl readback).
+     */
+    liveUsageSnapshot() {
+        return { ...this.liveUsage };
+    }
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+function truncate(text, maxLen) {
+    return text.length <= maxLen ? text : text.slice(0, maxLen) + '…';
+}
+/** elicitation schema property → UserQuestion（无法解析返回 null）。 */
+function elicitationPropertyToQuestion(prop) {
+    const title = prop.title?.trim();
+    if (!title)
+        return null;
+    const multiSelect = prop.type === 'array';
+    const rawOptions = multiSelect ? prop.items?.anyOf : prop.oneOf;
+    const options = (rawOptions ?? [])
+        .filter((opt) => typeof opt?.const === 'string')
+        .map((opt) => ({
+        label: opt.const,
+        ...(opt.description ? { description: opt.description } : {}),
+    }));
+    if (options.length === 0)
+        return null;
+    return {
+        question: title,
+        header: title,
+        multiSelect,
+        isOther: false,
+        options,
+    };
+}
+/** 选项命名空间是否匹配 kimi question 桥（q{n}_opt_{i} / q{n}_skip）。 */
+function optionIdsMatchQuestionNamespace(options) {
+    return (options ?? []).some((opt) => /^q\d+_(opt_\d+|skip)$/.test(opt.optionId));
+}
+/** 从 AskUserQuestion toolCall 提取题面（content 文本优先，标题兜底）。 */
+function extractQuestionText(toolCall) {
+    const content = toolCall?.content;
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            const text = block.content?.text;
+            if (typeof text === 'string' && text.trim())
+                return text.trim();
+        }
+    }
+    return toolCall?.title?.trim() || '请选择';
+}
+//# sourceMappingURL=translator.js.map

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

@@ -1 +1 @@
-export { KimiRunner } from './runner.js';
+export { KimiAcpRunner } from './acp/runner.js';

package/dist/runner/kimi/index.js

@@ -1,2 +1,2 @@
-export { KimiRunner } from './runner.js';
+export { KimiAcpRunner } from './acp/runner.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+export { OpencodeAcpRunner, type OpencodeAcpRunnerOptions } from './runner.js';

package/dist/runner/opencode/acp/index.js

@@ -0,0 +1,2 @@
+export { OpencodeAcpRunner } from './runner.js';
+//# sourceMappingURL=index.js.map