ylib-syim 0.0.33 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "description": "多 IM / 多 Agent 的会话路由与上下文管理（支持 /new）",
   "type": "module",
   "exports": {
@@ -47,7 +47,7 @@
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "ylib-dingtalk-connector": "0.7.10-beta.20",
-    "ylib-openclaw-lark": "2026.3.17-beta.24",
+    "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",

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: () => ({}),