@xmanrui/dsh-im 4.32.0 → 4.34.0

package/src/channels/feishu/message-utils.mjs

@@ -1,8 +1,11 @@
+import { addAbortSignal, Readable } from 'node:stream';
+import { downloadFeishuResourceRanges } from './resource-download.mjs';
 import { imageDownloadLimitMessage } from '../shared/image-prompt.mjs';
 import { ImagePromptError } from '../shared/image-prompt.mjs';
 import { t } from '../shared/i18n.mjs';
 
 const FEISHU_MISSING_MESSAGE_SCOPE_CODE = 99991672;
+const FEISHU_RESOURCE_SIZE_LIMIT_CODE = 234037;
 const FEISHU_CARD_MESSAGE_CONTENT_TYPE = 'raw_card_content';
 const FEISHU_ERROR_BODY_LIMIT = 64 * 1024;
 const FEISHU_ERROR_BODY_TIMEOUT_MS = 1_000;
@@ -305,31 +308,6 @@ async function readBoundedStream(stream, { signal, maxBytes }) {
   }
 }
 
-async function readStream(stream, { signal }) {
-  if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
-    throw new Error('Feishu file download returned no readable stream');
-  }
-  signal?.throwIfAborted();
-  const abort = () => stream.destroy?.(
-    signal.reason ?? new DOMException('Feishu file download aborted', 'AbortError'),
-  );
-  signal?.addEventListener('abort', abort, { once: true });
-  const chunks = [];
-  let size = 0;
-  try {
-    for await (const chunk of stream) {
-      signal?.throwIfAborted();
-      const data = Buffer.from(chunk);
-      size += data.length;
-      chunks.push(data);
-    }
-    signal?.throwIfAborted();
-    return Buffer.concat(chunks, size);
-  } finally {
-    signal?.removeEventListener('abort', abort);
-  }
-}
-
 function providerCode(value) {
   if (!value || typeof value !== 'object') return null;
   const code = value.code ?? value.error?.code;
@@ -375,7 +353,7 @@ async function feishuProviderCode(error, signal) {
     seen.add(value);
     const directCode = providerCode(value);
     const data = value.response?.data ?? value.data;
-    if (directCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
+    if (directCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE || directCode === FEISHU_RESOURCE_SIZE_LIMIT_CODE) {
       data?.destroy?.();
       return directCode;
     }
@@ -383,21 +361,22 @@ async function feishuProviderCode(error, signal) {
       const body = await readFeishuErrorBody(data, signal);
       try {
         const parsedCode = providerCode(JSON.parse(body));
-        if (parsedCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return parsedCode;
+        if (parsedCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE || parsedCode === FEISHU_RESOURCE_SIZE_LIMIT_CODE) return parsedCode;
       } catch {
         // Non-JSON provider failures keep the generic image download message.
       }
     } else {
       const dataCode = providerCode(data);
-      if (dataCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return dataCode;
+      if (dataCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE || dataCode === FEISHU_RESOURCE_SIZE_LIMIT_CODE) return dataCode;
     }
     pending.push(value.cause);
   }
   return null;
 }
 
-async function feishuImageDownloadError(error, signal) {
-  if (await feishuProviderCode(error, signal) !== FEISHU_MISSING_MESSAGE_SCOPE_CODE) return error;
+async function feishuImageDownloadError(error, signal, code = undefined) {
+  if (code === undefined) code = await feishuProviderCode(error, signal);
+  if (code !== FEISHU_MISSING_MESSAGE_SCOPE_CODE) return error;
   return new ImagePromptError(
     'feishu-image-permission-required',
     'Feishu image download requires the im:message:readonly tenant scope',
@@ -406,33 +385,59 @@ async function feishuImageDownloadError(error, signal) {
   );
 }
 
-function feishuImageSource(event, client, key) {
-  return {
-    async load({ signal, maxBytes }) {
-      signal?.throwIfAborted();
-      let resource;
+async function feishuResourceStream(event, client, key, type, { signal, maxBytes } = {}) {
+  signal?.throwIfAborted();
+  const path = { message_id: event.message.message_id, file_key: key };
+  let resource;
+  try {
+    resource = await client?.im?.v1?.messageResource?.get?.({ path, params: { type } });
+  } catch (error) {
+    if (signal?.aborted) {
+      error?.response?.data?.destroy?.();
+      signal.throwIfAborted();
+    }
+    const code = await feishuProviderCode(error, signal);
+    if (code !== FEISHU_RESOURCE_SIZE_LIMIT_CODE) {
+      throw type === 'image' ? await feishuImageDownloadError(error, signal, code) : error;
+    }
+    return Readable.from((async function* ranges() {
       try {
-        resource = await client?.im?.v1?.messageResource?.get?.({
-          path: {
-            message_id: event.message.message_id,
-            file_key: key,
-          },
-          params: { type: 'image' },
-        });
+        yield* downloadFeishuResourceRanges(client, path, type, { signal, maxBytes });
       } catch (error) {
-        throw await feishuImageDownloadError(error, signal);
-      }
-      signal?.throwIfAborted();
-      const size = declaredSize(resource?.headers);
-      if (size !== null && size > maxBytes) {
-        resource?.getReadableStream?.().destroy?.();
-        throw new ImagePromptError(
-          'image-too-large',
-          `Feishu image declares ${size} bytes; the limit is ${maxBytes}`,
-          imageDownloadLimitMessage(maxBytes),
-        );
+        try {
+          throw type === 'image' ? await feishuImageDownloadError(error, signal) : error;
+        } finally {
+          error?.response?.data?.destroy?.();
+        }
       }
-      return readBoundedStream(resource?.getReadableStream?.(), { signal, maxBytes });
+    }()), { objectMode: false, signal });
+  }
+  const stream = resource?.getReadableStream?.();
+  try {
+    signal?.throwIfAborted();
+    const size = declaredSize(resource?.headers);
+    if (size !== null && size > maxBytes) {
+      throw new ImagePromptError(
+        'image-too-large',
+        `Feishu image declares ${size} bytes; the limit is ${maxBytes}`,
+        imageDownloadLimitMessage(maxBytes),
+      );
+    }
+    if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
+      throw new Error(`Feishu ${type} download returned no readable stream`);
+    }
+    return signal ? addAbortSignal(signal, stream) : stream;
+  } catch (error) {
+    stream?.destroy?.();
+    throw error;
+  }
+}
+
+function feishuImageSource(event, client, key) {
+  return {
+    async load({ signal, maxBytes }) {
+      const stream = await feishuResourceStream(event, client, key, 'image', { signal, maxBytes });
+      return readBoundedStream(stream, { signal, maxBytes });
     },
   };
 }
@@ -443,16 +448,8 @@ function feishuFileSource(event, client, file) {
   return {
     name: nonEmptyString(file?.file_name) ?? 'file',
     async load({ signal } = {}) {
-      signal?.throwIfAborted();
-      const resource = await client?.im?.v1?.messageResource?.get?.({
-        path: {
-          message_id: event.message.message_id,
-          file_key: key,
-        },
-        params: { type: 'file' },
-      });
-      signal?.throwIfAborted();
-      return readStream(resource?.getReadableStream?.(), { signal });
+      const stream = await feishuResourceStream(event, client, key, 'file', { signal });
+      return { stream };
     },
   };
 }

package/src/channels/feishu/multi-bot-controller.mjs

@@ -1,5 +1,5 @@
 import { atConnectionStage, createConnectionDiagnostics } from '../shared/connection-error.mjs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { publicMessageFailure } from '../shared/message-failure.mjs';
 import { RegistrationManager } from './registration-manager.mjs';
@@ -563,10 +563,60 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async #deliveryAccount(config) {
+    let verified;
+    try {
+      const resolved = await this.#credentials.resolve(config.secretRef);
+      if (!resolved?.value) throw new Error('Account credentials unavailable');
+      verified = await this.#verifyApp({ appId: config.appId, appSecret: resolved.value, domain: config.domain });
+    } catch (cause) {
+      const error = new Error('Account credentials could not be verified', { cause });
+      error.code = 'account-unverified';
+      throw error;
+    }
+    if (!verified?.openId || verified.openId !== config.botOpenId) {
+      const error = new Error('Authenticated account identity changed');
+      error.code = 'account-changed';
+      throw error;
+    }
+    const fingerprint = createHash('sha256').update(JSON.stringify({
+      provider: 'feishu', domain: config.domain, appId: config.appId, botOpenId: verified.openId,
+    })).digest('hex');
+    return { fingerprint, ...(verified.name ? { name: verified.name } : {}) };
+  }
+
+  async describeDeliveryAccount(botId) {
+    this.#assertOpen('capability-unavailable');
+    return this.#withBotTransition(botId, async () => {
+      this.#assertOpen('capability-unavailable');
+      const config = this.#requireBot(botId);
+      const account = await this.#deliveryAccount(config);
+      this.#assertOpen('capability-unavailable');
+      return { version: 1, botId, channel: 'feishu', account,
+        connected: isConnected(connectionStatus(this.#runtimes.get(botId))),
+        capabilities: ['proactive-text-checked'] };
+    });
+  }
+
   async sendProactiveText(botId, target, text, options = {}) {
-    this.#assertOpen();
+    const checked = options.expectedFingerprint !== undefined;
+    this.#assertOpen(checked ? 'capability-unavailable' : undefined);
     return this.#withBotTransition(botId, async () => {
-      this.#requireBot(botId);
+      this.#assertOpen(checked ? 'capability-unavailable' : undefined);
+      const config = this.#requireBot(botId);
+      if (checked) {
+        const account = await this.#deliveryAccount(config);
+        if (account.fingerprint !== options.expectedFingerprint) {
+          const error = new Error('Authenticated account identity changed');
+          error.code = 'account-changed';
+          throw error;
+        }
+        // Account verification yields; a Registration can be replaced or disposed
+        // before the SDK request starts. Recheck its owner at the effect boundary.
+        options.beforeSend?.();
+        this.#assertOpen('capability-unavailable');
+        options.signal?.throwIfAborted();
+      }
       const runtime = this.#runtimes.get(botId);
       if (!isConnected(connectionStatus(runtime))
         || typeof runtime.sendProactiveText !== 'function') {
@@ -1386,8 +1436,12 @@ export class MultiBotDshFeishuController {
     return config;
   }
 
-  #assertOpen() {
-    if (this.#closed) throw new Error('The Feishu controller is closed');
+  #assertOpen(code) {
+    if (this.#closed) {
+      const error = new Error('The Feishu controller is closed');
+      if (code) error.code = code;
+      throw error;
+    }
   }
 
   #serializeConfig(operation) {

package/src/channels/feishu/resource-download.mjs

@@ -0,0 +1,120 @@
+import { ImagePromptError, imageDownloadLimitMessage } from '../shared/image-prompt.mjs';
+
+const RESOURCE_CHUNK_BYTES = 8 * 1024 * 1024;
+
+function headerValue(headers, name) {
+  if (typeof headers?.get === 'function') return headers.get(name) ?? null;
+  const key = Object.keys(headers ?? {}).find((key) => key.toLowerCase() === name);
+  return key ? headers[key] : null;
+}
+
+function checkLimit(size, maxBytes) {
+  if (size > maxBytes) {
+    throw new ImagePromptError(
+      'image-too-large',
+      `Feishu image exceeds ${maxBytes} bytes`,
+      imageDownloadLimitMessage(maxBytes),
+    );
+  }
+}
+
+function contentLength(headers) {
+  const value = headerValue(headers, 'content-length');
+  if (value === null || value === undefined) return null;
+  if (!/^\d+$/.test(String(value)) || !Number.isSafeInteger(Number(value))) {
+    throw new Error('Invalid Feishu resource Content-Length');
+  }
+  return Number(value);
+}
+
+function contentRange(headers, start, end, total) {
+  const match = /^bytes (\d+)-(\d+)\/(\d+)$/.exec(headerValue(headers, 'content-range') ?? '');
+  if (!match) throw new Error('Invalid Feishu resource Content-Range');
+  const [first, last, size] = match.slice(1).map(Number);
+  if (![first, last, size].every(Number.isSafeInteger)
+    || first !== start || last < first || last > end || last >= size
+    || (total !== null && size !== total)) {
+    throw new Error('Inconsistent Feishu resource Content-Range');
+  }
+  return { size, length: last - first + 1 };
+}
+
+/** Stream sequential ranges; never buffer an ordinary file or publish a partial success. */
+export async function* downloadFeishuResourceRanges(client, path, type, { signal, maxBytes } = {}) {
+  let offset = 0;
+  let total = null;
+  do {
+    signal?.throwIfAborted();
+    const end = Math.min(
+      offset + RESOURCE_CHUNK_BYTES - 1,
+      (total ?? maxBytes ?? Number.MAX_SAFE_INTEGER) - 1,
+    );
+    let status;
+    const response = await client.request({
+      method: 'GET',
+      url: `open-apis/im/v1/messages/${encodeURIComponent(path.message_id)}/resources/${encodeURIComponent(path.file_key)}`,
+      params: { type },
+      headers: { Range: `bytes=${offset}-${end}`, 'Accept-Encoding': 'identity' },
+      responseType: 'stream',
+      $return_headers: true,
+      decompress: false,
+      signal,
+      // The SDK strips status from successful responses, including stream responses.
+      validateStatus(value) {
+        status = value;
+        return value >= 200 && value < 300;
+      },
+    });
+    const stream = response?.data;
+    const abort = () => stream?.destroy?.(signal.reason);
+    signal?.addEventListener('abort', abort, { once: true });
+    try {
+      signal?.throwIfAborted();
+      if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
+        throw new Error('Feishu resource download returned no readable stream');
+      }
+      const encoding = headerValue(response.headers, 'content-encoding');
+      if (encoding && encoding !== 'identity') {
+        throw new Error('Unexpected Feishu resource Content-Encoding');
+      }
+      let length = contentLength(response.headers);
+      if (status === 206) {
+        const range = contentRange(response.headers, offset, end, total);
+        total = range.size;
+        checkLimit(total, maxBytes);
+        if (length !== null && length !== range.length) {
+          throw new Error('Feishu resource Content-Length disagrees with Content-Range');
+        }
+        length = range.length;
+      } else if (status === 200 && offset === 0) {
+        // A server may ignore the first Range. Read it once as a whole file.
+        if (headerValue(response.headers, 'content-range') !== null) {
+          throw new Error('Unexpected Feishu resource Content-Range on HTTP 200');
+        }
+        checkLimit(length, maxBytes);
+      } else {
+        throw new Error(`Unexpected Feishu resource range status: ${status}`);
+      }
+      let received = 0;
+      for await (const chunk of stream) {
+        signal?.throwIfAborted();
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        received += data.length;
+        checkLimit(offset + received, maxBytes);
+        if (length !== null && received > length) {
+          throw new Error('Feishu resource body exceeds the declared length');
+        }
+        yield data;
+      }
+      signal?.throwIfAborted();
+      if (length !== null && received !== length) {
+        throw new Error('Feishu resource body does not match the declared length');
+      }
+      if (status === 200) return;
+      offset += received;
+    } finally {
+      signal?.removeEventListener('abort', abort);
+      stream?.destroy?.();
+    }
+  } while (offset < total);
+}

package/src/channels/feishu/slash-command-panel.mjs

@@ -49,6 +49,8 @@ export const SLASH_COMMAND_MANIFEST = Object.freeze([
   { command: 'reasoning', icon: 'ai-deepthink_outlined', default: '查看或切换推理等级', en_us: 'Show or switch the reasoning effort' },
   { command: 'presetlist', icon: 'skill_outlined', default: '列出可用 Agent 预设', en_us: 'List available Agent Presets' },
   { command: 'preset', icon: 'skill_outlined', default: '查看或切换 Agent 预设', en_us: 'Show or switch the Agent Preset' },
+  { command: 'permissionlist', icon: 'skill_outlined', default: '按序号列出权限档位', en_us: 'List numbered permission presets' },
+  { command: 'permission', icon: 'skill_outlined', default: '查看或切换当前会话权限', en_us: 'Show or switch current session permissions' },
   { command: 'stop', icon: 'clear_outlined', default: '停止当前任务', en_us: 'Stop the current task' },
   { command: 'steer', icon: 'promptword_outlined', default: '给当前任务补充指令', en_us: 'Send additional instructions to the current task' },
   { command: 'batch', icon: 'chat-ai_outlined', default: '开始批量输入（仅私聊）', en_us: 'Start batch input (private chats only)' },

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

@@ -1,3 +1,4 @@
+import { isPermissionCommand, runPermissionCommand } from '../shared/permission-command.mjs';
 import { createDeferredDeliveryCoordinator, deferredOutcomeText } from '../shared/deferred-delivery-coordinator.mjs';
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
@@ -115,6 +116,9 @@ function helpText() {
     t('/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset'),
     t('纯数字 ID：/preset id:<ID>'),
     t('/preset --default  跟随 Host 默认'),
+    t('/permissionlist  按序号列出权限档位'),
+    t('/permission [序号或完整ID]  查看或切换当前会话权限'),
+    t('纯数字 ID：/permission id:<ID>'),
     t('/stop  停止当前任务'),
     t('/steer 补充指令  纠偏当前任务'),
     t('/batch  开始批量输入（仅私聊，最多 10 条文字）'),
@@ -523,7 +527,7 @@ export class QqHarnessBridge {
             text: commandText,
             hasImages: hasQqImageAttachments(message),
             hasFiles: hasQqFileAttachments(message),
-            ...(explicitMenu || numericMenu ? { isCommand: true } : {}),
+            ...(explicitMenu || numericMenu || isPermissionCommand(commandText) ? { isCommand: true } : {}),
           })
         : senderAllowed(message, this.#ownerUserOpenid)
           ? { allowed: true, reason: 'legacy-owner' }
@@ -594,6 +598,7 @@ export class QqHarnessBridge {
     const commandRunner = explicitMenu || numericMenu
       ? () => this.#runMenuCommand(message, menuInput, key)
       : isHistoryCommand(commandText) ? runHistoryCommand
+      : isPermissionCommand(commandText) ? runPermissionCommand
       : hasQqFileAttachments(message) ? null : isControlCommand(commandText)
       ? runControlCommand
       : (isModelCommand(commandText)

package/src/channels/shared/bot-workspace-store.mjs

@@ -2002,6 +2002,11 @@ export function createBotWorkspaceScope(
             models(...args) {
               return invokeCurrentSession('getSessionModels', args, 'model listing');
             },
+            ...(typeof target.getSessionPermissions === 'function' ? {
+              permissions(...args) {
+                return invokeCurrentSession('getSessionPermissions', args, 'permission listing');
+              },
+            } : {}),
             readHistory(...args) {
               return invokeCurrentSession('readSessionHistory', args, 'history read');
             },

package/src/channels/shared/command-list-snapshots.mjs

@@ -0,0 +1,33 @@
+export const COMMAND_LIST_TTL_MS = 15 * 60_000;
+export const COMMAND_LIST_MAX_ENTRIES = 256;
+
+/** Short-lived lists scoped to a bot's state and conversation, never persisted. */
+export function createCommandListSnapshots() {
+  const states = new WeakMap();
+  return {
+    save(state, key, value) {
+      if ((!state || typeof state !== 'object') && typeof state !== 'function') return;
+      let entries = states.get(state);
+      if (!entries) states.set(state, entries = new Map());
+      const now = Date.now();
+      for (const [entryKey, entry] of entries) {
+        if (entry.expiresAt <= now) entries.delete(entryKey);
+      }
+      entries.delete(key);
+      entries.set(key, { value, expiresAt: now + COMMAND_LIST_TTL_MS });
+      while (entries.size > COMMAND_LIST_MAX_ENTRIES) entries.delete(entries.keys().next().value);
+    },
+    load(state, key) {
+      const entries = states.get(state);
+      const entry = entries?.get(key);
+      if (!entry) return null;
+      if (entry.expiresAt <= Date.now()) {
+        entries.delete(key);
+        return null;
+      }
+      entries.delete(key);
+      entries.set(key, entry);
+      return entry.value;
+    },
+  };
+}

package/src/channels/shared/harness-client.mjs

@@ -1139,6 +1139,12 @@ export class HarnessClient {
     return validateModelCatalog(value, 'session.models', { session: true });
   }
 
+  async getSessionPermissions(sessionId, options = {}) {
+    if (typeof sessionId !== 'string' || !sessionId) throw new TypeError('sessionId is required');
+    await this.ensureRunning(options);
+    return this.rpc('session.permissions', { sessionId }, 30_000, options);
+  }
+
   async selectSessionModel(sessionId, selection, options = {}) {
     if (typeof sessionId !== 'string' || !sessionId) throw new TypeError('sessionId is required');
     if (!validModelSelection(selection)) {
@@ -1729,9 +1735,10 @@ export class HarnessClient {
       this.#registerInteractionOwnership(sessionId, ownership);
       this.#registerControlOwnership(ownership);
     }
-    // This is resource ownership, not a feature Gate: it lets the Host retain
-    // this Turn's snapshots until the channel has polled and claimed them.
-    const closeArtifactConsumer = outboundArtifactRegistry.openConsumer(sessionId, promptRpcId);
+    // Advertise delivery only when this request can actually claim its files.
+    const closeArtifactConsumer = typeof onArtifact === 'function'
+      ? outboundArtifactRegistry.openConsumer(sessionId, promptRpcId)
+      : null;
 
     try {
       const basePrompt = prompt;
@@ -1929,7 +1936,7 @@ export class HarnessClient {
           }
         }
       }
-      closeArtifactConsumer();
+      closeArtifactConsumer?.();
       if (ownership) {
         this.#unregisterControlOwnership(ownership);
         this.#unregisterInteractionOwnership(sessionId, ownership);

package/src/channels/shared/i18n-en/feishu.mjs

@@ -143,6 +143,8 @@ export default {
   '请输入补充指令后再提交。': 'Enter an instruction before submitting.',
   '操作过于频繁，请稍后再试。': 'Too many card actions are pending. Please try again shortly.',
   '卡片操作失败，请稍后重试。': 'The card action failed. Please try again later.',
+  '新会话操作的卡片状态未能更新，请发送 /m 重新打开菜单。':
+    'Could not update the new-session card status. Send /m to reopen the menu.',
   '请先选择至少一个会话。': 'Select at least one session first.',
   '已批量关注 {count} 个会话。': 'Now watching {count} sessions.',
   '已批量关注 {count} 个会话，另有 {failed} 个未成功。':
@@ -187,6 +189,11 @@ export default {
   '🤖 切换预设': '🤖 Switch preset',
   '🧠 切换模型': '🧠 Switch model',
   '🆕 新会话': '🆕 New session',
+  '正在开启…': 'Starting…',
+  '已执行：新会话': 'Done: new session',
+  '正在开启新会话…': 'Starting a new session…',
+  '已执行：新会话。发送消息即可开始。': 'Done: new session. Send a message to start.',
+  '新会话操作失败：{message}': 'New session action failed: {message}',
   '📋 会话/关注': '📋 Sessions / watches',
   '🗂 工作区列表': '🗂 Workspace list',
   '**任务控制**': '**Task controls**',

package/src/channels/shared/i18n-en/permission.mjs

@@ -0,0 +1,30 @@
+export default {
+  '用法：/permission 查看当前权限；/permissionlist 列出档位；/permission <序号或完整ID> 切换；纯数字 ID 使用 /permission id:<ID>。': 'Usage: /permission to show current permissions; /permissionlist to list presets; /permission <number or full ID> to switch; use /permission id:<ID> for numeric IDs.',
+  '仅影响当前会话；沙箱与审批策略会同时按 Host 的档位定义更新。': 'Applies only to the current session; sandbox and approval policies change together according to the Host preset.',
+  '请先执行 /permissionlist，再按列表序号选择权限档位。': 'Run /permissionlist first, then select a permission preset by its number.',
+  '完全文件访问，不再请求审批。': 'Full file access without approval prompts.',
+  '可写工作区和允许的临时目录；扩大访问范围需要审批。': 'Write inside the workspace and permitted temporary directories; wider retries require approval.',
+  '当前聊天绑定的会话已不存在，请先绑定或建立会话。': 'The bound session no longer exists. Bind or start a session first.',
+  '当前 Host 暂不支持从机器人查看或切换权限档位。': 'This Host does not support viewing or switching permission presets from the bot.',
+  '未能确认权限切换结果，请执行 /permission 核对当前档位。': 'Could not confirm the permission change. Run /permission to check the current preset.',
+  '暂时无法获取权限档位，请稍后重试。': 'Could not read permission presets. Please try again later.',
+  '权限命令仅支持纯文字，请移除图片或文件后重试。': 'Permission commands require plain text. Remove images or files and try again.',
+  '当前聊天尚未绑定会话，请先发送普通消息建立会话，或使用 /session 绑定已有会话。': 'This chat has no bound session. Send a regular message to start one, or use /session to bind an existing session.',
+  '当前会话已变化，请重新执行 /permissionlist。': 'The current session changed. Run /permissionlist again.',
+  '当前会话权限：{id}': 'Current session permissions: {id}',
+  ' ✓ 当前': ' ✓ Current',
+  '当前没有可用权限档位。': 'No permission presets are currently available.',
+  '切换：/permission <序号或完整ID>': 'Switch: /permission <number or full ID>',
+  '查看可用档位与序号：/permissionlist': 'Show available presets and numbers: /permissionlist',
+  '权限档位序号无效，请重新执行 /permissionlist。': 'Invalid permission preset number. Run /permissionlist again.',
+  '当前 Host 未注册 /permission 命令，请确认权限预设组件已启用。': 'This Host has not registered /permission. Check that permission presets are enabled.',
+  '该权限档位不存在或已不可用，请重新执行 /permissionlist。': 'That permission preset no longer exists or is unavailable. Run /permissionlist again.',
+  '权限切换失败。': 'Permission change failed.',
+  '当前会话权限已切换为：{id}': 'Current session permissions changed to: {id}',
+  '恢复工作区权限：/permission workspace-write（需 Host 支持该档位）': 'Restore workspace permissions: /permission workspace-write (if supported by the Host)',
+  '/permissionlist  按序号列出权限档位': '/permissionlist  List numbered permission presets',
+  '/permission [序号或完整ID]  查看或切换当前会话权限': '/permission [number or full ID]  Show or switch current session permissions',
+  '纯数字 ID：/permission id:<ID>': 'Numeric IDs: /permission id:<ID>',
+  '`/permissionlist` — 按序号列出权限档位': '`/permissionlist` — List numbered permission presets',
+  '`/permission [序号/ID]` — 查看或切换当前会话权限': '`/permission [number/ID]` — Show or switch current session permissions',
+};

package/src/channels/shared/i18n-en.mjs

@@ -1,4 +1,5 @@
 import imageInput from './i18n-en/image-input.mjs';
+import permission from './i18n-en/permission.mjs';
 import diagnostics from './i18n-en/diagnostics.mjs';
 // English translations for host-side user-facing text.
 // Keys are the exact Chinese literals passed to t() in src/channels/**.
@@ -26,6 +27,7 @@ export const EN = Object.freeze(Object.assign(
   {},
   diagnostics,
   imageInput,
+  permission,
   sharedA,
   sharedB,
   sharedC,