ylib-syim 0.0.9 → 0.0.11

package/bridges/main.ts

@@ -61,7 +61,10 @@ type RuntimeBotStatus = {
 };
 
 const runtimeStatusRegistry = new Map<string, RuntimeBotStatus>();
-let loadedConfigForRuntime: Record<string, unknown> | null = { "channels": {}, "bindings": [] } as { channels: Record<string, unknown>; bindings: any[] };;
+let loadedConfigForRuntime: Record<string, unknown> | null = {
+  channels: {},
+  bindings: [],
+} as { channels: Record<string, unknown>; bindings: any[] };
 let loadedConfigPathForRuntime: string | null = null;
 let configVersionHash = "";
 let configVersionUpdatedAt = nowIso();
@@ -74,6 +77,14 @@ let larkBridgeStarted = false;
 let larkBridgeStarting = false;
 let pluginTempHomeDir: string | null = null;
 
+type RuntimeGatewayChannel = "dingtalk" | "feishu";
+
+type RuntimeGatewayInvokeResult = {
+  ok: boolean;
+  error?: string;
+  result?: unknown;
+};
+
 function pluginHomeConfigPayload(
   cfg: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -109,7 +120,9 @@ function applyRemoteRuntimeConfigToPluginHome(): void {
     if (!fs.existsSync(syimDir)) {
       fs.mkdirSync(syimDir, { recursive: true });
     } else {
-      console.log(`[bridges/main] plugin temp HOME syim dir exists: ${syimDir}`);
+      console.log(
+        `[bridges/main] plugin temp HOME syim dir exists: ${syimDir}`,
+      );
     }
     fs.writeFileSync(syimPath, payload, "utf-8");
     const openclawDir = path.join(pluginTempHomeDir, ".openclaw");
@@ -117,11 +130,14 @@ function applyRemoteRuntimeConfigToPluginHome(): void {
     if (!fs.existsSync(openclawDir)) {
       fs.mkdirSync(openclawDir, { recursive: true });
     } else {
-      console.log(`[bridges/main] plugin temp HOME openclaw dir exists: ${openclawDir}`);
+      console.log(
+        `[bridges/main] plugin temp HOME openclaw dir exists: ${openclawDir}`,
+      );
     }
     fs.writeFileSync(openclawPath, payload, "utf-8");
     process.env.HOME = pluginTempHomeDir;
-    if (process.platform === "win32") process.env.USERPROFILE = pluginTempHomeDir;
+    if (process.platform === "win32")
+      process.env.USERPROFILE = pluginTempHomeDir;
     console.log(
       `[bridges/main] plugin temp HOME ready home=${pluginTempHomeDir} syim=${syimPath} openclaw=${openclawPath}`,
     );
@@ -584,6 +600,65 @@ async function readRequestJson(
   });
 }
 
+function normalizeGatewayChannel(input: unknown): RuntimeGatewayChannel | null {
+  const raw = String(input || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "dingtalk" || raw === "dingtalk-connector") return "dingtalk";
+  if (raw === "feishu" || raw === "lark" || raw === "openclaw-lark") {
+    return "feishu";
+  }
+  return null;
+}
+
+async function invokeGatewayMethodByChannel(args: {
+  channel: RuntimeGatewayChannel;
+  method: string;
+  params?: Record<string, unknown>;
+  accountId?: string;
+}): Promise<RuntimeGatewayInvokeResult> {
+  const method = String(args.method || "").trim();
+  if (!method) {
+    return { ok: false, error: "method is required" };
+  }
+
+  const invokerKey =
+    args.channel === "dingtalk"
+      ? "__IM_DINGTALK_BRIDGE_INVOKE_GATEWAY_METHOD__"
+      : "__IM_LARK_BRIDGE_INVOKE_GATEWAY_METHOD__";
+  const invoker = (globalThis as Record<string, unknown>)[invokerKey] as
+    | ((payload: {
+        method: string;
+        params?: Record<string, unknown>;
+        accountId?: string;
+      }) => Promise<RuntimeGatewayInvokeResult>)
+    | undefined;
+
+  if (typeof invoker !== "function") {
+    return {
+      ok: false,
+      error: `${args.channel} bridge gateway invoker not ready`,
+    };
+  }
+
+  try {
+    const result = await invoker({
+      method,
+      params: args.params || {},
+      accountId: args.accountId,
+    });
+    if (!result || typeof result !== "object") {
+      return { ok: false, error: "invalid gateway invoke response" };
+    }
+    return result;
+  } catch (err) {
+    return {
+      ok: false,
+      error: (err as Error).message || "gateway method invoke failed",
+    };
+  }
+}
+
 async function probeAndRefreshStatuses(): Promise<void> {
   if (!loadedConfigForRuntime) return;
   const cfg = loadedConfigForRuntime;
@@ -615,6 +690,7 @@ async function probeAndRefreshStatuses(): Promise<void> {
       const probe = statusApi?.probe as
         | ((args: {
             cfg: Record<string, unknown>;
+            accountId: string;
           }) => Promise<Record<string, unknown>>)
         | undefined;
       const probeAccount = statusApi?.probeAccount as
@@ -623,7 +699,7 @@ async function probeAndRefreshStatuses(): Promise<void> {
           }) => Promise<Record<string, unknown>>)
         | undefined;
 
-      if (listAccountIds && probe) {
+      if (listAccountIds) {
         const ids = configuredIds;
         if (resolveAccount && probeAccount) {
           for (const accountId of ids) {
@@ -690,15 +766,15 @@ async function probeAndRefreshStatuses(): Promise<void> {
               });
             }
           }
-        } else {
-          const probeResult = await probe({ cfg });
-          const ok = Boolean(probeResult?.ok);
-          if (!ok) {
-            console.error(
-              `[bridges/main] dingtalk probe failed raw=${toLogText(probeResult)}`,
-            );
-          }
+        } else if (probe) {
           for (const accountId of ids) {
+            const probeResult = await probe({ cfg, accountId });
+            const ok = Boolean(probeResult?.ok);
+            if (!ok) {
+              console.error(
+                `[bridges/main] dingtalk probe failed raw=${toLogText(probeResult)}`,
+              );
+            }
             const previous = runtimeStatusRegistry.get(
               keyOf("dingtalk", accountId),
             );
@@ -1354,10 +1430,7 @@ async function startInternalApiServer(): Promise<void> {
       );
       return;
     }
-    if (
-      req.method === "GET" &&
-      reqUrl.pathname === "/internal/runtime/logs"
-    ) {
+    if (req.method === "GET" && reqUrl.pathname === "/internal/runtime/logs") {
       const limitRaw = String(reqUrl.searchParams.get("limit") || "100").trim();
       const requestedLimit = Number(limitRaw) || 100;
       const clampedLimit = Math.max(1, Math.min(1000, requestedLimit));
@@ -1397,6 +1470,51 @@ async function startInternalApiServer(): Promise<void> {
       );
       return;
     }
+    if (
+      req.method === "POST" &&
+      (reqUrl.pathname === "/internal/runtime/gateway-method/invoke" ||
+        reqUrl.pathname === "/internal/runtime/plugins/gateway-method/invoke")
+    ) {
+      const body = await readRequestJson(req);
+      const channel = normalizeGatewayChannel(body.channel);
+      const method = String(body.method || "").trim();
+      const params =
+        body.params &&
+        typeof body.params === "object" &&
+        !Array.isArray(body.params)
+          ? (body.params as Record<string, unknown>)
+          : {};
+      const accountId = String(body.accountId || body.account_id || "").trim();
+
+      if (!channel || !method) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: "channel and method are required",
+          }),
+        );
+        return;
+      }
+
+      const invokeResult = await invokeGatewayMethodByChannel({
+        channel,
+        method,
+        params,
+        accountId: accountId || undefined,
+      });
+
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          ...invokeResult,
+          channel,
+          method,
+          runtime_instance_id: runtimeInstanceId,
+        }),
+      );
+      return;
+    }
     if (
       req.method === "POST" &&
       reqUrl.pathname === "/internal/runtime/config/reload"
@@ -1559,12 +1677,12 @@ async function startInternalApiServer(): Promise<void> {
       reqUrl.pathname === "/internal/runtime/restart-all"
     ) {
       const body = await readRequestJson(req);
-      const restartModeRaw = String(body.mode || "").trim().toLowerCase();
+      const restartModeRaw = String(body.mode || "")
+        .trim()
+        .toLowerCase();
       const restartMode = restartModeRaw === "full" ? "full" : "soft";
       // 重启流程：显式 stop 标记 -> 拉取并落盘配置 -> 进入 connecting -> 等待状态收敛。
-      console.log(
-        `[bridges/main] restart-all requested mode=${restartMode}`,
-      );
+      console.log(`[bridges/main] restart-all requested mode=${restartMode}`);
       const restartRequestAt = nowIso();
       console.log(
         `[bridges/main] restart-all step=enter at=${restartRequestAt} runtime_state=${runtimeState} instance=${runtimeInstanceId}`,
@@ -1655,9 +1773,7 @@ async function startInternalApiServer(): Promise<void> {
           );
         }
         if (loadedConfigForRuntime) {
-          console.log(
-            "[bridges/main] restart-all step=mark_connecting begin",
-          );
+          console.log("[bridges/main] restart-all step=mark_connecting begin");
           markConfiguredBotsAsConnecting(loadedConfigForRuntime);
           console.log(
             `[bridges/main] restart-all step=mark_connecting done total=${summarizeBots().total}`,
@@ -1688,7 +1804,10 @@ async function startInternalApiServer(): Promise<void> {
           readChannelAccountCount("dingtalk-connector") > 0;
         const shouldSoftRestartLark =
           isChannelEnabled("feishu") && readChannelAccountCount("feishu") > 0;
-        if (typeof dingtalkControl?.restart === "function" && shouldSoftRestartDingtalk) {
+        if (
+          typeof dingtalkControl?.restart === "function" &&
+          shouldSoftRestartDingtalk
+        ) {
           console.log("[bridges/main] restart-all step=soft_restart dingtalk");
           bridgeSoftRestart.dingtalk.attempted = true;
           try {
@@ -1722,7 +1841,10 @@ async function startInternalApiServer(): Promise<void> {
             );
           }
         }
-        if (typeof larkControl?.restart === "function" && shouldSoftRestartLark) {
+        if (
+          typeof larkControl?.restart === "function" &&
+          shouldSoftRestartLark
+        ) {
           console.log("[bridges/main] restart-all step=soft_restart lark");
           bridgeSoftRestart.lark.attempted = true;
           try {
@@ -1766,7 +1888,9 @@ async function startInternalApiServer(): Promise<void> {
           );
         } catch (err) {
           const msg =
-            err instanceof Error ? err.message : "ensure bridges started failed";
+            err instanceof Error
+              ? err.message
+              : "ensure bridges started failed";
           console.error(
             `[bridges/main] restart-all step=ensure_bridges_started failed err=${msg}`,
           );
@@ -2002,9 +2126,7 @@ function printConfigBootstrapGuide(): void {
     "- channels.feishu.accounts.<id>.appId/appSecret: 飞书应用凭据。",
   );
   console.log("- channels.feishu.accounts.<id>.gatewayBaseUrl: 网关地址。");
-  console.log(
-    "- channels.feishu.accounts.<id>.gatewayToken: 网关鉴权 token。",
-  );
+  console.log("- channels.feishu.accounts.<id>.gatewayToken: 网关鉴权 token。");
   console.log(
     "- channels.feishu.accounts.<id>.dmPolicy/allowFrom: 私聊与来源策略。",
   );

package/package.json

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

package/scripts/dingtalk-stdio-bridge.ts

@@ -16,6 +16,19 @@ import os from "node:os";
 import path from "node:path";
 
 const CHANNEL_KEY = "dingtalk-connector";
+type GatewayMethodHandler = (args: unknown) => Promise<unknown> | unknown;
+
+type DingtalkGatewayInvokePayload = {
+  method: string;
+  params?: Record<string, unknown>;
+  accountId?: string;
+};
+
+type DingtalkGatewayInvokeResult = {
+  ok: boolean;
+  error?: string;
+  result?: unknown;
+};
 
 function emitRuntimeEvent(
   accountId: string,
@@ -299,6 +312,14 @@ type DingtalkBridgeControl = {
   restart: () => Promise<void>;
 };
 
+const gatewayMethodHandlers = new Map<string, GatewayMethodHandler>();
+let bridgeRuntimeForGateway: Record<string, unknown> | null = null;
+const bridgeGatewayLog = {
+  info: (msg: string) => console.log("[DingTalk][GatewayMethod]", msg),
+  warn: (msg: string) => console.warn("[DingTalk][GatewayMethod]", msg),
+  error: (msg: string) => console.error("[DingTalk][GatewayMethod]", msg),
+};
+
 const activeAbortControllers = new Map<string, AbortController>();
 let bridgeCfg: Record<string, unknown> | null = null;
 let bridgeGatewayBaseUrl = "";
@@ -309,6 +330,73 @@ let bridgeResolveAccount: ((cfg: unknown, id?: string) => unknown) | undefined;
 let bridgeIsConfigured: ((a: unknown) => boolean) | undefined;
 let bridgeRestarting = false;
 
+async function invokeGatewayMethod(
+  payload: DingtalkGatewayInvokePayload,
+): Promise<DingtalkGatewayInvokeResult> {
+  if (!bridgeCfg) {
+    return { ok: false, error: "dingtalk 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));
 }
@@ -448,10 +536,18 @@ async function main(): Promise<void> {
     );
     process.exit(1);
   }
+  bridgeRuntimeForGateway = runtime as Record<string, unknown>;
   plugin.register({
     runtime,
     registerChannel: () => {},
-    registerGatewayMethod: () => {},
+    registerGatewayMethod: (method: string, handler: GatewayMethodHandler) => {
+      const methodName = String(method || "").trim();
+      if (!methodName || typeof handler !== "function") return;
+      gatewayMethodHandlers.set(methodName, handler);
+      console.log(
+        `[dingtalk-stdio-bridge] gateway method registered: ${methodName}`,
+      );
+    },
   });
   console.log(
     "[dingtalk-stdio-bridge] 插件与 connector 匹配: 已调用 plugin.register(api)",
@@ -502,6 +598,9 @@ async function main(): Promise<void> {
   };
   (globalThis as Record<string, unknown>).__IM_DINGTALK_BRIDGE_CONTROL__ =
     control;
+  (
+    globalThis as Record<string, unknown>
+  ).__IM_DINGTALK_BRIDGE_INVOKE_GATEWAY_METHOD__ = invokeGatewayMethod;
   await startConfiguredAccounts();
 }
 

package/scripts/lark-stdio-bridge.ts

@@ -25,6 +25,19 @@ import os from "node:os";
 import path from "node:path";
 
 const CHANNEL_KEY = "feishu";
+type GatewayMethodHandler = (args: unknown) => Promise<unknown> | unknown;
+
+type LarkGatewayInvokePayload = {
+  method: string;
+  params?: Record<string, unknown>;
+  accountId?: string;
+};
+
+type LarkGatewayInvokeResult = {
+  ok: boolean;
+  error?: string;
+  result?: unknown;
+};
 
 function emitRuntimeEvent(
   accountId: string,
@@ -373,17 +386,95 @@ type LarkBridgeControl = {
   restart: () => Promise<void>;
 };
 
+const gatewayMethodHandlers = new Map<string, GatewayMethodHandler>();
+let gatewayRuntimeForMethods: unknown = null;
+const gatewayMethodLog = {
+  info: (msg: string) => console.log("[Feishu][GatewayMethod]", msg),
+  warn: (msg: string) => console.warn("[Feishu][GatewayMethod]", msg),
+  error: (msg: string) => console.error("[Feishu][GatewayMethod]", msg),
+};
+
 let currentAbortController: AbortController | null = null;
 let currentMonitorPromise: Promise<void> | null = null;
 let currentCfg: Record<string, unknown> | null = null;
 let currentGatewayBaseUrl = "";
 let currentAccountIds: string[] = [];
-let currentRuntime: { log: (...args: unknown[]) => void; error: (...args: unknown[]) => void; exit: (code: number) => void } | null = null;
-let currentMonitorFeishuProvider:
-  | ((opts: unknown) => Promise<void>)
-  | null = null;
+let currentRuntime: {
+  log: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  exit: (code: number) => void;
+} | null = null;
+let currentMonitorFeishuProvider: ((opts: unknown) => Promise<void>) | null =
+  null;
 let bridgeRestarting = false;
 
+async function invokeGatewayMethod(
+  payload: LarkGatewayInvokePayload,
+): Promise<LarkGatewayInvokeResult> {
+  if (!currentCfg) {
+    return { ok: false, error: "feishu 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: currentCfg,
+        params,
+        accountId: accountId || undefined,
+        runtime: gatewayRuntimeForMethods,
+        log: gatewayMethodLog,
+      }),
+    );
+
+    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),
+    };
+  }
+}
+
 async function stopMonitor(reason: string): Promise<void> {
   const controller = currentAbortController;
   currentAbortController = null;
@@ -460,6 +551,7 @@ async function main(): Promise<void> {
     larkModule as { default?: { register?: (api: unknown) => void } }
   ).default;
   const minimalRuntime = buildMinimalRuntime(cfg);
+  gatewayRuntimeForMethods = minimalRuntime;
 
   if (typeof plugin?.register === "function") {
     plugin.register({
@@ -468,7 +560,17 @@ async function main(): Promise<void> {
       registerChannel: () => {},
       registerTool: () => {},
       registerCommand: () => {},
-      registerGatewayMethod: () => {},
+      registerGatewayMethod: (
+        method: string,
+        handler: GatewayMethodHandler,
+      ) => {
+        const methodName = String(method || "").trim();
+        if (!methodName || typeof handler !== "function") return;
+        gatewayMethodHandlers.set(methodName, handler);
+        console.log(
+          `[lark-stdio-bridge] gateway method registered: ${methodName}`,
+        );
+      },
       registerCli: () => {},
       on: () => {},
       config: cfg,
@@ -539,6 +641,9 @@ async function main(): Promise<void> {
     },
   };
   (globalThis as Record<string, unknown>).__IM_LARK_BRIDGE_CONTROL__ = control;
+  (
+    globalThis as Record<string, unknown>
+  ).__IM_LARK_BRIDGE_INVOKE_GATEWAY_METHOD__ = invokeGatewayMethod;
 
   console.log(
     "[lark-stdio-bridge] monitor started with gatewayBaseUrl =",