dsh-lark-bot 0.19.2 → 0.19.4

package/dist/plugin.d.ts

@@ -1321,9 +1321,11 @@ interface GuardianUpdateState {
     route: GuardianUpdateRoute;
     startedAt: string;
     finishedAt?: string;
+    errorCode?: GuardianUpdateErrorCode;
     error?: string;
     delivered?: boolean;
 }
+type GuardianUpdateErrorCode = 'filesystem-access' | 'registry-unavailable' | 'bootstrap-unavailable' | 'upgrade-failed';
 interface GuardianUpdateHandoffOptions {
     file: string;
     packageName: string;

package/dist/plugin.js

@@ -864,9 +864,9 @@ async function writeFileAtomic(target, data, options = {}) {
   }
 }
 async function rmSilently(path) {
-  const { rm: rm10 } = await import("fs/promises");
+  const { rm: rm11 } = await import("fs/promises");
   try {
-    await rm10(path, { force: true });
+    await rm11(path, { force: true });
   } catch {
   }
 }
@@ -2538,6 +2538,18 @@ function patchYamlFor(options) {
     "",
     "- id: hmr",
     "  disabled: true",
+    "",
+    // Model-invocable channel skill: expose the dsh-lark-bot operations guide
+    // to THIS agent session's skill catalog — the one the `skill` tool reads.
+    // The bridge engine registers the same skill on its own cordis context
+    // (plugin.ts), but that context is never the one the model reads. This row
+    // ensures the skill also lands on the agent runtime's context so that
+    // `skill("dsh-lark-bot")` resolves in a live SDK session. It is kept
+    // outside the bridgeTools gate because it needs no callback endpoint and
+    // is also useful to the guardian's core-only safe profile.
+    "- insert:",
+    "    - id: lark-skill",
+    `      name: '${own.name}/skill'`,
     ""
   ];
   if (bridgeTools) {
@@ -4561,7 +4573,11 @@ function processElements(state, locale, maxTools) {
 function thinkingPanel(state, locale, maxTools) {
   return {
     tag: "collapsible_panel",
-    expanded: state.terminal === "running",
+    // Default to collapsed: the top-level compatibility snapshot already shows
+    // the latest status and current tools, so keep the detailed per-tool list
+    // collapsed to avoid two overlapping expanded surfaces. (Both sections are
+    // retained for now.)
+    expanded: false,
     header: {
       title: { tag: "plain_text", content: `\u2699\uFE0F ${locale === "zh_cn" ? "\u6267\u884C\u8FC7\u7A0B" : "Execution"} \xB7 ${summaryText(state, locale)}` },
       icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
@@ -5247,6 +5263,15 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
           log.warn("run-flow", "card-update-failed", { scope: input.scope, error });
         }
       };
+      const unregisterReanchor = input.runCardAnchors?.register(input.chatId, async () => {
+        if (state.terminal !== "running") return;
+        try {
+          await controller.update(renderer(state, density, Date.now()));
+          if (typeof controller.reanchor === "function") await controller.reanchor();
+        } catch (error) {
+          log.warn("run-flow", "card-reanchor-failed", { scope: input.scope, error });
+        }
+      });
       const showResumeRecovery = async (error) => {
         if (classifySessionError(errorMessage(error)) === void 0) throw error;
         resumeFailure = errorMessage(error);
@@ -5420,6 +5445,7 @@ async function runAttempt(input, cwd, workspaceCwd, sessionId, resuming, replyOp
         unsubscribeQuestion?.();
         unsubscribePlan?.();
         unsubscribeApproval?.();
+        unregisterReanchor?.();
       }
     };
     let producerStarted = false;
@@ -9203,6 +9229,41 @@ var ResilientCardStreamController = class {
       });
     }
   }
+  /**
+   * Recall the current card and re-create it as the newest top-level message in
+   * the chat, rebinding the controller to the fresh message id. Because Feishu
+   * cannot reorder an existing message, this is the only way to keep an
+   * in-progress process card visible at the tail while interim agent bubbles are
+   * appended below. Best-effort: if the recall fails the card is left where it
+   * is (no duplicate is created); if the controller is closed or failed the id
+   * is left unchanged.
+   */
+  async reanchor() {
+    if (this.closed || this.failed) return this.messageId;
+    if (this.inFlight !== void 0) await this.inFlight;
+    if (this.timer !== void 0) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    const card = this.latest;
+    if (card === void 0) return this.messageId;
+    try {
+      await this.channel.recallMessage(this.messageId);
+    } catch (error) {
+      log.warn("lark-card-stream", "reanchor-recall-failed", {
+        messageId: this.messageId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return this.messageId;
+    }
+    const sent = await this.channel.send(this.chatId, { card }, {});
+    if (!sent.messageId) throw new Error("Feishu card re-anchor returned no message_id");
+    this.messageId = sent.messageId;
+    this.latest = card;
+    this.dirty = false;
+    this.failed = false;
+    return this.messageId;
+  }
 };
 function adaptLarkChannel(channel) {
   const base = {
@@ -11446,6 +11507,63 @@ function wizardContextFor(event, deps, channel, scope) {
   };
 }
 
+// src/bridge/run-card-anchors.ts
+var RunCardAnchors = class {
+  byChatId = /* @__PURE__ */ new Map();
+  /**
+   * Register a re-anchor callback for a chat. Returns a disposer; safe to call
+   * more than once (idempotent).
+   */
+  register(chatId, reanchor) {
+    const set = this.byChatId.get(chatId) ?? /* @__PURE__ */ new Set();
+    set.add(reanchor);
+    this.byChatId.set(chatId, set);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      set.delete(reanchor);
+      if (set.size === 0) this.byChatId.delete(chatId);
+    };
+  }
+  /** Notify that a new bubble was delivered to the chat. */
+  async bubbleSent(chatId) {
+    const set = this.byChatId.get(chatId);
+    if (!set || set.size === 0) return;
+    await Promise.allSettled([...set].map((reanchor) => reanchor()));
+  }
+};
+function attachRunCardAnchors(channel, anchors) {
+  const notify = (chatId) => {
+    void anchors.bubbleSent(chatId).catch((error) => {
+      log.warn("run-card-anchors", "bubble-sent-failed", {
+        chatId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+  };
+  return {
+    ...channel,
+    async sendMarkdown(chatId, markdown2, options) {
+      const result = await channel.sendMarkdown(chatId, markdown2, options);
+      notify(chatId);
+      return result;
+    },
+    async sendCard(chatId, card, options) {
+      if (typeof channel.sendCard !== "function") return void 0;
+      const result = await channel.sendCard(chatId, card, options);
+      notify(chatId);
+      return result;
+    },
+    async sendFile(chatId, fileName, content2, options) {
+      if (typeof channel.sendFile !== "function") return void 0;
+      const result = await channel.sendFile(chatId, fileName, content2, options);
+      notify(chatId);
+      return result;
+    }
+  };
+}
+
 // src/bridge/scope-directory.ts
 import { readFile as readFile11 } from "fs/promises";
 var ScopeDirectory = class {
@@ -15008,14 +15126,14 @@ function matchProfileProcess(cmdline, dshProfile) {
   if (/(?:^|\s)plugin(?:\s|$)/.test(cmdline)) return false;
   return hasProfileFlag(cmdline, dshProfile) && looksLikeDshProcess(cmdline);
 }
-async function listProcesses() {
-  if (process.platform === "win32") {
-    return listProcessesWindows();
+async function listProcesses(platform = process.platform, run = captureOutput) {
+  if (platform === "win32") {
+    return listProcessesWindows(run);
   }
-  return listProcessesPosix();
+  return listProcessesPosix(run);
 }
-async function listProcessesPosix() {
-  const { stdout } = await captureOutput("ps", ["-axo", "pid=,args="], 1e4);
+async function listProcessesPosix(run) {
+  const { stdout } = await run("ps", ["-axo", "pid=,args="], 1e4);
   const result = [];
   for (const line of stdout.split("\n")) {
     const match = /^\s*(\d+)\s+(.+)$/.exec(line);
@@ -15025,33 +15143,46 @@ async function listProcessesPosix() {
   }
   return result;
 }
-async function listProcessesWindows() {
-  const { stdout } = await captureOutput(
+async function listProcessesWindows(run) {
+  const { stdout } = await run(
     "powershell.exe",
     [
       "-NoProfile",
       "-NonInteractive",
       "-Command",
-      "Get-CimInstance Win32_Process | Select-Object ProcessId, CommandLine | ConvertTo-Csv -NoTypeInformation"
+      "Get-CimInstance Win32_Process | Select-Object ProcessId, CommandLine | ConvertTo-Json -Compress"
     ],
     1e4
   );
-  const result = [];
-  for (const line of stdout.split("\n").slice(1)) {
-    const [pid, ...rest] = line.trim().split(",");
-    const numeric = Number(pid?.replace(/"/g, ""));
-    if (Number.isInteger(numeric) && rest.length > 0) {
-      result.push({ pid: numeric, cmdline: rest.join(",").replace(/^"|"$/g, "") });
-    }
+  try {
+    const parsed = JSON.parse(stdout);
+    const rows = Array.isArray(parsed) ? parsed : [parsed];
+    return rows.flatMap((row) => {
+      if (typeof row !== "object" || row === null) return [];
+      const record = row;
+      const pid = Number(record.ProcessId);
+      const cmdline = record.CommandLine;
+      return Number.isInteger(pid) && pid > 0 && typeof cmdline === "string" ? [{ pid, cmdline }] : [];
+    });
+  } catch {
+    return [];
   }
-  return result;
 }
-async function captureOutput(command, args, timeoutMs = 3e4) {
+async function captureOutput(command, args, timeoutMs = 3e4, options = {}) {
   return new Promise((resolve6) => {
-    const child = spawn5(command, [...args], {
-      stdio: ["ignore", "pipe", "pipe"],
-      windowsHide: true
-    });
+    const previousUmask = options.umask !== void 0 && process.platform !== "win32" ? process.umask(options.umask) : void 0;
+    const child = (() => {
+      try {
+        return spawn5(command, [...args], {
+          stdio: ["ignore", "pipe", "pipe"],
+          windowsHide: true,
+          ...options.cwd ? { cwd: options.cwd } : {},
+          ...options.env ? { env: options.env } : {}
+        });
+      } finally {
+        if (previousUmask !== void 0) process.umask(previousUmask);
+      }
+    })();
     let stdout = "";
     let stderr = "";
     child.stdout?.on("data", (chunk) => {
@@ -16374,11 +16505,35 @@ function buildSecretHandler(deps) {
 init_own_package();
 
 // src/guardian/update-handoff.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID13 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { mkdir as mkdir20, readFile as readFile28 } from "fs/promises";
+import { chmod, mkdir as mkdir20, readFile as readFile28, rm as rm10 } from "fs/promises";
 import { dirname as dirname15, join as join23 } from "path";
 init_own_package();
+function guardianUpdateFailureHint(code) {
+  switch (code) {
+    case "filesystem-access":
+      return {
+        zh: "\u66F4\u65B0\u5DE5\u4F5C\u76EE\u5F55\u4E0D\u53EF\u8BBF\u95EE\uFF1B\u8BF7\u53D1\u9001 `/doctor` \u68C0\u67E5\u6587\u4EF6\u6743\u9650\u540E\u91CD\u8BD5\u3002",
+        en: "The private update workspace is inaccessible. Send `/doctor` to check file permissions, then retry."
+      };
+    case "registry-unavailable":
+      return {
+        zh: "\u65E0\u6CD5\u8FDE\u63A5 npm \u6B63\u5F0F\u6E90\uFF1B\u8BF7\u68C0\u67E5\u7F51\u7EDC\u540E\u91CD\u8BD5\u3002",
+        en: "The npm registry is unreachable. Check the network, then retry."
+      };
+    case "bootstrap-unavailable":
+      return {
+        zh: "\u65E0\u6CD5\u542F\u52A8 npm/npx\uFF1B\u8BF7\u53D1\u9001 `/doctor` \u68C0\u67E5 Node.js \u4E0E npm\u3002",
+        en: "npm/npx could not start. Send `/doctor` to check Node.js and npm."
+      };
+    default:
+      return {
+        zh: "\u5347\u7EA7\u547D\u4EE4\u672A\u5B8C\u6210\uFF1B\u8BF7\u53D1\u9001 `/doctor` \u68C0\u67E5\u540E\u91CD\u8BD5\u3002",
+        en: "The upgrade command did not complete. Send `/doctor`, then retry."
+      };
+  }
+}
 async function loadState(file) {
   try {
     const parsed = JSON.parse(await readFile28(file, "utf8"));
@@ -16734,6 +16889,7 @@ async function startBridgeEngine(options) {
   const questions = new QuestionRegistry();
   const plans = new PlanApprovalRegistry();
   const densityStore = new DensityStore();
+  const runCardAnchors = new RunCardAnchors();
   const models = new ModelStore();
   const wizardStore = new WizardStore();
   const dshConfig = new DshProviderManager({ env: process.env });
@@ -16964,6 +17120,7 @@ async function startBridgeEngine(options) {
           plans,
           densityStore,
           channel: streaming,
+          runCardAnchors,
           defaultWorkspace,
           replyTo: first.messageId,
           deliverFinalReply: (replyScope, chatId, markdown2, options2) => replyDispatcher.deliver(replyScope, chatId, markdown2, options2),
@@ -17166,17 +17323,18 @@ async function startBridgeEngine(options) {
       error: "channel does not expose getBotIdentity"
     });
   }
-  streaming = adaptLarkChannel(bridge.channel);
+  streaming = attachRunCardAnchors(adaptLarkChannel(bridge.channel), runCardAnchors);
   larkChannel = bridge.channel;
   const deliverUpdateResult = async () => {
     await updateHandoff.deliverResult(async (state) => {
       if (!streaming) throw new Error("channel is not ready");
+      const failureHint = guardianUpdateFailureHint(state.errorCode);
       const markdown2 = state.status === "succeeded" ? bilingualMarkdown(
         `\u2705 dsh-lark-bot \u5DF2\u66F4\u65B0\u5230 \`${state.targetVersion}\`\uFF0C\u673A\u5668\u4EBA\u5DF2\u5B8C\u6210\u91CD\u8F7D\u3002`,
         `\u2705 dsh-lark-bot was updated to \`${state.targetVersion}\` and reloaded.`
       ) : bilingualMarkdown(
-        `\u26A0\uFE0F dsh-lark-bot \u66F4\u65B0\u5230 \`${state.targetVersion}\` \u5931\u8D25\u3002\u8BF7\u91CD\u65B0\u53D1\u9001 \`/upgrade\`\uFF1B\u5982\u4ECD\u5931\u8D25\uFF0C\u53D1\u9001 \`/doctor\` \u68C0\u67E5\u3002`,
-        `\u26A0\uFE0F Failed to update dsh-lark-bot to \`${state.targetVersion}\`. Send \`/upgrade\` to retry, or \`/doctor\` if it still fails.`
+        `\u26A0\uFE0F dsh-lark-bot \u66F4\u65B0\u5230 \`${state.targetVersion}\` \u5931\u8D25\u3002${failureHint.zh}`,
+        `\u26A0\uFE0F Failed to update dsh-lark-bot to \`${state.targetVersion}\`. ${failureHint.en}`
       );
       await streaming.sendMarkdown(state.route.chatId, markdown2, {
         ...state.route.threadId ? { threadId: state.route.threadId } : {}