lark-remote 0.5.10 → 0.5.13

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

@@ -21,6 +21,7 @@
  */
 import type { DshApprovalStreamItem, DshCommandResult, DshModelCatalogValue, DshModelSelection, DshOpenTurnState, DshPermissionCatalogValue, DshJobView, DshPresetListValue, DshProjectionItem, DshProjectionSnapshot, DshQuestion, DshRemoteEventOutcome, DshSessionPageValue, DshStreamItem, DshTokenUsage } from './types.js';
 import type { GoalView } from '../types.js';
+export { DshError } from './errors.js';
 interface WebSocketMessageEvent {
     data: unknown;
 }
@@ -40,11 +41,6 @@ export interface WebSocketLike {
     close(): void;
 }
 export type WebSocketFactory = (url: string, options?: WebSocketOptions) => WebSocketLike;
-export declare class DshError extends Error {
-    readonly code: string;
-    readonly details: Record<string, unknown>;
-    constructor(code: string, message: string, details?: Record<string, unknown>);
-}
 export interface DshClientOptions {
     /** Configured DSH home; selects `.credentials.yaml` when no explicit file is given. */
     dshHome?: string;
@@ -256,7 +252,20 @@ export declare class DshClient {
      * Fallback probe: the newest durable event's type tells whether a turn is open.
      *
      * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
-     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     * 结算）、`turn/end` 都不算，判不出来就报告 `unknown`。
+     *
+     * 落盘顺序已从 DSH 源码验证（packages/core/agent-loop：agent.ts 的 turn()/
+     * step() + inbox.ts 的 mutate()）：prompt 提交只落 `agent/inbox/spliced`，
+     * `turn/start` 由 turn() 在认领前 append，`user/message` 在 step() 认领时才
+     * append——顺序是 spliced → turn/start → user/message。两个边界：
+     *
+     * - 尾部 `agent/inbox/spliced` → closed 是**对的**：turn 尚未打开，cancel
+     *   空闲 session 无害，随后 withdraw 探测会撤走排队 prompt；
+     * - 尾部 `user/message` → **unknown**：step() 里 user/message append 后要等
+     *   一整个 LLM 往返才有下一条 durable 事件（assistant 流帧是 process-local
+     *   的），这个秒级窗口内 turn 已打开；且压缩 checkpoint 也以 turn:null 落
+     *   user/message——两种解释并存时只能报 unknown（stop 按 unconfirmed 处理，
+     *   不假报已停止）。此前报 closed 会让一个 LLM 往返宽的窗口假报干净停止。
      */
     private probeOpenTurnByEvents;
     /**
@@ -290,6 +299,23 @@ export declare class DshClient {
      * keeps the card "running" until this run's turn actually finishes.
      */
     sessionEvents(sessionId: string, signal: AbortSignal, initialSeq?: number, promptRequestId?: string): AsyncGenerator<DshStreamItem>;
+    /**
+     * 快照缺口回填（经 DSH 源码验证后实现）。
+     *
+     * follow 开场快照按**消息**截取：host 的 paginate 只数 user/assistant
+     * message（工具事件随所在消息组搭车进快照，不占预算），`maxMessages` 内
+     * 装不下的更早前缀被截掉并以 `hasMore: true` 标记。断连期间积压超过
+     * FOLLOW_MAX_MESSAGES 条消息时，`lastSeq` 与快照起点之间的缺口若不补，
+     * 这些事件对本次 follow 永久缺失（卡片丢中段工具行；seq 去重只防重放
+     * 不补缺）。`session/page` 的 `throughSeq` 游标正是服务端为此设计的回填
+     * 通道——从缺口尾部向前翻页直到盖住 lastSeq、翻到日志头或达到页数上限。
+     *
+     * best-effort：翻页失败保留已取回的部分（缺口剩余与旧行为一致地丢失，
+     * 但只发生在超出 BACKFILL_MAX_PAGES×PAGE_MESSAGES 条消息的极端断连）。
+     * 返回 seq 升序的完整回放序列（回填 + 快照记录；与 lastSeq 重叠的条目
+     * 由回放循环的 seq 去重兜住）。
+     */
+    private replaySnapshotGap;
     /**
      * Host-wide live projection stream (`session/control`).
      *
@@ -342,4 +368,3 @@ export declare function dshQuestionsOf(request: Record<string, unknown>): DshQue
  * silently on the server side.
  */
 export declare function isTimedQuestionRequest(request: Record<string, unknown>): boolean;
-export {};

package/dist/runner/dsh/client.js

@@ -25,6 +25,9 @@ import { getLogger } from '../../logger/index.js';
 import { DSH_COOKIE_LIFETIME_MS, isDshCredentialsNotFound, mintDshBrowserCookie, readDshBrowserSecret, resolveDshCredentialsFile, } from './auth.js';
 import { DEFAULT_REQUEST_TIMEOUT_MS } from '../common/defaults.js';
 import { goalFromProjection } from './goal-view.js';
+import { DshError } from './errors.js';
+import { openMuxStream } from './mux-stream.js';
+export { DshError } from './errors.js';
 function defaultWebSocketFactory(url, options) {
     const socket = new WebSocket(url, {
         ...(options?.headers ? { headers: options.headers } : {}),
@@ -35,16 +38,6 @@ function defaultWebSocketFactory(url, options) {
     });
     return socket;
 }
-export class DshError extends Error {
-    code;
-    details;
-    constructor(code, message, details = {}) {
-        super(message);
-        this.name = 'DshError';
-        this.code = code;
-        this.details = details;
-    }
-}
 function isDshAuthError(error) {
     return (error instanceof DshError &&
         error.code === 'http' &&
@@ -52,8 +45,19 @@ function isDshAuthError(error) {
 }
 /** Backoff between mux reconnects to avoid a hot loop on a dropping server. */
 const RECONNECT_BACKOFF_MS = 200;
-/** Follow snapshot budget. `session/follow` also stays live after the snapshot. */
+/**
+ * Follow snapshot budget. `session/follow` also stays live after the snapshot.
+ *
+ * 语义（经 DSH 源码验证，packages/api/session-controller/src/history.ts
+ * 的 paginate）：按**消息**计数——只有 user/assistant message 占预算，工具
+ * 事件随所在消息组搭进快照。断连期间积压超过该预算时快照首条会越过
+ * lastSeq，缺口经 {@link replaySnapshotGap} 用 session/page 回填。
+ */
 const FOLLOW_MAX_MESSAGES = 200;
+/** 快照缺口回填的单页消息数（session/page 的 maxMessages）。 */
+const FOLLOW_GAP_BACKFILL_PAGE_MESSAGES = 200;
+/** 快照缺口回填的页数上限（×PAGE_MESSAGES = 单次重连最多回补 4000 条消息）。 */
+const FOLLOW_GAP_BACKFILL_MAX_PAGES = 20;
 /**
  * 只在 turn 内部落盘的会话事件类型：看到它们说明 turn 还没结束。
  * 名单刻意保守——`user/message`（压缩 checkpoint 会以 turn:null 落盘）、
@@ -116,7 +120,15 @@ export function extractDshToken(raw) {
         return value;
     try {
         const url = new URL(value.startsWith('?') ? `http://dsh.invalid/${value}` : value);
-        return url.searchParams.get('token') ?? 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;
@@ -540,7 +552,20 @@ export class DshClient {
      * Fallback probe: the newest durable event's type tells whether a turn is open.
      *
      * 只在拿不到 `running` 时用。名单刻意保守——`job/*`（后台任务可在 turn 外
-     * 结算）、`user/message`、`turn/end` 都不算，判不出来就报告 `unknown`。
+     * 结算）、`turn/end` 都不算，判不出来就报告 `unknown`。
+     *
+     * 落盘顺序已从 DSH 源码验证（packages/core/agent-loop：agent.ts 的 turn()/
+     * step() + inbox.ts 的 mutate()）：prompt 提交只落 `agent/inbox/spliced`，
+     * `turn/start` 由 turn() 在认领前 append，`user/message` 在 step() 认领时才
+     * append——顺序是 spliced → turn/start → user/message。两个边界：
+     *
+     * - 尾部 `agent/inbox/spliced` → closed 是**对的**：turn 尚未打开，cancel
+     *   空闲 session 无害，随后 withdraw 探测会撤走排队 prompt；
+     * - 尾部 `user/message` → **unknown**：step() 里 user/message append 后要等
+     *   一整个 LLM 往返才有下一条 durable 事件（assistant 流帧是 process-local
+     *   的），这个秒级窗口内 turn 已打开；且压缩 checkpoint 也以 turn:null 落
+     *   user/message——两种解释并存时只能报 unknown（stop 按 unconfirmed 处理，
+     *   不假报已停止）。此前报 closed 会让一个 LLM 往返宽的窗口假报干净停止。
      */
     async probeOpenTurnByEvents(sessionId, opts) {
         try {
@@ -555,6 +580,8 @@ export class DshClient {
             const last = value.records.at(-1)?.event;
             if (last === undefined)
                 return 'closed';
+            if (last.type === 'user/message')
+                return 'unknown';
             return last.type === 'turn/start' || IN_TURN_EVENT_TYPES.has(last.type) ? 'open' : 'closed';
         }
         catch (err) {
@@ -568,140 +595,15 @@ export class DshClient {
      * close, error, or `signal` abort.
      */
     async *muxStream(endpoint, payload, signal) {
-        const cookie = await this.authCookie();
-        const socket = this.webSocketImpl(`${this.baseUrl.replace(/^http/, 'ws')}/api/remote.mux`, cookie ? { headers: { cookie } } : undefined);
-        const streamId = `lr-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-        const queue = [];
-        let waiter = null;
-        let ended = false;
-        let failure;
-        const settle = (frame) => {
-            if (waiter) {
-                const resolve = waiter;
-                waiter = null;
-                resolve(frame);
-                return;
-            }
-            if (frame)
-                queue.push(frame);
-            else
-                ended = true;
-        };
-        socket.onopen = () => {
-            if (ended)
-                return;
-            try {
-                socket.send(JSON.stringify({
-                    type: 'open',
-                    streamId,
-                    endpoint,
-                    payload,
-                }));
-            }
-            catch (err) {
-                failure = new DshError('transport', `DSH remote mux send error: ${err.message}`);
-                ended = true;
-                settle(undefined);
-            }
-        };
-        socket.onmessage = (event) => {
-            if (ended)
-                return;
-            const text = typeof event.data === 'string'
-                ? event.data
-                : Buffer.isBuffer(event.data)
-                    ? event.data.toString('utf8')
-                    : String(event.data);
-            let message;
-            try {
-                message = JSON.parse(text);
-            }
-            catch {
-                getLogger().warn('[dsh] dropped malformed remote mux frame');
-                return;
-            }
-            if (message.streamId !== streamId)
-                return;
-            if (message.type === 'item' && message.value) {
-                settle(message.value);
-                return;
-            }
-            if (message.type === 'end') {
-                ended = true;
-                settle(undefined);
-                return;
-            }
-            if (message.type === 'error') {
-                failure = new DshError(message.error?.code ?? 'stream', message.error?.message ?? 'DSH remote stream failed', message.error?.details ?? {});
-                ended = true;
-                settle(undefined);
-            }
-        };
-        socket.onerror = () => {
-            if (ended)
-                return;
-            failure = new DshError('transport', 'DSH remote mux WebSocket error');
-            ended = true;
-            settle(undefined);
-        };
-        socket.onunexpectedresponse = (event) => {
-            if (ended)
-                return;
-            const status = event.statusCode;
-            failure = new DshError('http', `DSH remote mux WebSocket HTTP ${status === undefined ? 'error' : status}`, status === undefined ? {} : { status });
-            ended = true;
-            settle(undefined);
-        };
-        socket.onclose = () => {
-            if (ended)
-                return;
-            ended = true;
-            settle(undefined);
-        };
-        const onAbort = () => {
-            if (ended)
-                return;
-            ended = true;
-            settle(undefined);
-            try {
-                socket.close();
-            }
-            catch {
-                /* ignore close error */
-            }
-        };
-        signal.addEventListener('abort', onAbort, { once: true });
-        const next = () => new Promise((resolve) => {
-            if (queue.length > 0) {
-                resolve(queue.shift());
-                return;
-            }
-            if (ended) {
-                resolve(undefined);
-                return;
-            }
-            waiter = resolve;
+        yield* openMuxStream({
+            baseUrl: this.baseUrl,
+            endpoint,
+            payload,
+            signal,
+            requestTimeoutMs: this.requestTimeoutMs,
+            authCookie: () => this.authCookie(),
+            webSocketFactory: this.webSocketImpl,
         });
-        try {
-            while (!signal.aborted) {
-                const frame = await next();
-                if (frame === undefined) {
-                    if (failure && !signal.aborted)
-                        throw failure;
-                    return;
-                }
-                yield frame;
-            }
-        }
-        finally {
-            signal.removeEventListener('abort', onAbort);
-            try {
-                socket.close();
-            }
-            catch {
-                /* ignore close error */
-            }
-        }
     }
     /** One logical `session/follow` stream. */
     async *followStream(sessionId, signal) {
@@ -734,6 +636,12 @@ export class DshClient {
                     const frame = raw;
                     if (frame.type === 'ready') {
                         authRefreshAttempted = false;
+                        // 成功建连后补充重连预算：goal 驱动的 turn 可跑数小时，DSH 重启 +
+                        // 网络抖动累计掉线超过 3 次后，旧实现会让 $events 永久 unavailable
+                        // ——已渲染的提问卡持有过期 clientId（点答案必失败）、Host 的 cancel
+                        // 帧也收不到，违反「同一 waterfall 在 $events 重连后会被重投」的
+                        // 不变量。预算语义是「单次断连窗口内的连续失败上限」，不是终身配额。
+                        reconnectAttempts = 0;
                         sawReady = true;
                         streamClientId = frame.clientId;
                         yield { kind: 'ready', clientId: streamClientId };
@@ -904,9 +812,10 @@ export class DshClient {
                         return;
                     authRefreshAttempted = false;
                     if (frame.type === 'snapshot') {
-                        for (const record of frame.records ?? []) {
-                            const ev = record.event;
-                            if (!ev || ev.seq <= state.lastSeq)
+                        // 快照可能只覆盖尾部窗口（见 replaySnapshotGap）：先补缺口再回放，
+                        // 回放循环与原逻辑逐条相同（去重 / admit / turn/end 早退）。
+                        for (const ev of await this.replaySnapshotGap(sessionId, signal, state.lastSeq, frame)) {
+                            if (ev.seq <= state.lastSeq)
                                 continue;
                             state.lastSeq = ev.seq;
                             if (!admit(ev))
@@ -963,6 +872,63 @@ export class DshClient {
             await new Promise((resolve) => setTimeout(resolve, RECONNECT_BACKOFF_MS));
         }
     }
+    /**
+     * 快照缺口回填（经 DSH 源码验证后实现）。
+     *
+     * follow 开场快照按**消息**截取：host 的 paginate 只数 user/assistant
+     * message（工具事件随所在消息组搭车进快照，不占预算），`maxMessages` 内
+     * 装不下的更早前缀被截掉并以 `hasMore: true` 标记。断连期间积压超过
+     * FOLLOW_MAX_MESSAGES 条消息时，`lastSeq` 与快照起点之间的缺口若不补，
+     * 这些事件对本次 follow 永久缺失（卡片丢中段工具行；seq 去重只防重放
+     * 不补缺）。`session/page` 的 `throughSeq` 游标正是服务端为此设计的回填
+     * 通道——从缺口尾部向前翻页直到盖住 lastSeq、翻到日志头或达到页数上限。
+     *
+     * best-effort：翻页失败保留已取回的部分（缺口剩余与旧行为一致地丢失，
+     * 但只发生在超出 BACKFILL_MAX_PAGES×PAGE_MESSAGES 条消息的极端断连）。
+     * 返回 seq 升序的完整回放序列（回填 + 快照记录；与 lastSeq 重叠的条目
+     * 由回放循环的 seq 去重兜住）。
+     */
+    async replaySnapshotGap(sessionId, signal, lastSeq, frame) {
+        const records = (frame.records ?? [])
+            .map((record) => record.event)
+            .filter((ev) => !!ev);
+        if (frame.hasMore !== true || signal.aborted)
+            return records;
+        const firstSeq = records[0]?.seq;
+        const gapEnd = firstSeq !== undefined ? firstSeq - 1 : frame.cursor;
+        if (gapEnd <= lastSeq)
+            return records;
+        const pages = [];
+        try {
+            let throughSeq = gapEnd;
+            for (let page = 0; page < FOLLOW_GAP_BACKFILL_MAX_PAGES; page++) {
+                const value = await this.page(sessionId, throughSeq, FOLLOW_GAP_BACKFILL_PAGE_MESSAGES, {
+                    signal,
+                });
+                const events = (value.records ?? [])
+                    .map((record) => record.event)
+                    .filter((ev) => !!ev);
+                if (events.length > 0)
+                    pages.push(events);
+                const oldest = events[0]?.seq;
+                // hasMore=false（日志头）或本页已盖住 lastSeq：缺口补齐，停。
+                if (value.hasMore !== true || oldest === undefined || oldest <= lastSeq + 1)
+                    break;
+                throughSeq = oldest - 1;
+            }
+        }
+        catch (err) {
+            getLogger().warn(`[dsh] follow snapshot gap backfill incomplete sessionId=${sessionId}: ${err.message}`);
+        }
+        // pages 是「从新到旧」收集的；倒序拼接得到 seq 升序回放。
+        const backfill = [];
+        for (let index = pages.length - 1; index >= 0; index--)
+            backfill.push(...pages[index]);
+        if (backfill.length > 0) {
+            getLogger().info(`[dsh] backfilled ${backfill.length} events before follow snapshot sessionId=${sessionId} gapEnd=${gapEnd} lastSeq=${lastSeq}`);
+        }
+        return [...backfill, ...records];
+    }
     /**
      * Host-wide live projection stream (`session/control`).
      *

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

@@ -28,8 +28,6 @@ interface SpawnedDaemon {
     failure(): Error | undefined;
     exited(): boolean;
 }
-/** Resolve the same Harness home DSH resolves: configured, env, then ~/.dsh. */
-export declare function resolveDshHome(configured?: string, env?: NodeJS.ProcessEnv): string;
 /** True only for the loopback HTTP address this process may start and probe. */
 export declare function isLoopbackHttpUrl(value: string): boolean;
 /**

package/dist/runner/dsh/daemon.js

@@ -12,10 +12,10 @@
  */
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
-import os from 'node:os';
 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';
 const DEFAULT_START_TIMEOUT_MS = 30_000;
 const READY_POLL_MS = 100;
 /** User-facing daemon failure; the bridge renders `message` in the chat card. */
@@ -30,11 +30,6 @@ export class DshDaemonError extends Error {
 function stripTrailingSlash(value) {
     return value.replace(/\/+$/, '');
 }
-/** Resolve the same Harness home DSH resolves: configured, env, then ~/.dsh. */
-export function resolveDshHome(configured, env = process.env) {
-    const value = configured?.trim() || env.DSH_HOME?.trim();
-    return path.resolve(value && value.length > 0 ? value : path.join(os.homedir(), '.dsh'));
-}
 /** True only for the loopback HTTP address this process may start and probe. */
 export function isLoopbackHttpUrl(value) {
     try {

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

@@ -0,0 +1,5 @@
+export declare class DshError extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}

package/dist/runner/dsh/errors.js

@@ -0,0 +1,11 @@
+export class DshError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.name = 'DshError';
+        this.code = code;
+        this.details = details;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/runner/dsh/exit-cancel.d.ts

@@ -12,8 +12,6 @@
  * curl transport the session reader already uses: bounded by `timeoutMs` and
  * never throws.
  */
-/** Upper bound on the exit-path cancel:退出不能被一个卡住的 host 拖住。 */
-export declare const EXIT_CANCEL_TIMEOUT_MS = 2000;
 export interface SyncCancelOptions {
     baseUrl: string;
     sessionId: string;

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

@@ -12,12 +12,15 @@
  * curl transport the session reader already uses: bounded by `timeoutMs` and
  * never throws.
  */
+import fs from 'node:fs';
+import os from 'node:os';
+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';
 /** Upper bound on the exit-path cancel:退出不能被一个卡住的 host 拖住。 */
-export const EXIT_CANCEL_TIMEOUT_MS = 2_000;
+const EXIT_CANCEL_TIMEOUT_MS = 2_000;
 /**
  * Fire one `session/cancel` synchronously. Never throws: a failed cancel must
  * not block the exit path or mask the real exit reason.
@@ -44,29 +47,65 @@ export function cancelSessionSync(opts) {
         method: 'session/cancel',
         payload: { args: { request: { sessionId: opts.sessionId } } },
     });
-    const res = spawnProcessSync('curl', [
-        '-s',
-        '-o',
-        isWin32() ? 'NUL' : '/dev/null',
-        '-w',
-        '%{http_code}',
-        '-X',
-        'POST',
-        `${opts.baseUrl.replace(/\/$/, '')}/api/session/cancel`,
-        '-H',
-        'content-type: application/json',
-        '-H',
-        `Cookie: ${cookie}`,
-        '--max-time',
-        String(Math.max(1, Math.ceil(timeoutMs / 1000))),
-        '--data',
-        body,
-    ], { encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 1024 * 1024 });
-    const status = String(res.stdout ?? '').trim();
-    const ok = status === '200';
-    if (!ok) {
-        logger.warn(`[dsh] exit-cancel failed for ${opts.sessionId}: ${res.error?.message ?? `http ${status || 'n/a'}`}`);
+    // Cookie 不走 argv（`-H "Cookie: …"` 会在 curl 运行期间对本机任何进程的
+    // ps 可见——1 小时有效的 v1 凭据泄露面）：写 0600 临时文件用 `-H @file`
+    // 传入，用完即删。临时目录必须用 mkdtemp（0700、随机名）：Linux 的 /tmp
+    // 所有用户可写，固定名（如 `<pid>.hdr`）可被本地用户预建软链，而
+    // writeFileSync 会跟随软链把 cookie 写进攻击者可读的文件；后续 chmod
+    // 也救不回已被打开的 fd。文件写失败时回退 argv——退出路径的 cancel
+    // 不能因此放弃。
+    let headerDir;
+    let cookieHeaderArgs;
+    try {
+        headerDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lark-remote-exit-cancel-'));
+        const headerFile = path.join(headerDir, 'cookie.hdr');
+        fs.writeFileSync(headerFile, `Cookie: ${cookie}\n`, { mode: 0o600, flag: 'wx' });
+        cookieHeaderArgs = ['-H', `@${headerFile}`];
+    }
+    catch (err) {
+        logger.warn(`[dsh] exit-cancel header file unavailable: ${err.message}`);
+        removeDir(headerDir);
+        headerDir = undefined;
+        cookieHeaderArgs = ['-H', `Cookie: ${cookie}`];
+    }
+    try {
+        const res = spawnProcessSync('curl', [
+            '-s',
+            '-o',
+            isWin32() ? 'NUL' : '/dev/null',
+            '-w',
+            '%{http_code}',
+            '-X',
+            'POST',
+            `${opts.baseUrl.replace(/\/$/, '')}/api/session/cancel`,
+            '-H',
+            'content-type: application/json',
+            ...cookieHeaderArgs,
+            '--max-time',
+            String(Math.max(1, Math.ceil(timeoutMs / 1000))),
+            '--data',
+            body,
+        ], { encoding: 'utf-8', timeout: timeoutMs, maxBuffer: 1024 * 1024 });
+        const status = String(res.stdout ?? '').trim();
+        const ok = status === '200';
+        if (!ok) {
+            logger.warn(`[dsh] exit-cancel failed for ${opts.sessionId}: ${res.error?.message ?? `http ${status || 'n/a'}`}`);
+        }
+        return ok;
+    }
+    finally {
+        removeDir(headerDir);
+    }
+}
+/** 删除 cookie 临时目录（best-effort）；目录未创建时是空操作。 */
+function removeDir(dir) {
+    if (!dir)
+        return;
+    try {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        /* best-effort cleanup */
     }
-    return ok;
 }
 //# sourceMappingURL=exit-cancel.js.map

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

@@ -0,0 +1,2 @@
+/** Resolve the same DSH home DSH itself uses: configured, env, then ~/.dsh. */
+export declare function resolveDshHome(configured?: string, env?: NodeJS.ProcessEnv): string;

package/dist/runner/dsh/home.js

@@ -0,0 +1,8 @@
+import os from 'node:os';
+import path from 'node:path';
+/** Resolve the same DSH home DSH itself uses: configured, env, then ~/.dsh. */
+export function resolveDshHome(configured, env = process.env) {
+    const value = configured?.trim() || env.DSH_HOME?.trim();
+    return path.resolve(value && value.length > 0 ? value : path.join(os.homedir(), '.dsh'));
+}
+//# sourceMappingURL=home.js.map

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

@@ -58,5 +58,3 @@ export interface DshInflightReconcileResult {
  * entries are left in the file so a later startup can retry.
  */
 export declare function reconcileInflightDshRuns(opts: DshInflightReconcileOptions): Promise<DshInflightReconcileResult>;
-/** One short owner-facing notice; session ids are truncated, not paths. */
-export declare function formatInflightWarning(entries: DshInflightEntry[]): string;

package/dist/runner/dsh/inflight.js

@@ -126,7 +126,7 @@ export async function reconcileInflightDshRuns(opts) {
     return { removed, open: open.length, skipped: false };
 }
 /** One short owner-facing notice; session ids are truncated, not paths. */
-export function formatInflightWarning(entries) {
+function formatInflightWarning(entries) {
     const lines = entries.slice(0, 3).map((entry) => {
         const id = entry.sessionId.length > 8 ? entry.sessionId.slice(0, 8) : entry.sessionId;
         return `- session ${id}（${entry.cwd ?? '未知目录'}）`;

package/dist/runner/dsh/mux-stream.d.ts

@@ -0,0 +1,26 @@
+interface MuxSocket {
+    onopen: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    onunexpectedresponse?: ((event: {
+        statusCode?: number;
+    }) => void) | null;
+    send(data: string): void;
+    close(): void;
+}
+export interface OpenMuxStreamOptions {
+    baseUrl: string;
+    endpoint: string;
+    payload: unknown;
+    signal: AbortSignal;
+    requestTimeoutMs: number;
+    authCookie(): Promise<string | undefined>;
+    webSocketFactory(url: string, options?: {
+        headers?: Record<string, string>;
+    }): MuxSocket;
+}
+export declare function openMuxStream(opts: OpenMuxStreamOptions): AsyncGenerator<unknown>;
+export {};