dsh-lark-bot 0.10.0 → 0.10.1

package/README.md

@@ -127,7 +127,7 @@ DSH_LARK_APP_ID=cli_xxx DSH_LARK_APP_SECRET=<secret> DSH_LARK_TENANT=feishu \
 > 卸载：`dsh plugin --profile dsh-lark remove dsh-lark-bot`。
 > Uninstall: `dsh plugin --profile dsh-lark remove dsh-lark-bot`.
 
-### 4. 基本使用 | Basic usage
+### 3. 基本使用 | Basic usage
 
 在飞书里向 bot 发送普通消息即可开始工作，常用命令：
 
@@ -231,8 +231,9 @@ you answer — no extra command needed. The run-timeout watchdog pauses while a
 - `/safemode stop`：终止当前正在运行的安全模式任务（也可点击任务卡片上的 ⏹ 按钮）；
 - `/safemode exit`：退出安全模式，守护重启完整 profile 并把飞书通道交还给正常形态；
 
-安全模式任务有墙钟超时（`DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS`，默认 10 分钟），超时或失败都会
-在卡片上给出明确终态，不会无声挂起。全程不需要命令行；dsh 恢复后守护自动断开并回归静默。安装：
+安全模式任务有**空闲超时**（`DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS`，默认 10 分钟：任务持续无
+活动事件才被终止，活跃的流式任务不会被误杀），超时或失败都会在卡片上给出明确终态，不会无声
+挂起。全程不需要命令行；dsh 恢复后守护自动断开并回归静默。安装：
 
 ```bash
 # 随 setup 默认安装（无需额外参数）；已安装后也可单独安装 / 重装：
@@ -258,8 +259,9 @@ takes over the Feishu channel so you can self-heal without touching the command
 - `/safemode exit`: leave safe mode — the guardian relaunches the full profile and hands the
   Feishu channel back;
 
-Safe-mode tasks are bounded by a wall-clock timeout
-(`DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS`, default 10 minutes); timeouts and failures always surface a
+Safe-mode tasks are bounded by an **idle timeout**
+(`DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS`, default 10 minutes: a task is stopped only after it has
+been silent for the whole window, so active streaming work is never cut short); timeouts and failures always surface a
 clear terminal state on the card instead of hanging silently. No command line is needed for the
 whole rescue flow; once dsh is back, the guardian releases the channel automatically. Install:
 
@@ -494,7 +496,7 @@ Core environment variables:
 | `DSH_LARK_MAX_TOKENS` | 未设置 | SDK agent 每请求输出 token 上限<br>Per-request output token cap for SDK agents |
 | `DSH_LARK_ACCESS_DEFAULT_DENY` | `false` | 无白名单时拒绝私聊<br>Reject private chats when no allowlist is configured |
 | `DSH_LARK_EVENT_FRESHNESS_MS` | `600000` | 过期消息拒绝窗口（0 关闭）<br>Stale-message rejection window (0 disables) |
-| `DSH_LARK_RUN_TIMEOUT_MS` | `300000` | 单次运行墙钟超时<br>Wall-clock timeout for a single run |
+| `DSH_LARK_RUN_TIMEOUT_MS` | `300000` | 单次运行空闲超时：持续无活动事件才终止（活跃任务不会被误杀）<br>Idle timeout for a single run: stops only after the run has been silent for this long |
 | `DSH_LARK_STOP_GRACE_MS` | `5000` | SIGTERM 后等待优雅退出再 SIGKILL 的宽限期<br>Grace period after SIGTERM before SIGKILL |
 | `DSH_LARK_SCOPE_CONCURRENCY` | `2` | 每个 scope 的并行任务数（1=严格串行）<br>Concurrent runs per scope (1 = strictly serial) |
 | `DSH_LARK_RETENTION_MSGS` | `40` | 每个 scope 保留的消息条数（0=全部保留）<br>Messages kept per scope (0 keeps everything) |
@@ -508,7 +510,7 @@ Core environment variables:
 | `DSH_LARK_GUARDIAN_STALE_MS` | `15000` | 心跳超时阈值，超过且无 dsh 进程则接管飞书通道<br>Heartbeat staleness threshold before channel takeover |
 | `DSH_LARK_GUARDIAN_ENGINE_DEAD_MS` | `120000` | dsh 进程存活但心跳持续超时该时长，判定桥接引擎已死并接管<br>Live dsh process with heartbeat stale this long is treated as engine-dead (takeover) |
 | `DSH_LARK_GUARDIAN_SAFE_ADAPTER` | `auto` | 安全模式引擎：`auto` 优先 SDK 流式、失败回退 headless；`sdk` 强制 SDK；`headless` 跳过预置<br>Safe-mode engine: `auto` tries the SDK streaming runtime then falls back to headless; `sdk` requires it; `headless` skips provisioning |
-| `DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS` | `600000` | 安全模式单任务墙钟超时（到时停止并出超时卡）<br>Safe-mode per-task wall-clock timeout (stops the run and renders a timeout card) |
+| `DSH_LARK_GUARDIAN_SAFE_TIMEOUT_MS` | `600000` | 安全模式单任务空闲超时（持续无活动事件才停止并出超时卡）<br>Safe-mode per-task idle timeout (stops the run after it has been silent this long and renders a timeout card) |
 | `DSH_LARK_GUARDIAN_CARD_DENSITY` | `detailed` | 安全模式任务卡片密度（compact / standard / detailed）<br>Card density for safe-mode run cards |
 
 启动时会自动查找本机常见的 `@deepseek-ai/dsh` 安装位置。只有自动发现失败或需要指定特殊 profile 时，才需要设置这两个变量。
@@ -574,14 +576,14 @@ availability probe for the current adapter (`sdk` / `acp` / `headless` runtime h
 Common issues:
 
 - **bot 静默 / 长连接失败**：查看 stderr 上的 JSONL 日志，关注 `channel` 与 `channel-command` 类别；SDK 会自动重连。
-- **agent 无响应**：发送 `/status` 查看当前 scope、cwd 和 active run；发送 `/stop` 终止当前任务；超过 `DSH_LARK_RUN_TIMEOUT_MS` 时看门狗会自动终止。
+- **agent 无响应**：发送 `/status` 查看当前 scope、cwd 和 active run；发送 `/stop` 终止当前任务；持续无响应超过 `DSH_LARK_RUN_TIMEOUT_MS` 时看门狗会自动终止（空闲超时，活跃任务不会被误杀）。
 - **首次扫码失败**：确认本机时间准确、网络可访问飞书开放平台；已拿到 App ID/Secret 时可用 `--app-id` / `--app-secret` 跳过扫码。
 
 - **Silent bot / long-connection failure**: check the JSONL logs on stderr, focusing on the
   `channel` and `channel-command` categories; the SDK reconnects automatically.
 - **Unresponsive agent**: send `/status` to view the scope, cwd and active run; send `/stop` to
-  terminate the current task; the watchdog terminates it automatically after
-  `DSH_LARK_RUN_TIMEOUT_MS`.
+  terminate the current task; the idle watchdog terminates it automatically after it has been
+  silent for `DSH_LARK_RUN_TIMEOUT_MS` (active streaming work is never cut short).
 - **First QR binding fails**: make sure the local clock is accurate and the Feishu open platform
   is reachable; with an existing App ID/Secret you can skip scanning via `--app-id` /
   `--app-secret`.

package/cordis.patch.yml

@@ -1,12 +1,13 @@
 # dsh-lark-bot as a profile bundle.
-
-# Installed with `dsh plugin --profile <name> add dsh-lark-bot` (or the
-# single `dsh-lark-bot setup` command), dsh appends this package to the profile's
+#
+# Installed with `dsh plugin --profile <name> add dsh-lark-bot` (or the single
+# `dsh-lark-bot setup` command), dsh appends this package to the profile's
 # `dsh.profile.bundles` and applies this patch on boot:
 #   - `dsh-lark-bot/plugin` starts the full bridge engine IN-PROCESS (Feishu
 #     channel, workspace/session layers, notify server, nested dsh SDK
 #     runtime) and exposes `ctx.larkBridge` (status / stop).
-#   - `dsh-lark-bot/notify` mounts the `lark_notify` tool for the host agent.
+#   - `dsh-lark-bot/notify` mounts the `lark_notify` tool for the host agent
+#     (mentions + cross-session messages).
 # First boot without credentials prints a QR code for one-time binding.
 # Set DSH_LARK_DISABLED=1 to keep the engine stopped.
 

package/dist/cli.js

@@ -1146,6 +1146,7 @@ function waitWithTimeout(promise, timeoutMs) {
 var SdkDshAdapter = class {
   id = "dsh-sdk";
   displayName = "DeepSeek Harness (SDK)";
+  resumeCapable = true;
   launch;
   provider;
   model;
@@ -2901,7 +2902,41 @@ async function runAgentBatch(input) {
   const workspace = input.workspaceManager ? await input.workspaceManager.ensure(input.scope, requestedCwd) : { cwd: requestedCwd };
   const cwd = workspace.cwd;
   const sessionId = activeBefore === 0 ? input.sessions.resumeFor(input.scope, cwd) : void 0;
-  const history = input.sessions.historyFor(input.scope, cwd);
+  const resuming = sessionId !== void 0 && input.adapter.resumeCapable === true;
+  try {
+    await runAttempt(input, cwd, sessionId, resuming, replyOptions);
+  } catch (error) {
+    if (resuming) {
+      log.warn("run-flow", "resume-fallback", { scope: input.scope, sessionId });
+      input.sessions.clearSession(input.scope);
+      try {
+        await runAttempt(input, cwd, void 0, false, replyOptions);
+        return;
+      } catch (retryError) {
+        log.fail("run-flow", retryError, {
+          scope: input.scope,
+          step: "resume-fallback"
+        });
+        await reportRunFailure(input, retryError, replyOptions);
+        return;
+      }
+    }
+    await reportRunFailure(input, error, replyOptions);
+  }
+}
+async function reportRunFailure(input, error, replyOptions) {
+  log.fail("run-flow", error, { scope: input.scope });
+  try {
+    await input.channel.sendMarkdown(
+      input.chatId,
+      `\u26A0\uFE0F agent \u8FD0\u884C\u5931\u8D25\uFF1A${errorMessage(error)}`,
+      replyOptions
+    );
+  } catch {
+  }
+}
+async function runAttempt(input, cwd, sessionId, resuming, replyOptions) {
+  const history = resuming ? [] : input.sessions.historyFor(input.scope, cwd);
   const prompt = buildPrompt(history, input.messages, input.role);
   const runId = randomUUID4();
   const run = input.adapter.run({
@@ -2938,6 +2973,8 @@ async function runAgentBatch(input) {
       input.chatId,
       renderCard(state, density),
       async (controller) => {
+        let timeoutTimer;
+        let armTimeout;
         const ticker = setInterval(() => {
           void controller.update(renderCard(state, density, Date.now())).catch(() => {
           });
@@ -2956,13 +2993,13 @@ async function runAgentBatch(input) {
             if (event.type === "system" && event.sessionId) {
               input.sessions.set(input.scope, event.sessionId, event.cwd ?? cwd);
             }
+            armTimeout?.();
             await controller.update(renderCard(state, density));
           }
         };
-        let timeoutTimer;
-        let armTimeout;
         const timeoutPromise = timeoutMs > 0 ? new Promise((resolve5) => {
           armTimeout = () => {
+            if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
             timeoutTimer = setTimeout(() => {
               if (timedOut) return;
               if (input.questions?.pendingCount(input.scope)) {
@@ -3008,15 +3045,6 @@ async function runAgentBatch(input) {
         }).then(() => pruneArchives(input))
       } : {}
     });
-  } catch (error) {
-    log.fail("run-flow", error, { scope: input.scope, runId });
-    state = markInterrupted(state);
-    try {
-      await input.channel.sendMarkdown(input.chatId, `\u26A0\uFE0F agent \u8FD0\u884C\u5931\u8D25\uFF1A${errorMessage(error)}`, {
-        ...replyOptions
-      });
-    } catch {
-    }
   } finally {
     input.activeRuns.delete(input.scope, runId);
     if (input.approvals) {
@@ -4159,7 +4187,7 @@ var HELP = [
   "- `/status` \u2014 \u67E5\u770B\u5F53\u524D\u72B6\u6001",
   "- `/resume` \u2014 \u67E5\u770B\u5F53\u524D\u4F1A\u8BDD\u6700\u8FD1\u4E0A\u4E0B\u6587",
   "- `/stop` \u2014 \u7EC8\u6B62\u5F53\u524D\u4EFB\u52A1",
-  "- `/timeout [N|off|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6",
+  "- `/timeout [N|off|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF08\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 N \u5206\u949F\u624D\u7EC8\u6B62\uFF09",
   "- `/concurrency [N|default]` \u2014 \u67E5\u770B\u6216\u8BBE\u7F6E\u5F53\u524D scope \u7684\u5E76\u884C\u4EFB\u52A1\u6570",
   "- `/role list|show <id>|set <id>|clear` \u2014 \u67E5\u770B / \u7ED1\u5B9A\u89D2\u8272",
   "- `/role save <id> <name> [--persona \u6587\u6848] [--model <id>] [--tools <csv>] [--rules \u6587\u6848]` \u2014 \u521B\u5EFA/\u66F4\u65B0\u89D2\u8272\uFF08\u7BA1\u7406\u5458\uFF09",
@@ -4314,18 +4342,18 @@ async function handleTimeout(args, ctx) {
     const minutes2 = effectiveMs > 0 ? Math.round(effectiveMs / 6e4) : 0;
     await reply5(
       ctx,
-      minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes2} \u5206\u949F\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A\u5173\u95ED\u3002"
+      minutes2 > 0 ? `\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 ${minutes2} \u5206\u949F\u624D\u7EC8\u6B62\u3002\u53EF\u7528 \`/timeout <N|off|default>\` \u8C03\u6574\u3002` : "\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u5173\u95ED\u3002"
     );
     return;
   }
   if (input === "off") {
     ctx.runPolicies.set(ctx.scope, 0);
-    await reply5(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\u3002");
+    await reply5(ctx, "\u5DF2\u5173\u95ED\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\u3002");
     return;
   }
   if (input === "default") {
     ctx.runPolicies.clear(ctx.scope);
-    await reply5(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u8FD0\u884C\u8D85\u65F6\u3002");
+    await reply5(ctx, "\u5DF2\u6062\u590D\u9ED8\u8BA4\u7A7A\u95F2\u8D85\u65F6\u3002");
     return;
   }
   const minutes = Number(input);
@@ -4334,7 +4362,7 @@ async function handleTimeout(args, ctx) {
     return;
   }
   ctx.runPolicies.set(ctx.scope, minutes * 6e4);
-  await reply5(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u8FD0\u884C\u8D85\u65F6\uFF1A${minutes} \u5206\u949F\u3002`);
+  await reply5(ctx, `\u5DF2\u8BBE\u7F6E\u5F53\u524D\u4F1A\u8BDD\u7A7A\u95F2\u8D85\u65F6\uFF1A\u6301\u7EED\u65E0\u6D3B\u52A8\u4E8B\u4EF6 ${minutes} \u5206\u949F\u624D\u7EC8\u6B62\u3002`);
 }
 async function handleConcurrency(args, ctx) {
   const input = args.trim();
@@ -5180,6 +5208,16 @@ var SessionStore = class {
     const record = this.data.chats[scopeId];
     return record && record.cwd === cwd ? record.sessionId : void 0;
   }
+  /**
+   * Drop the native dsh session binding for a scope. The transcript is kept so
+   * the next run can start a fresh session and replay history from the store.
+   */
+  clearSession(scopeId) {
+    const existing = this.data.chats[scopeId];
+    if (!existing) return;
+    this.data.chats[scopeId] = { ...existing, sessionId: void 0 };
+    this.schedulePersist();
+  }
   async flush() {
     await this.pendingArchive;
     await this.saving;
@@ -7185,6 +7223,7 @@ var GuardianService = class {
           }, SAFE_CARD_TICK_MS);
           ticker.unref?.();
           let timeoutTimer;
+          let armTimeout;
           try {
             const consume = async () => {
               for await (const event of run.events) {
@@ -7201,20 +7240,25 @@ var GuardianService = class {
                   this.sessionIds.set(scope, event.sessionId);
                 }
                 if (event.type === "error") errorText = event.message;
+                armTimeout?.();
                 await controller.update(renderCard(state, density, Date.now()));
               }
             };
             const timeoutPromise = timeoutMs > 0 ? new Promise((resolve5) => {
-              timeoutTimer = setTimeout(() => {
-                if (timedOut) return;
-                timedOut = true;
-                state = markIdleTimeout(
-                  state,
-                  Math.round(timeoutMs / 6e4)
-                );
-                void run.stop();
-                resolve5();
-              }, timeoutMs);
+              armTimeout = () => {
+                if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+                timeoutTimer = setTimeout(() => {
+                  if (timedOut) return;
+                  timedOut = true;
+                  state = markIdleTimeout(
+                    state,
+                    Math.round(timeoutMs / 6e4)
+                  );
+                  void run.stop();
+                  resolve5();
+                }, timeoutMs);
+              };
+              armTimeout();
             }) : void 0;
             if (timeoutPromise) {
               await Promise.race([consume(), timeoutPromise]);