ylib-syim 0.0.29 → 0.0.31

package/bridges/main.ts

@@ -1,6 +1,7 @@
 import { formatBeijingLogTimestamp, setupBridgeLogger } from "./logger.ts";
 import fs from "node:fs";
 import http from "node:http";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -30,6 +31,7 @@ process.env.TZ = "Asia/Shanghai";
 // 3) 提供内部控制 API（status/config/apply/bot control/restart）。
 const bridgeDir = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(bridgeDir, "..");
+const requireAtBridge = createRequire(import.meta.url);
 
 // 当前进程运行实例 ID，会在 restart-all 成功后旋转。
 let runtimeInstanceId = `bridges-${process.pid}-${Date.now()}`;
@@ -7097,103 +7099,159 @@ function resolveRawSchema(
   return {};
 }
 
+type PluginSchemaDescriptor = {
+  pluginId: "dingtalk-connector" | "openclaw-lark" | "openclaw-weixin";
+  channel: "dingtalk" | "feishu" | "weixin";
+  packageName: string;
+  dynamicLoader: () => Promise<Record<string, unknown>>;
+};
+
+const pluginSchemaDescriptors: PluginSchemaDescriptor[] = [
+  {
+    pluginId: "dingtalk-connector",
+    channel: "dingtalk",
+    packageName: "ylib-dingtalk-connector",
+    dynamicLoader: async () =>
+      (await import("ylib-dingtalk-connector")) as Record<string, unknown>,
+  },
+  {
+    pluginId: "openclaw-lark",
+    channel: "feishu",
+    packageName: "ylib-openclaw-lark",
+    dynamicLoader: async () =>
+      (await import("ylib-openclaw-lark")) as Record<string, unknown>,
+  },
+  {
+    pluginId: "openclaw-weixin",
+    channel: "weixin",
+    packageName: "ylib-openclaw-weixin",
+    dynamicLoader: async () => {
+      try {
+        return (await import("ylib-openclaw-weixin")) as Record<
+          string,
+          unknown
+        >;
+      } catch {
+        return (await import("../../openclaw-weixin/index.ts")) as Record<
+          string,
+          unknown
+        >;
+      }
+    },
+  },
+];
+
+function asRawSchema(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readStaticPluginRawSchema(
+  descriptor: PluginSchemaDescriptor,
+): { rawSchema: Record<string, unknown>; source: string } | null {
+  const candidates: string[] = [];
+  try {
+    const pluginJsonPath = requireAtBridge.resolve(
+      `${descriptor.packageName}/openclaw.plugin.json`,
+    );
+    candidates.push(path.join(path.dirname(pluginJsonPath), "schema.json"));
+  } catch {
+    // package not found: static schema unavailable
+  }
+
+  for (const candidate of candidates) {
+    if (!candidate || !fs.existsSync(candidate)) continue;
+    const raw = fs.readFileSync(candidate, "utf8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const parsedPluginId = String(parsed.pluginId || "").trim();
+    if (parsedPluginId && parsedPluginId !== descriptor.pluginId) {
+      throw new Error(
+        `schema pluginId mismatch at ${candidate}: expected ${descriptor.pluginId}, got ${parsedPluginId}`,
+      );
+    }
+    const rawSchema = asRawSchema(parsed.rawSchema);
+    if (!rawSchema) {
+      throw new Error(`schema.rawSchema missing or invalid at ${candidate}`);
+    }
+    return {
+      rawSchema,
+      source: `static:${candidate}`,
+    };
+  }
+  return null;
+}
+
 // getPluginSchemas: 运行时辅助函数。
 async function getPluginSchemas(): Promise<Array<Record<string, unknown>>> {
   // 聚合三个渠道插件 schema，并附带 effective whitelist 供前端渲染表单。
   const whitelist = readEffectiveWhitelist();
   const result: Array<Record<string, unknown>> = [];
-  try {
-    const dingtalkMod = (await import("ylib-dingtalk-connector")) as Record<
+  for (const descriptor of pluginSchemaDescriptors) {
+    const effectiveWhitelist = (whitelist[descriptor.pluginId] as Record<
       string,
       unknown
-    >;
-    const dRawSchema = resolveRawSchema(dingtalkMod, "dingtalk-connector");
-    result.push({
-      pluginId: "dingtalk-connector",
-      channel: "dingtalk",
-      rawSchema: dRawSchema,
-      schemaHash: calcSchemaHash(dRawSchema),
-      effectiveWhitelist: (whitelist["dingtalk-connector"] as Record<
-        string,
-        unknown
-      >) || { fields: [] },
-    });
-  } catch (err) {
-    result.push({
-      pluginId: "dingtalk-connector",
-      channel: "dingtalk",
-      rawSchema: {},
-      schemaHash: calcSchemaHash({}),
-      effectiveWhitelist: (whitelist["dingtalk-connector"] as Record<
-        string,
-        unknown
-      >) || { fields: [] },
-      error: (err as Error).message,
-    });
-  }
-  try {
-    const larkMod = (await import("ylib-openclaw-lark")) as Record<
-      string,
-      unknown
-    >;
-    const lRawSchema = resolveRawSchema(larkMod, "openclaw-lark");
-    result.push({
-      pluginId: "openclaw-lark",
-      channel: "feishu",
-      rawSchema: lRawSchema,
-      schemaHash: calcSchemaHash(lRawSchema),
-      effectiveWhitelist: (whitelist["openclaw-lark"] as Record<
-        string,
-        unknown
-      >) || { fields: [] },
-    });
-  } catch (err) {
-    result.push({
-      pluginId: "openclaw-lark",
-      channel: "feishu",
-      rawSchema: {},
-      schemaHash: calcSchemaHash({}),
-      effectiveWhitelist: (whitelist["openclaw-lark"] as Record<
-        string,
-        unknown
-      >) || { fields: [] },
-      error: (err as Error).message,
-    });
-  }
-  try {
-    let weixinMod: Record<string, unknown>;
+    >) || { fields: [] };
+    let staticError: string | null = null;
+    let staticSchema: { rawSchema: Record<string, unknown>; source: string } | null =
+      null;
     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
-      >;
+      staticSchema = readStaticPluginRawSchema(descriptor);
+    } catch (readErr) {
+      staticError = (readErr as Error).message;
+    }
+    if (staticSchema) {
+      result.push({
+        pluginId: descriptor.pluginId,
+        channel: descriptor.channel,
+        rawSchema: staticSchema.rawSchema,
+        schemaHash: calcSchemaHash(staticSchema.rawSchema),
+        effectiveWhitelist,
+        schemaSource: staticSchema.source,
+        ...(staticError ? { staticError } : {}),
+      });
+      continue;
+    }
+    try {
+      const pluginMod = await descriptor.dynamicLoader();
+      const rawSchema = resolveRawSchema(pluginMod, descriptor.pluginId);
+      result.push({
+        pluginId: descriptor.pluginId,
+        channel: descriptor.channel,
+        rawSchema,
+        schemaHash: calcSchemaHash(rawSchema),
+        effectiveWhitelist,
+        schemaSource: staticError ? "dynamic-fallback" : "dynamic",
+        ...(staticError ? { staticError } : {}),
+      });
+    } catch (dynamicError) {
+      try {
+        const localStatic = readStaticPluginRawSchema(descriptor);
+        if (!localStatic) throw dynamicError;
+        result.push({
+          pluginId: descriptor.pluginId,
+          channel: descriptor.channel,
+          rawSchema: localStatic.rawSchema,
+          schemaHash: calcSchemaHash(localStatic.rawSchema),
+          effectiveWhitelist,
+          schemaSource: `${localStatic.source}:fallback`,
+          error: (dynamicError as Error).message,
+          ...(staticError ? { staticError } : {}),
+        });
+      } catch {
+        result.push({
+          pluginId: descriptor.pluginId,
+          channel: descriptor.channel,
+          rawSchema: {},
+          schemaHash: calcSchemaHash({}),
+          effectiveWhitelist,
+          schemaSource: "error",
+          error: (dynamicError as Error).message,
+          ...(staticError ? { staticError } : {}),
+        });
+      }
     }
-    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;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "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.16",
-    "ylib-openclaw-lark": "2026.3.17-beta.21",
-    "ylib-openclaw-weixin": "2.1.7-beta.9",
+    "ylib-dingtalk-connector": "0.7.10-beta.18",
+    "ylib-openclaw-lark": "2026.3.17-beta.23",
+    "ylib-openclaw-weixin": "2.1.7-beta.11",
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "fluent-ffmpeg": "^2.1.3",