ylib-syim 0.0.32 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.32",
+  "version": "0.0.34",
   "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.19",
-    "ylib-openclaw-lark": "2026.3.17-beta.23",
-    "ylib-openclaw-weixin": "2.1.7-beta.11",
+    "ylib-dingtalk-connector": "0.7.10-beta.20",
+    "ylib-openclaw-lark": "2026.3.17-beta.25",
+    "ylib-openclaw-weixin": "2.1.7-beta.12",
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "fluent-ffmpeg": "^2.1.3",

package/scripts/lark-stdio-bridge.ts

@@ -513,6 +513,180 @@ function buildCfg(): {
 // ---------------------------------------------------------------------------
 
 function buildMinimalRuntime(cfg: Record<string, unknown>): unknown {
+  type BridgeGroupConfig = {
+    requireMention?: boolean;
+  };
+  type BridgeGroups = Record<string, BridgeGroupConfig | undefined>;
+
+  const normalizeAccountId = (value: unknown): string => {
+    const text = String(value || "").trim();
+    return text || "__default__";
+  };
+
+  const resolveAccountEntry = (
+    accounts: Record<string, unknown> | undefined,
+    accountId: unknown,
+  ): Record<string, unknown> | undefined => {
+    if (!accounts || typeof accounts !== "object") return undefined;
+    const normalized = normalizeAccountId(accountId);
+    const exact = accounts[normalized];
+    if (exact && typeof exact === "object" && !Array.isArray(exact)) {
+      return exact as Record<string, unknown>;
+    }
+    const fallback = accounts["__default__"];
+    if (fallback && typeof fallback === "object" && !Array.isArray(fallback)) {
+      return fallback as Record<string, unknown>;
+    }
+    return undefined;
+  };
+
+  const resolveChannelGroups = (
+    inCfg: Record<string, unknown>,
+    channel: string,
+    accountId?: unknown,
+  ): BridgeGroups | undefined => {
+    const channelsObj =
+      inCfg.channels && typeof inCfg.channels === "object"
+        ? (inCfg.channels as Record<string, unknown>)
+        : undefined;
+    const channelCfg =
+      channelsObj && channelsObj[channel] && typeof channelsObj[channel] === "object"
+        ? (channelsObj[channel] as Record<string, unknown>)
+        : undefined;
+    if (!channelCfg) return undefined;
+    const accountsObj =
+      channelCfg.accounts && typeof channelCfg.accounts === "object"
+        ? (channelCfg.accounts as Record<string, unknown>)
+        : undefined;
+    const accountEntry = resolveAccountEntry(accountsObj, accountId);
+    const accountGroups =
+      accountEntry && accountEntry.groups && typeof accountEntry.groups === "object"
+        ? (accountEntry.groups as BridgeGroups)
+        : undefined;
+    if (accountGroups) return accountGroups;
+    if (channelCfg.groups && typeof channelCfg.groups === "object") {
+      return channelCfg.groups as BridgeGroups;
+    }
+    return undefined;
+  };
+
+  const resolveChannelGroupPolicyMode = (
+    inCfg: Record<string, unknown>,
+    channel: string,
+    accountId?: unknown,
+  ): "open" | "allowlist" | "disabled" | undefined => {
+    const channelsObj =
+      inCfg.channels && typeof inCfg.channels === "object"
+        ? (inCfg.channels as Record<string, unknown>)
+        : undefined;
+    const channelCfg =
+      channelsObj && channelsObj[channel] && typeof channelsObj[channel] === "object"
+        ? (channelsObj[channel] as Record<string, unknown>)
+        : undefined;
+    if (!channelCfg) return undefined;
+    const accountsObj =
+      channelCfg.accounts && typeof channelCfg.accounts === "object"
+        ? (channelCfg.accounts as Record<string, unknown>)
+        : undefined;
+    const accountEntry = resolveAccountEntry(accountsObj, accountId);
+    const accountPolicy = String(accountEntry?.groupPolicy || "").trim();
+    if (accountPolicy === "open" || accountPolicy === "allowlist" || accountPolicy === "disabled") {
+      return accountPolicy;
+    }
+    const topPolicy = String(channelCfg.groupPolicy || "").trim();
+    if (topPolicy === "open" || topPolicy === "allowlist" || topPolicy === "disabled") {
+      return topPolicy;
+    }
+    return undefined;
+  };
+
+  const resolveChannelGroupConfig = (
+    groups: BridgeGroups | undefined,
+    groupId: string,
+    caseInsensitive: boolean,
+  ): BridgeGroupConfig | undefined => {
+    if (!groups) return undefined;
+    const direct = groups[groupId];
+    if (direct) return direct;
+    if (!caseInsensitive) return undefined;
+    const target = groupId.toLowerCase();
+    const matchedKey = Object.keys(groups).find(
+      (key) => key !== "*" && key.toLowerCase() === target,
+    );
+    return matchedKey ? groups[matchedKey] : undefined;
+  };
+
+  const resolveBridgeGroupPolicy = (params: {
+    cfg: Record<string, unknown>;
+    channel: string;
+    groupId?: string | null;
+    accountId?: string | null;
+    groupIdCaseInsensitive?: boolean;
+    hasGroupAllowFrom?: boolean;
+  }): {
+    allowlistEnabled: boolean;
+    allowed: boolean;
+    groupConfig?: BridgeGroupConfig;
+    defaultConfig?: BridgeGroupConfig;
+  } => {
+    const groups = resolveChannelGroups(params.cfg, params.channel, params.accountId);
+    const groupPolicy = resolveChannelGroupPolicyMode(
+      params.cfg,
+      params.channel,
+      params.accountId,
+    );
+    const hasGroups = Boolean(groups && Object.keys(groups).length > 0);
+    const allowlistEnabled = groupPolicy === "allowlist" || hasGroups;
+    const normalizedGroupId = String(params.groupId || "").trim();
+    const groupConfig = normalizedGroupId
+      ? resolveChannelGroupConfig(groups, normalizedGroupId, Boolean(params.groupIdCaseInsensitive))
+      : undefined;
+    const defaultConfig = groups?.["*"];
+    const allowAll = allowlistEnabled && Boolean(groups && Object.hasOwn(groups, "*"));
+    const senderFilterBypass =
+      groupPolicy === "allowlist" && !hasGroups && Boolean(params.hasGroupAllowFrom);
+    const allowed =
+      groupPolicy === "disabled"
+        ? false
+        : !allowlistEnabled || allowAll || Boolean(groupConfig) || senderFilterBypass;
+    return {
+      allowlistEnabled,
+      allowed,
+      groupConfig,
+      defaultConfig,
+    };
+  };
+
+  const resolveBridgeRequireMention = (params: {
+    cfg: Record<string, unknown>;
+    channel: string;
+    groupId?: string | null;
+    accountId?: string | null;
+    groupIdCaseInsensitive?: boolean;
+    requireMentionOverride?: boolean;
+    overrideOrder?: "before-config" | "after-config";
+  }): boolean => {
+    const { requireMentionOverride } = params;
+    const overrideOrder = params.overrideOrder || "after-config";
+    const { groupConfig, defaultConfig } = resolveBridgeGroupPolicy(params);
+    const configMention =
+      typeof groupConfig?.requireMention === "boolean"
+        ? groupConfig.requireMention
+        : typeof defaultConfig?.requireMention === "boolean"
+          ? defaultConfig.requireMention
+          : undefined;
+    if (overrideOrder === "before-config" && typeof requireMentionOverride === "boolean") {
+      return requireMentionOverride;
+    }
+    if (typeof configMention === "boolean") {
+      return configMention;
+    }
+    if (overrideOrder !== "before-config" && typeof requireMentionOverride === "boolean") {
+      return requireMentionOverride;
+    }
+    return true;
+  };
+
   return {
     log: (...args: unknown[]) => console.log("[Feishu]", ...args),
     error: (...args: unknown[]) => console.error("[Feishu][ERR]", ...args),
@@ -531,6 +705,10 @@ function buildMinimalRuntime(cfg: Record<string, unknown>): unknown {
         resolveCommandAuthorizedFromAuthorizers: async () => false,
         isControlCommandMessage: () => false,
       },
+      groups: {
+        resolveGroupPolicy: resolveBridgeGroupPolicy,
+        resolveRequireMention: resolveBridgeRequireMention,
+      },
       reply: {
         resolveEnvelopeFormatOptions: () => ({}),
         finalizeInboundContext: () => ({}),

package/scripts/weixin-stdio-bridge.ts

@@ -1,10 +1,168 @@
 import fs from "node:fs";
+import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import crypto from "node:crypto";
+import { fileTypeFromBuffer } from "file-type";
 
 const CHANNEL_KEY = "openclaw-weixin";
 let bridgeDefaultAccountAlias = "weixin-single";
 const bridgeAliasLogMemo = new Set<string>();
+const MEDIA_FILE_MODE = 0o644;
+const DEFAULT_MEDIA_MAX_BYTES = 5 * 1024 * 1024;
+const EXT_BY_MIME: Record<string, string> = {
+  "image/heic": ".heic",
+  "image/heif": ".heif",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "audio/ogg": ".ogg",
+  "audio/mpeg": ".mp3",
+  "audio/x-m4a": ".m4a",
+  "audio/mp4": ".m4a",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "application/zip": ".zip",
+  "application/gzip": ".gz",
+  "application/x-tar": ".tar",
+  "application/x-7z-compressed": ".7z",
+  "application/vnd.rar": ".rar",
+  "application/msword": ".doc",
+  "application/vnd.ms-excel": ".xls",
+  "application/vnd.ms-powerpoint": ".ppt",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+    ".docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+    ".pptx",
+  "text/csv": ".csv",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+};
+const MIME_BY_EXT: Record<string, string> = {
+  ...Object.fromEntries(Object.entries(EXT_BY_MIME).map(([mime, ext]) => [ext, mime])),
+  ".jpeg": "image/jpeg",
+  ".js": "text/javascript",
+};
+
+function sanitizeFilename(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) return "";
+  const sanitized = trimmed.replace(/[^\p{L}\p{N}._-]+/gu, "_");
+  return sanitized.replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+
+function normalizeMimeType(mime?: string | null): string | undefined {
+  if (!mime) return undefined;
+  const cleaned = mime.split(";")[0]?.trim().toLowerCase();
+  return cleaned || undefined;
+}
+
+function extensionForMime(mime?: string | null): string | undefined {
+  const normalized = normalizeMimeType(mime);
+  if (!normalized) return undefined;
+  return EXT_BY_MIME[normalized];
+}
+
+function getFileExtension(filePath?: string | null): string | undefined {
+  if (!filePath) return undefined;
+  try {
+    if (/^https?:\/\//i.test(filePath)) {
+      const url = new URL(filePath);
+      return path.extname(url.pathname).toLowerCase() || undefined;
+    }
+  } catch {
+    // fall back
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  return ext || undefined;
+}
+
+function isGenericMime(mime?: string): boolean {
+  if (!mime) return true;
+  const lower = mime.toLowerCase();
+  return lower === "application/octet-stream" || lower === "application/zip";
+}
+
+function isMissingPathError(err: unknown): err is NodeJS.ErrnoException {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+
+async function retryAfterRecreatingDir<T>(
+  dir: string,
+  run: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await run();
+  } catch (err) {
+    if (!isMissingPathError(err)) throw err;
+    await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+    return await run();
+  }
+}
+
+async function detectMime(opts: {
+  buffer?: Buffer;
+  headerMime?: string | null;
+  filePath?: string;
+}): Promise<string | undefined> {
+  const ext = getFileExtension(opts.filePath);
+  const extMime = ext ? MIME_BY_EXT[ext] : undefined;
+  const headerMime = normalizeMimeType(opts.headerMime);
+  let sniffed: string | undefined;
+  if (opts.buffer) {
+    try {
+      const fileType = await fileTypeFromBuffer(opts.buffer);
+      sniffed = fileType?.mime ?? undefined;
+    } catch {
+      sniffed = undefined;
+    }
+  }
+  if (sniffed && (!isGenericMime(sniffed) || !extMime)) return sniffed;
+  if (extMime) return extMime;
+  if (headerMime && !isGenericMime(headerMime)) return headerMime;
+  if (sniffed) return sniffed;
+  if (headerMime) return headerMime;
+  return undefined;
+}
+
+async function saveMediaBufferFromOpenclaw(
+  buffer: Buffer,
+  contentType?: string,
+  subdir = "inbound",
+  maxBytes = DEFAULT_MEDIA_MAX_BYTES,
+  originalFilename?: string,
+): Promise<{ id: string; path: string; size: number; contentType?: string }> {
+  if (buffer.byteLength > maxBytes) {
+    throw new Error(
+      `Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`,
+    );
+  }
+  const dir = path.join(os.tmpdir(), "openclaw-media", subdir);
+  await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+  const uuid = crypto.randomUUID();
+  const headerExt = extensionForMime(contentType?.split(";")[0]?.trim());
+  const mime = await detectMime({ buffer, headerMime: contentType });
+  const ext = headerExt ?? extensionForMime(mime) ?? "";
+
+  let id: string;
+  if (originalFilename) {
+    const base = path.parse(originalFilename).name;
+    const sanitized = sanitizeFilename(base);
+    id = sanitized ? `${sanitized}---${uuid}${ext}` : `${uuid}${ext}`;
+  } else {
+    id = ext ? `${uuid}${ext}` : uuid;
+  }
+
+  const dest = path.join(dir, id);
+  await retryAfterRecreatingDir(dir, () =>
+    fsPromises.writeFile(dest, buffer, { mode: MEDIA_FILE_MODE }),
+  );
+  return { id, path: dest, size: buffer.byteLength, contentType: mime };
+}
 
 function logBridgeAlias(from: string, to: string, reason: string): void {
   const key = `${from}->${to}:${reason}`;
@@ -503,6 +661,9 @@ function buildMinimalRuntime(
       activity: {
         record: () => {},
       },
+      media: {
+        saveMediaBuffer: saveMediaBufferFromOpenclaw,
+      },
     },
     system: {
       enqueueSystemEvent: () => {},