@xmanrui/dsh-im 1.4.0 → 2.0.0

package/src/channels/shared/workspace-command.mjs

@@ -1,6 +1,7 @@
 import { realpath, stat } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 
+import { t } from './i18n.mjs';
 import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
 
 const WORKSPACE_COMMAND = /^\/workspace(?:\s+([\s\S]+))?$/i;
@@ -60,28 +61,34 @@ async function existingWorkspacePaths(values) {
 
 async function selectedWorkspacePath(value) {
   if (typeof value !== 'string' || !isAbsolute(value.trim())) {
-    return { error: `工作区必须是绝对路径。\n${SESSION_LIST_USAGE}` };
+    return { error: t(`工作区必须是绝对路径。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   }
   const workspace = normalizedWorkspacePath(value.trim());
   if (!workspace) {
-    return { error: `工作区路径包含不支持的字符或长度超过限制。\n${SESSION_LIST_USAGE}` };
+    return { error: t(`工作区路径包含不支持的字符或长度超过限制。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   }
   let info;
   try {
     info = await stat(workspace);
   } catch {
-    return { error: `工作区路径不存在。\n${SESSION_LIST_USAGE}` };
+    return { error: t(`工作区路径不存在。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   }
   if (!info.isDirectory()) {
-    return { error: `工作区路径必须指向一个目录。\n${SESSION_LIST_USAGE}` };
+    return { error: t(`工作区路径必须指向一个目录。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   }
   try {
     const canonical = normalizedWorkspacePath(await realpath(workspace));
     return canonical
       ? { workspace: canonical }
-      : { error: `工作区路径包含不支持的字符或长度超过限制。\n${SESSION_LIST_USAGE}` };
+      : { error: t(`工作区路径包含不支持的字符或长度超过限制。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   } catch {
-    return { error: `工作区路径不存在。\n${SESSION_LIST_USAGE}` };
+    return { error: t(`工作区路径不存在。
+{usage}`, { usage: t(SESSION_LIST_USAGE) }) };
   }
 }
 
@@ -120,38 +127,38 @@ export function splitWorkspaceCommandMessage(message) {
 }
 
 async function runWorkspaceListCommand(match, harness) {
-  if (match[1]?.trim()) return commandResult('用法：/workspacelist');
+  if (match[1]?.trim()) return commandResult(t('用法：/workspacelist'));
   if (typeof harness?.listWorkspaces !== 'function') {
-    return commandResult('当前机器人暂不支持列出工作区。');
+    return commandResult(t('当前机器人暂不支持列出工作区。'));
   }
   try {
     const { current, paths } = await workspacePathSnapshot(harness);
     if (paths.length === 0) {
-      return commandResult('当前 Harness Host 上没有仍然存在的已登记工作区。');
+      return commandResult(t('当前 Harness Host 上没有仍然存在的已登记工作区。'));
     }
     const lines = [
-      `当前 Harness Host 上存在的工作区（${paths.length}）：`,
+      t('当前 Harness Host 上存在的工作区（{count}）：', { count: paths.length }),
       ...paths.map((workspace, index) => (
-        `${index + 1}. ${workspace}${workspace === current ? '（当前）' : ''}`
+        `${index + 1}. ${workspace}${workspace === current ? t('（当前）') : ''}`
       )),
       '',
-      '切换用法：/workspace 工作区绝对路径',
-      '查看会话：/sessionlist 工作区序号或绝对路径',
+      t('切换用法：/workspace 工作区绝对路径'),
+      t('查看会话：/sessionlist 工作区序号或绝对路径'),
     ];
     const message = lines.join('\n');
     return commandResult(message, splitWorkspaceCommandMessage(message));
   } catch (error) {
     if (error?.code === 'workspace-bot-not-found') {
-      return commandResult('机器人正在移除或已重新接入，无法列出原会话的工作区。');
+      return commandResult(t('机器人正在移除或已重新接入，无法列出原会话的工作区。'));
     }
-    return commandResult('暂时无法获取工作区列表，请稍后重试。');
+    return commandResult(t('暂时无法获取工作区列表，请稍后重试。'));
   }
 }
 
 export async function resolveSessionListWorkspace(selector, harness) {
   if (!selector) {
     if (typeof harness?.currentWorkspace !== 'function') {
-      return { error: '当前机器人没有可用的工作区。' };
+      return { error: t('当前机器人没有可用的工作区。') };
     }
     const selected = await selectedWorkspacePath(harness.currentWorkspace());
     harness.assertWorkspaceScope?.();
@@ -160,12 +167,12 @@ export async function resolveSessionListWorkspace(selector, harness) {
 
   if (/^\d+$/u.test(selector)) {
     if (typeof harness?.listWorkspaces !== 'function') {
-      return { error: '当前机器人暂不支持按序号选择工作区。' };
+      return { error: t('当前机器人暂不支持按序号选择工作区。') };
     }
     const { paths } = await workspacePathSnapshot(harness);
     const position = Number(selector);
     if (!Number.isSafeInteger(position) || position < 1 || position > paths.length) {
-      return { error: '工作区序号不存在，请先执行 /workspacelist。' };
+      return { error: t('工作区序号不存在，请先执行 /workspacelist。') };
     }
     return { workspace: paths[position - 1] };
   }
@@ -185,13 +192,13 @@ function formatSessionRelativeTime(value) {
   const startOfDay = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
   const now = new Date();
   const dayDiff = Math.round((startOfDay(now) - startOfDay(date)) / 86_400_000);
-  if (dayDiff === 0) return `今天 ${hm}`;
-  if (dayDiff === 1) return `昨天 ${hm}`;
-  if (dayDiff === 2) return `前天 ${hm}`;
+  if (dayDiff === 0) return t('今天 {time}', { time: hm });
+  if (dayDiff === 1) return t('昨天 {time}', { time: hm });
+  if (dayDiff === 2) return t('前天 {time}', { time: hm });
   if (date.getFullYear() === now.getFullYear()) {
-    return `${date.getMonth() + 1}月${date.getDate()}日 ${hm}`;
+    return t('{month}月{day}日 {time}', { month: date.getMonth() + 1, day: date.getDate(), time: hm });
   }
-  return `${date.getFullYear()}年${date.getMonth() + 1}月${date.getDate()}日`;
+  return t('{year}年{month}月{day}日', { year: date.getFullYear(), month: date.getMonth() + 1, day: date.getDate() });
 }
 
 function sessionListMessage(workspace, sessions, { currentWorkspace = false } = {}) {
@@ -199,22 +206,24 @@ function sessionListMessage(workspace, sessions, { currentWorkspace = false } =
     const sessionId = safeDisplayText(session?.sessionId);
     if (!sessionId) throw new TypeError('Harness returned an invalid session id');
     const title = session?.summaryAvailable === false
-      ? '标题暂不可用'
-      : safeDisplayText(session?.title) || '暂无标题';
+      ? t('标题暂不可用')
+      : safeDisplayText(session?.title) || t('暂无标题');
     const timeText = formatSessionRelativeTime(session?.time);
-    const annotation = `${timeText ? ` · ${timeText}` : ''}${session?.archived === true ? '（已归档）' : ''}`;
+    const annotation = `${timeText ? ` · ${timeText}` : ''}${session?.archived === true ? t('（已归档）') : ''}`;
     return `${title}${annotation}\n   ID: ${sessionId}`;
   });
-  if (rows.length === 0) return `工作区：${workspace}\n该工作区暂无会话。`;
+  if (rows.length === 0) return t(`工作区：{workspace}
+该工作区暂无会话。`, { workspace });
   return [
-    `工作区：${workspace}`,
-    `会话（${rows.length}）：`,
+    t('工作区：{workspace}', { workspace }),
+    t('会话（{count}）：', { count: rows.length }),
     '',
     ...rows.map((row, index) => `${index + 1}. ${row}`),
     '',
     currentWorkspace
-      ? '绑定用法：/session Session ID 或当前工作区序号（/session N）'
-      : '绑定用法：/session Session ID\n提示：/session N 只按机器人当前工作区的序号绑定。',
+      ? t('绑定用法：/session Session ID 或当前工作区序号（/session N）')
+      : t(`绑定用法：/session Session ID
+提示：/session N 只按机器人当前工作区的序号绑定。`),
   ].join('\n');
 }
 
@@ -227,7 +236,7 @@ async function currentSessionListWorkspace(harness) {
 
 async function runSessionListCommand(match, harness) {
   if (typeof harness?.listWorkspaceSessions !== 'function') {
-    return commandResult('当前机器人暂不支持列出工作区会话。');
+    return commandResult(t('当前机器人暂不支持列出工作区会话。'));
   }
   const selector = match[1]?.trim() ?? '';
   try {
@@ -246,36 +255,37 @@ async function runSessionListCommand(match, harness) {
     return commandResult(message, splitWorkspaceCommandMessage(message));
   } catch (error) {
     if (error?.code === 'workspace-bot-not-found') {
-      return commandResult('机器人正在移除或已重新接入，无法列出原会话的工作区会话。');
+      return commandResult(t('机器人正在移除或已重新接入，无法列出原会话的工作区会话。'));
     }
-    return commandResult('暂时无法获取工作区会话列表，请稍后重试。');
+    return commandResult(t('暂时无法获取工作区会话列表，请稍后重试。'));
   }
 }
 
 function sessionBindErrorMessage(error) {
   if (error?.code === 'session-id-invalid') {
-    return `Session ID 格式无效。\n${SESSION_BIND_USAGE}`;
+    return t(`Session ID 格式无效。
+{usage}`, { usage: t(SESSION_BIND_USAGE) });
   }
   if (['session-not-registered', 'session-not-found'].includes(error?.code)) {
-    return '未找到该会话，请先执行 /sessionlist 确认 Session ID。';
+    return t('未找到该会话，请先执行 /sessionlist 确认 Session ID。');
   }
   if (error?.code === 'session-subagent-unsupported') {
-    return '子代理会话不能绑定到机器人对话，请选择普通会话。';
+    return t('子代理会话不能绑定到机器人对话，请选择普通会话。');
   }
   if (error?.code === 'session-workspace-ambiguous') {
-    return '该会话的工作区归属不明确，暂时无法绑定。';
+    return t('该会话的工作区归属不明确，暂时无法绑定。');
   }
   if (error?.code === 'session-summary-unavailable') {
-    return '暂时无法读取该会话的信息，请稍后重试。';
+    return t('暂时无法读取该会话的信息，请稍后重试。');
   }
   if (error?.code === 'workspace-bot-not-found') {
-    return '机器人正在移除或已重新接入，无法绑定原对话的会话。';
+    return t('机器人正在移除或已重新接入，无法绑定原对话的会话。');
   }
   if ([WORKSPACE_SESSION_STALE, 'agent-busy', 'session-conflict', 'workspace-conflict']
     .includes(error?.code)) {
-    return '工作区或会话状态已发生变化，请重试。';
+    return t('工作区或会话状态已发生变化，请重试。');
   }
-  return '暂时无法绑定会话，请稍后重试。';
+  return t('暂时无法绑定会话，请稍后重试。');
 }
 
 async function runSessionBindCommand(command, harness, conversationKey) {
@@ -285,7 +295,7 @@ async function runSessionBindCommand(command, harness, conversationKey) {
     // 序号模式：把 /session N 解析成当前工作区会话列表中的第 N 个会话
     if (typeof harness?.listWorkspaceSessions !== 'function'
       || typeof harness?.currentWorkspace !== 'function') {
-      return commandResult('当前机器人暂不支持按序号绑定，请使用 /session Session ID。');
+      return commandResult(t('当前机器人暂不支持按序号绑定，请使用 /session Session ID。'));
     }
     try {
       const selected = await selectedWorkspacePath(harness.currentWorkspace());
@@ -298,7 +308,7 @@ async function runSessionBindCommand(command, harness, conversationKey) {
       const position = Number(sessionId);
       if (!Number.isSafeInteger(position) || position < 1
         || position > listed.sessions.length) {
-        return commandResult('会话序号不存在，请先执行 /sessionlist 查看序号。');
+        return commandResult(t('会话序号不存在，请先执行 /sessionlist 查看序号。'));
       }
       const selectedSessionId = listed.sessions[position - 1]?.sessionId;
       if (!validSessionId(selectedSessionId)) {
@@ -309,15 +319,15 @@ async function runSessionBindCommand(command, harness, conversationKey) {
       if (error?.code === 'workspace-bot-not-found') {
         return commandResult(sessionBindErrorMessage(error));
       }
-      return commandResult('暂时无法获取会话列表，请稍后重试。');
+      return commandResult(t('暂时无法获取会话列表，请稍后重试。'));
     }
   }
-  if (!validSessionId(sessionId)) return commandResult(SESSION_BIND_USAGE);
+  if (!validSessionId(sessionId)) return commandResult(t(SESSION_BIND_USAGE));
   if (typeof harness?.bindWorkspaceSession !== 'function') {
-    return commandResult('当前机器人暂不支持绑定已有会话。');
+    return commandResult(t('当前机器人暂不支持绑定已有会话。'));
   }
   if (typeof conversationKey !== 'string' || !conversationKey) {
-    return commandResult('当前消息缺少可绑定的会话上下文。');
+    return commandResult(t('当前消息缺少可绑定的会话上下文。'));
   }
   try {
     const bound = await harness.bindWorkspaceSession(conversationKey, sessionId);
@@ -327,13 +337,13 @@ async function runSessionBindCommand(command, harness, conversationKey) {
     if (!workspace || !boundSessionId) {
       throw new TypeError('Harness returned an invalid bound session');
     }
-    const title = safeDisplayText(bound?.title) || '暂无标题';
+    const title = safeDisplayText(bound?.title) || t('暂无标题');
     const message = [
-      '当前聊天已绑定会话：',
-      `工作区：${workspace}`,
-      `标题：${title}`,
+      t('当前聊天已绑定会话：'),
+      t('工作区：{workspace}', { workspace }),
+      t('标题：{title}', { title }),
       `ID：${boundSessionId}`,
-      `归档：${bound?.archived === true ? '是' : '否'}`,
+      t('归档：{archived}', { archived: bound?.archived === true ? t('是') : t('否') }),
     ].join('\n');
     return commandResult(message, splitWorkspaceCommandMessage(message));
   } catch (error) {
@@ -355,20 +365,21 @@ export async function runWorkspaceCommand(text, harness, conversationKey) {
   if (!match) return null;
   const workspace = match[1]?.trim();
   if (!workspace) {
-    return commandResult('用法：/workspace 工作区绝对路径');
+    return commandResult(t('用法：/workspace 工作区绝对路径'));
   }
   if (typeof harness?.switchWorkspace !== 'function') {
-    return commandResult('当前机器人暂不支持切换工作区。');
+    return commandResult(t('当前机器人暂不支持切换工作区。'));
   }
   try {
     const current = await harness.switchWorkspace(workspace);
-    return commandResult(`工作区已切换为：${current}`);
+    return commandResult(t('工作区已切换为：{workspace}', { workspace: current }));
   } catch (error) {
     if (['workspace-not-absolute', 'workspace-not-found', 'workspace-not-directory'].includes(error?.code)) {
-      return commandResult(`${error.message}\n用法：/workspace 工作区绝对路径`);
+      return commandResult(t(`{message}
+用法：/workspace 工作区绝对路径`, { message: error.message }));
     }
     if (error?.code === 'workspace-bot-not-found') {
-      return commandResult('机器人正在移除或已重新接入，无法切换原会话的工作区。');
+      return commandResult(t('机器人正在移除或已重新接入，无法切换原会话的工作区。'));
     }
     throw error;
   }

package/src/channels/slack/config-store.mjs

@@ -2,6 +2,8 @@ import { createHash } from 'node:crypto';
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 
+import { t } from '../shared/i18n.mjs';
+
 const EMPTY_DOCUMENT = Object.freeze({ version: 1, bots: Object.freeze([]) });
 const BOT_ID_PATTERN = /^slack_[a-f0-9]{24}$/;
 const BOT_TOKEN_REF_PATTERN = /^DSH_SLACK_BOT_TOKEN_[A-F0-9]{24}$/;
@@ -27,7 +29,7 @@ export function maskSlackBotId(platformId) {
   const value = cleanString(platformId) ?? '';
   const [teamId, userId] = value.split(':');
   if (teamId && userId) return `${teamId.slice(0, 5)}••• · ${userId.slice(0, 5)}•••`;
-  return value ? `${value.slice(0, 6)}••••` : 'Slack机器人';
+  return value ? `${value.slice(0, 6)}••••` : t('Slack机器人');
 }
 
 export class SlackConfigStore {

package/src/channels/slack/slack-api.mjs

@@ -1,5 +1,6 @@
 import { fetchFileStream } from '../shared/file-download.mjs';
 import { fetchImageBuffer, ImagePromptError } from '../shared/image-prompt.mjs';
+import { t } from '../shared/i18n.mjs';
 
 const DEFAULT_BASE_URL = 'https://slack.com/api/';
 const SLACK_FILE_HOST = 'files.slack.com';
@@ -430,7 +431,7 @@ export class SlackApi {
         throw new ImagePromptError(
           'slack-file-access-required',
           'Slack redirected a private file request to the workspace because file access was not granted',
-          'Slack 未授权机器人读取该文件。请为应用添加 files:read 后重新安装，再重新发送图片。',
+          t('Slack 未授权机器人读取该文件。请为应用添加 files:read 后重新安装，再重新发送图片。'),
         );
       }
       return response;
@@ -505,19 +506,19 @@ export class SlackApi {
 
 export async function inspectSlackCredentials({ botToken, appToken }, options = {}) {
   if (!validSlackBotToken(botToken)) {
-    const error = new TypeError('Slack Bot Token 必须以 xoxb- 开头。');
+    const error = new TypeError(t('Slack Bot Token 必须以 xoxb- 开头。'));
     error.code = 'slack-invalid-bot-token';
     throw error;
   }
   if (!validSlackAppToken(appToken)) {
-    const error = new TypeError('Slack App Token 必须以 xapp- 开头。');
+    const error = new TypeError(t('Slack App Token 必须以 xapp- 开头。'));
     error.code = 'slack-invalid-app-token';
     throw error;
   }
   const api = new SlackApi({ botToken, appToken, ...options });
   const [identity, connection] = await Promise.all([api.authTest(), api.openConnection()]);
   if (!identity?.team_id || !identity?.user_id || !identity?.bot_id) {
-    throw new Error('Slack Bot Token 没有返回完整的机器人身份。');
+    throw new Error(t('Slack Bot Token 没有返回完整的机器人身份。'));
   }
   let socketUrl;
   try {
@@ -526,7 +527,7 @@ export async function inspectSlackCredentials({ botToken, appToken }, options =
     socketUrl = null;
   }
   if (!socketUrl || socketUrl.protocol !== 'wss:') {
-    const error = new Error('Slack App Token 无法创建 Socket Mode 连接，请确认已启用 Socket Mode 和 connections:write。');
+    const error = new Error(t('Slack App Token 无法创建 Socket Mode 连接，请确认已启用 Socket Mode 和 connections:write。'));
     error.code = 'slack-socket-mode';
     throw error;
   }

package/src/channels/slack/slack-controller.mjs

@@ -1,4 +1,5 @@
 import { connectionTestMessage } from '../shared/connection-test.mjs';
+import { t } from '../shared/i18n.mjs';
 import { deriveSlackBotIdentity, maskSlackBotId } from './config-store.mjs';
 import { inspectSlackCredentials } from './slack-api.mjs';
 import { SLACK_DESCRIPTOR } from './slack-bridge.mjs';
@@ -60,7 +61,7 @@ export class SlackController {
         if (!resolved) {
           this.#errors.set(config.botId, safeError(
             'missing-token',
-            'Slack机器人凭据缺失，请移除后重新接入。',
+            t('Slack机器人凭据缺失，请移除后重新接入。'),
           ));
           return;
         }
@@ -70,7 +71,7 @@ export class SlackController {
         } catch (error) {
           this.#errors.set(config.botId, safeError(
             'connection-failed',
-            'Slack Socket Mode 连接未就绪，插件会自动重试。',
+            t('Slack Socket Mode 连接未就绪，插件会自动重试。'),
           ));
           this.#logger.warn?.(
             `[dsh-im:slack] bot ${config.botId} failed to initialize:`,
@@ -135,7 +136,7 @@ export class SlackController {
       } catch (error) {
         this.#errors.set(identity.botId, safeError(
           'connection-failed',
-          'Slack机器人已接入，Socket Mode 连接暂未就绪。',
+          t('Slack机器人已接入，Socket Mode 连接暂未就绪。'),
         ));
         this.#logger.warn?.(
           `[dsh-im:slack] bot ${identity.botId} credential connection failed:`,
@@ -159,7 +160,7 @@ export class SlackController {
       } catch (error) {
         this.#errors.set(botId, safeError(
           'connection-failed',
-          'Slack Socket Mode 连接仍未就绪，请检查两个 Token。',
+          t('Slack Socket Mode 连接仍未就绪，请检查两个 Token。'),
         ));
         throw error;
       } finally {
@@ -175,13 +176,13 @@ export class SlackController {
     return this.#withBotTransition(botId, async () => {
       const runtime = this.#runtimes.get(botId);
       if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
-        const error = new Error('Slack机器人尚未连接');
+        const error = new Error(t('Slack机器人尚未连接'));
         error.code = 'test-target-unavailable';
         throw error;
       }
       await runtime.sendConnectionTest(connectionTestMessage(
         `${config.name}（${maskSlackBotId(config.platformId)}）`,
-        'Slack机器人',
+        t('Slack机器人'),
       ));
       return { sent: true };
     });
@@ -243,9 +244,9 @@ export class SlackController {
         },
         health: {
           status: connected ? 'healthy' : state === 'error' ? 'error' : 'offline',
-          summary: connected ? `Slack${SLACK_DESCRIPTOR.connectionLabel}运行正常`
-            : state === 'error' ? 'Slack连接未就绪，插件会自动重试'
-              : 'Slack连接当前离线',
+          summary: connected ? t(`Slack${SLACK_DESCRIPTOR.connectionLabel}运行正常`)
+            : state === 'error' ? t('Slack连接未就绪，插件会自动重试')
+              : t('Slack连接当前离线'),
           lastCheckedAt: runtimeStatus?.lastCheckedAt ?? null,
           lastConnectedAt: runtimeStatus?.lastConnectedAt ?? null,
         },

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

@@ -1,4 +1,5 @@
 import { splitMessageText } from '../shared/editable-message-stream.mjs';
+import { t } from '../shared/i18n.mjs';
 import { SlackApi } from './slack-api.mjs';
 import { createSlackBridgeStatus, SlackHarnessBridge } from './slack-bridge.mjs';
 
@@ -135,8 +136,18 @@ export function normalizeSlackEvent(payload, botUserId, {
   };
 }
 
-function isToolProgress(text) {
-  return typeof text === 'string' && /^正在使用.+…$/.test(text.trim());
+export function isSlackToolProgress(text) {
+  if (typeof text !== 'string') return false;
+  const marker = '__DSH_IM_TOOL_NAME__';
+  const template = t('正在使用{name}…', { name: marker });
+  const markerIndex = template.indexOf(marker);
+  if (markerIndex < 0) return false;
+  const prefix = template.slice(0, markerIndex);
+  const suffix = template.slice(markerIndex + marker.length);
+  const source = text.trim();
+  return source.startsWith(prefix)
+    && source.endsWith(suffix)
+    && source.length > prefix.length + suffix.length;
 }
 
 async function appendInChunks(api, target, ts, text, signal) {
@@ -204,7 +215,8 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
       return [...providerMessageIds];
     },
     update(text) {
-      if (closed || broken || typeof text !== 'string' || !text.trim() || isToolProgress(text)) return;
+      if (closed || broken || typeof text !== 'string' || !text.trim()
+        || isSlackToolProgress(text)) return;
       pending = text;
       schedule();
     },
@@ -217,7 +229,7 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
       await inFlight?.catch(() => undefined);
 
       const chunks = splitMessageText(text, SLACK_MESSAGE_LIMIT);
-      const first = chunks[0] ?? '处理完成。';
+      const first = chunks[0] ?? t('处理完成。');
       if (!broken && first.startsWith(appended)) {
         await appendInChunks(api, target, ts, first.slice(appended.length), signal);
         await api.stopStream({ channelId: target.channelId, ts, signal });

package/src/channels/telegram/config-store.mjs

@@ -1,3 +1,4 @@
+import { t } from '../shared/i18n.mjs';
 import {
   deriveTokenBotIdentity,
   maskPlatformId,
@@ -66,7 +67,7 @@ export function deriveTelegramBotIdentity(platformId) {
 }
 
 export function maskTelegramBotId(platformId) {
-  return maskPlatformId(platformId, 'Telegram机器人');
+  return maskPlatformId(platformId, t('Telegram机器人'));
 }
 
 export class TelegramConfigStore extends TokenBotConfigStore {