lark-remote 0.5.13 → 0.5.15

package/dist/runner/dsh/client.js

@@ -21,8 +21,9 @@
  */
 import { randomUUID } from 'node:crypto';
 import WebSocket from 'ws';
+import { dshArgs, extractDshToken } from '../../dsh/protocol.js';
 import { getLogger } from '../../logger/index.js';
-import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecret, resolveDshCredentialsFile, } from './auth.js';
+import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecret, resolveDshCredentialsFile, } from '../../dsh/auth.js';
 import { DEFAULT_REQUEST_TIMEOUT_MS } from '../common/defaults.js';
 import { goalFromProjection } from './goal-view.js';
 import { DshError } from './errors.js';
@@ -111,60 +112,6 @@ function inboxItemsOf(values) {
     }
     return out;
 }
-/** Extract the `token` query parameter from a pasted `dsh web` URL. */
-export function extractDshToken(raw) {
-    const value = (raw ?? '').trim();
-    if (!value)
-        return '';
-    if (!value.includes('token=') && !value.includes('://'))
-        return value;
-    try {
-        const url = new URL(value.startsWith('?') ? `http://dsh.invalid/${value}` : value);
-        const token = url.searchParams.get('token');
-        if (token)
-            return token;
-        // 带 scheme 却没有 token 参数的输入是误贴的 host URL（如
-        // `http://127.0.0.1:3080`）：整串不是合法 token，参与握手只会得到
-        // 指向性缺失的 401。返回空串让上游走「token 缺失」的诊断路径。
-        if (value.includes('://'))
-            return '';
-        return value;
-    }
-    catch {
-        return value;
-    }
-}
-/**
- * Remote methods take named parameters. Most session methods call their single
- * argument `request`; `session/list` reserves `_request`; catalog methods take
- * no arguments. `commands/*` address the receiving agent by its wire field
- * `agentId`, so their payload is already in wire shape (pass-through).
- * The gateway rejects any other `args` shape.
- */
-const DSH_ARGS_KEY = {
-    'session/list': '_request',
-    'session/create': 'request',
-    'session/prompt': 'request',
-    'session/cancel': 'request',
-    'session/selectModel': 'request',
-    'session/projections': 'request',
-    'session/page': 'request',
-    'session/follow': 'request',
-    'session/updateQueue': 'request',
-    'job/list': 'request',
-    'job/kill': 'request',
-    'session/modelCatalog': null,
-    'agentPresets/list': null,
-    'permissionPresets/catalog': null,
-};
-export function dshArgs(method, payload) {
-    const key = DSH_ARGS_KEY[method];
-    if (key === null)
-        return {};
-    if (key === undefined)
-        return payload;
-    return { [key]: payload };
-}
 export class DshClient {
     baseUrl;
     token;
@@ -483,6 +430,11 @@ export class DshClient {
         // 拿不到投影 = 宿主没这个会话的投影，不等于"没有 goal"。
         if (!snapshot)
             return { known: false, goal: null };
+        // 投影快照存在但没有 goal 域 = 宿主明确没有目标（未用过 goal 的会话就是这样）。
+        // 不能把缺失当成"读不懂"：goalFromProjection(undefined) 也返回 undefined，
+        // 那会把每次普通会话都误报成「目标状态未确认」。
+        if (!('goal' in snapshot.values))
+            return { known: true, goal: null };
         const parsed = goalFromProjection(snapshot.values.goal);
         if (parsed === undefined)
             return { known: false, goal: null };

package/dist/runner/dsh/daemon.js

@@ -15,7 +15,8 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { DEFAULT_DSH_HOST } from '../../config/index.js';
 import { mergeProcessEnv, spawnProcess } from '../../platform/spawn.js';
-import { resolveDshHome } from './home.js';
+import { getLogger } from '../../logger/index.js';
+import { resolveDshHome } from '../../dsh/home.js';
 const DEFAULT_START_TIMEOUT_MS = 30_000;
 const READY_POLL_MS = 100;
 /** User-facing daemon failure; the bridge renders `message` in the chat card. */
@@ -174,7 +175,13 @@ export class DshDaemon {
             const stats = await fsp.stat(lockDir);
             return Date.now() - stats.mtimeMs > this.startTimeoutMs() * 2;
         }
-        catch {
+        catch (err) {
+            // ENOENT = 锁目录刚被持有者清掉（正常，等下一轮重查）。
+            // 其余（EACCES/EPERM…）= 无法判断是否陈旧：保守判「不陈旧」继续等，
+            // 但必须留痕，否则超时文案会误报成「等待其他 lark-remote」。
+            if (err.code !== 'ENOENT') {
+                getLogger().warn(`[dsh] cannot stat start lock ${lockDir}: ${err?.message ?? String(err)}`);
+            }
             return false;
         }
     }

package/dist/runner/dsh/exit-cancel.js

@@ -18,7 +18,7 @@ import path from 'node:path';
 import { getLogger } from '../../logger/index.js';
 import { isWin32 } from '../../platform/select.js';
 import { spawnProcessSync } from '../../platform/spawn.js';
-import { DSH_COOKIE_LIFETIME_MS, mintDshBrowserCookie, readDshBrowserSecretSync, resolveDshCredentialsFile, } from './auth.js';
+import { DSH_COOKIE_LIFETIME_MS, mintDshBrowserCookie, readDshBrowserSecretSync, resolveDshCredentialsFile, } from '../../dsh/auth.js';
 /** Upper bound on the exit-path cancel:退出不能被一个卡住的 host 拖住。 */
 const EXIT_CANCEL_TIMEOUT_MS = 2_000;
 /**

package/dist/runner/dsh/mux-stream.js

@@ -1,5 +1,23 @@
 import { getLogger } from '../../logger/index.js';
 import { DshError } from './errors.js';
+/**
+ * onerror 的事件对象在 ws 实现之间形态不一（{message} / {error} / {type}）。
+ * 尽力取出可读描述；取不到就不追加，别拿 '[object Object]' 充数。
+ */
+function describeSocketError(event) {
+    if (!event || typeof event !== 'object')
+        return undefined;
+    const e = event;
+    if (typeof e.message === 'string' && e.message)
+        return e.message;
+    if (e.error instanceof Error && e.error.message)
+        return e.error.message;
+    if (typeof e.error === 'string' && e.error)
+        return e.error;
+    if (typeof e.type === 'string' && e.type)
+        return e.type;
+    return undefined;
+}
 export async function* openMuxStream(opts) {
     const cookie = await opts.authCookie();
     const socket = opts.webSocketFactory(`${opts.baseUrl.replace(/^http/, 'ws')}/api/remote.mux`, cookie ? { headers: { cookie } } : undefined);
@@ -87,10 +105,11 @@ export async function* openMuxStream(opts) {
             settle(undefined);
         }
     };
-    socket.onerror = () => {
+    socket.onerror = (event) => {
         if (ended)
             return;
-        failure = new DshError('transport', 'DSH remote mux WebSocket error');
+        const detail = describeSocketError(event);
+        failure = new DshError('transport', `DSH remote mux WebSocket error${detail ? `: ${detail}` : ''}`);
         ended = true;
         settle(undefined);
     };

package/dist/runner/dsh/runner.d.ts

@@ -17,7 +17,8 @@
  * approval on the same card. If `$events` is unavailable, the runner falls
  * back to the Web UI prompt.
  */
-import type { AgentEvent, AgentSessionReader, AgentStatusInfo, SpawnOptions, StopOutcome } from '../types.js';
+import type { AgentSessionReader } from '../../session-contract.js';
+import type { AgentEvent, AgentStatusInfo, SpawnOptions, StopOutcome } from '../types.js';
 import type { AgentRunner } from '../types.js';
 import { DshClient, type WebSocketFactory } from './client.js';
 import type { DshDaemon } from './daemon.js';
@@ -134,6 +135,25 @@ export declare class DshRunner implements AgentRunner {
      * the live catalog for that provider's default (or first) model.
      */
     private resolveModelSelection;
+    /**
+     * 新建 DSH session 并取回 sessionId；run 在挂起期间被 stop 时返回 undefined。
+     *
+     * 红线：不把 run 的 abort signal 直接交给 create —— abort 掉请求会丢掉刚创建的
+     * sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。改为 abort
+     * 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
+     */
+    private acquireSessionId;
+    /**
+     * 把本轮消息交给 DSH 的排队收件箱，返回本轮的身份与起始水位。
+     *
+     * 三条不变量（都关系到「迟到/抢先的 stop 能否被正确撤销」）：
+     * - 起始水位取 prompt **之前**的 latestEventSeq：session/page 返回整个会话，
+     *   从 0 开始会把首轮已完成 turn 在每次后续消息时重放一遍。
+     * - 身份（requestId）在请求发出**之前**就公布：stop 可能落在 session/prompt 的
+     *   在途窗口里，那时它必须知道宿主受理后该撤销哪个收件项。
+     * - `promptAdmitted` 只在宿主接受后置真：撤销路径据此区分「还没进去」与「已排队」。
+     */
+    private submitPrompt;
     run(message: string, opts: SpawnOptions): AsyncGenerator<AgentEvent>;
     /**
      * Consume one turn from both transports. `session/follow` owns transcript

package/dist/runner/dsh/runner.js

@@ -178,6 +178,20 @@ function parseToolArguments(raw) {
         return {};
     }
 }
+/**
+ * 用户 stop 的终态结果（run() 的 5 个中止点各 yield 同一形状）。
+ *
+ * 必须 yield result 而不是裸 return：调用方靠 result 收尾 run 卡，否则卡片
+ * 停留在「运行中」（见 run() 内 startup abort 注释）。
+ */
+function interruptedResult(sessionId) {
+    return {
+        type: 'result',
+        subtype: 'interrupted',
+        session_id: sessionId,
+        errorMessage: 'run stopped',
+    };
+}
 export class DshRunner {
     kind = 'dsh';
     /**
@@ -323,6 +337,57 @@ export class DshRunner {
         }
         return { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}) };
     }
+    /**
+     * 新建 DSH session 并取回 sessionId；run 在挂起期间被 stop 时返回 undefined。
+     *
+     * 红线：不把 run 的 abort signal 直接交给 create —— abort 掉请求会丢掉刚创建的
+     * sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。改为 abort
+     * 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
+     */
+    async acquireSessionId(cwd, signal) {
+        const createPromise = this.client.createSession({
+            cwd,
+            ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
+        });
+        const created = await this.awaitOrAbort(createPromise, signal);
+        if (created)
+            return created.sessionId;
+        void createPromise.then((c) => this.cancelSessionQuietly(c.sessionId), () => {
+            /* create failed after stop — nothing to cancel */
+        });
+        getLogger().info('[dsh] run stopped during session/create; will cancel if it settles');
+        return undefined;
+    }
+    /**
+     * 把本轮消息交给 DSH 的排队收件箱，返回本轮的身份与起始水位。
+     *
+     * 三条不变量（都关系到「迟到/抢先的 stop 能否被正确撤销」）：
+     * - 起始水位取 prompt **之前**的 latestEventSeq：session/page 返回整个会话，
+     *   从 0 开始会把首轮已完成 turn 在每次后续消息时重放一遍。
+     * - 身份（requestId）在请求发出**之前**就公布：stop 可能落在 session/prompt 的
+     *   在途窗口里，那时它必须知道宿主受理后该撤销哪个收件项。
+     * - `promptAdmitted` 只在宿主接受后置真：撤销路径据此区分「还没进去」与「已排队」。
+     */
+    async submitPrompt(sessionId, cwd, message, signal) {
+        const prePromptSeq = await this.client.latestEventSeq(sessionId, { signal });
+        const promptRequestId = newPromptRequestId();
+        this.activePromptRequestId = promptRequestId;
+        this.promptAdmitted = false;
+        this.inflight?.record({
+            sessionId,
+            promptRequestId,
+            baseUrl: this.client.baseUrl,
+            cwd,
+        });
+        await this.client.unary('session/prompt', {
+            requestId: promptRequestId,
+            sessionId,
+            mode: 'queue',
+            content: [{ type: 'text', text: message }],
+        }, { signal });
+        this.promptAdmitted = true;
+        return { prePromptSeq, promptRequestId };
+    }
     async *run(message, opts) {
         if (this.running) {
             throw new Error('DshRunner is already running');
@@ -346,29 +411,13 @@ export class DshRunner {
             // session/create 必须包进同一 try/finally，否则创建失败（服务端不可达/报错）
             // 会在进入旧 try 之前抛异常，finally 不执行 → running 恒 true、activeAbort 残留。
             if (!sessionId) {
-                const createPromise = this.client.createSession({
-                    cwd: opts.cwd,
-                    ...(this.agentPreset ? { agentPreset: this.agentPreset } : {}),
-                });
-                // 不把 run 的 abort signal 直接交给 create：abort 掉请求会丢掉刚创建
-                // 的 sessionId，服务端若已完成创建就留下一个无法 cancel 的孤儿 session。
-                // 改为 abort 时立即放行 run（队列不被挂起），create 后台落定后再补 cancel。
-                const created = await this.awaitOrAbort(createPromise, abort.signal);
-                if (!created) {
-                    void createPromise.then((c) => this.cancelSessionQuietly(c.sessionId), () => {
-                        /* create failed after stop — nothing to cancel */
-                    });
-                    getLogger().info('[dsh] run stopped during session/create; will cancel if it settles');
+                const created = await this.acquireSessionId(opts.cwd, abort.signal);
+                if (created === undefined) {
                     terminalEmitted = true;
-                    yield {
-                        type: 'result',
-                        subtype: 'interrupted',
-                        session_id: '',
-                        errorMessage: 'run stopped',
-                    };
+                    yield interruptedResult('');
                     return;
                 }
-                sessionId = created.sessionId;
+                sessionId = created;
             }
             this.activeSessionId = sessionId;
             // Startup abort：createSession 挂起期间 stop() 已 abort（此时 sessionId 尚
@@ -380,12 +429,7 @@ export class DshRunner {
                 await this.cancelSessionQuietly(sessionId);
                 getLogger().info(`[dsh] run aborted during startup, cancelled session ${sessionId}`);
                 terminalEmitted = true;
-                yield {
-                    type: 'result',
-                    subtype: 'interrupted',
-                    session_id: sessionId,
-                    errorMessage: 'run stopped',
-                };
+                yield interruptedResult(sessionId);
                 return;
             }
             // provider/模型/推理强度对齐：会话首次 run 时 selectModel 一次
@@ -403,12 +447,7 @@ export class DshRunner {
                     if (abort.signal.aborted) {
                         getLogger().info(`[dsh] run stopped during selectModel session=${sessionId}`);
                         terminalEmitted = true;
-                        yield {
-                            type: 'result',
-                            subtype: 'interrupted',
-                            session_id: sessionId,
-                            errorMessage: 'run stopped',
-                        };
+                        yield interruptedResult(sessionId);
                         return;
                     }
                     if (this.configuredProvider) {
@@ -425,12 +464,7 @@ export class DshRunner {
             // Abort 可能在上述 unary 完成与检查之间到达：不进入 prompt/turn。
             if (abort.signal.aborted) {
                 terminalEmitted = true;
-                yield {
-                    type: 'result',
-                    subtype: 'interrupted',
-                    session_id: sessionId,
-                    errorMessage: 'run stopped',
-                };
+                yield interruptedResult(sessionId);
                 return;
             }
             yield {
@@ -448,53 +482,29 @@ export class DshRunner {
                 timeoutMs: GOAL_PROBE_TIMEOUT_MS,
             });
             const lastGoal = seedGoal.known ? seedGoal.goal : undefined;
-            // 只有确实存在 goal 才产事件：没有 goal 的会话保持事件序列不变（少一次
-            // 渲染，也不让"读不到"变成一张多出来的卡片事件）。
-            if (seedGoal.known && seedGoal.goal)
-                yield goalStateEvent(seedGoal.goal, true);
+            if (seedGoal.known) {
+                // 只有确实存在 goal 才产事件：没有 goal 的会话保持事件序列不变（少一次
+                // 渲染，也不让"读不到"变成一张多出来的卡片事件）。
+                if (seedGoal.goal)
+                    yield goalStateEvent(seedGoal.goal, true);
+            }
+            else {
+                // 读不到 ≠ 没有目标。必须显式把 unknown 交给卡片，否则收尾只能按
+                // 「没有 goal」写成「已完成」——正是 GoalStateEvent 契约禁止的推断。
+                yield goalStateEvent(null, false);
+            }
             try {
-                // Snapshot the pre-prompt high-water mark before mutating the session.
-                // DSH session/page returns the whole session, so starting from seq 0
-                // would replay the first completed turn on every follow-up prompt.
-                const prePromptSeq = await this.client.latestEventSeq(sessionId, {
-                    signal: abort.signal,
-                });
-                // Keep the prompt identity: DSH echoes it into the durable user/message
-                // source.rpcId, which is how runTurn tells this run's turn from a turn
-                // it is merely queued behind.
-                promptRequestId = newPromptRequestId();
-                // Publish the identity before the request leaves: a stop that arrives
-                // while `session/prompt` is in flight must still know which inbox item
-                // (if any) to withdraw once the host admits it.
-                this.activePromptRequestId = promptRequestId;
-                this.promptAdmitted = false;
-                this.inflight?.record({
-                    sessionId,
-                    promptRequestId,
-                    baseUrl: this.client.baseUrl,
-                    cwd: opts.cwd,
-                });
-                await this.client.unary('session/prompt', {
-                    requestId: promptRequestId,
-                    sessionId,
-                    mode: 'queue',
-                    content: [{ type: 'text', text: message }],
-                }, { signal: abort.signal });
-                this.promptAdmitted = true;
+                const submitted = await this.submitPrompt(sessionId, opts.cwd, message, abort.signal);
+                promptRequestId = submitted.promptRequestId;
                 if (abort.signal.aborted) {
                     // stop() 在 prompt 已受理后到达：cancel 由 stop() 发出，这里直接收尾，
                     // 不再打开 mux（否则会看到 cancel 产生的 turn/end 事件）。
                     terminalEmitted = true;
-                    yield {
-                        type: 'result',
-                        subtype: 'interrupted',
-                        session_id: sessionId,
-                        errorMessage: 'run stopped',
-                    };
+                    yield interruptedResult(sessionId);
                     return;
                 }
                 try {
-                    for await (const ev of this.runTurn(sessionId, opts.cwd, prePromptSeq, promptRequestId, abort, { last: lastGoal })) {
+                    for await (const ev of this.runTurn(sessionId, opts.cwd, submitted.prePromptSeq, promptRequestId, abort, { last: lastGoal, known: seedGoal.known })) {
                         yield ev;
                         if (ev.type === 'result') {
                             terminalEmitted = true;
@@ -731,7 +741,16 @@ export class DshRunner {
                                 signal,
                                 timeoutMs: GOAL_PROBE_TIMEOUT_MS,
                             });
-                            if (finalGoal.known && !sameGoal(finalGoal.goal, goal.last)) {
+                            if (!finalGoal.known) {
+                                // 收尾读不到：seed 已报过 unknown 就不重复发，否则把状态降级
+                                // 交给卡片（卡片据此不再宣布完成）。
+                                if (goal.known) {
+                                    goal.known = false;
+                                    yield goalStateEvent(null, false);
+                                }
+                            }
+                            else if (!goal.known || !sameGoal(finalGoal.goal, goal.last)) {
+                                goal.known = true;
                                 goal.last = finalGoal.goal;
                                 yield goalStateEvent(finalGoal.goal, true);
                             }

package/dist/runner/dsh/translator.d.ts

@@ -24,7 +24,7 @@
  *     cache_creation_tokens (cacheWrite = cache creation) + total_tokens sum.
  */
 import type { AgentEvent, ResultEvent } from '../types.js';
-import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from './types.js';
+import type { DshAssistantStreamFrame, DshSessionEvent, DshTokenUsage } from '../../dsh/types.js';
 export declare class DshTranslator {
     /** 本 turn 累计用量：DSH 每次模型调用（step）一条 usage，工具往返 = 多条。 */
     private turnUsage;

package/dist/runner/index.d.ts

@@ -15,6 +15,6 @@ export { KimiAcpRunner } from './kimi/index.js';
 export { DshRunner } from './dsh/index.js';
 export { BashProcessRunner, type BashRunner } from './bash/index.js';
 export { AgentRegistry } from './registry.js';
-export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentKind, AgentSession, AgentSessionContentEvent, AgentSessionUsage, SessionContent, SessionSummary, AgentSessionReader, AgentRunner, TurnStartedEvent, TurnDiffEvent, FinalAnswerEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
+export type { ResultEvent, PlanEvent, FileChangeEvent, AgentEvent, Runner, RunnerLifetime, AgentRunner, TurnStartedEvent, TurnDiffEvent, FinalAnswerEvent, NoticeEvent, SessionInfoEvent, ToolHint, ApprovalView, ApprovalRequestedEvent, ApprovalResolvedEvent, GoalView, GoalStateEvent, } from './types.js';
 export { resolveAgentChoices } from './resolve-agent-choices.js';
 export { syncAgentChoices } from './sync-agent-choices.js';

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

@@ -17,7 +17,9 @@
  * - AskUserQuestion flows through elicitation forms + a request_permission
  *   question bridge (buildQuestionResponse)
  */
-import type { AgentKind, AgentSessionReader, AgentStatusInfo, SpawnOptions } from '../../types.js';
+import type { AgentKind } from '../../../agent-kinds.js';
+import type { AgentSessionReader } from '../../../session-contract.js';
+import type { AgentStatusInfo, SpawnOptions } from '../../types.js';
 import { JsonRpcClient } from '../../common/jsonrpc/client.js';
 import { KimiAcpTranslator } from './translator.js';
 import { type SessionPromptResult } from '../../common/acp/protocol-types.js';
@@ -167,6 +169,25 @@ export declare class KimiAcpRunner extends BaseAcpRunner<KimiAcpTranslator> {
      * stdout(+stderr) 到缓冲，立即回 {terminalId}。
      */
     private handleTerminalCreate;
+    /**
+     * 走 shell seam：argv 逐 token 保留，只把「可执行文件在哪」收口——win32 上
+     * Git Bash 缺失时在这里抛 ShellUnavailableError，由 handleTerminalRequest 转成
+     * 明确的 Terminal request failed 回执，而不是一个语焉不详的 spawn ENOENT。
+     */
+    private spawnTerminalProcess;
+    /**
+     * 有界输出缓冲：每个流独立 decoder（多字节字符跨 chunk 拆分时由 decoder 保留
+     * 不完整序列，避免按 chunk 单独 toString 产生 U+FFFD 替换符）。
+     */
+    private attachTerminalOutputBuffer;
+    /**
+     * 退出/错误收尾管线：tool_result 必须先入队，再放行 `wait_for_exit`。
+     */
+    private wireTerminalExit;
+    /** Bash 面板的 tool_result 帧（输出全量 + 是否失败）。 */
+    private pushTerminalToolResult;
+    /** Bash 面板的 tool_use 帧（真实命令 + cwd，create 时立刻可见）。 */
+    private pushTerminalToolUse;
     /** terminal/output: 回累计全量输出 + truncated + 当前退出状态（可未退出）。 */
     private handleTerminalOutput;
     /** terminal/wait_for_exit: 未退出则等 exit promise 再回 {exitCode, signal}。 */