lark-remote 0.5.9 → 0.5.12

package/dist/index.js

@@ -34,9 +34,17 @@ import { InboundAuthorizer } from './inbound/authorize.js';
 import { stripPlaceholders } from './inbound/placeholder.js';
 import { buildSessionHistoryCard, pickResumeCardEvents } from './router/card-helpers.js';
 import { newSessionButton, resumeCompactButton, agentDisplayName } from './card/card-shared.js';
+import { sleep } from './common/sleep.js';
 import path from 'node:path';
 import fs from 'node:fs';
 import { bestEffortUnlink } from './common/fs.js';
+/**
+ * 会话变更类卡片动作执行前冲刷入站装配窗口的等待预算（ms）。flush 本身无下载
+ * 在途时瞬时完成（顺序保证完整）；预算只挡「in-flight 媒体下载卡住」的场景
+ * （下载超时 5 分钟/资源）——SDK 把卡片动作放进与消息共享的 per-chat 串行
+ * lane 并 await 到底，无界等待会让整个 chat 停摆到下载超时。
+ */
+const SESSION_MUTATING_FLUSH_BUDGET_MS = 2_000;
 /**
  * /stop 命令别名单源：普通消息的停止分支与 clone 活跃期拦截的排除条件
  * 共用同一判定，防止将来加别名时两处漂移。
@@ -363,9 +371,12 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             };
             let cwd = sessionStore.getCwd(turn.userId) ?? '';
             if (!cwd && workspaceStore) {
-                const workspaces = workspaceStore.list();
-                if (workspaces.length > 0)
-                    cwd = workspaces[0].path;
+                // 兜底取「最近使用」而非插入序首位：WorkspaceStore.list() 按 Map 插入序
+                // 返回（touch 原地改时间戳不重排），[0] 恒为最早保存的别名——触发时会把
+                // 消息静默发到最旧工作区，与「最近使用」直觉相反。
+                const recent = [...workspaceStore.list()].sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+                if (recent.length > 0)
+                    cwd = recent[0].path;
             }
             const binding = bridge.currentBinding(turn.userId);
             bridge.enqueue(cwd, async () => {
@@ -456,6 +467,14 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
             logger.warn(`[media] rejected inbound media from non-owner ${msg.userId}`);
             return;
         }
+        // clone 状态机活跃期：一切输入归 clone 流程、不落盘附件
+        // （inbound-unified-input-design.md §5.8；文本入口有同款闸门）。静默丢弃
+        // 而非发回执——装配器的「📎 已保存」回执会与 clone 引导话术冲突，诱导
+        // 用户「说一句话」触发 clone 的婉拒回复。
+        if (cloneSession.isActive()) {
+            logger.info(`[media] dropped inbound media during clone session ${msg.messageId}`);
+            return;
+        }
         // 读 router.config（活引用）：/config 保存后 setConfigValues 返回新对象，
         // 启动时捕获的 config 参数会过期（修复）。
         if (!router.config.inboundMedia.enabled) {
@@ -599,26 +618,14 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         // Add Typing reaction to indicate "still alive"
         void connector.addReaction(messageId, 'Typing');
         if (actionValue.cmd === 'stop') {
-            if (!actionValue.runId) {
-                logger.warn('[control] ignored stop card action without runId');
-                // Card button clicks must have visible feedback (design constraint: card button
-                // 点击必须有可见反馈，见 design.md §6.2)。
-                void bridge
-                    .sendResult({ text: '⚠️ 无效的停止请求，缺少必要信息' }, { userId, chatId, messageId })
-                    .catch((err) => logger.error('[control] card stop feedback failed:', err));
-                return;
-            }
-            void (async () => {
-                const stopped = await bridge.interruptCurrentRun({
-                    userId,
-                    chatId,
-                    runId: actionValue.runId,
-                });
-                if (!stopped) {
-                    // runId mismatch or run already exited — mirror /stop text miss path.
-                    await bridge.sendResult({ text: '该任务已结束，无需终止' }, { userId, chatId, messageId });
-                }
-            })().catch((err) => logger.error('[control] card stop failed:', err));
+            // 委托 router 的 handleCardStop（单一来源）：miss 反馈与 DSH unconfirmed
+            // 警告（「未能确认 turn 已停止，可能仍在后台运行」）都在那里。此前这里
+            // 内联只调 interruptCurrentRun——unconfirmed 反馈被丢，run 卡被翻成
+            // interrupted 却暗示干净停止；miss 文案也与 router 形成两份漂移拷贝。
+            // stop 绕串行队列的原则不变：本分支在队列分发之前直接 return。
+            void router
+                .handleCardAction({ ...actionValue, cmd: 'stop' }, { userId, chatId, messageId })
+                .catch((err) => logger.error('[control] card stop failed:', err));
             return;
         }
         const isImmediate = isImmediateAction(actionValue.cmd);
@@ -632,8 +639,19 @@ function setupMessageHandlers(connector, router, bridge, sessionStore, workspace
         // 保证窗口内先到的文本消息在本动作之前 commit（绑定旧 session/cwd/agent）。
         // 否则 700ms 静默窗内的消息会漂移到动作之后的新状态：例如输入「重新构建」
         // 后立即点「新会话」，消息会落到新会话。名单以 router 单源为准。
+        //
+        // 有界等待：flush 会等 in-flight 媒体下载落定（超时 5 分钟/
+        // 资源），而 SDK 的 chatQueue.cardActions 默认 'same'——卡片动作与消息共享
+        // 同一 per-chat 串行 lane 且被 await 到底。无界等待下，一个大视频在途 +
+        // 点「新会话」= 整个 chat 的所有消息与卡片动作停摆到下载超时。超预算后
+        // 放行本动作，flush 在后台继续：窗口内仍有未落定下载时，文本 commit 可能
+        // 落到本动作之后（漂移风险收窄到「卡住的下载 + 2s 内点击」的组合，可接受；
+        // 完整解法需要把 binding 快照进装配器，见 inbound-unified-input-design.md）。
         if (SESSION_MUTATING_ACTION_CMDS.has(actionValue.cmd)) {
-            await assembler.flush(userId, chatId, 'flush');
+            const flushP = assembler
+                .flush(userId, chatId, 'flush')
+                .catch((err) => logger.error('[control] inbound flush failed:', err));
+            await Promise.race([flushP, sleep(SESSION_MUTATING_FLUSH_BUDGET_MS)]);
         }
         // queue.input / config.save / approval.respond / approval.toggle /
         // approval.answer 系列返回 CardActionResponse toast 给点击用户即时反馈。

package/dist/instance-lock.d.ts

@@ -33,7 +33,15 @@ export declare class InstanceLock {
      * 与 CIM CommandLine 首 token 归一后必然一致（bun/node 垫片场景亦然）。
      */
     private lockContents;
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     private tryCreate;
     /**
      * 把夺来的活锁放回原位。优先 `link`（目标已存在会失败，不会覆盖更新的锁），

package/dist/instance-lock.js

@@ -177,22 +177,57 @@ export class InstanceLock {
     lockContents(pid) {
         return `${pid}\n${binaryName(process.execPath)}`;
     }
-    /** 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。 */
+    /**
+     * 原子创建锁文件；已存在返回 false，其它 IO 错误向上抛。
+     *
+     * 先写完整临时文件再 `link()`：`open(wx)` 与 `write` 之间存在微秒级「空文件」
+     * 窗口，并发进程在该窗口读到的锁是「空 → 损坏 → 陈旧」，rename 夺走后双方
+     * 各持一份（A 的 fd 写进已被删掉的 inode、B 建了自己的锁 → 双实例）。
+     * link() 创建即含全部内容，窗口不存在；文件系统不支持 hardlink 时退回 wx
+     * 直建（该类 FS 上保留既有行为，竞态面收窄到该类文件系统）。
+     */
     tryCreate() {
+        const tmp = `${this.lockPath}.new-${process.pid}-${randomBytes(6).toString('hex')}`;
         try {
-            const fd = fs.openSync(this.lockPath, 'wx');
+            const fd = fs.openSync(tmp, 'wx');
             try {
                 fs.writeSync(fd, this.lockContents(process.pid));
             }
             finally {
                 fs.closeSync(fd);
             }
-            return true;
+            try {
+                fs.linkSync(tmp, this.lockPath);
+                return true;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'EEXIST')
+                    return false;
+                if (code === 'EPERM' || code === 'EOPNOTSUPP' || code === 'ENOSYS' || code === 'EXDEV') {
+                    // hardlink 不可用（网络/overlay FS）：退回 wx 直建。
+                    try {
+                        const direct = fs.openSync(this.lockPath, 'wx');
+                        try {
+                            fs.writeSync(direct, this.lockContents(process.pid));
+                        }
+                        finally {
+                            fs.closeSync(direct);
+                        }
+                        return true;
+                    }
+                    catch (err2) {
+                        if (err2.code === 'EEXIST')
+                            return false;
+                        throw err2;
+                    }
+                }
+                throw err;
+            }
         }
-        catch (err) {
-            if (err.code === 'EEXIST')
-                return false;
-            throw err;
+        finally {
+            // 成功 link 后 tmp 与 lockPath 同 inode：删 tmp 只去掉多余名字（nlink 2→1）。
+            bestEffortUnlink(tmp);
         }
     }
     /**

package/dist/platform/identity.js

@@ -12,9 +12,9 @@
  *   （killOrphan）应按需调用，真机矩阵需实测整体耗时；
  * - platform 显式注入，win32 语义可在任意宿主上单测。
  */
-import { execFileSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { currentPlatform, isWin32 } from './select.js';
+import { spawnProcess, spawnProcessSync } from './spawn.js';
 const DEFAULT_TIMEOUT_MS = 3000;
 /** 拉起一次性查询进程并收全 stdout；超时/拉起失败/进程报错一律 null。 */
 function collect(file, args, timeoutMs) {
@@ -24,7 +24,7 @@ function collect(file, args, timeoutMs) {
             // stderr 用 ignore：查询进程的错误输出我们不需要，pipe 而不消费在极端
             // 情况下（管道缓冲满）会阻塞子进程，把一次性查询拖成挂起。
             // windowsHide：避免查询进程在桌面闪控制台窗口
-            proc = spawn(file, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+            proc = spawnProcess(file, args, { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
         }
         catch {
             resolve(null);
@@ -243,12 +243,13 @@ export function verifyPidIdentityVerdictSync(pid, opts) {
         return 'unknown';
     let stdout;
     try {
-        stdout = execFileSync('ps', ['-o', 'command=', '-p', String(pid)], {
+        const res = spawnProcessSync('ps', ['-o', 'command=', '-p', String(pid)], {
             encoding: 'utf-8',
             timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
             stdio: ['ignore', 'pipe', 'ignore'],
             windowsHide: true,
         });
+        stdout = String(res.stdout ?? '');
     }
     catch {
         // 进程不存在 / ps 不可用 / 超时：查不到身份 → unknown（不杀）

package/dist/platform/path.js

@@ -21,8 +21,10 @@ function resolveOptions(opts) {
  */
 export function pathKey(p, opts) {
     const { platform } = resolveOptions(opts);
+    // linux：剥尾部分隔符，与 darwin/win32 同口径（否则 `/cd ~/repo/` 与
+    // `/cd ~/repo` 会被判成两个目录——darwin 分支注释写明的不变量）。
     if (platform === 'linux')
-        return p;
+        return p.replace(/\/+$/, '');
     if (isWin32(platform)) {
         // win32：\ 与 / 都是分隔符，且路径大小写不敏感
         return p.replaceAll('\\', '/').replace(/\/+$/, '').toLowerCase();

package/dist/platform/terminator-win32.d.ts

@@ -1,3 +1,15 @@
+/**
+ * win32 终止器：协议停止通道 → grace 等待 → taskkill 树杀。
+ *
+ * 状态机：
+ *   1. 进程已退出 → nothing（via='already-exited'）
+ *   2. immediate  → taskkill /PID <pid> /T /F
+ *   3. 优雅       → AgentStopperRegistry 查协议通道
+ *      - 无通道：打日志显式跳过优雅段（不等一个不会来的退出事件）→ 直接树杀
+ *      - 有通道：调用后与 exit 事件竞速等 graceMs，仍存活 → 树杀
+ *
+ * 依赖（spawn / 等待器 / 日志）全部构造注入，win32 语义可在任意宿主上单测。
+ */
 import type { ChildProcess, SpawnOptions } from 'node:child_process';
 import type { Terminator } from './terminator.js';
 import { AgentStopperRegistry } from './agent-stopper.js';
@@ -11,7 +23,7 @@ export interface Win32TerminatorDeps {
     agent?: string;
     /** 协议通道注册表注入（测试隔离）；默认进程级单例 */
     stoppers?: AgentStopperRegistry;
-    /** spawn 注入（测试用）；默认 node:child_process */
+    /** spawn 注入（测试用）；默认 platform/spawn.ts 的 spawnProcess */
     spawn?: SpawnLike;
     /** grace 等待器注入（测试用）；默认与 exit 事件竞速 */
     waitForExit?: WaitForExit;

package/dist/platform/terminator-win32.js

@@ -1,17 +1,5 @@
-/**
- * win32 终止器：协议停止通道 → grace 等待 → taskkill 树杀。
- *
- * 状态机：
- *   1. 进程已退出 → nothing（via='already-exited'）
- *   2. immediate  → taskkill /PID <pid> /T /F
- *   3. 优雅       → AgentStopperRegistry 查协议通道
- *      - 无通道：打日志显式跳过优雅段（不等一个不会来的退出事件）→ 直接树杀
- *      - 有通道：调用后与 exit 事件竞速等 graceMs，仍存活 → 树杀
- *
- * 依赖（spawn / 等待器 / 日志）全部构造注入，win32 语义可在任意宿主上单测。
- */
-import { spawn as nodeSpawn } from 'node:child_process';
 import { agentStopperRegistry } from './agent-stopper.js';
+import { spawnProcess } from './spawn.js';
 /** 退出判定统一口径（红线）：exitCode !== null || signalCode !== null。 */
 function isAlive(proc) {
     return proc.exitCode === null && proc.signalCode === null;
@@ -36,7 +24,9 @@ async function defaultWaitForExit(proc, ms) {
     });
 }
 export function createWin32Terminator(deps) {
-    const spawnFn = deps.spawn ?? nodeSpawn;
+    // 默认走 platform/spawn.ts 单点收口：taskkill 是系统二进制，
+    // cross-spawn 在 win32 之外直通、在 win32 垫片场景下受控执行。
+    const spawnFn = deps.spawn ?? spawnProcess;
     const stoppers = deps.stoppers ?? agentStopperRegistry;
     const waitForExit = deps.waitForExit ?? defaultWaitForExit;
     const log = deps.log;