ylib-syim 0.0.21 → 0.0.22

package/bridges/runtime/http-control-server.ts

@@ -1,7 +1,23 @@
 import http from "node:http";
 
 export function createHttpControlServer(
-  handler: (req: http.IncomingMessage, res: http.ServerResponse) => void,
+  handler: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+  ) => void | Promise<void>,
 ): http.Server {
-  return http.createServer(handler);
+  return http.createServer((req, res) => {
+    Promise.resolve(handler(req, res)).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[http-control-server] unhandled error: ${message}`);
+      if (res.headersSent) {
+        if (!res.writableEnded) {
+          res.end();
+        }
+        return;
+      }
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: message }));
+    });
+  });
 }

package/bridges/runtime-event-reporter.ts

@@ -1,15 +1,21 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { writeBridgeStructuredLog } from "./logger.ts";
 
 // runtime-event-reporter 负责把 bridge 侧 lifecycle/console 信号
 // 统一包装为 main.ts 可消费的 runtime event，避免各 bridge 自行拼装上报逻辑。
 type Platform = "dingtalk" | "feishu" | "weixin";
 const runtimeEventAliasLogMemo = new Set<string>();
+const runtimeEventWarnMemo = new Map<string, number>();
 // 保留原生 console 引用，避免调试日志被 console hook 二次识别。
 const runtimeEventRawConsoleLog = console.log.bind(console);
 // reporter 调试日志开关：默认关闭，排障时启用。
 const runtimeEventVerboseLog = process.env.RUNTIME_EVENT_VERBOSE_LOG === "1";
+const runtimeEventWarnCooldownMs = Math.max(
+  1000,
+  Number(process.env.RUNTIME_EVENT_WARN_COOLDOWN_MS || "60000") || 60000,
+);
 
 // logRuntimeEventDebug: 受控输出 reporter 调试日志。
 function logRuntimeEventDebug(message: string): void {
@@ -17,6 +23,16 @@ function logRuntimeEventDebug(message: string): void {
   runtimeEventRawConsoleLog(`[runtime-event-reporter][debug] ${message}`);
 }
 
+function logRuntimeEventWarning(key: string, message: string): void {
+  const now = Date.now();
+  const prevAt = runtimeEventWarnMemo.get(key) || 0;
+  if (now - prevAt < runtimeEventWarnCooldownMs) return;
+  runtimeEventWarnMemo.set(key, now);
+  const line = `[runtime-event-reporter][warn] ${message}`;
+  writeBridgeStructuredLog("warn", line);
+  runtimeEventRawConsoleLog(line);
+}
+
 // logSingleAccountAlias: 记录单账号 alias 映射日志（带去重）。
 function logSingleAccountAlias(
   platform: Platform,
@@ -179,7 +195,13 @@ export async function reportRuntimeEvent(
 ): Promise<void> {
   // 统一事件上报出口：所有 bridge 生命周期与日志信号都经此入站 main.ts。
   const token = (process.env.INTERNAL_FIXED_TOKEN || "").trim();
-  if (!token) return;
+  if (!token) {
+    logRuntimeEventWarning(
+      "missing_internal_token",
+      "skip runtime event report: INTERNAL_FIXED_TOKEN is empty",
+    );
+    return;
+  }
   const port = Number(process.env.INTERNAL_CONTROL_PORT || "18999");
   const emittedAt = new Date().toISOString();
   const payload = {
@@ -197,23 +219,44 @@ export async function reportRuntimeEvent(
     `report event platform=${platform} account=${accountId} status=${linkStatus} event=${String(extra?.eventName || "")}`,
   );
   try {
-    if (typeof fetch !== "function") return;
+    if (typeof fetch !== "function") {
+      logRuntimeEventWarning(
+        "fetch_unavailable",
+        "skip runtime event report: global fetch is unavailable",
+      );
+      return;
+    }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 1500);
     try {
-      await fetch(`http://127.0.0.1:${port}/internal/runtime/events/report`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${token}`,
-          "Content-Type": "application/json",
+      const response = await fetch(
+        `http://127.0.0.1:${port}/internal/runtime/events/report`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify(payload),
+          signal: controller.signal,
         },
-        body: JSON.stringify(payload),
-        signal: controller.signal,
-      });
+      );
+      if (!response.ok) {
+        logRuntimeEventWarning(
+          `report_http_status_${response.status}`,
+          `runtime event report response not ok status=${response.status} platform=${platform} account=${accountId} event=${String(extra?.eventName || "")}`,
+        );
+      }
     } finally {
       clearTimeout(timeout);
     }
-  } catch {}
+  } catch (err) {
+    const errMessage = err instanceof Error ? err.message : String(err);
+    logRuntimeEventWarning(
+      "report_runtime_event_exception",
+      `runtime event report request failed platform=${platform} account=${accountId} event=${String(extra?.eventName || "")} err=${errMessage}`,
+    );
+  }
 }
 
 // wireBridgeLifecycleReporter: 绑定生命周期事件并上报基础状态。

package/bridges/weixin-stdio-bridge.ts

@@ -52,15 +52,18 @@ process.on("unhandledRejection", (reason) => {
       | ((payload: Record<string, unknown>) => void)
       | undefined;
     const nowIso = new Date().toISOString();
-    sink?.({
-      platform: "weixin",
-      bot_account_id: payload.accountId,
-      link_status: payload.linkStatus,
-      last_error: payload.lastError || null,
-      status_source: "event",
-      last_event_at: nowIso,
-      last_heartbeat_at: nowIso,
-    });
+    if (sink) {
+      sink({
+        platform: "weixin",
+        bot_account_id: payload.accountId,
+        link_status: payload.linkStatus,
+        last_error: payload.lastError || null,
+        status_source: "event",
+        last_event_at: nowIso,
+        last_heartbeat_at: nowIso,
+      });
+      return Promise.resolve({ ok: true, transport: "in_process_sink" });
+    }
   } catch {
     // ignore
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "多 IM / 多 Agent 的会话路由与上下文管理（支持 /new）",
   "type": "module",
   "exports": {
@@ -46,9 +46,9 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "ylib-dingtalk-connector": "0.7.10-beta.13",
-    "ylib-openclaw-lark": "2026.3.17-beta.19",
-    "ylib-openclaw-weixin": "2.1.7-beta.5",
+    "ylib-dingtalk-connector": "0.7.10-beta.14",
+    "ylib-openclaw-lark": "2026.3.17-beta.20",
+    "ylib-openclaw-weixin": "2.1.7-beta.6",
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "fluent-ffmpeg": "^2.1.3",

package/scripts/dingtalk-stdio-bridge.ts

@@ -62,6 +62,10 @@ function emitRuntimeEvent(
           lastError?: string | null;
         }) => Promise<unknown>)
       | undefined;
+    if (reporter) {
+      void reporter({ accountId, linkStatus, lastError });
+      return;
+    }
     const nowIso = new Date().toISOString();
     sink?.({
       platform: "dingtalk",
@@ -72,8 +76,6 @@ function emitRuntimeEvent(
       last_event_at: nowIso,
       last_heartbeat_at: nowIso,
     });
-    if (!reporter) return;
-    void reporter({ accountId, linkStatus, lastError });
   } catch {}
 }
 
@@ -304,14 +306,36 @@ function channelsForLog(
 
 /** 加载 syim.json，与 connector-host 一致 */
 function loadOpenClawConfig(): Record<string, unknown> | null {
+  const runtimeConfig = (globalThis as Record<string, unknown>)
+    .__IM_RUNTIME_CONFIG__;
+  if (
+    runtimeConfig &&
+    typeof runtimeConfig === "object" &&
+    !Array.isArray(runtimeConfig)
+  ) {
+    console.log(
+      "[dingtalk-stdio-bridge] 从 runtime 内存配置加载，跳过本地 syim fallback",
+    );
+    try {
+      return JSON.parse(JSON.stringify(runtimeConfig)) as Record<string, unknown>;
+    } catch {
+      return { ...(runtimeConfig as Record<string, unknown>) };
+    }
+  }
   const runtimeConfigPath = String(
     (globalThis as Record<string, unknown>).__IM_RUNTIME_CONFIG_PATH__ || "",
   ).trim();
-  const configPaths = [
-    runtimeConfigPath,
-    path.join(getProjectRoot(), "syim.json"),
-    path.join(os.homedir(), ".syim", "syim.json"),
-  ].filter((p) => Boolean(p));
+  const envConfigPath = String(process.env.OPENCLAW_CONFIG_PATH || "").trim();
+  const configPaths = Array.from(
+    new Set(
+      [
+        envConfigPath,
+        runtimeConfigPath,
+        path.join(os.homedir(), ".syim", "syim.json"),
+        path.join(getProjectRoot(), "syim.json"),
+      ].filter((p) => Boolean(p)),
+    ),
+  );
   for (const configPath of configPaths) {
     if (!fs.existsSync(configPath)) continue;
     try {
@@ -507,6 +531,30 @@ const bridgeLifecycleLog = {
   warn: (msg: string) => console.warn("[DingTalk]", msg),
   error: (msg: string) => console.error("[DingTalk]", msg),
 };
+const bridgeAccountControlTimeoutMs = Math.max(
+  1_000,
+  Number(process.env.RUNTIME_ACCOUNT_CONTROL_TIMEOUT_MS || "10000") || 10000,
+);
+
+async function withBridgeControlTimeout<T>(
+  work: Promise<T>,
+  timeoutMessage: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      work,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(timeoutMessage)),
+          bridgeAccountControlTimeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 
 function resolveBridgeAccount(accountId: string): ResolvedAccount | null {
   if (!bridgeCfg) return null;
@@ -623,15 +671,18 @@ async function stopSingleAccount(
 
   if (typeof bridgeStopAccount === "function" && bridgeCfg) {
     try {
-      await Promise.resolve(
-        bridgeStopAccount({
-          cfg: bridgeCfg,
-          accountId: effectiveAccountId,
-          account,
-          log: bridgeLifecycleLog,
-          setStatus: (patch: Record<string, unknown>) =>
-            applyBridgeStatusPatch(effectiveAccountId, patch),
-        }),
+      await withBridgeControlTimeout(
+        Promise.resolve(
+          bridgeStopAccount({
+            cfg: bridgeCfg,
+            accountId: effectiveAccountId,
+            account,
+            log: bridgeLifecycleLog,
+            setStatus: (patch: Record<string, unknown>) =>
+              applyBridgeStatusPatch(effectiveAccountId, patch),
+          }),
+        ),
+        `dingtalk stop hook timeout account=${effectiveAccountId}`,
       );
     } catch (err) {
       const detail = toDetailedErrorText(err);

package/scripts/lark-stdio-bridge.ts

@@ -71,6 +71,10 @@ function emitRuntimeEvent(
           lastError?: string | null;
         }) => Promise<unknown>)
       | undefined;
+    if (reporter) {
+      void reporter({ accountId, linkStatus, lastError });
+      return;
+    }
     const nowIso = new Date().toISOString();
     sink?.({
       platform: "feishu",
@@ -81,8 +85,6 @@ function emitRuntimeEvent(
       last_event_at: nowIso,
       last_heartbeat_at: nowIso,
     });
-    if (!reporter) return;
-    void reporter({ accountId, linkStatus, lastError });
   } catch {}
 }
 
@@ -321,10 +323,36 @@ function channelsForLog(
 // ---------------------------------------------------------------------------
 
 function loadOpenClawConfig(): Record<string, unknown> | null {
-  const configPaths = [
-    path.join(getProjectRoot(), "syim.json"),
-    path.join(os.homedir(), ".syim", "syim.json"),
-  ];
+  const runtimeConfig = (globalThis as Record<string, unknown>)
+    .__IM_RUNTIME_CONFIG__;
+  if (
+    runtimeConfig &&
+    typeof runtimeConfig === "object" &&
+    !Array.isArray(runtimeConfig)
+  ) {
+    console.log(
+      "[lark-stdio-bridge] 从 runtime 内存配置加载，跳过本地 syim fallback",
+    );
+    try {
+      return JSON.parse(JSON.stringify(runtimeConfig)) as Record<string, unknown>;
+    } catch {
+      return { ...(runtimeConfig as Record<string, unknown>) };
+    }
+  }
+  const runtimeConfigPath = String(
+    (globalThis as Record<string, unknown>).__IM_RUNTIME_CONFIG_PATH__ || "",
+  ).trim();
+  const envConfigPath = String(process.env.OPENCLAW_CONFIG_PATH || "").trim();
+  const configPaths = Array.from(
+    new Set(
+      [
+        envConfigPath,
+        runtimeConfigPath,
+        path.join(os.homedir(), ".syim", "syim.json"),
+        path.join(getProjectRoot(), "syim.json"),
+      ].filter((p) => Boolean(p)),
+    ),
+  );
   for (const configPath of configPaths) {
     if (!fs.existsSync(configPath)) continue;
     try {
@@ -584,6 +612,30 @@ const bridgeLifecycleLog = {
   warn: (msg: string) => console.warn("[Feishu]", msg),
   error: (msg: string) => console.error("[Feishu][ERR]", msg),
 };
+const bridgeAccountControlTimeoutMs = Math.max(
+  1_000,
+  Number(process.env.RUNTIME_ACCOUNT_CONTROL_TIMEOUT_MS || "10000") || 10000,
+);
+
+async function withBridgeControlTimeout<T>(
+  work: Promise<T>,
+  timeoutMessage: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      work,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(timeoutMessage)),
+          bridgeAccountControlTimeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 
 function ensureGatewayBaseOnCfg(
   cfg: Record<string, unknown>,
@@ -788,16 +840,19 @@ async function stopSingleAccount(
 
   if (typeof bridgeStopAccount === "function" && currentCfg) {
     try {
-      await Promise.resolve(
-        bridgeStopAccount({
-          cfg: currentCfg,
-          accountId: effectiveAccountId,
-          account,
-          runtime: currentRuntime,
-          log: bridgeLifecycleLog,
-          setStatus: (patch: Record<string, unknown>) =>
-            applyBridgeStatusPatch(effectiveAccountId, patch),
-        }),
+      await withBridgeControlTimeout(
+        Promise.resolve(
+          bridgeStopAccount({
+            cfg: currentCfg,
+            accountId: effectiveAccountId,
+            account,
+            runtime: currentRuntime,
+            log: bridgeLifecycleLog,
+            setStatus: (patch: Record<string, unknown>) =>
+              applyBridgeStatusPatch(effectiveAccountId, patch),
+          }),
+        ),
+        `feishu stop hook timeout account=${effectiveAccountId}`,
       );
     } catch (err) {
       const detail = toDetailedErrorText(err);

package/scripts/weixin-stdio-bridge.ts

@@ -64,6 +64,10 @@ function emitRuntimeEvent(
           lastError?: string | null;
         }) => Promise<unknown>)
       | undefined;
+    if (reporter) {
+      void reporter({ accountId, linkStatus, lastError });
+      return;
+    }
     const nowIso = new Date().toISOString();
     sink?.({
       platform: "weixin",
@@ -74,8 +78,6 @@ function emitRuntimeEvent(
       last_event_at: nowIso,
       last_heartbeat_at: nowIso,
     });
-    if (!reporter) return;
-    void reporter({ accountId, linkStatus, lastError });
   } catch {
     // ignore
   }
@@ -278,14 +280,36 @@ function normalizeConfiguredAccountIds(ids: string[]): string[] {
 }
 
 function loadOpenClawConfig(): Record<string, unknown> | null {
+  const runtimeConfig = (globalThis as Record<string, unknown>)
+    .__IM_RUNTIME_CONFIG__;
+  if (
+    runtimeConfig &&
+    typeof runtimeConfig === "object" &&
+    !Array.isArray(runtimeConfig)
+  ) {
+    console.log(
+      "[weixin-stdio-bridge] 从 runtime 内存配置加载，跳过本地 syim fallback",
+    );
+    try {
+      return JSON.parse(JSON.stringify(runtimeConfig)) as Record<string, unknown>;
+    } catch {
+      return { ...(runtimeConfig as Record<string, unknown>) };
+    }
+  }
   const runtimeConfigPath = String(
     (globalThis as Record<string, unknown>).__IM_RUNTIME_CONFIG_PATH__ || "",
   ).trim();
-  const configPaths = [
-    runtimeConfigPath,
-    path.join(getProjectRoot(), "syim.json"),
-    path.join(os.homedir(), ".syim", "syim.json"),
-  ].filter(Boolean);
+  const envConfigPath = String(process.env.OPENCLAW_CONFIG_PATH || "").trim();
+  const configPaths = Array.from(
+    new Set(
+      [
+        envConfigPath,
+        runtimeConfigPath,
+        path.join(os.homedir(), ".syim", "syim.json"),
+        path.join(getProjectRoot(), "syim.json"),
+      ].filter((p) => Boolean(p)),
+    ),
+  );
 
   for (const configPath of configPaths) {
     if (!fs.existsSync(configPath)) continue;
@@ -512,6 +536,30 @@ const bridgeLifecycleLog = {
   warn: (msg: string) => console.warn("[Weixin]", msg),
   error: (msg: string) => console.error("[Weixin][ERR]", msg),
 };
+const bridgeAccountControlTimeoutMs = Math.max(
+  1_000,
+  Number(process.env.RUNTIME_ACCOUNT_CONTROL_TIMEOUT_MS || "10000") || 10000,
+);
+
+async function withBridgeControlTimeout<T>(
+  work: Promise<T>,
+  timeoutMessage: string,
+): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      work,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(timeoutMessage)),
+          bridgeAccountControlTimeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 
 function resolveBridgeAccount(accountId: string): ResolvedAccount | null {
   if (!bridgeCfg) return null;
@@ -600,7 +648,7 @@ async function startSingleAccount(
     account,
     abortSignal: abort.signal,
     log: bridgeLifecycleLog,
-    runtime: bridgeLifecycleLog,
+    runtime: bridgeRuntimeForGateway || bridgeLifecycleLog,
     setStatus: (patch: Record<string, unknown>) =>
       applyBridgeStatusPatch(account.accountId, patch),
   })
@@ -634,15 +682,18 @@ async function stopSingleAccount(
 
   if (typeof bridgeStopAccount === "function" && bridgeCfg) {
     try {
-      await Promise.resolve(
-        bridgeStopAccount({
-          cfg: bridgeCfg,
-          accountId: effectiveAccountId,
-          account,
-          log: bridgeLifecycleLog,
-          setStatus: (patch: Record<string, unknown>) =>
-            applyBridgeStatusPatch(effectiveAccountId, patch),
-        }),
+      await withBridgeControlTimeout(
+        Promise.resolve(
+          bridgeStopAccount({
+            cfg: bridgeCfg,
+            accountId: effectiveAccountId,
+            account,
+            log: bridgeLifecycleLog,
+            setStatus: (patch: Record<string, unknown>) =>
+              applyBridgeStatusPatch(effectiveAccountId, patch),
+          }),
+        ),
+        `weixin stop hook timeout account=${effectiveAccountId}`,
       );
     } catch (err) {
       const detail = toDetailedErrorText(err);