dsh-lark-bot 0.19.10 → 0.19.11

package/dist/cli.js

@@ -3700,6 +3700,10 @@ var DEFAULTS = {
   guardianBridgeProfile: "default",
   upgradeNotify: false,
   upgradeCheckIntervalMs: 6 * 60 * 6e4,
+  channelPingTimeoutSec: 30,
+  channelKeepalive: true,
+  channelKeepaliveMs: 15e3,
+  channelHealthPollMs: 5e3,
   sessionBackfillMessages: 20,
   sessionBackfillBytes: 64 * 1024,
   sessionStreamUpdateMs: 800
@@ -3930,6 +3934,22 @@ function loadRuntimeEnv(source = process.env) {
       source.DSH_LARK_GUARDIAN_ENGINE_DEAD_MS,
       DEFAULTS.guardianEngineDeadMs,
       "DSH_LARK_GUARDIAN_ENGINE_DEAD_MS"
+    ),
+    channelPingTimeoutSec: parsePositiveIntMin(
+      source.DSH_LARK_CHANNEL_PING_TIMEOUT_SEC,
+      DEFAULTS.channelPingTimeoutSec,
+      "DSH_LARK_CHANNEL_PING_TIMEOUT_SEC"
+    ),
+    channelKeepalive: parseBoolean(source.DSH_LARK_CHANNEL_KEEPALIVE, DEFAULTS.channelKeepalive),
+    channelKeepaliveMs: parsePositiveIntMin(
+      source.DSH_LARK_CHANNEL_KEEPALIVE_MS,
+      DEFAULTS.channelKeepaliveMs,
+      "DSH_LARK_CHANNEL_KEEPALIVE_MS"
+    ),
+    channelHealthPollMs: parsePositiveIntMin(
+      source.DSH_LARK_CHANNEL_HEALTH_POLL_MS,
+      DEFAULTS.channelHealthPollMs,
+      "DSH_LARK_CHANNEL_HEALTH_POLL_MS"
     )
   };
 }
@@ -4477,15 +4497,6 @@ function guardianStatePath(root) {
   return join11(root, ".dsh-lark", "guardian.json");
 }
 
-// src/upgrade/detect.ts
-init_own_package();
-import { readFile as readFile10 } from "fs/promises";
-import { join as join12 } from "path";
-import { homedir as homedir7 } from "os";
-init_dsh_runtime();
-init_process();
-import { existsSync as existsSync6 } from "fs";
-
 // src/guardian/heartbeat.ts
 import { readFile as readFile9 } from "fs/promises";
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 5e3;
@@ -4496,15 +4507,25 @@ async function readHeartbeat(file) {
     if (typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string" || typeof parsed.ts !== "number") {
       return void 0;
     }
-    return {
+    const payload = {
       pid: parsed.pid,
       startedAt: parsed.startedAt,
       ts: parsed.ts
     };
+    const channel = parsed.channel;
+    if (isChannelSnapshot(channel)) {
+      payload.channel = channel;
+    }
+    return payload;
   } catch {
     return void 0;
   }
 }
+function isChannelSnapshot(value) {
+  if (!value || typeof value !== "object") return false;
+  const snapshot = value;
+  return typeof snapshot.state === "string" && typeof snapshot.ready === "boolean";
+}
 function heartbeatAgeMs(payload, now = Date.now()) {
   return Math.max(0, now - payload.ts);
 }
@@ -4512,12 +4533,34 @@ function isHeartbeatFresh(payload, maxAgeMs, now = Date.now()) {
   if (payload === void 0) return false;
   return heartbeatAgeMs(payload, now) < maxAgeMs;
 }
-function startHeartbeat(file, pid, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS) {
+function channelHealthLabel(channel) {
+  if (channel === void 0) return "\u672A\u4E0A\u62A5";
+  if (channel.ready) {
+    return `ready (generation ${channel.generation ?? "-"})`;
+  }
+  switch (channel.state) {
+    case "connecting":
+      return "connecting";
+    case "reconnecting":
+      return `reconnecting (attempt ${channel.reconnectAttempts ?? "-"})`;
+    case "failed":
+      return "failed";
+    case "stopped":
+      return "stopped";
+    default:
+      return channel.state;
+  }
+}
+function startHeartbeat(file, pid, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS, getChannelHealth) {
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   let stopped = false;
   const beat = async () => {
     if (stopped) return;
     const payload = { pid, startedAt, ts: Date.now() };
+    const channel = getChannelHealth?.();
+    if (channel !== void 0) {
+      payload.channel = channel;
+    }
     try {
       await writeFileAtomic(file, `${JSON.stringify(payload)}
 `, {
@@ -4540,6 +4583,13 @@ function startHeartbeat(file, pid, intervalMs = DEFAULT_HEARTBEAT_INTERVAL_MS) {
 }
 
 // src/upgrade/detect.ts
+init_own_package();
+import { readFile as readFile10 } from "fs/promises";
+import { join as join12 } from "path";
+import { homedir as homedir7 } from "os";
+init_dsh_runtime();
+init_process();
+import { existsSync as existsSync6 } from "fs";
 async function readInstalledPackage(dshHome, profile, packageName) {
   const manifest = join12(
     dshHome,
@@ -5918,6 +5968,18 @@ async function runDoctorChecks(options) {
   } catch (error) {
     lines.push(`service: \u26A0\uFE0F \u72B6\u6001\u68C0\u67E5\u5931\u8D25\uFF08${error instanceof Error ? error.message : String(error)}\uFF09`);
   }
+  try {
+    const heartbeat = await readHeartbeat(
+      paths.profilePath(env.guardianBridgeProfile, "guardian", "heartbeat.json")
+    );
+    lines.push(`channel: ${channelHealthLabel(heartbeat?.channel)}`);
+    if (heartbeat?.channel && !heartbeat.channel.ready) {
+      lines.push(
+        "channel: \u26A0\uFE0F \u5F15\u64CE\u8FDB\u7A0B\u5B58\u6D3B\u4F46\u901A\u9053\u672A\u5C31\u7EEA\uFF08\u534A\u5F00/\u91CD\u8FDE/\u5931\u8D25\uFF09\uFF1B\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8DEF\u7531\u6216\u91CD\u542F managed engine"
+      );
+    }
+  } catch {
+  }
   try {
     const state = await loadUpgradeState(upgradeStatePath(env.home));
     if (state?.lastUpgrade.pendingRestart === true) {
@@ -7057,6 +7119,106 @@ var LanguagePolicyStore = class {
 // src/bridge/channel.ts
 import { createLarkChannel as createLarkChannel2 } from "@larksuite/channel";
 
+// src/bridge/channel-health.ts
+function mapState(state) {
+  switch (state) {
+    case "connected":
+      return "ready";
+    case "reconnecting":
+      return "reconnecting";
+    case "failed":
+      return "failed";
+    case "connecting":
+      return "connecting";
+    case "idle":
+    default:
+      return "connecting";
+  }
+}
+var ChannelHealthMonitor = class {
+  channel;
+  pollMs;
+  onUpdate;
+  generation = 0;
+  connectedAt;
+  lastInboundAt;
+  lastReconnectAt;
+  lastError;
+  observedState = "connecting";
+  reconnectAttempts = 0;
+  at = 0;
+  pollTimer;
+  constructor(channel, options = {}) {
+    this.channel = channel;
+    this.pollMs = options.pollMs ?? 5e3;
+    this.onUpdate = options.onUpdate;
+  }
+  /** Latest snapshot (always a copy; safe to persist). */
+  snapshot() {
+    return {
+      state: this.observedState,
+      ready: this.observedState === "ready",
+      generation: this.generation,
+      ...this.connectedAt !== void 0 ? { connectedAt: this.connectedAt } : {},
+      reconnectAttempts: this.reconnectAttempts,
+      ...this.lastInboundAt !== void 0 ? { lastInboundAt: this.lastInboundAt } : {},
+      ...this.lastReconnectAt !== void 0 ? { lastReconnectAt: this.lastReconnectAt } : {},
+      ...this.lastError !== void 0 ? { lastError: this.lastError } : {},
+      at: this.at
+    };
+  }
+  /** Bind transport hooks from the bridge event subscription. */
+  observeMessage() {
+    this.lastInboundAt = Date.now();
+    this.markChanged();
+  }
+  observeReconnecting() {
+    this.observedState = "reconnecting";
+    this.markChanged();
+  }
+  observeReconnected() {
+    this.generation += 1;
+    const now = Date.now();
+    this.connectedAt = now;
+    this.lastReconnectAt = now;
+    this.observedState = "ready";
+    this.markChanged();
+  }
+  observeError(error) {
+    this.lastError = error instanceof Error ? error.message : String(error);
+    if (this.observedState !== "reconnecting" && this.observedState !== "failed") {
+      this.observedState = "failed";
+    }
+    this.markChanged();
+  }
+  /** Poll the SDK's connection-status snapshot. */
+  start() {
+    if (this.pollTimer) return;
+    this.refresh();
+    this.pollTimer = setInterval(() => this.refresh(), this.pollMs);
+    this.pollTimer.unref?.();
+  }
+  stop() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = void 0;
+    }
+    this.observedState = "stopped";
+    this.markChanged();
+  }
+  refresh() {
+    const status = this.channel.getConnectionStatus?.();
+    this.observedState = mapState(status?.state);
+    this.reconnectAttempts = status?.reconnectAttempts ?? this.reconnectAttempts;
+    this.markChanged();
+  }
+  markChanged() {
+    const now = Date.now();
+    this.at = now;
+    this.onUpdate?.(this.snapshot());
+  }
+};
+
 // src/commands/index.ts
 import { stat as stat8 } from "fs/promises";
 import { homedir as homedir14 } from "os";
@@ -13751,6 +13913,8 @@ The value is written only by the local bridge and is not sent to the agent.` },
 }
 
 // src/bridge/channel.ts
+var DEFAULT_CHANNEL_PING_TIMEOUT_SEC = 30;
+var DEFAULT_CHANNEL_KEEPALIVE_MS = 15e3;
 async function startChannel(deps) {
   const channel = (deps.createChannel ?? createLarkChannel2)({
     appId: deps.appId,
@@ -13777,7 +13941,26 @@ async function startChannel(deps) {
     resolveChatMode: true,
     handshakeTimeoutMs: 8e3,
     httpTimeoutMs: 3e4,
-    respectProxyEnv: true
+    respectProxyEnv: true,
+    // Issue #108: detect a half-open WebSocket (TCP ESTABLISHED but Feishu no
+    // longer delivering). `pingTimeout` force-reconnects when no inbound frame
+    // arrives after the last ping; the app-level `keepalive` probes and
+    // force-reconnects, and `onUnrecoverable` fires when even that fails so the
+    // engine can exit and let the managed service / guardian restart it.
+    wsConfig: { pingTimeout: deps.channelPingTimeoutSec ?? DEFAULT_CHANNEL_PING_TIMEOUT_SEC },
+    keepalive: {
+      enabled: deps.channelKeepalive ?? true,
+      intervalMs: deps.channelKeepaliveMs ?? DEFAULT_CHANNEL_KEEPALIVE_MS,
+      onUnrecoverable: (error) => {
+        log.fail("channel", "unrecoverable", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+        deps.onChannelUnrecoverable?.(error);
+      }
+    }
+  });
+  const channelHealth = new ChannelHealthMonitor(channel, {
+    ...deps.channelHealthPollMs !== void 0 ? { pollMs: deps.channelHealthPollMs } : {}
   });
   const streaming = adaptLarkChannel(channel);
   const commandChannel = streaming;
@@ -13818,6 +14001,7 @@ async function startChannel(deps) {
   const isolationStore = deps.isolationStore ?? EMPTY_ISOLATION_STORE;
   let groupPoller;
   const processMessage = async (msg, alreadyClaimed = false) => {
+    channelHealth.observeMessage();
     if (groupPoller && !alreadyClaimed && !groupPoller.claim(msg.messageId)) return;
     const chatMode = msg.chatMode ?? msg.chatType;
     const botSender = msg.senderType === "bot";
@@ -14394,21 +14578,25 @@ ${msg.content}`,
     },
     reconnecting: () => {
       log.warn("channel", "reconnecting", {});
+      channelHealth.observeReconnecting();
       void reconnectNotifier.reconnecting().catch((error) => {
         log.fail("channel-reconnect-notice", error);
       });
     },
     reconnected: () => {
       log.info("channel", "reconnected", {});
+      channelHealth.observeReconnected();
       void reconnectNotifier.reconnected().catch((error) => {
         log.fail("channel-reconnect-notice", error);
       });
     },
     error: (error) => {
       log.fail("channel", error);
+      channelHealth.observeError(error);
     }
   });
   await channel.connect();
+  channelHealth.start();
   if (sessionProjectionBridge) {
     void sessionProjectionBridge.start().catch((error) => {
       log.fail("session-projection", error, { step: "start" });
@@ -14425,8 +14613,10 @@ ${msg.content}`,
   }
   return {
     channel,
+    channelHealth: () => channelHealth.snapshot(),
     disconnect: async () => {
       await groupPoller?.stop();
+      channelHealth.stop();
       sessionProjection?.close();
       await sessionProjectionBridge?.close();
       await channel.disconnect();
@@ -18586,7 +18776,18 @@ async function startBridgeEngine(options) {
     },
     allowedUsers: activeProfile.access.allowedUsers,
     allowedChats: activeProfile.access.allowedChats,
-    ...options.createChannel ? { createChannel: options.createChannel } : {}
+    ...options.createChannel ? { createChannel: options.createChannel } : {},
+    channelPingTimeoutSec: env.channelPingTimeoutSec,
+    channelKeepalive: env.channelKeepalive,
+    channelKeepaliveMs: env.channelKeepaliveMs,
+    channelHealthPollMs: env.channelHealthPollMs,
+    onChannelUnrecoverable: (error) => {
+      log.fail("engine", "channel-unrecoverable", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      process.exitCode = 1;
+      setTimeout(() => process.exit(1), 300);
+    }
   };
   if (activeProfile.preferences.stopGraceMs !== void 0) {
     channelInput.stopGraceMs = activeProfile.preferences.stopGraceMs;
@@ -18651,7 +18852,8 @@ async function startBridgeEngine(options) {
   const heartbeat = startHeartbeat(
     paths.profilePath(profileName, "guardian", "heartbeat.json"),
     process.pid,
-    env.heartbeatMs
+    env.heartbeatMs,
+    () => bridge.channelHealth?.()
   );
   await updateHandoff.reconcile(currentVersion());
   void deliverUpdateResult().catch((error) => log.fail("upgrade", error, { step: "deliver-result" }));
@@ -19730,6 +19932,7 @@ var GuardianService = class {
       dshUp: this.dshUp,
       heartbeatAgeMs: this.lastHeartbeatAgeMs,
       channelConnected: this.channel !== void 0,
+      channelState: this.lastHeartbeatChannel?.state,
       safeEngine: this.safeEngine?.kind,
       safeRuns: this.safeRuns.size,
       pid: process.pid,
@@ -19740,6 +19943,9 @@ var GuardianService = class {
   }
   dshUp = false;
   lastHeartbeatAgeMs;
+  lastHeartbeatChannel;
+  /** When the engine reported a non-ready channel while its heartbeat was fresh. */
+  channelUnhealthySinceMs;
   log() {
     return this.options.logger ?? log;
   }
@@ -19774,7 +19980,24 @@ var GuardianService = class {
       const now = (this.options.now ?? Date.now)();
       const heartbeatFresh = isHeartbeatFresh(heartbeat, this.options.staleMs, now);
       this.lastHeartbeatAgeMs = heartbeat ? heartbeatAgeMs(heartbeat, now) : void 0;
+      this.lastHeartbeatChannel = heartbeat?.channel;
       if (heartbeatFresh) this.lastHeartbeatFreshAt = now;
+      const channelSnapshot = this.lastHeartbeatChannel;
+      const channelUnhealthy = heartbeatFresh && channelSnapshot !== void 0 && channelSnapshot.ready === false;
+      if (channelUnhealthy) {
+        if (this.channelUnhealthySinceMs === void 0) {
+          this.channelUnhealthySinceMs = now;
+          this.log().warn("guardian", "channel-unhealthy", {
+            dshProfile: this.state.dshProfile,
+            state: channelSnapshot.state,
+            generation: channelSnapshot.generation,
+            reconnectAttempts: channelSnapshot.reconnectAttempts,
+            lastError: channelSnapshot.lastError
+          });
+        }
+      } else {
+        this.channelUnhealthySinceMs = void 0;
+      }
       const processFound = await (this.options.findProcess ?? findProfileProcess)(
         this.state.dshProfile
       );
@@ -20822,6 +21045,7 @@ async function statusGuardianCommand(options = {}, deps = {}) {
     `\u6865\u63A5 profile\uFF1A${state.bridgeProfile}`,
     `dsh \u662F\u5426\u5728\u7EBF\uFF1A${up ? "\u662F" : "\u5426"}${processFound ? `\uFF08pid ${processFound.pid}\uFF09` : ""}`,
     `\u5FC3\u8DF3\u9F84\uFF1A${heartbeat ? `${heartbeatAgeMs(heartbeat)}ms` : "\u65E0"}`,
+    `\u98DE\u4E66\u901A\u9053\uFF1A${channelHealthLabel(heartbeat?.channel)}`,
     `\u5DF2\u89C2\u5BDF\u8FC7 dsh \u8FD0\u884C\uFF1A${state.profileSeenUp ? "\u662F" : "\u5426"}`,
     guardianProcess === void 0 ? "\u5B88\u62A4\u8FDB\u7A0B pid\uFF1A\u672A\u53D1\u73B0\uFF08\u65E0\u6CD5\u552F\u4E00\u8BC1\u660E resident guardian \u8EAB\u4EFD\uFF09" : `\u5B88\u62A4\u8FDB\u7A0B pid\uFF1A${guardianProcess.pid}`,
     `\u72B6\u6001\u6587\u4EF6\uFF1A${layout.stateFile}`,
@@ -20860,7 +21084,7 @@ function managerFor(options, version) {
     version
   });
 }
-function formatServiceStatus(status, heartbeatAge2) {
+function formatServiceStatus(status, heartbeatAge2, channel) {
   return [
     "dsh-lark-bot \u6B63\u5E38\u5F15\u64CE\u670D\u52A1",
     `  name:      ${status.name}`,
@@ -20871,7 +21095,8 @@ function formatServiceStatus(status, heartbeatAge2) {
     `  detail:    ${status.detail}`,
     `  pid:       ${status.pid ?? "-"}`,
     `  restarts:  ${status.restarts ?? "-"}`,
-    `  heartbeat: ${heartbeatAge2 === void 0 ? "\u6682\u65E0" : `${heartbeatAge2}ms`}`
+    `  heartbeat: ${heartbeatAge2 === void 0 ? "\u6682\u65E0" : `${heartbeatAge2}ms`}`,
+    `  channel:   ${channelHealthLabel(channel)}`
   ].join("\n");
 }
 async function heartbeatAge() {
@@ -20884,6 +21109,16 @@ async function heartbeatAge() {
   const heartbeat = await readHeartbeat(file);
   return heartbeat ? heartbeatAgeMs(heartbeat) : void 0;
 }
+async function heartbeatChannel() {
+  const env = loadRuntimeEnv(process.env);
+  const file = resolveAppPaths(env.home).profilePath(
+    env.guardianBridgeProfile,
+    "guardian",
+    "heartbeat.json"
+  );
+  const heartbeat = await readHeartbeat(file);
+  return heartbeat?.channel;
+}
 async function runServiceCommand(action, options = {}, deps = {}) {
   const manager = deps.manager ?? managerFor(options, deps.version ?? "0.0.0");
   const output = deps.output ?? ((text) => process.stdout.write(text));
@@ -20900,7 +21135,11 @@ ${logs.text || "\uFF08\u6682\u65E0\u65E5\u5FD7\uFF09"}
       return;
     }
     const status = action === "install" ? await manager.install() : action === "start" ? await manager.start() : action === "restart" ? await manager.restart() : action === "stop" ? await manager.stop() : action === "uninstall" ? await manager.uninstall() : await manager.status();
-    output(`${formatServiceStatus(status, await (deps.heartbeatAge ?? heartbeatAge)())}
+    const [age, channel] = await Promise.all([
+      (deps.heartbeatAge ?? heartbeatAge)(),
+      (deps.heartbeatChannel ?? heartbeatChannel)()
+    ]);
+    output(`${formatServiceStatus(status, age, channel)}
 `);
     if ((action === "install" || action === "start" || action === "restart") && status.state !== "running") process.exitCode = 1;
     if (action === "status" && (!status.installed || status.state === "error")) {