@xmanrui/dsh-im 4.19.1 → 4.19.2

package/scripts/verify-interface-language.mjs

@@ -0,0 +1,333 @@
+/**
+ * Run the built plugin through an original DSH CLI and prove that bot messages
+ * follow the DSH interface language (issue #185).
+ *
+ * Mirrors scripts/verify-lan-management.mjs: an isolated, empty home, the
+ * unmodified CLI, and real HTTP against the public /api carrier. Nothing is
+ * mocked — the assertions are on what the Host resolves from DSH's own
+ * user-settings document.
+ *
+ * Set DSH_IM_TELEGRAM_TOKEN to additionally bind a real bot and assert the
+ * command menu Telegram itself stores. That step is skipped without a token,
+ * and it restores the bot's original menu when it finishes.
+ */
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { access, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
+import { request as httpRequest } from 'node:http';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+
+const harnessRoot = process.argv[2];
+if (!harnessRoot || process.argv.includes('--help')) {
+  console.log('Usage: node scripts/verify-interface-language.mjs /path/to/built/deepseek-harness');
+  console.log('       DSH_IM_TELEGRAM_TOKEN=<token> node scripts/verify-interface-language.mjs ... (adds the live menu check)');
+  process.exit(harnessRoot ? 0 : 1);
+}
+const pluginRoot = resolve(import.meta.dirname, '..');
+await access(join(pluginRoot, 'lib/index.js'));
+
+/**
+ * Accept either a built Harness checkout or an installed @deepseek-ai/dsh
+ * package, so this runs against a release as well as a working tree.
+ */
+async function resolveHarness(root) {
+  const layouts = [
+    { kind: 'checkout', cli: 'apps/cli/lib/bin.js', base: 'packages/bundle/base', webApp: 'packages/bundle/web-app' },
+    { kind: 'package', cli: 'lib/bin.js', base: 'node_modules/@deepseek-ai/dsh-base', webApp: 'node_modules/@deepseek-ai/dsh-web-app' },
+  ];
+  for (const layout of layouts) {
+    const paths = {
+      kind: layout.kind,
+      cli: resolve(root, layout.cli),
+      base: resolve(root, layout.base),
+      webApp: resolve(root, layout.webApp),
+    };
+    try {
+      await Promise.all([access(paths.cli), access(paths.base), access(paths.webApp)]);
+      return paths;
+    } catch {
+      // Try the next known layout.
+    }
+  }
+  throw new Error(`no DSH CLI found under ${root}: expected apps/cli/lib/bin.js or lib/bin.js`);
+}
+
+const harness = await resolveHarness(harnessRoot);
+const cli = harness.cli;
+const botToken = process.env.DSH_IM_TELEGRAM_TOKEN;
+let telegramMenu;
+const directory = await mkdtemp(join(tmpdir(), 'dsh-im-language-test-'));
+const home = join(directory, 'home');
+const profile = join(home, 'profiles/web');
+const settingsPath = join(home, 'settings.yaml');
+const mirrorPath = join(home, 'integrations/dsh-im/interface-language.json');
+const results = [];
+let child;
+
+function request(url, { method = 'GET', headers = {}, body } = {}) {
+  return new Promise((resolveRequest, reject) => {
+    const req = httpRequest({
+      hostname: '127.0.0.1', port: url.port, path: `${url.pathname}${url.search}`,
+      method, headers: { host: url.host, ...headers },
+    }, res => {
+      let text = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { text += chunk; });
+      res.on('error', reject);
+      res.on('end', () => resolveRequest({ status: res.statusCode, headers: res.headers, body: text }));
+    });
+    req.on('error', reject);
+    req.setTimeout(15_000, () => req.destroy(new Error('HTTP request timed out')));
+    req.end(body);
+  });
+}
+
+function start() {
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => (
+    !/^DSH_/i.test(key) && !/(?:KEY|SECRET|TOKEN|PASSWORD|PROXY)/i.test(key)
+  )));
+  child = spawn(process.execPath, [cli, 'web', '--no-open', '--host', '127.0.0.1', '--port', '0'], {
+    cwd: directory,
+    env: { ...env, DSH_HOME: home, DSH_AGENTS_HOME: join(directory, '.agents'),
+      DSH_TELEMETRY_DISABLED: '1', SSH_CONNECTION: '', SSH_TTY: '' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return new Promise((resolveStart, reject) => {
+    let output = '';
+    const timer = setTimeout(() => finish(new Error('DSH startup timed out')), 60_000);
+    let settled = false;
+    function finish(error, url) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) reject(new Error(`${error.message}\n${output.replace(/([?&]token=)[^\s)]+/g, '$1<redacted>')}`));
+      else resolveStart(new URL(url));
+    }
+    function append(chunk) {
+      output = `${output}${chunk}`.slice(-100_000);
+      const match = /dsh web: (http:\/\/[^\s]+)/.exec(output);
+      if (match) finish(null, match[1]);
+    }
+    child.stdout.on('data', append);
+    child.stderr.on('data', append);
+    child.once('error', error => finish(error));
+    child.once('exit', code => finish(new Error(`DSH exited before readiness: ${code}`)));
+  });
+}
+
+async function stop() {
+  if (!child || child.exitCode !== null || child.signalCode !== null) return;
+  const stopped = new Promise(resolveStop => child.once('exit', resolveStop));
+  child.kill('SIGTERM');
+  const timer = setTimeout(() => child.kill('SIGKILL'), 10_000);
+  try { await stopped; } finally { clearTimeout(timer); }
+}
+
+async function login(launchUrl) {
+  const response = await request(launchUrl);
+  assert.equal(response.status, 303, 'Harness must exchange its launch token for a browser cookie');
+  const cookie = response.headers['set-cookie']?.map(value => value.split(';', 1)[0]).join('; ');
+  assert.ok(cookie, 'Harness did not issue a browser cookie');
+  const browser = { origin: launchUrl.origin, cookie };
+  // HTTP readiness precedes asynchronous plugin activation, notably after
+  // restart. Wait only for the route to appear; other failures stay fatal.
+  await waitFor('the plugin language route becomes ready after HTTP startup', async () => {
+    try {
+      const result = await rpc(browser, 'dsh-im-language', 'settings.language.get');
+      return result.ok === true;
+    } catch (error) {
+      if (error.code === 'ERR_ASSERTION' && error.actual === 404) return false;
+      throw error;
+    }
+  });
+  return browser;
+}
+
+async function rpc(browser, channel, method, payload = {}) {
+  const response = await request(new URL(`/api/dsh-im/${channel}`, browser.origin), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', origin: browser.origin, cookie: browser.cookie },
+    body: JSON.stringify({ type: 'client-request', rpcId: 'language-test',
+      method: `dsh-im/${channel}`, payload: { method, payload } }),
+  });
+  assert.equal(response.status, 200, `${channel}/${method} -> HTTP ${response.status}: ${response.body.slice(0, 300)}`);
+  return JSON.parse(response.body).result;
+}
+
+/** Rewrite only the `locale` section, leaving the rest of the document alone. */
+async function selectInterfaceLanguage(value) {
+  let raw = '';
+  try { raw = await readFile(settingsPath, 'utf8'); } catch { raw = ''; }
+  const withoutLocale = raw.replace(/(^|\n)locale:\n(?:[ \t]+.*\n?)*/g, '$1').trimEnd();
+  await writeFile(settingsPath, value === null
+    ? `${withoutLocale}\n`
+    : `${withoutLocale}\nlocale:\n  preference: ${value}\n`, 'utf8');
+}
+
+async function waitFor(describe, predicate, { attempts = 60, delayMs = 250 } = {}) {
+  let last;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    last = await predicate();
+    if (last) return last;
+    await new Promise(sleep => setTimeout(sleep, delayMs));
+  }
+  throw new Error(`${describe} never held (last: ${JSON.stringify(last)?.slice(0, 300)})`);
+}
+
+function record(check, detail) {
+  results.push({ check, detail: detail ?? '', result: 'PASS' });
+}
+
+const HAN = /[\p{Script=Han}]/u;
+
+async function telegram(method, payload) {
+  const response = await fetch(`https://api.telegram.org/bot${botToken}/${method}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(payload ?? {}),
+  });
+  const parsed = await response.json();
+  assert.equal(parsed.ok, true, `telegram ${method} failed`);
+  return parsed.result;
+}
+
+try {
+  await mkdir(profile, { recursive: true });
+  const packages = {
+    '@deepseek-ai/dsh-base': harness.base,
+    '@deepseek-ai/dsh-web-app': harness.webApp,
+    '@xmanrui/dsh-im': pluginRoot,
+  };
+  for (const [name, path] of Object.entries(packages)) {
+    const target = join(profile, 'node_modules', name);
+    await mkdir(dirname(target), { recursive: true });
+    await symlink(path, target, 'dir');
+  }
+  await writeFile(join(profile, 'cordis.yml'), '[]\n');
+  await writeFile(join(profile, 'package.json'), JSON.stringify({
+    name: 'dsh-im-language-test', private: true,
+    dependencies: Object.fromEntries(Object.entries(packages).map(([name, path]) => [name, `link:${path}`])),
+    dsh: { profile: { bundles: Object.keys(packages) } },
+  }));
+
+  // A Chinese interface selection, exactly as DSH's Language row stores it.
+  await selectInterfaceLanguage('zh');
+  let browser = await login(await start());
+  const language = (method, payload) => rpc(browser, 'dsh-im-language', method, payload);
+
+  const initial = await language('settings.language.get');
+  assert.equal(initial.ok, true, JSON.stringify(initial));
+  assert.deepEqual(initial.value, { language: 'zh', tag: 'zh', source: 'settings', pinned: false },
+    'the plugin must read DSH\'s own locale preference');
+  record('DSH locale namespace is registered and read Host-side', JSON.stringify(initial.value));
+
+  await selectInterfaceLanguage('en');
+  const switched = await waitFor('the bot language follows DSH to English', async () => {
+    const snapshot = await language('settings.language.get');
+    return snapshot.value?.language === 'en' ? snapshot.value : null;
+  });
+  assert.deepEqual(switched, { language: 'en', tag: 'en', source: 'settings', pinned: false });
+  record('switching DSH\'s interface language switches the bot language live', 'no restart');
+
+  const mirrored = await language('settings.language.mirror', { locale: 'zh-CN' });
+  assert.deepEqual(mirrored.value, { language: 'en', tag: 'en', source: 'settings', pinned: false },
+    'the mirror must never outrank an explicit selection');
+  record('an explicit DSH selection outranks the mirrored interface locale', 'settings > mirror');
+
+  await selectInterfaceLanguage(null);
+  const fallback = await waitFor('the mirror applies once the selection is cleared', async () => {
+    const snapshot = await language('settings.language.get');
+    return snapshot.value?.source === 'mirror' ? snapshot.value : null;
+  });
+  assert.deepEqual(fallback, { language: 'zh', tag: 'zh-CN', source: 'mirror', pinned: false });
+  record('clearing the selection falls back to the mirrored interface locale', 'mirror > default');
+
+  // The reported case: an English interface that DSH never stored, because it
+  // came from the browser's language list rather than the Language row.
+  const browserEnglish = await language('settings.language.mirror', { locale: 'en-GB' });
+  assert.deepEqual(browserEnglish.value, { language: 'en', tag: 'en-GB', source: 'mirror', pinned: false });
+  assert.deepEqual(JSON.parse(await readFile(mirrorPath, 'utf8')),
+    { version: 1, interfaceLanguage: 'en-GB' });
+  record('a browser-derived English interface reaches the Host and is persisted', 'issue #185 case');
+
+  for (const [method, payload] of [
+    ['settings.language.mirror', { locale: 'not a tag' }],
+    ['settings.language.mirror', {}],
+    ['settings.language.get', { locale: 'en' }],
+    ['settings.language.unknown', {}],
+  ]) {
+    const refused = await language(method, payload);
+    assert.equal(refused.ok, false, `${method} must be refused`);
+    assert.equal(refused.error.code, 'bad-request');
+  }
+  record('the language route refuses malformed payloads', '4 cases');
+
+  if (botToken) {
+    telegramMenu = await telegram('getMyCommands');
+    const bound = await rpc(browser, 'telegram', 'bot.bind-credentials', { token: botToken });
+    assert.equal(bound.ok, true, 'the bot must bind');
+    const botId = bound.value.bots.at(-1).botId;
+    await waitFor('the bot connects', async () => {
+      const status = await rpc(browser, 'telegram', 'connection.status');
+      return status.value?.bots?.find(item => item.botId === botId)?.connected ? true : null;
+    });
+    const english = await waitFor('Telegram stores the English menu', async () => {
+      const commands = await telegram('getMyCommands');
+      const help = commands.find(item => item.command === 'help');
+      return help && !HAN.test(help.description) ? commands : null;
+    });
+    record('Telegram stores the English command menu while DSH is English', `${english.length} commands`);
+
+    await selectInterfaceLanguage('zh');
+    const chinese = await waitFor('Telegram stores the Chinese menu after the switch', async () => {
+      const commands = await telegram('getMyCommands');
+      const help = commands.find(item => item.command === 'help');
+      return help && HAN.test(help.description) ? commands : null;
+    });
+    assert.equal(chinese.length, english.length, 'the same catalog in another language');
+    const still = await rpc(browser, 'telegram', 'connection.status');
+    assert.equal(still.value.bots.find(item => item.botId === botId).connected, true,
+      'the command menu must be re-sent without reconnecting the bot');
+    record('switching language re-sends the Telegram menu with no reconnect', `${chinese.length} commands`);
+    await selectInterfaceLanguage(null);
+  }
+
+  // A restart must keep answering in the mirrored language, before any browser
+  // connects, and must resolve it before the first bot registers its menu.
+  await stop();
+  const restarted = await login(await start());
+  browser = restarted;
+  const afterRestart = await rpc(restarted, 'dsh-im-language', 'settings.language.get');
+  assert.deepEqual(afterRestart.value, { language: 'en', tag: 'en-GB', source: 'mirror', pinned: false });
+  record('the mirrored language survives a Host restart', 'resolved before channels start');
+
+  // Back-compatibility: an operator pin keeps winning and ignores DSH entirely.
+  await stop();
+  await writeFile(join(profile, 'cordis.patch.yml'),
+    '- id: xmanrui-dsh-im\n  config:\n    language: zh-CN\n');
+  await selectInterfaceLanguage('en');
+  const pinnedBrowser = await login(await start());
+  const pinned = await rpc(pinnedBrowser, 'dsh-im-language', 'settings.language.get');
+  assert.deepEqual(pinned.value, { language: 'zh', tag: 'zh-CN', source: 'config', pinned: true },
+    'a configured language must ignore DSH\'s interface language');
+  record('an operator-configured language still wins', 'existing setups unchanged');
+
+  console.table(results);
+  console.log(`Passed ${results.length} real HTTP checks against an unmodified DSH CLI (${harness.kind} layout).`);
+  console.log(botToken
+    ? 'The live Telegram menu was exercised and the bot\'s original menu was restored.'
+    : 'Set DSH_IM_TELEGRAM_TOKEN to additionally assert the menu Telegram itself stores.');
+  console.log('The temporary home contains no bot credentials and is removed after the server stops.');
+} finally {
+  await stop();
+  if (botToken && telegramMenu !== undefined) {
+    try {
+      if (telegramMenu.length > 0) await telegram('setMyCommands', { commands: telegramMenu });
+      else await telegram('deleteMyCommands');
+    } catch {
+      console.error('could not restore the bot\'s original command menu');
+    }
+  }
+  await rm(directory, { recursive: true, force: true });
+}

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

@@ -149,7 +149,7 @@ async function sendThreadUncertainNotice(api, normalized, signal) {
     await api.createMessage({
       channelId: normalized.replyTarget.channelId,
       replyToMessageId: normalized.replyTarget.replyToMessageId,
-      content: 'Thread 创建结果暂时无法确认。若已创建，请在对应 Thread 中重试；若未创建，请稍后重新 @机器人。',
+      content: t('Thread 创建结果暂时无法确认。若已创建，请在对应 Thread 中重试；若未创建，请稍后重新 @机器人。'),
       signal,
     });
   } catch (error) {

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

@@ -5,4 +5,6 @@ export default {
     'The Discord Gateway Intents are misconfigured. Please check the Bot settings in the Developer Portal.',
   'Discord机器人': 'Discord Bot',
   ' Gateway 长连接': ' Gateway long-lived connection',
+  'Thread 创建结果暂时无法确认。若已创建，请在对应 Thread 中重试；若未创建，请稍后重新 @机器人。':
+    'The Thread creation result cannot be confirmed yet. If the Thread was created, retry inside it; if it was not, mention the bot again shortly.',
 };

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

@@ -1,5 +1,10 @@
 // English translations (telegram area). Keys are exact Chinese literals passed to t().
 export default {
+  // Terminal status written back over a placeholder whose in-place edit was
+  // rejected, so it is the last thing a reader sees on a degraded reply.
+  '回复已发送。': 'The reply was sent.',
+  '回复发送结果未能确认。': 'The reply delivery result could not be confirmed.',
+  '消息发送失败，请稍后重试。': 'The message could not be sent. Try again later.',
   '开启一个全新会话': 'Start a brand-new Session',
   '压缩当前会话的较早上下文': 'Compact the earlier context of the current Session',
   '切换工作区': 'Switch Workspace',

package/src/channels/shared/i18n.mjs

@@ -10,17 +10,60 @@ import { EN } from './i18n-en.mjs';
 
 let language = 'zh';
 
+const listeners = new Set();
+
 // Accepts 'en', 'en-US', 'english' (any case) as English; anything else
-// (including undefined and unrecognized values) selects Chinese.
-export function setImHostLanguage(lang) {
+// (including undefined and unrecognized values) selects Chinese. Pure: use it
+// to judge a candidate tag without switching the active language.
+export function normalizeImHostLanguage(lang) {
   const normalized = typeof lang === 'string' ? lang.trim().toLowerCase() : '';
-  language = normalized === 'english' || /^en(?:[-_].*)?$/u.test(normalized) ? 'en' : 'zh';
+  return normalized === 'english' || /^en(?:[-_].*)?$/u.test(normalized) ? 'en' : 'zh';
+}
+
+/**
+ * Select the language of every host-side message. Subscribers registered
+ * through onImHostLanguageChange are notified only when the resolved language
+ * actually changes, so re-applying the same selection in a different spelling
+ * (or an unrecognized tag that keeps falling back to Chinese) is free.
+ */
+export function setImHostLanguage(lang) {
+  const next = normalizeImHostLanguage(lang);
+  if (next === language) return language;
+  const previous = language;
+  language = next;
+  // Snapshot first: a subscriber may unsubscribe (or subscribe) while running.
+  for (const listener of [...listeners]) {
+    if (!listeners.has(listener)) continue;
+    try {
+      listener(next, previous);
+    } catch {
+      // Each subscriber owns its own diagnostics; one that fails must not
+      // strand the rest, nor abandon a language switch that already happened.
+    }
+  }
+  return language;
 }
 
 export function getImHostLanguage() {
   return language;
 }
 
+/**
+ * Observe committed changes to the host message language. Platform-side
+ * surfaces that were localized once at connect time (the Telegram command
+ * menu, for example) re-synchronize from here instead of waiting for a
+ * reconnect. Subscribers must not throw; the disposer is idempotent.
+ */
+export function onImHostLanguageChange(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('onImHostLanguageChange requires a listener function');
+  }
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
 // Translate a user-facing Chinese literal. In zh mode (the default) this is
 // the identity function. Optional `params` fills `{name}` placeholders in
 // both the Chinese key and its translation, e.g.

package/src/channels/shared/interface-language-store.mjs

@@ -0,0 +1,127 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+
+import { normalizeInterfaceLanguageTag } from './interface-language.mjs';
+
+const DOCUMENT_VERSION = 1;
+
+function invalidTagError() {
+  const error = new Error('Invalid DSH interface language tag.');
+  error.code = 'interface-language-invalid';
+  return error;
+}
+
+// Mirrors the atomic settings writes of the inbound attachment TTL store and
+// the update service: create a private temporary file, then rename it in.
+async function writeSettingsDocument(path, document) {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, {
+      encoding: 'utf8',
+      mode: 0o600,
+      flag: 'wx',
+    });
+    await rename(temporary, path);
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error.code !== 'ENOENT') throw error;
+    });
+  }
+}
+
+/**
+ * Durable mirror of the DSH interface language, so bot messages keep following
+ * it across Host restarts and before any browser has connected. Only the
+ * lowest resolution layer lives here (see ./interface-language.mjs): an
+ * unreadable document resolves to "nothing mirrored" rather than pinning a
+ * language nobody chose.
+ */
+export class InterfaceLanguageStore {
+  #path;
+  #tag = null;
+  // Whether the document on disk is known to already say what #tag says. False
+  // for a missing or unreadable document, so the next report repairs it.
+  #stored = false;
+
+  constructor(path) {
+    if (typeof path !== 'string' || !path) {
+      throw new TypeError('interface language store path is required');
+    }
+    this.#path = path;
+  }
+
+  async load() {
+    let raw;
+    try {
+      raw = await readFile(this.#path, 'utf8');
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      this.#tag = null;
+      this.#stored = false;
+      await this.#removeStaleTemporaries();
+      return this;
+    }
+    const read = this.#readTag(raw);
+    this.#tag = read === undefined ? null : read;
+    this.#stored = read !== undefined;
+    await this.#removeStaleTemporaries();
+    return this;
+  }
+
+  // Crash leftovers from an interrupted atomic write are unreferenced by
+  // anyone; remove them so the settings directory stays clean.
+  async #removeStaleTemporaries() {
+    const directory = dirname(this.#path);
+    const prefix = `${basename(this.#path)}.`;
+    try {
+      const entries = await readdir(directory);
+      await Promise.all(entries
+        .filter((name) => name.startsWith(prefix) && name.endsWith('.tmp'))
+        .map((name) => unlink(join(directory, name)).catch(() => {})));
+    } catch {
+      // A missing directory or concurrent removal is fine; cleanup is best-effort.
+    }
+  }
+
+  // Returns the mirrored tag (null when the document mirrors nothing), or
+  // undefined when the document is damaged or from an unknown future version.
+  #readTag(raw) {
+    let document;
+    try {
+      document = JSON.parse(raw);
+    } catch {
+      return undefined;
+    }
+    if (!document || typeof document !== 'object' || Array.isArray(document)) return undefined;
+    if (document.version !== DOCUMENT_VERSION) return undefined;
+    if (document.interfaceLanguage === undefined) return null;
+    return normalizeInterfaceLanguageTag(document.interfaceLanguage) ?? undefined;
+  }
+
+  getLanguageTag() {
+    return this.#tag;
+  }
+
+  /**
+   * Record the interface language reported by the settings UI. Passing null
+   * clears the mirror, returning resolution to the layers above it. The
+   * settings page reports its locale on every mount, so an unchanged value is
+   * accepted without rewriting the document.
+   */
+  async setLanguageTag(value) {
+    const tag = value === null || value === undefined
+      ? null
+      : normalizeInterfaceLanguageTag(value);
+    if (tag === null && value !== null && value !== undefined) throw invalidTagError();
+    if (tag === this.#tag && this.#stored) return tag;
+    await writeSettingsDocument(this.#path, {
+      version: DOCUMENT_VERSION,
+      ...(tag === null ? {} : { interfaceLanguage: tag }),
+    });
+    this.#tag = tag;
+    this.#stored = true;
+    return tag;
+  }
+}

package/src/channels/shared/interface-language.mjs

@@ -0,0 +1,51 @@
+// Resolution policy for the DSH interface language that dsh-im's bot messages
+// follow.
+//
+// The host message language (./i18n.mjs) is a two-value switch: English, or
+// Chinese as the always-available fallback. The DSH interface language is a
+// BCP 47-style tag that a language pack may extend beyond the shipped zh/en
+// pair, so a tag is carried verbatim through resolution and persistence and is
+// collapsed to a dictionary language only where it reaches setImHostLanguage().
+
+/** Tag shape accepted by DSH's own locale preference (@deepseek-ai/dsh-client-locale). */
+const LANGUAGE_TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/u;
+
+/**
+ * Resolution layers, highest precedence first.
+ *
+ * - `config`: the plugin's own `language` option (or `DSH_IM_LANGUAGE`). An
+ *   operator who pinned a language in the Host composition keeps it, whatever
+ *   any individual browser reads the interface in.
+ * - `settings`: the explicit selection in DSH's Language row, read from the
+ *   Host user-settings document. This is the setting users mean by "DSH is set
+ *   to English".
+ * - `mirror`: the last effective interface locale reported by the settings UI.
+ *   DSH stores nothing when the interface language came from the browser's
+ *   language list, so without this layer a reader who never opened the
+ *   Language row would still be answered in Chinese.
+ */
+export const HOST_LANGUAGE_SOURCES = Object.freeze(['config', 'settings', 'mirror']);
+
+/**
+ * Normalize one interface-language tag. Surrounding whitespace is trimmed;
+ * anything that is not a BCP 47-style tag returns null so a malformed layer is
+ * skipped rather than silently overriding the layers below it.
+ */
+export function normalizeInterfaceLanguageTag(value) {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return LANGUAGE_TAG.test(trimmed) ? trimmed : null;
+}
+
+/**
+ * Pick the winning interface-language tag across the layers, in
+ * HOST_LANGUAGE_SOURCES order. Returns `{ tag: null, source: 'default' }` when
+ * no layer names a usable tag, which keeps Chinese as the shipped default.
+ */
+export function resolveHostLanguageTag(layers = {}) {
+  for (const source of HOST_LANGUAGE_SOURCES) {
+    const tag = normalizeInterfaceLanguageTag(layers[source]);
+    if (tag !== null) return { tag, source };
+  }
+  return { tag: null, source: 'default' };
+}

package/src/channels/shared/token-bot-controller.mjs

@@ -324,6 +324,32 @@ export class TokenBotController {
     };
   }
 
+  /**
+   * Re-synchronize the platform-side command menu of every connected bot.
+   *
+   * Called when the host message language changes: a menu the platform stored
+   * at connect time would otherwise keep the previous language until the bot
+   * reconnected. Runtimes of channels without a platform-side menu expose no
+   * refresh hook and are skipped, and one bot's failure never hides the rest.
+   * @returns the number of bots that accepted a refreshed menu.
+   */
+  async refreshCommandMenus() {
+    if (this.#closed) return 0;
+    const refreshed = await Promise.all([...this.#runtimes].map(async ([botId, runtime]) => {
+      if (typeof runtime?.refreshCommandMenu !== 'function') return false;
+      try {
+        return await runtime.refreshCommandMenu() === true;
+      } catch (error) {
+        this.#logger.warn?.(
+          `[dsh-im:${this.#descriptor.key}] bot ${botId} command menu refresh failed:`,
+          error,
+        );
+        return false;
+      }
+    }));
+    return refreshed.filter(Boolean).length;
+  }
+
   async close() {
     if (this.#closed) return;
     this.#closed = true;