ylib-syim 0.0.13 → 0.0.14

package/bridges/main.ts

@@ -43,7 +43,7 @@ const runtimeErrorLogFallbackLines = Math.max(
 );
 
 type RuntimeBotStatus = {
-  platform: "dingtalk" | "feishu";
+  platform: "dingtalk" | "feishu" | "weixin";
   bot_account_id: string;
   link_status:
     | "connecting"
@@ -70,14 +70,16 @@ let configVersionHash = "";
 let configVersionUpdatedAt = nowIso();
 let runtimeState: "running" | "restarting" = "running";
 let runtimeReady = false;
-let startupOnlyMode: "all" | "dingtalk" | "lark" = "all";
+let startupOnlyMode: "all" | "dingtalk" | "lark" | "weixin" = "all";
 let dingtalkBridgeStarted = false;
 let dingtalkBridgeStarting = false;
 let larkBridgeStarted = false;
 let larkBridgeStarting = false;
+let weixinBridgeStarted = false;
+let weixinBridgeStarting = false;
 let pluginTempHomeDir: string | null = null;
 
-type RuntimeGatewayChannel = "dingtalk" | "feishu";
+type RuntimeGatewayChannel = "dingtalk" | "feishu" | "weixin";
 
 type RuntimeGatewayInvokeResult = {
   ok: boolean;
@@ -157,7 +159,10 @@ function rotateRuntimeInstanceId(): string {
   return runtimeInstanceId;
 }
 
-function keyOf(platform: "dingtalk" | "feishu", accountId: string): string {
+function keyOf(
+  platform: "dingtalk" | "feishu" | "weixin",
+  accountId: string,
+): string {
   return `${platform}:${accountId}`;
 }
 
@@ -263,7 +268,7 @@ function toLogText(value: unknown, limit = 1500): string {
 
 function readRecentBridgeErrorFromLog(
   accountId: string,
-  platform: "dingtalk" | "feishu",
+  platform: "dingtalk" | "feishu" | "weixin",
 ): string | null {
   try {
     const loggerState = (globalThis as Record<string, unknown>)
@@ -280,7 +285,9 @@ function readRecentBridgeErrorFromLog(
     const platformHints =
       platform === "dingtalk"
         ? ["dingtalk-stdio-bridge", "[DingTalk]", "dingtalk"]
-        : ["lark-stdio-bridge", "[Feishu]", "feishu"];
+        : platform === "feishu"
+          ? ["lark-stdio-bridge", "[Feishu]", "feishu"]
+          : ["weixin-stdio-bridge", "[Weixin]", "weixin"];
 
     for (const line of lines) {
       const lower = line.toLowerCase();
@@ -356,7 +363,9 @@ function readRuntimeLogLines(limit: number): {
   }
 }
 
-function clearPlatformStatuses(platform: "dingtalk" | "feishu"): void {
+function clearPlatformStatuses(
+  platform: "dingtalk" | "feishu" | "weixin",
+): void {
   for (const key of Array.from(runtimeStatusRegistry.keys())) {
     if (key.startsWith(`${platform}:`)) {
       runtimeStatusRegistry.delete(key);
@@ -366,7 +375,7 @@ function clearPlatformStatuses(platform: "dingtalk" | "feishu"): void {
 
 function readConfiguredAccountIds(
   cfg: Record<string, unknown>,
-  channelKey: "dingtalk-connector" | "feishu",
+  channelKey: "dingtalk-connector" | "feishu" | "openclaw-weixin",
 ): string[] {
   const channels = (cfg.channels as Record<string, unknown>) || {};
   const channel = channels[channelKey] as Record<string, unknown> | undefined;
@@ -384,13 +393,18 @@ function readConfiguredAccountIds(
 }
 
 function isConfiguredRuntimeAccount(
-  platform: "dingtalk" | "feishu",
+  platform: "dingtalk" | "feishu" | "weixin",
   accountId: string,
 ): boolean {
   if (!accountId) return false;
   const cfg = loadedConfigForRuntime as Record<string, unknown> | null;
   if (!cfg) return false;
-  const channelKey = platform === "dingtalk" ? "dingtalk-connector" : "feishu";
+  const channelKey =
+    platform === "dingtalk"
+      ? "dingtalk-connector"
+      : platform === "feishu"
+        ? "feishu"
+        : "openclaw-weixin";
   const configured = readConfiguredAccountIds(cfg, channelKey);
   if (configured.length === 0) return false;
   return configured.includes(accountId);
@@ -452,9 +466,30 @@ function markConfiguredBotsAsConnecting(config: Record<string, unknown>): void {
       });
     }
   }
+
+  const weixin = channels["openclaw-weixin"] as
+    | Record<string, unknown>
+    | undefined;
+  const weixinAccounts = (weixin?.accounts as Record<string, unknown>) || {};
+  if (Object.keys(weixinAccounts).length > 0) {
+    for (const accountId of Object.keys(weixinAccounts)) {
+      upsertRuntimeStatus({
+        platform: "weixin",
+        bot_account_id: accountId,
+        link_status: "connecting",
+        started_at: nowIso(),
+        last_heartbeat_at: nowIso(),
+        last_error: null,
+        reconnect_count: 0,
+        last_event: "config_loaded",
+        status_source: "manual",
+        last_probe_at: null,
+      });
+    }
+  }
 }
 
-function markPlatformStarted(platform: "dingtalk" | "feishu"): void {
+function markPlatformStarted(platform: "dingtalk" | "feishu" | "weixin"): void {
   for (const [key, value] of runtimeStatusRegistry.entries()) {
     if (!key.startsWith(`${platform}:`)) continue;
     runtimeStatusRegistry.set(key, {
@@ -497,6 +532,7 @@ async function ensureBridgesStartedByConfig(): Promise<void> {
     (startupOnlyMode === "all" || startupOnlyMode === "lark") &&
     isChannelEnabled("feishu") &&
     readChannelAccountCount("feishu") > 0;
+  const canStartWeixin = startupOnlyMode === "all" || startupOnlyMode === "weixin";
 
   const tasks: Array<Promise<void>> = [];
 
@@ -562,11 +598,73 @@ async function ensureBridgesStartedByConfig(): Promise<void> {
     );
   }
 
+  if (!weixinBridgeStarted && !weixinBridgeStarting) {
+    if (canStartWeixin) {
+      weixinBridgeStarting = true;
+      console.log("[bridges/main] starting weixin bridge...");
+      tasks.push(
+        import("./weixin-stdio-bridge.ts")
+          .then(() => {
+            weixinBridgeStarted = true;
+            markPlatformStarted("weixin");
+            console.log("[bridges/main] weixin bridge started");
+          })
+          .catch((err) => {
+            console.error(
+              `[bridges/main] weixin bridge start failed, keep alive: ${(err as Error).message}`,
+            );
+          })
+          .finally(() => {
+            weixinBridgeStarting = false;
+          }),
+      );
+    } else if (startupOnlyMode === "all" || startupOnlyMode === "weixin") {
+      console.log(
+        "[bridges/main] skip weixin bridge start: enabled=false",
+      );
+    }
+  } else {
+    console.log(
+      `[bridges/main] skip weixin bridge start: already_started=${String(weixinBridgeStarted)} starting=${String(weixinBridgeStarting)}`,
+    );
+  }
+
   if (tasks.length > 0) {
     await Promise.all(tasks);
   }
 }
 
+async function ensureWeixinBridgeReadyForGatewayInvoke(): Promise<void> {
+  if (weixinBridgeStarted) {
+    return;
+  }
+  if (!(startupOnlyMode === "all" || startupOnlyMode === "weixin")) {
+    return;
+  }
+  if (weixinBridgeStarting) {
+    const deadline = Date.now() + 5000;
+    while (weixinBridgeStarting && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return;
+  }
+
+  weixinBridgeStarting = true;
+  console.log("[bridges/main] lazy starting weixin bridge for gateway invoke...");
+  try {
+    await import("./weixin-stdio-bridge.ts");
+    weixinBridgeStarted = true;
+    markPlatformStarted("weixin");
+    console.log("[bridges/main] weixin bridge lazy started");
+  } catch (err) {
+    console.error(
+      `[bridges/main] weixin bridge lazy start failed: ${(err as Error).message}`,
+    );
+  } finally {
+    weixinBridgeStarting = false;
+  }
+}
+
 function markAllBotsStopped(reason: string): void {
   for (const [key, value] of runtimeStatusRegistry.entries()) {
     runtimeStatusRegistry.set(key, {
@@ -608,6 +706,9 @@ function normalizeGatewayChannel(input: unknown): RuntimeGatewayChannel | null {
   if (raw === "feishu" || raw === "lark" || raw === "openclaw-lark") {
     return "feishu";
   }
+  if (raw === "weixin" || raw === "openclaw-weixin") {
+    return "weixin";
+  }
   return null;
 }
 
@@ -625,7 +726,9 @@ async function invokeGatewayMethodByChannel(args: {
   const invokerKey =
     args.channel === "dingtalk"
       ? "__IM_DINGTALK_BRIDGE_INVOKE_GATEWAY_METHOD__"
-      : "__IM_LARK_BRIDGE_INVOKE_GATEWAY_METHOD__";
+      : args.channel === "feishu"
+        ? "__IM_LARK_BRIDGE_INVOKE_GATEWAY_METHOD__"
+        : "__IM_WEIXIN_BRIDGE_INVOKE_GATEWAY_METHOD__";
   const invoker = (globalThis as Record<string, unknown>)[invokerKey] as
     | ((payload: {
         method: string;
@@ -634,7 +737,19 @@ async function invokeGatewayMethodByChannel(args: {
       }) => Promise<RuntimeGatewayInvokeResult>)
     | undefined;
 
-  if (typeof invoker !== "function") {
+  if (args.channel === "weixin" && typeof invoker !== "function") {
+    await ensureWeixinBridgeReadyForGatewayInvoke();
+  }
+
+  const ensuredInvoker = (globalThis as Record<string, unknown>)[invokerKey] as
+    | ((payload: {
+        method: string;
+        params?: Record<string, unknown>;
+        accountId?: string;
+      }) => Promise<RuntimeGatewayInvokeResult>)
+    | undefined;
+
+  if (typeof ensuredInvoker !== "function") {
     return {
       ok: false,
       error: `${args.channel} bridge gateway invoker not ready`,
@@ -642,7 +757,7 @@ async function invokeGatewayMethodByChannel(args: {
   }
 
   try {
-    const result = await invoker({
+    const result = await ensuredInvoker({
       method,
       params: args.params || {},
       accountId: args.accountId,
@@ -902,6 +1017,61 @@ async function probeAndRefreshStatuses(): Promise<void> {
   } catch (err) {
     console.error("[bridges/main] feishu probe failed", (err as Error).message);
   }
+
+  try {
+    const configuredIds = readConfiguredAccountIds(cfg, "openclaw-weixin");
+    if (configuredIds.length === 0) {
+      clearPlatformStatuses("weixin");
+    } else {
+      for (const accountId of configuredIds) {
+        const previous = runtimeStatusRegistry.get(keyOf("weixin", accountId));
+        const invoke = await invokeGatewayMethodByChannel({
+          channel: "weixin",
+          method: "weixin.probe",
+          params: { accountId },
+          accountId,
+        });
+        const probeResult =
+          invoke?.result && typeof invoke.result === "object"
+            ? (invoke.result as Record<string, unknown>)
+            : null;
+        const probeOk =
+          invoke?.ok === true &&
+          (!probeResult || probeResult.ok === undefined || probeResult.ok !== false);
+        const probeError = probeResult
+          ? buildDetailedProbeErrorMessage(probeResult)
+          : String(invoke?.error || "").trim();
+        const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(probeError)
+          ? pickMoreSpecificErrorMessage(
+              probeError,
+              readRecentBridgeErrorFromLog(accountId, "weixin"),
+            )
+          : probeError;
+        const linkStatus: RuntimeBotStatus["link_status"] = probeOk
+          ? "connected"
+          : weixinBridgeStarted
+            ? "error"
+            : "connecting";
+        upsertRuntimeStatus({
+          platform: "weixin",
+          bot_account_id: accountId,
+          link_status: linkStatus,
+          started_at: previous?.started_at || nowIso(),
+          last_heartbeat_at: nowIso(),
+          last_error: probeOk
+            ? null
+            : pickMoreSpecificErrorMessage(
+                previous?.last_error || null,
+                probeErrorWithLogFallback || invoke?.error || null,
+              ),
+          status_source: "probe",
+          last_probe_at: nowIso(),
+        });
+      }
+    }
+  } catch (err) {
+    console.error("[bridges/main] weixin probe failed", (err as Error).message);
+  }
 }
 
 function startProbeLoop(): void {
@@ -1208,6 +1378,24 @@ function readEffectiveWhitelistFromConfig(
         "project_id",
       ],
     },
+    "openclaw-weixin": {
+      fields: [
+        "enabled",
+        "botId",
+        "modelName",
+        "agentId",
+        "gatewayBaseUrl",
+        "gatewayToken",
+        "uploadHost",
+      ],
+      runtimeReadonlyFields: [
+        "scopeType",
+        "projectId",
+        "scope_type",
+        "type",
+        "project_id",
+      ],
+    },
   };
   const filePath = process.env.EFFECTIVE_WHITELIST_FILE || "";
   const fromRuntime = runtimeConfig?.effectiveWhitelist;
@@ -1243,7 +1431,9 @@ function normalizeRuntimeConfigByWhitelist(config: Record<string, unknown>): {
         ? "dingtalk-connector"
         : channelKey === "feishu"
           ? "openclaw-lark"
-          : "";
+          : channelKey === "openclaw-weixin"
+            ? "openclaw-weixin"
+            : "";
     if (!pluginId) return new Set();
     const pluginWhitelist = whitelist[pluginId] as Record<string, unknown>;
     const fields = Array.isArray(pluginWhitelist?.fields)
@@ -1338,6 +1528,12 @@ function resolveRawSchema(
     const schema = (cs?.schema as Record<string, unknown>) || {};
     return schema;
   }
+  if (pluginId === "openclaw-weixin") {
+    const p = pluginModule.default as Record<string, unknown> | undefined;
+    const cs = p?.configSchema as Record<string, unknown> | undefined;
+    const schema = (cs?.schema as Record<string, unknown>) || {};
+    return schema;
+  }
   return {};
 }
 
@@ -1402,6 +1598,41 @@ async function getPluginSchemas(): Promise<Array<Record<string, unknown>>> {
       error: (err as Error).message,
     });
   }
+  try {
+    let weixinMod: Record<string, unknown>;
+    try {
+      const weixinPkg = "ylib-openclaw-weixin";
+      weixinMod = (await import(weixinPkg)) as Record<string, unknown>;
+    } catch {
+      weixinMod = (await import("../../openclaw-weixin/index.ts")) as Record<
+        string,
+        unknown
+      >;
+    }
+    const wRawSchema = resolveRawSchema(weixinMod, "openclaw-weixin");
+    result.push({
+      pluginId: "openclaw-weixin",
+      channel: "weixin",
+      rawSchema: wRawSchema,
+      schemaHash: calcSchemaHash(wRawSchema),
+      effectiveWhitelist: (whitelist["openclaw-weixin"] as Record<
+        string,
+        unknown
+      >) || { fields: [] },
+    });
+  } catch (err) {
+    result.push({
+      pluginId: "openclaw-weixin",
+      channel: "weixin",
+      rawSchema: {},
+      schemaHash: calcSchemaHash({}),
+      effectiveWhitelist: (whitelist["openclaw-weixin"] as Record<
+        string,
+        unknown
+      >) || { fields: [] },
+      error: (err as Error).message,
+    });
+  }
   return result;
 }
 
@@ -1820,6 +2051,11 @@ async function startInternalApiServer(): Promise<void> {
             ok: false,
             reason: "control_not_available",
           },
+          weixin: {
+            attempted: false,
+            ok: false,
+            reason: "control_not_available",
+          },
         };
         const dingtalkControl = (globalThis as Record<string, unknown>)
           .__IM_DINGTALK_BRIDGE_CONTROL__ as
@@ -1829,11 +2065,18 @@ async function startInternalApiServer(): Promise<void> {
           .__IM_LARK_BRIDGE_CONTROL__ as
           | { restart?: () => Promise<void>; stop?: () => Promise<void> }
           | undefined;
+        const weixinControl = (globalThis as Record<string, unknown>)
+          .__IM_WEIXIN_BRIDGE_CONTROL__ as
+          | { restart?: () => Promise<void>; stop?: () => Promise<void> }
+          | undefined;
         const shouldSoftRestartDingtalk =
           isChannelEnabled("dingtalk-connector") &&
           readChannelAccountCount("dingtalk-connector") > 0;
         const shouldSoftRestartLark =
           isChannelEnabled("feishu") && readChannelAccountCount("feishu") > 0;
+        const shouldSoftRestartWeixin =
+          isChannelEnabled("openclaw-weixin") &&
+          readChannelAccountCount("openclaw-weixin") > 0;
         if (
           typeof dingtalkControl?.restart === "function" &&
           shouldSoftRestartDingtalk
@@ -1908,6 +2151,43 @@ async function startInternalApiServer(): Promise<void> {
             );
           }
         }
+        if (
+          typeof weixinControl?.restart === "function" &&
+          shouldSoftRestartWeixin
+        ) {
+          console.log("[bridges/main] restart-all step=soft_restart weixin");
+          bridgeSoftRestart.weixin.attempted = true;
+          try {
+            await weixinControl.restart();
+            bridgeSoftRestart.weixin.ok = true;
+            bridgeSoftRestart.weixin.reason = "restarted";
+          } catch (err) {
+            bridgeSoftRestart.weixin.ok = false;
+            bridgeSoftRestart.weixin.reason =
+              err instanceof Error ? err.message : "restart_failed";
+          }
+        } else if (!shouldSoftRestartWeixin) {
+          if (typeof weixinControl?.stop === "function") {
+            console.log(
+              "[bridges/main] restart-all step=soft_restart weixin stop_only: enabled=false or accounts empty",
+            );
+            bridgeSoftRestart.weixin.attempted = true;
+            try {
+              await weixinControl.stop();
+              bridgeSoftRestart.weixin.ok = true;
+              bridgeSoftRestart.weixin.reason = "stopped_no_accounts";
+            } catch (err) {
+              bridgeSoftRestart.weixin.ok = false;
+              bridgeSoftRestart.weixin.reason =
+                err instanceof Error ? err.message : "stop_failed";
+            }
+          } else {
+            bridgeSoftRestart.weixin.reason = "skipped_no_accounts";
+            console.log(
+              "[bridges/main] restart-all step=soft_restart weixin skipped: enabled=false or accounts empty",
+            );
+          }
+        }
         console.log(
           "[bridges/main] restart-all step=ensure_bridges_started begin",
         );
@@ -1998,7 +2278,9 @@ async function startInternalApiServer(): Promise<void> {
       const botAccountId = String(body.bot_account_id || "").trim();
       const linkStatus = String(body.link_status || "").trim();
       if (
-        (platform !== "dingtalk" && platform !== "feishu") ||
+        (platform !== "dingtalk" &&
+          platform !== "feishu" &&
+          platform !== "weixin") ||
         !botAccountId ||
         !linkStatus
       ) {
@@ -2006,7 +2288,7 @@ async function startInternalApiServer(): Promise<void> {
         res.end(JSON.stringify({ ok: false, error: "invalid payload" }));
         return;
       }
-      const p = platform as "dingtalk" | "feishu";
+      const p = platform as "dingtalk" | "feishu" | "weixin";
       if (!isConfiguredRuntimeAccount(p, botAccountId)) {
         console.log(
           `[bridges/main] runtime event ignored: unconfigured account platform=${p} account=${botAccountId}`,
@@ -2072,16 +2354,22 @@ async function startInternalApiServer(): Promise<void> {
 /**
  * 统一桥接入口。
  *
- * 默认同时启动钉钉和飞书两个 bridge。
+ * 默认同时启动钉钉、飞书、微信三个 bridge。
  * 可通过参数控制：
  *   --only=dingtalk
  *   --only=lark
+ *   --only=weixin
  *   --only=all
  */
-function parseOnlyArg(): "all" | "dingtalk" | "lark" {
+function parseOnlyArg(): "all" | "dingtalk" | "lark" | "weixin" {
   const onlyArg = process.argv.find((arg) => arg.startsWith("--only="));
   const onlyValue = (onlyArg?.slice("--only=".length) || "all").toLowerCase();
-  if (onlyValue === "dingtalk" || onlyValue === "lark" || onlyValue === "all") {
+  if (
+    onlyValue === "dingtalk" ||
+    onlyValue === "lark" ||
+    onlyValue === "weixin" ||
+    onlyValue === "all"
+  ) {
     return onlyValue;
   }
   console.warn(

package/bridges/runtime-event-reporter.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
-type Platform = "dingtalk" | "feishu";
+type Platform = "dingtalk" | "feishu" | "weixin";
 
 function loadConfig(): Record<string, unknown> | null {
   const configPaths = [
@@ -26,7 +26,12 @@ function listAccountIds(
   cfg: Record<string, unknown>,
 ): string[] {
   const channels = (cfg.channels as Record<string, unknown>) || {};
-  const channelKey = platform === "dingtalk" ? "dingtalk-connector" : "feishu";
+  const channelKey =
+    platform === "dingtalk"
+      ? "dingtalk-connector"
+      : platform === "feishu"
+        ? "feishu"
+        : "openclaw-weixin";
   const channelCfg = channels[channelKey] as
     | Record<string, unknown>
     | undefined;

package/bridges/weixin-stdio-bridge.ts

@@ -0,0 +1,62 @@
+/**
+ * 主目录入口：微信 stdio bridge。
+ * 真实实现在 scripts 目录，保持与其它 bridge 一致的入口结构。
+ */
+import { setupBridgeLogger } from "./logger.ts";
+import {
+  wireBridgeLifecycleReporter,
+  installConsoleEventHook,
+  reportRuntimeEvent,
+} from "./runtime-event-reporter.ts";
+
+function formatErr(err: unknown): string {
+  if (err instanceof Error) {
+    return `${err.message}\n${err.stack || ""}`.trim();
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+const logFilePath = setupBridgeLogger("weixin-bridge");
+console.log("[weixin-bridge] log file:", logFilePath);
+
+wireBridgeLifecycleReporter("weixin");
+installConsoleEventHook("weixin");
+
+process.on("uncaughtException", (err) => {
+  console.error("[weixin-bridge] uncaughtException:\n" + formatErr(err));
+});
+
+process.on("unhandledRejection", (reason) => {
+  console.error("[weixin-bridge] unhandledRejection:\n" + formatErr(reason));
+});
+
+(globalThis as any).__IM_RUNTIME_EVENT_REPORTER__ = (payload: {
+  accountId: string;
+  linkStatus:
+    | "connecting"
+    | "connected"
+    | "degraded"
+    | "disconnected"
+    | "error";
+  lastError?: string | null;
+}) => {
+  return reportRuntimeEvent(
+    "weixin",
+    payload.accountId,
+    payload.linkStatus,
+    payload.lastError || null,
+  );
+};
+
+try {
+  await import("../scripts/weixin-stdio-bridge.ts");
+} catch (err) {
+  console.error(
+    "[weixin-bridge] failed to load/start script:\n" + formatErr(err),
+  );
+  throw err;
+}

package/package.json

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

package/scripts/weixin-stdio-bridge.ts

@@ -0,0 +1,663 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const CHANNEL_KEY = "openclaw-weixin";
+
+type GatewayMethodHandler = (args: unknown) => Promise<unknown> | unknown;
+
+type WeixinGatewayInvokePayload = {
+  method: string;
+  params?: Record<string, unknown>;
+  accountId?: string;
+};
+
+type WeixinGatewayInvokeResult = {
+  ok: boolean;
+  error?: string;
+  result?: unknown;
+};
+
+type ResolvedAccount = {
+  accountId: string;
+  config: Record<string, unknown>;
+  enabled: boolean;
+};
+
+type WeixinBridgeControl = {
+  stop: () => Promise<void>;
+  restart: () => Promise<void>;
+};
+
+function emitRuntimeEvent(
+  accountId: string,
+  linkStatus:
+    | "connecting"
+    | "connected"
+    | "degraded"
+    | "disconnected"
+    | "error",
+  lastError: string | null = null,
+): void {
+  try {
+    const reporter = (globalThis as any).__IM_RUNTIME_EVENT_REPORTER__ as
+      | ((payload: {
+          accountId: string;
+          linkStatus: string;
+          lastError?: string | null;
+        }) => Promise<unknown>)
+      | undefined;
+    if (!reporter) return;
+    void reporter({ accountId, linkStatus, lastError });
+  } catch {
+    // ignore
+  }
+}
+
+function toDetailedErrorText(err: unknown): string {
+  if (!err) return "unknown error";
+  const asAny = err as any;
+  const message = String(asAny?.message || err || "unknown error").trim();
+  const responseData = asAny?.response?.data;
+  const responseStatus = asAny?.response?.status;
+  const responseStatusText = asAny?.response?.statusText;
+  const code = asAny?.code;
+
+  const details: string[] = [];
+  if (code) details.push(`code=${String(code)}`);
+  if (responseStatus) details.push(`status=${String(responseStatus)}`);
+  if (responseStatusText)
+    details.push(`statusText=${String(responseStatusText)}`);
+  if (responseData !== undefined) {
+    try {
+      details.push(`response=${JSON.stringify(responseData)}`);
+    } catch {
+      details.push(`response=${String(responseData)}`);
+    }
+  }
+
+  const out =
+    details.length > 0 ? `${message}; ${details.join("; ")}` : message;
+  return out.slice(0, 1200);
+}
+
+function getProjectRoot(): string {
+  const main = process.argv[1];
+  if (main) {
+    const resolved = path.resolve(main);
+    const base = path.basename(resolved);
+    if (
+      base === "weixin-stdio-bridge.ts" ||
+      base === "weixin-stdio-bridge.cjs" ||
+      base === "weixin-stdio-bridge.mjs"
+    ) {
+      return path.join(path.dirname(resolved), "..");
+    }
+  }
+  return process.cwd();
+}
+
+function firstStringInAccounts(
+  accounts: Record<string, unknown> | undefined,
+  field: string,
+): string {
+  if (!accounts || typeof accounts !== "object") return "";
+  for (const acc of Object.values(accounts)) {
+    if (!acc || typeof acc !== "object") continue;
+    const value = (acc as Record<string, unknown>)[field];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return "";
+}
+
+function loadOpenClawConfig(): Record<string, unknown> | null {
+  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);
+
+  for (const configPath of configPaths) {
+    if (!fs.existsSync(configPath)) continue;
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content) as Record<string, unknown>;
+      console.log("[weixin-stdio-bridge] config loaded:", configPath);
+      return config;
+    } catch (err) {
+      console.warn(
+        "[weixin-stdio-bridge] failed to read config:",
+        configPath,
+        (err as Error).message,
+      );
+    }
+  }
+  console.log("[weixin-stdio-bridge] no syim.json found, fallback to env");
+  return null;
+}
+
+function buildCfg(): {
+  cfg: Record<string, unknown>;
+  gatewayBaseUrl: string;
+  gatewayToken: string;
+} {
+  const raw = loadOpenClawConfig();
+  const channelConfig = (raw?.channels as Record<string, unknown>)?.[
+    CHANNEL_KEY
+  ] as Record<string, unknown> | undefined;
+
+  const envBase = (
+    process.env.WEIXIN_GATEWAY_URL ||
+    process.env.GATEWAY_URL ||
+    ""
+  ).trim();
+  const accountsMap = channelConfig?.accounts as
+    | Record<string, unknown>
+    | undefined;
+  const fileBase =
+    (channelConfig?.gatewayBaseUrl as string)?.trim() ||
+    firstStringInAccounts(accountsMap, "gatewayBaseUrl") ||
+    "";
+  const gatewayBaseUrl = (envBase || fileBase).replace(/\/+$/, "");
+
+  const gatewayToken = (
+    process.env.WEIXIN_GATEWAY_TOKEN ||
+    process.env.GATEWAY_TOKEN ||
+    process.env.OPENCLAW_GATEWAY_TOKEN ||
+    process.env.OPENCLAW_GATEWAY_API_KEY ||
+    (channelConfig?.gatewayToken as string)?.trim() ||
+    firstStringInAccounts(accountsMap, "gatewayToken") ||
+    ""
+  ).trim();
+
+  let cfg: Record<string, unknown>;
+  if (channelConfig) {
+    const base = { ...channelConfig } as Record<string, unknown>;
+    const accounts = base.accounts as
+      | Record<string, Record<string, unknown>>
+      | undefined;
+    delete base.accounts;
+    if (gatewayBaseUrl) {
+      base.gatewayBaseUrl = gatewayBaseUrl;
+    }
+    if (gatewayToken) base.gatewayToken = gatewayToken;
+
+    if (accounts && typeof accounts === "object") {
+      const merged: Record<string, Record<string, unknown>> = {};
+      for (const [id, acc] of Object.entries(accounts)) {
+        if (!acc || typeof acc !== "object") continue;
+        const accObj = acc as Record<string, unknown>;
+        merged[id] = {
+          ...base,
+          ...accObj,
+          ...(!accObj.gatewayBaseUrl ? { gatewayBaseUrl } : {}),
+          ...(!accObj.gatewayToken && gatewayToken ? { gatewayToken } : {}),
+        };
+        if (!gatewayBaseUrl) {
+          delete merged[id].gatewayBaseUrl;
+        }
+      }
+      cfg = {
+        channels: {
+          [CHANNEL_KEY]: {
+            ...base,
+            accounts: merged,
+          },
+        },
+        ...(raw?.bindings ? { bindings: raw.bindings } : {}),
+      };
+    } else {
+      cfg = {
+        channels: {
+          [CHANNEL_KEY]: base,
+        },
+        ...(raw?.bindings ? { bindings: raw.bindings } : {}),
+      };
+    }
+  } else {
+    cfg = {
+      channels: {
+        [CHANNEL_KEY]: {
+            ...(gatewayBaseUrl ? { gatewayBaseUrl } : {}),
+          gatewayToken: gatewayToken || undefined,
+          modelName: "main",
+          agentId: "main",
+        },
+      },
+    };
+  }
+
+  console.log(
+    "[weixin-stdio-bridge] gatewayBaseUrl =",
+    gatewayBaseUrl || "<absent>",
+  );
+  console.log(
+    "[weixin-stdio-bridge] gatewayToken =",
+    gatewayToken ? "<present>" : "<absent>",
+  );
+
+  return { cfg, gatewayBaseUrl, gatewayToken };
+}
+
+function buildMinimalRuntime(
+  cfg: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    version: process.env.OPENCLAW_HOST_VERSION || "2026.3.22",
+    log: (...args: unknown[]) => console.log("[Weixin]", ...args),
+    error: (...args: unknown[]) => console.error("[Weixin][ERR]", ...args),
+    exit: (code: number) => process.exit(code),
+    gateway: { port: 0 },
+    config: {
+      loadConfig: () => cfg,
+      featureFlags: {},
+    },
+    channel: {
+      commands: {
+        shouldComputeCommandAuthorized: () => false,
+        resolveCommandAuthorizedFromAuthorizers: async () => false,
+        isControlCommandMessage: () => false,
+      },
+      routing: {
+        resolveAgentRoute: ({ accountId, peer }: any) => {
+          const peerId = String(peer?.id || "").trim() || "unknown";
+          const account =
+            String(accountId || "__default__").trim() || "__default__";
+          const sessionKey = `weixin:${account}:${peerId}`;
+          return {
+            agentId: "main",
+            sessionKey,
+            mainSessionKey: sessionKey,
+          };
+        },
+      },
+      session: {
+        resolveStorePath: () => "",
+        recordInboundSession: async () => {},
+      },
+      reply: {
+        finalizeInboundContext: (ctx: unknown) => ctx,
+        resolveHumanDelayConfig: () => null,
+        createReplyDispatcherWithTyping: () => ({
+          dispatcher: {
+            sendFinalReply: () => false,
+            sendBlockReply: () => false,
+            sendToolResult: () => false,
+            waitForIdle: async () => {},
+            getQueuedCounts: () => ({}),
+            markComplete: () => {},
+          },
+          replyOptions: {},
+          markDispatchIdle: () => {},
+        }),
+        withReplyDispatcher: async ({
+          run,
+        }: {
+          run: () => Promise<unknown>;
+        }) => {
+          await run();
+        },
+        dispatchReplyFromConfig: async () => {},
+      },
+      activity: {
+        record: () => {},
+      },
+    },
+    system: {
+      enqueueSystemEvent: () => {},
+    },
+    messages: {
+      groupChat: { historyLimit: 0 },
+    },
+  };
+}
+
+const gatewayMethodHandlers = new Map<string, GatewayMethodHandler>();
+let bridgeRuntimeForGateway: Record<string, unknown> | null = null;
+const bridgeGatewayLog = {
+  info: (msg: string) => console.log("[Weixin][GatewayMethod]", msg),
+  warn: (msg: string) => console.warn("[Weixin][GatewayMethod]", msg),
+  error: (msg: string) => console.error("[Weixin][GatewayMethod]", msg),
+};
+
+const activeAbortControllers = new Map<string, AbortController>();
+let bridgeCfg: Record<string, unknown> | null = null;
+let bridgeGatewayBaseUrl = "";
+let bridgeGatewayToken = "";
+let bridgeStartAccount: ((ctx: unknown) => Promise<unknown>) | null = null;
+let bridgeListAccountIds: ((cfg: unknown) => string[]) | undefined;
+let bridgeResolveAccount: ((cfg: unknown, id?: string) => unknown) | undefined;
+let bridgeIsConfigured: ((a: unknown) => boolean) | undefined;
+let bridgeRestarting = false;
+
+async function invokeGatewayMethod(
+  payload: WeixinGatewayInvokePayload,
+): Promise<WeixinGatewayInvokeResult> {
+  if (!bridgeCfg) {
+    return { ok: false, error: "weixin bridge config not ready" };
+  }
+
+  const method = String(payload?.method || "").trim();
+  if (!method) {
+    return { ok: false, error: "method is required" };
+  }
+
+  const handler = gatewayMethodHandlers.get(method);
+  if (!handler) {
+    return { ok: false, error: `gateway method not registered: ${method}` };
+  }
+
+  const params =
+    payload?.params && typeof payload.params === "object" ? payload.params : {};
+  const accountId = String(
+    (params as Record<string, unknown>).accountId || payload?.accountId || "",
+  ).trim();
+
+  let hasResponded = false;
+  let responseOk = false;
+  let responseData: unknown = undefined;
+  const respond = (ok: boolean, data?: unknown) => {
+    hasResponded = true;
+    responseOk = Boolean(ok);
+    responseData = data;
+  };
+
+  try {
+    await Promise.resolve(
+      handler({
+        respond,
+        cfg: bridgeCfg,
+        params,
+        accountId: accountId || undefined,
+        log: bridgeGatewayLog,
+        runtime: bridgeRuntimeForGateway,
+      }),
+    );
+
+    if (hasResponded) {
+      if (responseOk) {
+        return { ok: true, result: responseData };
+      }
+      const errText =
+        responseData && typeof responseData === "object"
+          ? String(
+              (responseData as Record<string, unknown>).error ||
+                "gateway method call failed",
+            )
+          : "gateway method call failed";
+      return { ok: false, error: errText, result: responseData };
+    }
+
+    return { ok: true, result: {} };
+  } catch (err) {
+    return {
+      ok: false,
+      error: toDetailedErrorText(err),
+    };
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function stopAllAccounts(reason: string): Promise<void> {
+  const entries = Array.from(activeAbortControllers.entries());
+  activeAbortControllers.clear();
+  for (const [accountId, controller] of entries) {
+    try {
+      controller.abort();
+      emitRuntimeEvent(accountId, "disconnected", reason);
+    } catch (err) {
+      const detail = toDetailedErrorText(err);
+      console.warn(
+        `[weixin-stdio-bridge] stop account failed accountId=${accountId} err=${detail}`,
+      );
+    }
+  }
+}
+
+async function startConfiguredAccounts(): Promise<void> {
+  if (!bridgeCfg || !bridgeStartAccount) return;
+  const cfg = bridgeCfg;
+  const startAccount = bridgeStartAccount;
+  const listAccountIds = bridgeListAccountIds;
+  const resolveAccount = bridgeResolveAccount;
+  const isConfigured = bridgeIsConfigured;
+
+  const accountIds = listAccountIds ? listAccountIds(cfg) : ["__default__"];
+  if (accountIds.length === 0) {
+    console.warn("[weixin-stdio-bridge] no account found");
+    return;
+  }
+
+  const log = {
+    info: (msg: string) => console.log("[Weixin]", msg),
+    warn: (msg: string) => console.warn("[Weixin]", msg),
+    error: (msg: string) => console.error("[Weixin][ERR]", msg),
+  };
+
+  const cfgChannels = (cfg as Record<string, unknown>).channels as
+    | Record<string, unknown>
+    | undefined;
+  const defaultAccount: ResolvedAccount = {
+    accountId: "__default__",
+    config: (cfgChannels?.[CHANNEL_KEY] as Record<string, unknown>) ?? {},
+    enabled: true,
+  };
+
+  let startedCount = 0;
+  for (const accountId of accountIds) {
+    const account: ResolvedAccount = (
+      resolveAccount ? resolveAccount(cfg, accountId) : defaultAccount
+    ) as ResolvedAccount;
+
+    if (!account?.enabled) {
+      emitRuntimeEvent(accountId, "disconnected", "account disabled");
+      continue;
+    }
+    if (isConfigured && !isConfigured(account)) {
+      emitRuntimeEvent(accountId, "error", "account not configured");
+      continue;
+    }
+
+    const accConfig = (account as { config?: Record<string, unknown> }).config;
+    if (accConfig && typeof accConfig === "object") {
+      if (!accConfig.gatewayBaseUrl && bridgeGatewayBaseUrl)
+        accConfig.gatewayBaseUrl = bridgeGatewayBaseUrl;
+      if (bridgeGatewayToken && !accConfig.gatewayToken) {
+        accConfig.gatewayToken = bridgeGatewayToken;
+      }
+      if (!accConfig.botId) {
+        accConfig.botId = account.accountId;
+      }
+    }
+
+    emitRuntimeEvent(account.accountId, "connecting", null);
+    const abort = new AbortController();
+    activeAbortControllers.set(account.accountId, abort);
+    startAccount({
+      cfg,
+      accountId: account.accountId,
+      account,
+      abortSignal: abort.signal,
+      log,
+      runtime: log,
+    }).catch((err: unknown) => {
+      const detail = toDetailedErrorText(err);
+      log.error(`[${account.accountId}] start failed: ${detail}`);
+      emitRuntimeEvent(account.accountId, "error", detail);
+    });
+    emitRuntimeEvent(account.accountId, "connected", null);
+    startedCount++;
+  }
+
+  console.log(
+    `[weixin-stdio-bridge] started accounts=${startedCount} total=${accountIds.length}`,
+  );
+}
+
+async function importWeixinModule(): Promise<Record<string, unknown>> {
+  try {
+    const weixinPkg = "ylib-openclaw-weixin";
+    return (await import(weixinPkg)) as Record<string, unknown>;
+  } catch (err) {
+    console.warn(
+      `[weixin-stdio-bridge] import ylib-openclaw-weixin failed, fallback to local source: ${String(err)}`,
+    );
+    return (await import("../../openclaw-weixin/index.ts")) as Record<
+      string,
+      unknown
+    >;
+  }
+}
+
+async function main(): Promise<void> {
+  const { cfg, gatewayBaseUrl, gatewayToken } = buildCfg();
+
+  const channels = (cfg as Record<string, unknown>).channels as
+    | Record<string, unknown>
+    | undefined;
+  const channelEntry = channels?.[CHANNEL_KEY];
+  if (channelEntry && typeof channelEntry === "object") {
+    if (gatewayBaseUrl) {
+      (channelEntry as Record<string, unknown>).gatewayBaseUrl = gatewayBaseUrl;
+    }
+    if (gatewayToken) {
+      (channelEntry as Record<string, unknown>).gatewayToken = gatewayToken;
+    }
+  }
+
+  const runtime = buildMinimalRuntime(cfg);
+  const pluginModule = await importWeixinModule();
+  const plugin = pluginModule.default as
+    | {
+        register?: (api: unknown) => void;
+      }
+    | undefined;
+
+  if (typeof plugin?.register !== "function") {
+    console.error(
+      JSON.stringify({ error: "openclaw-weixin default.register is missing" }),
+    );
+    process.exit(1);
+  }
+
+  let registeredChannelPlugin: Record<string, unknown> | null = null;
+  bridgeRuntimeForGateway = runtime;
+
+  plugin.register({
+    runtime,
+    registerChannel: ({ plugin: channelPlugin }: { plugin: unknown }) => {
+      if (channelPlugin && typeof channelPlugin === "object") {
+        registeredChannelPlugin = channelPlugin as Record<string, unknown>;
+      }
+    },
+    registerGatewayMethod: (method: string, handler: GatewayMethodHandler) => {
+      const methodName = String(method || "").trim();
+      if (!methodName || typeof handler !== "function") return;
+      gatewayMethodHandlers.set(methodName, handler);
+      console.log(
+        `[weixin-stdio-bridge] gateway method registered: ${methodName}`,
+      );
+    },
+    registerTool: () => {},
+    registerCommand: () => {},
+    registerCli: () => {},
+    on: () => {},
+    config: cfg,
+    logger: {
+      info: (...args: unknown[]) => console.log("[Weixin]", ...args),
+      warn: (...args: unknown[]) => console.warn("[Weixin]", ...args),
+      error: (...args: unknown[]) => console.error("[Weixin][ERR]", ...args),
+      debug: () => {},
+    },
+  });
+
+  if (!registeredChannelPlugin) {
+    console.error(
+      JSON.stringify({
+        error: "openclaw-weixin channel plugin not registered",
+      }),
+    );
+    process.exit(1);
+    return;
+  }
+
+  const channelPlugin = registeredChannelPlugin as Record<string, unknown>;
+
+  const configApi = (channelPlugin["config"] as Record<string, unknown>) || {};
+  const gatewayApi =
+    (channelPlugin["gateway"] as Record<string, unknown>) || {};
+
+  const listAccountIds = configApi.listAccountIds as
+    | ((cfg: unknown) => string[])
+    | undefined;
+  const resolveAccount = configApi.resolveAccount as
+    | ((cfg: unknown, accountId?: string) => unknown)
+    | undefined;
+  const isConfigured = configApi.isConfigured as
+    | ((a: unknown) => boolean)
+    | undefined;
+  const startAccount = gatewayApi.startAccount as
+    | ((ctx: unknown) => Promise<unknown>)
+    | undefined;
+
+  if (typeof startAccount !== "function") {
+    console.error(
+      JSON.stringify({
+        error: "openclaw-weixin gateway.startAccount is missing",
+      }),
+    );
+    process.exit(1);
+  }
+
+  bridgeCfg = cfg;
+  bridgeGatewayBaseUrl = gatewayBaseUrl;
+  bridgeGatewayToken = gatewayToken;
+  bridgeStartAccount = startAccount;
+  bridgeListAccountIds = listAccountIds;
+  bridgeResolveAccount = resolveAccount;
+  bridgeIsConfigured = isConfigured;
+
+  const control: WeixinBridgeControl = {
+    stop: async () => {
+      await stopAllAccounts("manual_stop");
+    },
+    restart: async () => {
+      if (bridgeRestarting) return;
+      bridgeRestarting = true;
+      try {
+        const latest = buildCfg();
+        bridgeCfg = latest.cfg;
+        bridgeGatewayBaseUrl = latest.gatewayBaseUrl;
+        bridgeGatewayToken = latest.gatewayToken;
+        await stopAllAccounts("soft_restart");
+        await sleep(250);
+        await startConfiguredAccounts();
+      } finally {
+        bridgeRestarting = false;
+      }
+    },
+  };
+
+  (globalThis as Record<string, unknown>).__IM_WEIXIN_BRIDGE_CONTROL__ =
+    control;
+  (
+    globalThis as Record<string, unknown>
+  ).__IM_WEIXIN_BRIDGE_INVOKE_GATEWAY_METHOD__ = invokeGatewayMethod;
+
+  await startConfiguredAccounts();
+}
+
+main().catch((err) => {
+  const detail = toDetailedErrorText(err);
+  emitRuntimeEvent("__default__", "error", detail);
+  console.error("[weixin-stdio-bridge]", err);
+  process.exit(1);
+});