@xmanrui/dsh-im 4.3.0 → 4.4.0

package/src/channels/feishu/feishu-runtime.mjs

@@ -114,6 +114,7 @@ export class FeishuRuntime {
   #harness;
   #state;
   #contextEnhancement;
+  #accessPolicy;
   #replyTimeoutMs;
   #connectTimeoutMs;
   #requestTimeoutMs;
@@ -143,6 +144,7 @@ export class FeishuRuntime {
     harness,
     state,
     contextEnhancement,
+    accessPolicy,
     repair,
     replyTimeoutMs = 600000,
     connectTimeoutMs = 15000,
@@ -176,6 +178,7 @@ export class FeishuRuntime {
     this.#harness = harness;
     this.#state = state;
     this.#contextEnhancement = contextEnhancement;
+    this.#accessPolicy = accessPolicy;
     this.#repair = repair ?? null;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#connectTimeoutMs = connectTimeoutMs;
@@ -276,6 +279,7 @@ export class FeishuRuntime {
         harness: this.#harness,
         state: this.#state,
         contextEnhancement: this.#contextEnhancement,
+        accessPolicy: this.#accessPolicy,
         status: this.#status,
         allowedSenderOpenIds: new Set(this.#ownerOpenIds),
         botId: this.#botId,

package/src/channels/qq/qq-bridge.mjs

@@ -54,6 +54,10 @@ import {
   messageFailureText,
   setLastMessageFailure,
 } from '../shared/message-failure.mjs';
+import {
+  COMMAND_PERMISSION_DENIED_MESSAGE,
+  evaluateInboundAccess,
+} from '../shared/inbound-access.mjs';
 import { sendMarkdownReply } from './markdown-reply.mjs';
 import { t } from '../shared/i18n.mjs';
 
@@ -110,9 +114,6 @@ function conversationKey(message) {
 }
 
 function senderAllowed(message, ownerUserOpenid) {
-  // QR binding yields a C2C user_openid, while group events identify senders
-  // with a group-scoped member_openid. Treat group membership plus @mention as
-  // the access boundary, and keep the scanner restriction for private chats.
   return message?.kind === 'group'
     || ownerUserOpenid === '*'
     || message?.senderId === ownerUserOpenid;
@@ -376,6 +377,7 @@ export class QqHarnessBridge {
   #harness;
   #state;
   #contextEnhancement;
+  #accessPolicy;
   #status;
   #logger;
   #replyTimeoutMs;
@@ -398,6 +400,7 @@ export class QqHarnessBridge {
     harness,
     state,
     contextEnhancement,
+    accessPolicy,
     status = createQqBridgeStatus(),
     logger = console,
     replyTimeoutMs = 600_000,
@@ -417,6 +420,7 @@ export class QqHarnessBridge {
     this.#harness = harness;
     this.#state = state;
     this.#contextEnhancement = contextEnhancement;
+    this.#accessPolicy = accessPolicy;
     this.#status = status;
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
@@ -439,6 +443,26 @@ export class QqHarnessBridge {
       || this.#state.hasSeen(messageId)
       || this.#acceptedMessageIds.has(messageId)) return Promise.resolve();
     const key = conversationKey(message);
+    const addressed = message.kind !== 'group'
+      || message.rawEventType === 'GROUP_AT_MESSAGE_CREATE';
+    const commandText = safeText(message);
+    if (addressed) {
+      const access = this.#accessPolicy
+        ? evaluateInboundAccess(this.#accessPolicy, {
+            conversationType: message.kind === 'c2c' ? 'direct' : 'group',
+            senderIds: sender,
+            text: commandText,
+            hasImages: hasQqImageAttachments(message),
+            hasFiles: hasQqFileAttachments(message),
+          })
+        : senderAllowed(message, this.#ownerUserOpenid)
+          ? { allowed: true, reason: 'legacy-owner' }
+          : { allowed: false, reason: 'sender-not-allowed' };
+      if (!access.allowed) {
+        this.#acceptedMessageIds.set(messageId, null);
+        return this.#finishAccessDecision(message, messageId, access);
+      }
+    }
     this.#acceptedMessageIds.set(messageId, captureContextEnhancement(
       this.#contextEnhancement,
       message.kind === 'c2c' ? 'direct' : 'group',
@@ -450,20 +474,16 @@ export class QqHarnessBridge {
       rememberConnectionTestTarget(this.#state, message.replyTarget);
     }
     const pending = this.#pendingInteractions.get(key);
-    const commandText = safeText(message);
-    const allowed = senderAllowed(message, this.#ownerUserOpenid);
-    const addressed = message.kind !== 'group'
-      || message.rawEventType === 'GROUP_AT_MESSAGE_CREATE';
     const batchCommand = isBatchInputCommand(commandText);
     const batchStatus = this.#batchInputs.status(key);
-    if (batchCommand && allowed && addressed && message.kind === 'group') {
+    if (batchCommand && addressed && message.kind === 'group') {
       return this.#finishBatchResult(
         message,
         messageId,
         { message: batchInputGroupUnsupportedMessage() },
       );
     }
-    if (allowed && message.kind === 'c2c'
+    if (message.kind === 'c2c'
       && (batchCommand || batchStatus.phase === 'collecting')) {
       const exactBatchStart = /^\/batch$/iu.test(commandText);
       const result = exactBatchStart
@@ -493,7 +513,7 @@ export class QqHarnessBridge {
       : (isModelCommand(commandText)
           ? runModelCommand
           : (isPresetCommand(commandText) ? runPresetCommand : null));
-    if (commandRunner && allowed && addressed) {
+    if (commandRunner && addressed) {
       let task;
       task = this.#processFastCommand(
         message,
@@ -578,10 +598,9 @@ export class QqHarnessBridge {
     alreadyRecorded = false,
     batchSubmission = null,
   } = {}) {
-    const allowed = senderAllowed(message, this.#ownerUserOpenid);
     const addressed = message.kind !== 'group'
       || message.rawEventType === 'GROUP_AT_MESSAGE_CREATE';
-    const preparedMessage = allowed && addressed
+    const preparedMessage = addressed
       ? prefetchInboundFiles(
           qqInboundMessage(message, { fetchImpl: this.#fetchImpl }),
           { signal: this.#signal },
@@ -668,6 +687,34 @@ export class QqHarnessBridge {
     return task;
   }
 
+  #finishAccessDecision(message, messageId, access) {
+    let task;
+    task = Promise.resolve().then(async () => {
+      if (this.#state.hasSeen(messageId)) return;
+      await this.#state.markSeen(messageId);
+      if (access.reason === 'command-not-allowed') {
+        this.#status.messagesReceived += 1;
+        this.#status.lastMessageAt = new Date().toISOString();
+        await this.#bot.sendText(message.replyTarget, t(COMMAND_PERMISSION_DENIED_MESSAGE));
+        this.#status.messagesReplied += 1;
+        this.#status.lastReplyAt = new Date().toISOString();
+      } else {
+        this.#status.messagesRejected += 1;
+        this.#status.lastRejectedAt = new Date().toISOString();
+      }
+      this.#status.lastError = null;
+    }).catch((error) => {
+      if (this.#signal?.aborted) return;
+      this.#status.lastError = error?.message ?? String(error);
+      this.#logger.error?.('[dsh-im:qq] failed to apply inbound access policy:', error);
+    }).finally(() => {
+      this.#acceptedMessageIds.delete(messageId);
+      this.#commandTasks.delete(task);
+    });
+    this.#commandTasks.add(task);
+    return task;
+  }
+
   async #deliverArtifacts(target, replyTo, artifacts = [], baseReceipt = null) {
     if (artifacts.length === 0) {
       return { receipt: baseReceipt, failureNoticeVisible: false, artifactSendErrors: 0 };
@@ -730,11 +777,6 @@ export class QqHarnessBridge {
       await this.#state.markSeen(messageId);
       messageRecorded = true;
     };
-    if (!senderAllowed(message, this.#ownerUserOpenid)) {
-      this.#status.messagesRejected += 1;
-      this.#status.lastRejectedAt = new Date().toISOString();
-      return;
-    }
     if (message.kind === 'group' && message.rawEventType !== 'GROUP_AT_MESSAGE_CREATE') return;
 
     const target = message.replyTarget;

package/src/channels/qq/qq-runtime.mjs

@@ -5,6 +5,7 @@ import {
   connectionTestTargetUnavailable,
 } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
+import { evaluateInboundAccess } from '../shared/inbound-access.mjs';
 import { createQqBridgeStatus, QqHarnessBridge } from './qq-bridge.mjs';
 
 function timeoutError() {
@@ -32,6 +33,7 @@ export class QqRuntime {
   #harness;
   #state;
   #contextEnhancement;
+  #accessPolicy;
   #logger;
   #replyTimeoutMs;
   #connectTimeoutMs;
@@ -50,6 +52,7 @@ export class QqRuntime {
     harness,
     state,
     contextEnhancement,
+    accessPolicy,
     logger = console,
     replyTimeoutMs = 600_000,
     connectTimeoutMs = 20_000,
@@ -64,6 +67,7 @@ export class QqRuntime {
     this.#harness = harness;
     this.#state = state;
     this.#contextEnhancement = contextEnhancement;
+    this.#accessPolicy = accessPolicy;
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#connectTimeoutMs = connectTimeoutMs;
@@ -166,6 +170,7 @@ export class QqRuntime {
       harness: this.#harness,
       state: this.#state,
       contextEnhancement: this.#contextEnhancement,
+      accessPolicy: this.#accessPolicy,
       status: this.#status,
       logger: this.#logger,
       replyTimeoutMs: this.#replyTimeoutMs,
@@ -177,8 +182,21 @@ export class QqRuntime {
     bot.use(contentSanitizer({ parseFaceTags: true }));
     bot.use?.(this.#typingMiddleware({
       keepAlive: true,
-      predicate: (ctx) => this.#config.ownerUserOpenid === '*'
-        || ctx?.message?.senderId === this.#config.ownerUserOpenid,
+      predicate: (ctx) => {
+        const message = ctx?.message;
+        if (!message || (message.kind === 'group'
+          && message.rawEventType !== 'GROUP_AT_MESSAGE_CREATE')) return false;
+        if (!this.#accessPolicy) {
+          return message.kind === 'group'
+            || this.#config.ownerUserOpenid === '*'
+            || message.senderId === this.#config.ownerUserOpenid;
+        }
+        return evaluateInboundAccess(this.#accessPolicy, {
+          conversationType: message.kind === 'c2c' ? 'direct' : 'group',
+          senderIds: message.senderId,
+          text: typeof message.content === 'string' ? message.content.trim() : '',
+        }).allowed;
+      },
     }));
 
     let readyResolve;

package/src/channels/shared/access-policy.mjs

@@ -0,0 +1,210 @@
+// Shared by the Host and settings UI; keep this module browser-compatible.
+export const ACCESS_POLICY_MODES = Object.freeze(['open', 'allowlist']);
+export const ACCESS_POLICY_CONVERSATION_TYPES = Object.freeze(['direct', 'group']);
+export const ACCESS_POLICY_USER_ID_MAX_LENGTH = 256;
+
+const POLICY_KEYS = ['direct', 'group'];
+const SCOPE_KEYS = ['mode', 'open', 'allowlist'];
+const OPEN_KEYS = ['defaultCanExecuteCommands', 'commandPermissionOverrides'];
+const ALLOWLIST_KEYS = ['users'];
+const USER_KEYS = ['id', 'canExecuteCommands'];
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/;
+
+function invalidAccessPolicy(message) {
+  const error = new TypeError(message);
+  error.code = 'access-policy-invalid';
+  return error;
+}
+
+function hasExactKeys(input, keys) {
+  return input && typeof input === 'object' && !Array.isArray(input)
+    && [Object.prototype, null].includes(Object.getPrototypeOf(input))
+    && Reflect.ownKeys(input).length === keys.length
+    && keys.every((key) => Object.hasOwn(input, key));
+}
+
+/** Normalize one opaque channel identity without interpreting its contents. */
+export function normalizeAccessPolicyUserId(value) {
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw invalidAccessPolicy('用户标识无效。');
+    value = String(value);
+  } else if (typeof value === 'bigint') {
+    value = String(value);
+  }
+  if (typeof value !== 'string') throw invalidAccessPolicy('用户标识必须是字符串。');
+  const id = value.trim();
+  if (!id || id.length > ACCESS_POLICY_USER_ID_MAX_LENGTH || CONTROL_CHARACTERS.test(id)) {
+    throw invalidAccessPolicy(`用户标识不能为空、包含控制字符或超过 ${ACCESS_POLICY_USER_ID_MAX_LENGTH} 个字符。`);
+  }
+  return id;
+}
+
+function validateAccessPolicyUser(input) {
+  if (!hasExactKeys(input, USER_KEYS)) {
+    throw invalidAccessPolicy('用户条目必须包含用户标识和命令权限。');
+  }
+  if (typeof input.canExecuteCommands !== 'boolean') {
+    throw invalidAccessPolicy('命令权限必须是布尔值。');
+  }
+  return Object.freeze({
+    id: normalizeAccessPolicyUserId(input.id),
+    canExecuteCommands: input.canExecuteCommands,
+  });
+}
+
+function validateUsers(input, { listMessage, duplicateMessage }) {
+  if (!Array.isArray(input)) throw invalidAccessPolicy(listMessage);
+  const users = input.map(validateAccessPolicyUser);
+  if (new Set(users.map(({ id }) => id)).size !== users.length) {
+    throw invalidAccessPolicy(duplicateMessage);
+  }
+  return Object.freeze(users);
+}
+
+function validateOpenSettings(input) {
+  if (!hasExactKeys(input, OPEN_KEYS)) {
+    throw invalidAccessPolicy('开放模式设置必须完整。');
+  }
+  if (typeof input.defaultCanExecuteCommands !== 'boolean') {
+    throw invalidAccessPolicy('开放模式默认命令权限必须是布尔值。');
+  }
+  return Object.freeze({
+    defaultCanExecuteCommands: input.defaultCanExecuteCommands,
+    commandPermissionOverrides: validateUsers(input.commandPermissionOverrides, {
+      listMessage: '开放模式命令权限覆盖用户必须是数组。',
+      duplicateMessage: '开放模式命令权限覆盖用户不能包含重复的用户标识。',
+    }),
+  });
+}
+
+function validateAllowlistSettings(input) {
+  if (!hasExactKeys(input, ALLOWLIST_KEYS)) {
+    throw invalidAccessPolicy('白名单模式设置必须完整。');
+  }
+  return Object.freeze({
+    users: validateUsers(input.users, {
+      listMessage: '白名单模式用户必须是数组。',
+      duplicateMessage: '白名单模式用户不能包含重复的用户标识。',
+    }),
+  });
+}
+
+function validateAccessPolicyScope(input) {
+  if (!hasExactKeys(input, SCOPE_KEYS)) {
+    throw invalidAccessPolicy('访问场景设置必须同时包含模式、开放模式设置和白名单模式设置。');
+  }
+  if (!ACCESS_POLICY_MODES.includes(input.mode)) {
+    throw invalidAccessPolicy('访问模式只能是 open 或 allowlist。');
+  }
+  return Object.freeze({
+    mode: input.mode,
+    open: validateOpenSettings(input.open),
+    allowlist: validateAllowlistSettings(input.allowlist),
+  });
+}
+
+/** Validate one canonical direct + group atomic save. */
+export function validateAccessPolicy(input) {
+  if (!hasExactKeys(input, POLICY_KEYS)) {
+    throw invalidAccessPolicy('请同时提交完整的私聊和群聊访问设置。');
+  }
+  return Object.freeze({
+    direct: validateAccessPolicyScope(input.direct),
+    group: validateAccessPolicyScope(input.group),
+  });
+}
+
+/** Normalize canonical persisted/runtime data; damaged settings fail closed. */
+export function normalizeAccessPolicy(input) {
+  try {
+    return validateAccessPolicy(input);
+  } catch {
+    return null;
+  }
+}
+
+/** Small canonical constructor used by channel initialization. */
+export function createAccessPolicyScope(options) {
+  return validateAccessPolicyScope(options === undefined ? {
+    mode: 'allowlist',
+    open: {
+      defaultCanExecuteCommands: false,
+      commandPermissionOverrides: [],
+    },
+    allowlist: { users: [] },
+  } : options);
+}
+
+const DENY_SCOPE = createAccessPolicyScope();
+
+export const DEFAULT_ACCESS_POLICY = Object.freeze({
+  direct: DENY_SCOPE,
+  group: DENY_SCOPE,
+});
+
+export const DENY_ALL_ACCESS_POLICY = DEFAULT_ACCESS_POLICY;
+
+export function createAccessPolicy({
+  direct = DEFAULT_ACCESS_POLICY.direct,
+  group = DEFAULT_ACCESS_POLICY.group,
+} = {}) {
+  return validateAccessPolicy({ direct, group });
+}
+
+const ALLOWED = Object.freeze({ allowed: true, reason: 'allowed' });
+const POLICY_UNAVAILABLE = Object.freeze({ allowed: false, reason: 'policy-unavailable' });
+const INVALID_CONTEXT = Object.freeze({ allowed: false, reason: 'invalid-context' });
+const SENDER_UNAVAILABLE = Object.freeze({ allowed: false, reason: 'sender-unavailable' });
+const SENDER_NOT_ALLOWED = Object.freeze({ allowed: false, reason: 'sender-not-allowed' });
+const COMMAND_NOT_ALLOWED = Object.freeze({ allowed: false, reason: 'command-not-allowed' });
+
+/**
+ * Decide access for one ordinary message or one already-recognized command.
+ * `senderIds` accepts multiple identities so WhatsApp can reuse its JID aliases.
+ * Privileged/owner bypass is intentionally handled by the inbound adapter.
+ */
+export function evaluateAccessPolicy(policy, {
+  conversationType,
+  senderIds,
+  isCommand = false,
+  equals = (left, right) => left === right,
+} = {}) {
+  const normalizedPolicy = normalizeAccessPolicy(policy);
+  if (!normalizedPolicy) return POLICY_UNAVAILABLE;
+  if (!ACCESS_POLICY_CONVERSATION_TYPES.includes(conversationType)
+    || typeof isCommand !== 'boolean' || typeof equals !== 'function') {
+    return INVALID_CONTEXT;
+  }
+  const candidates = (Array.isArray(senderIds) ? senderIds : [senderIds])
+    .flatMap((candidate) => {
+      try {
+        return [normalizeAccessPolicyUserId(candidate)];
+      } catch {
+        return [];
+      }
+    });
+  if (candidates.length === 0) return SENDER_UNAVAILABLE;
+
+  const scope = normalizedPolicy[conversationType];
+  const users = scope.mode === 'open'
+    ? scope.open.commandPermissionOverrides
+    : scope.allowlist.users;
+  let matchedUsers;
+  try {
+    matchedUsers = users.filter((user) => (
+      candidates.some((candidate) => equals(candidate, user.id) === true)
+    ));
+  } catch {
+    return INVALID_CONTEXT;
+  }
+  if (scope.mode === 'allowlist' && matchedUsers.length === 0) return SENDER_NOT_ALLOWED;
+  if (isCommand) {
+    const canExecuteCommands = scope.mode === 'open'
+      ? (matchedUsers.length > 0
+        ? matchedUsers.every((user) => user.canExecuteCommands)
+        : scope.open.defaultCanExecuteCommands)
+      : matchedUsers.every((user) => user.canExecuteCommands);
+    if (!canExecuteCommands) return COMMAND_NOT_ALLOWED;
+  }
+  return ALLOWED;
+}