@xmanrui/dsh-im 4.3.0 → 4.5.0

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

@@ -490,7 +490,7 @@ export function menuHelpText() {
     '/sessionlist 或 /sessions  列出工作区会话',
     '/session ID  绑定已有会话',
     '/workspacelist  列出工作区',
-    '/workspace 路径  切换工作区',
+    '/workspace 工作区序号或绝对路径  切换工作区',
     '/new  开启全新会话',
     '',
     '📊 状态 / 压缩',
@@ -554,7 +554,7 @@ const HELP_TEXT_COMMANDS = [
   '`/new` — 开启全新会话',
   '`/session ID` — 绑定已有会话',
   '`/sessionlist [工作区]` 或 `/sessions [工作区]` — 列出会话',
-  '`/workspace 路径` — 切换工作区',
+  '`/workspace 工作区序号或绝对路径` — 切换工作区',
   '`/workspacelist` — 列出工作区',
   '`/status` — 查看连接状态',
   '`/compact` — 压缩上下文',

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

@@ -205,15 +205,45 @@ export class VerifiedFeishuChannel {
     }
 
     const cards = [];
+    let activeCard = null;
+    let rotating = false;
     try {
-      const firstCard = await this.#createStreamCard(chatId, options.replyTo);
-      cards.push(firstCard);
+      activeCard = await this.#createStreamCard(chatId, options.replyTo);
+      cards.push(activeCard);
       let lastContent = this.#initialText;
+      // issue #86：独立交互消息（提问/审批）落在占位卡下方后，最终答案不得
+      // 回写旧卡。rotate() 把旧卡定格为「过程记录 + 指引行」并标记换卡态；
+      // 下一次 setContent（过程更新或最终答案）才创建新卡——新卡必然创建于
+      // 交互消息之后。旧卡纳入 cards，参与 recall 与 providerMessageIds。
+      const ensureActiveCard = async () => {
+        if (!rotating) return activeCard;
+        activeCard = await this.#createStreamCard(chatId, options.replyTo);
+        cards.push(activeCard);
+        rotating = false;
+        return activeCard;
+      };
       const controller = {
-        messageId: firstCard.messageId,
+        get messageId() {
+          return activeCard.messageId;
+        },
+        rotate: async () => {
+          if (rotating) return;
+          rotating = true;
+          try {
+            await this.#updateStreamCard(
+              activeCard,
+              `${streamPreview(lastContent)}\n\n${t('⤵️ 最终结果见下方')}`,
+            );
+            await this.#finishStreamCard(activeCard);
+          } catch (error) {
+            // 明确降级：定格失败不阻塞交互呈现，旧卡保留原内容。
+            console.warn('[dsh-feishu] unable to finalize the superseded stream card:', error.message);
+          }
+        },
         setContent: async (content) => {
           const next = String(content ?? '') || '…';
-          await this.#updateStreamCard(firstCard, streamPreview(next));
+          const card = await ensureActiveCard();
+          await this.#updateStreamCard(card, streamPreview(next));
           // Updates are replaceable snapshots, including progress/tool text.
           // Retain the full latest snapshot even when its preview is unchanged.
           lastContent = next;
@@ -224,14 +254,14 @@ export class VerifiedFeishuChannel {
       const chunks = splitStreamContent(lastContent);
       for (const [index, chunk] of chunks.entries()) {
         const card = index === 0
-          ? firstCard
+          ? await ensureActiveCard()
           : await this.#createStreamCard(chatId, options.replyTo);
         if (index > 0) cards.push(card);
         await this.#updateStreamCard(card, chunk);
         await this.#finishStreamCard(card);
       }
       return {
-        messageId: firstCard.messageId,
+        messageId: cards[0].messageId,
         providerMessageIds: cards.map((card) => card.messageId),
       };
     } catch (error) {

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';
 
@@ -81,7 +85,7 @@ function helpText() {
     t('/new  开启一个全新会话'),
     t('/compact  压缩当前会话的较早上下文'),
     t('/history [数量]  查看最近历史消息（默认 3 条，最多 5 条）'),
-    t('/workspace 工作区绝对路径  切换工作区'),
+    t('/workspace 工作区序号或绝对路径  切换工作区'),
     t('/workspacelist  列出工作区绝对路径'),
     t('/sessionlist 或 /sessions [工作区序号或绝对路径]  列出会话 ID 和标题'),
     t('/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话'),
@@ -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;
@@ -798,12 +840,15 @@ export class QqHarnessBridge {
         ? await promptContentForMessage(promptMessage, { signal: this.#signal })
         : undefined;
       const snapshot = this.#acceptedMessageIds.get(messageId);
+      let contextEnhanced = false;
       if (snapshot) {
-        content = enhanceContextContent(content ?? text, snapshot, () => ({
+        const originalContent = content ?? text;
+        content = enhanceContextContent(originalContent, snapshot, () => ({
           channel: 'qq',
           senderId: sender,
           senderName: message.kind === 'group' ? message.senderName : undefined,
         }));
+        contextEnhanced = content !== originalContent;
       }
       // QQ stream_messages can acknowledge a final frame without rendering it in
       // some C2C clients. Standard Markdown delivery is the reliable reply path.
@@ -818,7 +863,9 @@ export class QqHarnessBridge {
           harness: this.#harness,
           state: this.#state,
           key,
-          ...(content !== undefined ? { content } : { text }),
+          text,
+          content,
+          contextEnhanced,
           createOptions: { signal: this.#signal },
           existsOptions: { signal: this.#signal },
           askOptions: {

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;
+}