dsh-lark-bot 0.8.5 → 0.9.0

package/README.md

@@ -195,6 +195,11 @@ run in that scope carries the role instructions, and the role model wins below t
 dsh 工具（SDK / ACP 两种 runtime 均可装配）：agent 完成任务后可主动向其他群 / 话题发消息并
 @ 指定成员，桥接进程通过 127.0.0.1 本地回调端口 + 随机 token 校验，不暴露公网。
 
+**任务中向你提问（问答卡）**：agent 需要你拍板、确认或补充缺失信息时，会通过
+`lark_ask_user` 工具主动向当前会话弹一张**问答卡**（单选 / 多选 / 自由文本），
+你回答后任务自动继续——无需额外命令。问答卡等待期间任务不会被运行超时打断。
+（与 `/ask` 的“你主动发结构化问题”方向相反：这是 agent 主动来问你。）
+
 **Outbound mentions & cross-session notify**: the outbound contract supports `mentions` and
 cross-chat/thread sends; `/notify <scope|chatId> <text>` pushes a report to another session
 (admin). The agent also gets a built-in `lark_notify` dsh tool (wired into both SDK and ACP
@@ -202,6 +207,12 @@ runtime profiles): after a task finishes it can push messages to other groups/to
 members. The bridge listens on 127.0.0.1 with a random per-boot token — nothing is exposed to the
 public network.
 
+**Mid-task questions (question cards)**: when the agent needs a decision, confirmation, or
+missing information, it proactively sends a **question card** to the current chat via the
+`lark_ask_user` tool (single choice / multi choice / free text) and resumes automatically once
+you answer — no extra command needed. The run-timeout watchdog pauses while a card is waiting.
+(This is the opposite direction of `/ask`, which is you asking the agent.)
+
 **安全网守护（Safe-mode guardian）**：默认随 `setup` 一起安装的、独立于 dsh 进程、系统级常驻的
 最小守护进程（Linux systemd user unit / macOS LaunchAgent / Windows 启动项）。dsh 正常运行时守护保持静默；
 一旦 dsh 进程下线或无法 boot（例如某个第三方插件破坏了整个 profile 组合），守护自动接管飞书
@@ -504,7 +515,7 @@ This tool runs **locally**; before installing, be aware that it accesses:
 - **dsh 配置**：`/model` `/providers` `/provider` `/key` 命令按 dsh 官方存储协议读写
   `~/.dsh/settings.yaml` 与 `~/.dsh/.credentials.yaml`（仅管理员可写；settings 只存 `apiKeyEnv`
   引用，凭据文件权限 0600、目录 0700，字面密钥不进入 settings 或聊天记录）。
-- **安全网守护（可选）**：安装后为系统级常驻进程，读取 `~/.dsh-lark/config.json` 中的飞书
+- **安全网守护（默认随 `setup` 安装）**：系统级常驻进程，读取 `~/.dsh-lark/config.json` 中的飞书
   凭据；dsh 下线时接管同一 bot 的飞书长连接并扫描本机进程（仅 `ps` 命令行，不读内存）；
   `/safemode` 时在 `~/.dsh/profiles/<profile>-safe` 创建仅核心的 dsh profile 并逐条执行
   `dsh --profile <safe> "<prompt>"` 子进程。
@@ -559,11 +570,12 @@ Common issues:
   is reachable; with an existing App ID/Secret you can skip scanning via `--app-id` /
   `--app-secret`.
 
-桥接引擎日志写入 `~/.dsh-lark/profiles/<profile>/logs/bot.log`（JSON Lines）；dsh 宿主日志走
-dsh 自己的日志体系。
+桥接引擎日志以 JSON Lines 输出到 stderr（由 dsh 宿主进程捕获；`logs/bot.log` 是 0.6.0
+独立服务时代的遗留路径，0.7.0 起不再写入）；dsh 宿主日志走 dsh 自己的日志体系。
 
-The bridge engine logs to `~/.dsh-lark/profiles/<profile>/logs/bot.log` (JSON Lines); the dsh
-host uses its own logging.
+The bridge engine logs JSON Lines to stderr (captured by the dsh host; `logs/bot.log` is a
+leftover path from the 0.6.0 standalone-service era and is no longer written since 0.7.0); the
+dsh host uses its own logging.
 
 **回滚 / Rollback**：`dsh plugin --profile dsh-lark remove dsh-lark-bot` 后重装固定版本即可
 （如 `dsh plugin --profile dsh-lark add dsh-lark-bot@0.6.0`）；`~/.dsh-lark` 状态独立于插件

package/SECURITY.md

@@ -37,7 +37,7 @@
    `/invite admin <open_id>` 定义）；查看类命令（`/model`、`/providers`、`/key list`）开放。
 10. **本地回调隔离**：`lark_notify` 工具的回调服务只绑定 `127.0.0.1`，每次启动生成随机
     token 鉴权（不落盘、不进日志），请求体限 1MB；`/notify` 与角色 / 配置写命令同为管理员操作。
-11. **安全网守护（可选安装）**：
+11. **安全网守护（默认随 `setup` 安装）**：
     - 守护是独立于 dsh / Cordis 的最小进程，只读取本地状态与进程命令行（`ps`，不读内存），
       不导入任何 dsh 代码、不监听公网端口；
     - dsh 在线时守护**不连接飞书**（同 app 长连接仅允许单连接，避免抢占正常通道）；仅在
@@ -54,7 +54,8 @@
 - 飞书凭据明文保存在本机配置文件；日志与卡片不输出真实密钥。
 - 桥接引擎在 dsh 宿主进程内运行，凭据与 `DSH_LARK_*` 环境直接随 dsh 进程提供，无独立服务
   环境快照文件；敏感值不进日志与卡片。
-- 后台运行日志写入 `~/.dsh-lark/profiles/<profile>/logs/bot.log`（JSON Lines，密钥字段脱敏后输出）。
+- 桥接引擎日志以 JSON Lines 输出到 stderr（由 dsh 宿主进程捕获），密钥字段脱敏后输出；
+  `logs/bot.log` 是 0.6.0 独立服务时代的遗留路径，0.7.0 起不再写入。
 - 聊天命令管理的 dsh 配置按官方存储协议写入：`~/.dsh/settings.yaml`（只存 `apiKeyEnv`
   引用，不落字面密钥）与 `~/.dsh/.credentials.yaml`（目录 0700、文件 0600）。bot 永不回显
   密钥值；群聊中粘贴密钥会对群成员可见，建议私聊使用或改用环境变量 / dsh Web 页面录入。

package/dist/cli.js

@@ -226,6 +226,14 @@ function acpPatchYaml(provider, model) {
     "      config:",
     "        endpoint: !!js process.env.DSH_LARK_NOTIFY_URL",
     "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
+    "",
+    // Question-card tool (same contract as the SDK runtime).
+    "- insert:",
+    "    - id: lark-ask",
+    `      name: '${own.name}/ask'`,
+    "      config:",
+    "        endpoint: !!js process.env.DSH_LARK_ASK_URL",
+    "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
     ""
   ].join("\n");
 }
@@ -1323,6 +1331,15 @@ function patchYamlFor() {
     "      config:",
     "        endpoint: !!js process.env.DSH_LARK_NOTIFY_URL",
     "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
+    "",
+    // Question-card tool: the agent asks the user for decisions / missing
+    // information; the bridge shows a card and returns the answer.
+    "- insert:",
+    "    - id: lark-ask",
+    `      name: '${own.name}/ask'`,
+    "      config:",
+    "        endpoint: !!js process.env.DSH_LARK_ASK_URL",
+    "        token: !!js process.env.DSH_LARK_NOTIFY_TOKEN",
     ""
   ].join("\n");
 }
@@ -2194,6 +2211,28 @@ var PendingQueue = class {
 import { randomUUID as randomUUID3 } from "crypto";
 var QuestionRegistry = class {
   pending = /* @__PURE__ */ new Map();
+  settledListeners = /* @__PURE__ */ new Map();
+  /** Number of question cards currently awaiting an answer in a scope. */
+  pendingCount(scope) {
+    let count = 0;
+    for (const key of this.pending.keys()) {
+      if (key.startsWith(`${scope}:`)) count += 1;
+    }
+    return count;
+  }
+  /** Subscribe to question settlements in a scope; returns an unsubscribe. */
+  onSettled(scope, listener) {
+    const listeners = this.settledListeners.get(scope) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    this.settledListeners.set(scope, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) this.settledListeners.delete(scope);
+    };
+  }
+  notifySettled(scope) {
+    for (const listener of this.settledListeners.get(scope) ?? []) listener();
+  }
   register(scope, input) {
     const id = `question-${randomUUID3().replaceAll("-", "")}`;
     const full = { ...input, id };
@@ -2208,6 +2247,7 @@ var QuestionRegistry = class {
     pending.settled = true;
     this.pending.delete(`${scope}:${id}`);
     pending.resolve(answer);
+    this.notifySettled(scope);
     return true;
   }
   settleAll(scope) {
@@ -2220,6 +2260,7 @@ var QuestionRegistry = class {
       pending.resolve(void 0);
       count += 1;
     }
+    if (count > 0) this.notifySettled(scope);
     return count;
   }
   get(scope, id) {
@@ -2879,12 +2920,26 @@ async function runAgentBatch(input) {
           }
         };
         let timeoutTimer;
+        let armTimeout;
         const timeoutPromise = timeoutMs > 0 ? new Promise((resolve5) => {
-          timeoutTimer = setTimeout(() => {
-            timedOut = true;
-            void run.stop();
-            resolve5();
-          }, timeoutMs);
+          armTimeout = () => {
+            timeoutTimer = setTimeout(() => {
+              if (timedOut) return;
+              if (input.questions?.pendingCount(input.scope)) {
+                armTimeout?.();
+                return;
+              }
+              timedOut = true;
+              void run.stop();
+              resolve5();
+            }, timeoutMs);
+          };
+          armTimeout();
+        }) : void 0;
+        const unsubscribeSettled = timeoutPromise ? input.questions?.onSettled(input.scope, () => {
+          if (timedOut) return;
+          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+          armTimeout?.();
         }) : void 0;
         try {
           if (timeoutPromise) {
@@ -2896,6 +2951,7 @@ async function runAgentBatch(input) {
           await controller.update(renderCard(state, density));
         } finally {
           if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
+          unsubscribeSettled?.();
         }
       },
       replyOptions
@@ -4655,6 +4711,7 @@ var NotifyServer = class {
   token;
   deps;
   url;
+  askUrl;
   constructor(deps) {
     this.deps = deps;
     this.token = deps.token;
@@ -4670,6 +4727,7 @@ var NotifyServer = class {
       server.listen(this.deps.port ?? 0, "127.0.0.1", () => {
         const address = server.address();
         this.url = `http://127.0.0.1:${String(address.port)}/notify`;
+        this.askUrl = `http://127.0.0.1:${String(address.port)}/ask`;
         resolve5();
       });
     });
@@ -4690,12 +4748,38 @@ var NotifyServer = class {
       res.end(`${JSON.stringify(body)}
 `);
     };
-    if (req.method !== "POST" || req.url !== "/notify") {
-      respond(404, { ok: false, error: "not found" });
-      return;
-    }
     try {
       const body = await readBody(req);
+      if (req.method !== "POST") {
+        respond(404, { ok: false, error: "not found" });
+        return;
+      }
+      if (req.url === "/ask") {
+        if (!this.deps.ask) {
+          respond(404, { ok: false, error: "ask channel is not wired" });
+          return;
+        }
+        const payload = JSON.parse(body);
+        if (payload.token !== this.token) {
+          respond(401, { ok: false, error: "invalid token" });
+          return;
+        }
+        if (!payload.sessionId || !payload.question?.trim()) {
+          respond(400, { ok: false, error: "sessionId and question are required" });
+          return;
+        }
+        const result = await this.deps.ask(payload);
+        if (!result.ok) {
+          respond(404, { ok: false, ...result.error === void 0 ? {} : { error: result.error } });
+          return;
+        }
+        respond(200, { ok: true, ...result.answer === void 0 ? {} : { answer: result.answer } });
+        return;
+      }
+      if (req.url !== "/notify") {
+        respond(404, { ok: false, error: "not found" });
+        return;
+      }
       const message = JSON.parse(body);
       if (message.token !== this.token) {
         respond(401, { ok: false, error: "invalid token" });
@@ -4739,6 +4823,46 @@ function generateNotifyToken() {
   return `dsh-lark-${randomBytes2(18).toString("hex")}`;
 }
 
+// src/notify/ask-handler.ts
+function buildAskHandler(deps) {
+  return async (payload) => {
+    const scope = deps.sessions.scopeForSession(payload.sessionId);
+    if (!scope) {
+      return { ok: false, error: `unknown session: ${payload.sessionId}` };
+    }
+    const destination = deps.scopeDirectory.resolve(scope);
+    if (!destination) {
+      return { ok: false, error: `unknown scope: ${scope}` };
+    }
+    const kind = payload.kind ?? (payload.options && payload.options.length > 0 ? "single" : "text");
+    const input = {
+      kind,
+      question: payload.question,
+      ...payload.options && payload.options.length > 0 ? { options: payload.options } : {}
+    };
+    const { id, promise } = deps.questions.register(scope, input);
+    try {
+      await deps.channel.sendCard(
+        destination.chatId,
+        renderQuestionCard({ ...input, id }),
+        destination.threadId ? { threadId: destination.threadId } : void 0
+      );
+    } catch (error) {
+      log.fail("ask-card", error, { scope });
+      deps.questions.settleAll(scope);
+      return {
+        ok: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const answer = await promise;
+    if (answer === void 0) {
+      return { ok: false, error: "question cancelled" };
+    }
+    return { ok: true, answer };
+  };
+}
+
 // src/config/access-manager.ts
 var AccessManager = class {
   constructor(store, profileName) {
@@ -4892,6 +5016,8 @@ ${safeContent}`
 import { readFile as readFile6 } from "fs/promises";
 var SessionStore = class {
   data = { chats: {} };
+  /** Live session-id → scope index (used by the agent question-card router). */
+  sessionScopes = /* @__PURE__ */ new Map();
   saving = Promise.resolve();
   pendingArchive = Promise.resolve();
   path;
@@ -4929,8 +5055,22 @@ var SessionStore = class {
       cwd,
       messages: existing?.messages ?? []
     };
+    if (sessionId) this.sessionScopes.set(sessionId, scopeId);
     this.schedulePersist();
   }
+  /**
+   * Reverse lookup used by the bridge question-card router: map a live dsh
+   * session id back to its bridge scope. Falls back to a scan of the loaded
+   * records (e.g. after a fresh load before any live run registered).
+   */
+  scopeForSession(sessionId) {
+    const direct = this.sessionScopes.get(sessionId);
+    if (direct !== void 0) return direct;
+    for (const [scope, record] of Object.entries(this.data.chats)) {
+      if (record.sessionId === sessionId) return scope;
+    }
+    return void 0;
+  }
   historyFor(scopeId, cwd) {
     const record = this.data.chats[scopeId];
     return record && record.cwd === cwd ? record.messages : [];
@@ -5599,7 +5739,19 @@ async function startBridgeEngine(options) {
         ...destination.threadId ? { threadId: destination.threadId } : {},
         ...payload.mentions ? { mentions: payload.mentions } : {}
       });
-    }
+    },
+    ask: buildAskHandler({
+      sessions,
+      scopeDirectory,
+      questions,
+      channel: {
+        sendCard: async (chatId, card, options2) => {
+          if (!streaming) throw new Error("bridge channel is not ready");
+          if (!streaming.sendCard) throw new Error("bridge channel does not support cards");
+          await streaming.sendCard(chatId, card, options2);
+        }
+      }
+    })
   });
   process.env.DSH_LARK_NOTIFY_TOKEN = notifyToken;
   const pending = new PendingQueue(
@@ -5696,6 +5848,7 @@ async function startBridgeEngine(options) {
   larkChannel = bridge.channel;
   await notifyServer.start();
   process.env.DSH_LARK_NOTIFY_URL = notifyServer.url ?? "";
+  process.env.DSH_LARK_ASK_URL = notifyServer.askUrl ?? "";
   const heartbeat = startHeartbeat(
     paths.profilePath(profileName, "guardian", "heartbeat.json"),
     process.pid,