@xmanrui/dsh-im 4.19.1 → 4.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.19.1",
+  "version": "4.19.2",
   "description": "把十一种 IM 渠道和公网 AI Office 接入本机 DeepSeek Harness。 Connect eleven IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",
@@ -52,6 +52,10 @@
     {
       "name": "geekyfoxlab",
       "url": "https://github.com/geekyfoxlab"
+    },
+    {
+      "name": "grloper",
+      "url": "https://github.com/grloper"
     }
   ],
   "license": "MIT",

package/plugin-src/client/index.js

@@ -51,6 +51,10 @@ import { IMESSAGE_RPC_CHANNEL } from './channels/imessage/api.js';
 import { IMessageSettingsTab } from './channels/imessage/index.js';
 import { installIMessageStyles } from './channels/imessage/styles.js';
 import { en, h, IM_LOCALE_NAMESPACE, setImTranslator, zh } from './i18n.js';
+import {
+  HOST_LANGUAGE_RPC_CHANNEL,
+  installInterfaceLanguageMirror,
+} from './interface-language.js';
 import { BotSettingsContext } from './channel-card-meta.js';
 import {
   DELIVERY_RPC_CHANNEL,
@@ -398,6 +402,17 @@ export function apply(ctx) {
   const t = ctx.locale.bind(IM_LOCALE_NAMESPACE);
   setImTranslator(t);
 
+  // The settings page is the only place that knows the locale the interface is
+  // actually rendered in: DSH stores nothing when it came from the browser's
+  // language list. Report it so bot messages follow the same language.
+  ctx.effect(
+    () => installInterfaceLanguageMirror(ctx, {
+      rpcCall: (endpoint, payload, signal) =>
+        callManagementRpc(ctx.connection, HOST_LANGUAGE_RPC_CHANNEL, endpoint, payload, signal),
+    }),
+    'im-settings: mirror the DSH interface language',
+  );
+
   ctx.effect(() => installSessionChannelLogos(), 'im-settings: Session channel logos');
 
   ctx.effect(() => {

package/plugin-src/client/interface-language.js

@@ -0,0 +1,89 @@
+import { normalizeInterfaceLanguageTag } from '../../src/channels/shared/interface-language.mjs';
+import { createPollScheduler } from './lifecycle.js';
+
+/** Host route serving the interface-language mirror (plugin-src/host/host-language-rpc.mjs). */
+export const HOST_LANGUAGE_RPC_CHANNEL = '/dsh-im-language';
+export const HOST_LANGUAGE_ENDPOINTS = Object.freeze({
+  get: 'settings.language.get',
+  mirror: 'settings.language.mirror',
+});
+
+/** Widening retry delays for a report the Connection could not carry yet. */
+const RETRY_DELAYS_MS = Object.freeze([1_000, 4_000, 15_000]);
+
+/**
+ * Report the locale the settings UI is actually rendered in to the Host, so
+ * bot chat messages and command menus follow the DSH interface language.
+ *
+ * DSH stores a locale preference only when the reader picks one in the
+ * Language row: a locale derived from the browser's language list leaves the
+ * Host user-settings document empty. This mirror closes that gap, and the Host
+ * keeps an explicit selection ranked above it (see
+ * src/channels/shared/interface-language.mjs).
+ *
+ * The first report runs at plugin load, when the Connection may not be
+ * established yet, so a failed report is retried on a widening delay rather
+ * than waiting for a locale change that may never come. A failure is both a
+ * rejected promise and a resolved `{ ok: false }` envelope — the Host returns
+ * the latter when it could not persist the mirror, and that must retry too.
+ *
+ * @param ctx - client cordis context providing `locale` and the event bus.
+ * @param options.rpcCall - management RPC caller for HOST_LANGUAGE_RPC_CHANNEL.
+ * @returns an idempotent disposer that stops reporting and cancels any retry.
+ */
+export function installInterfaceLanguageMirror(ctx, {
+  rpcCall,
+  setTimeoutFn = (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+  clearTimeoutFn = (timer) => globalThis.clearTimeout(timer),
+  retryDelaysMs = RETRY_DELAYS_MS,
+} = {}) {
+  if (typeof rpcCall !== 'function' || typeof ctx?.locale?.getLocale !== 'function') {
+    return () => {};
+  }
+  const delays = retryDelaysMs.length > 0 ? retryDelaysMs : RETRY_DELAYS_MS;
+  const scheduler = createPollScheduler({ setTimeoutFn, clearTimeoutFn });
+  let mirrored = null;
+  let attempt = 0;
+
+  const retry = (active) => {
+    // Leave the tag unmirrored so the retry re-sends it. A Host that cannot
+    // persist the mirror still answers in its stored language; there is
+    // nothing for the reader to act on here.
+    if (mirrored === active) mirrored = null;
+    scheduler.schedule(report, delays[Math.min(attempt, delays.length - 1)]);
+    attempt += 1;
+  };
+
+  const report = () => {
+    if (scheduler.disposed) return;
+    const active = normalizeInterfaceLanguageTag(ctx.locale.getLocale()?.active);
+    if (active === null || active === mirrored) return;
+    mirrored = active;
+    Promise.resolve(rpcCall(HOST_LANGUAGE_ENDPOINTS.mirror, { locale: active })).then(
+      (result) => {
+        // Connection resolves failed business results normally; only a
+        // resolved ok envelope proves the Host actually persisted the mirror.
+        if (result?.ok === true) {
+          attempt = 0;
+          return;
+        }
+        retry(active);
+      },
+      () => retry(active),
+    );
+  };
+
+  report();
+  // A deliberate switch is worth reporting immediately, so it restarts the
+  // delay ladder instead of inheriting a previous failure's backoff.
+  const off = typeof ctx.on === 'function'
+    ? ctx.on('locale/change', () => {
+      attempt = 0;
+      report();
+    })
+    : null;
+  return () => {
+    scheduler.dispose();
+    if (typeof off === 'function') off();
+  };
+}

package/plugin-src/host/channels/shared/startup.mjs

@@ -1,7 +1,29 @@
 import { registerManagementRpc } from '../../../management-rpc.mjs';
+import { onImHostLanguageChange } from '../../../../src/channels/shared/i18n.mjs';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
 import { publicChannelInitializing, publicChannelStartupError } from './startup-error.mjs';
 
+/**
+ * Keep a channel's platform-side command menu in the current host message
+ * language. Menus are registered with the platform when a bot connects, so a
+ * later language change has to re-send them; channels that publish no menu
+ * expose no refresh hook and are left alone.
+ */
+function followHostLanguage(ctx, channel, controller, logger) {
+  if (typeof controller?.refreshCommandMenus !== 'function') return;
+  const unsubscribe = onImHostLanguageChange(() => {
+    // Never run a slow or failing platform call inside the language switch:
+    // subscribers are synchronous and must not delay or break one another.
+    void Promise.resolve()
+      .then(() => controller.refreshCommandMenus())
+      .catch((error) => logger.warn?.(
+        `[dsh-im] failed to re-send the ${channel} command menu after a language change`,
+        error,
+      ));
+  });
+  ctx.effect(() => unsubscribe, `dsh-im: follow the host language for ${channel} command menus`);
+}
+
 /** Mount the native management RPC before any fallible production initialization. */
 export async function installProductionChannel(ctx, config, {
   channel, rpcChannel, createProduction, createHandler,
@@ -31,6 +53,7 @@ export async function installProductionChannel(ctx, config, {
       ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
     const readyHandler = createHandler(production.controller);
     ctx.effect(() => closeProduction, `dsh-im: close ${channel} connections`);
+    followHostLanguage(ctx, channel, production.controller, logger);
     handler = readyHandler;
   } catch (error) {
     startupError = publicChannelStartupError(channel, error);

package/plugin-src/host/host-language-rpc.mjs

@@ -0,0 +1,71 @@
+import { registerManagementRpc } from '../management-rpc.mjs';
+import { normalizeInterfaceLanguageTag } from '../../src/channels/shared/interface-language.mjs';
+
+export const HOST_LANGUAGE_RPC_CHANNEL = '/dsh-im-language';
+export const HOST_LANGUAGE_ENDPOINTS = Object.freeze({
+  get: 'settings.language.get',
+  mirror: 'settings.language.mirror',
+});
+
+const ENDPOINTS = new Set(Object.values(HOST_LANGUAGE_ENDPOINTS));
+
+export function validHostLanguagePayload(endpoint, payload) {
+  if (!ENDPOINTS.has(endpoint)) return false;
+  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return false;
+  const keys = Object.keys(payload);
+  if (endpoint === HOST_LANGUAGE_ENDPOINTS.mirror) {
+    if (keys.length !== 1 || keys[0] !== 'locale') return false;
+    // An explicit null clears the mirror; anything else must be a usable tag.
+    return payload.locale === null || normalizeInterfaceLanguageTag(payload.locale) !== null;
+  }
+  return keys.length === 0;
+}
+
+/**
+ * Serve the interface-language mirror. The settings UI is the only caller: it
+ * knows the locale the interface is actually rendered in, including a
+ * browser-derived one that DSH never stores.
+ */
+export function createHostLanguageRpcHandler({ controller, logger = null } = {}) {
+  if (!controller || typeof controller.snapshot !== 'function'
+    || typeof controller.mirror !== 'function') {
+    throw new TypeError('createHostLanguageRpcHandler requires a host language controller');
+  }
+  return async (endpoint, payload, signal) => {
+    if (!validHostLanguagePayload(endpoint, payload)) {
+      return { ok: false, error: { code: 'bad-request', message: 'Invalid interface language request.' } };
+    }
+    if (signal?.aborted) {
+      return { ok: false, error: { code: 'cancelled', message: 'Request cancelled.' } };
+    }
+    try {
+      if (endpoint === HOST_LANGUAGE_ENDPOINTS.get) {
+        return { ok: true, value: controller.snapshot() };
+      }
+      return { ok: true, value: await controller.mirror(payload.locale) };
+    } catch (error) {
+      // The failure is almost always a settings-directory write problem; keep
+      // the path and the underlying message out of the browser response.
+      logger?.warn?.('[dsh-im] could not persist the mirrored DSH interface language', error);
+      return {
+        ok: false,
+        error: {
+          code: 'interface-language-unavailable',
+          message: 'interface-language-unavailable',
+        },
+      };
+    }
+  };
+}
+
+export function installHostLanguageRpc(ctx, controller, authority) {
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:language')
+    : (ctx?.logger ?? null);
+  return registerManagementRpc(
+    ctx,
+    HOST_LANGUAGE_RPC_CHANNEL,
+    createHostLanguageRpcHandler({ controller, logger }),
+    { authority },
+  );
+}

package/plugin-src/host/host-language.mjs

@@ -0,0 +1,157 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import {
+  getImHostLanguage,
+  normalizeImHostLanguage,
+  onImHostLanguageChange,
+  setImHostLanguage,
+} from '../../src/channels/shared/i18n.mjs';
+import {
+  normalizeInterfaceLanguageTag,
+  resolveHostLanguageTag,
+} from '../../src/channels/shared/interface-language.mjs';
+import { InterfaceLanguageStore } from '../../src/channels/shared/interface-language-store.mjs';
+
+/** Settings namespace and field owned by @deepseek-ai/dsh-client-locale. */
+export const DSH_LOCALE_NAMESPACE = 'locale';
+export const DSH_LOCALE_PREFERENCE_FIELD = 'preference';
+
+/**
+ * Resolve the durable interface-language mirror. The dshHome resolution
+ * mirrors pluginPaths: config.dshHome, then DSH_HOME, then the user's home
+ * directory. Channel-specific dataDir values never apply.
+ */
+export function interfaceLanguageSettingsPath(config = {}) {
+  const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
+  return resolve(dshHome, 'integrations', 'dsh-im', 'interface-language.json');
+}
+
+/**
+ * Own the host message language across its resolution layers. `apply()` is
+ * idempotent: it re-resolves the layers and hands the winner to
+ * setImHostLanguage, which notifies observers only on a real change.
+ */
+export function createHostLanguageController({
+  store = null,
+  config: configLanguage,
+  readSettingsPreference = () => undefined,
+  logger = null,
+} = {}) {
+  const pinned = normalizeInterfaceLanguageTag(configLanguage);
+  let readPreference = typeof readSettingsPreference === 'function'
+    ? readSettingsPreference
+    : () => undefined;
+
+  const settingsTag = () => {
+    // A pinned language wins outright, so never consult the settings service
+    // for it: a detached provider must not produce a spurious diagnostic.
+    if (pinned !== null) return undefined;
+    try {
+      return readPreference();
+    } catch (error) {
+      logger?.warn?.(
+        '[dsh-im] could not read the DSH interface language preference; using the mirrored language',
+        error,
+      );
+      return undefined;
+    }
+  };
+
+  const mirrorTag = () => (typeof store?.getLanguageTag === 'function' ? store.getLanguageTag() : null);
+
+  const resolution = () => resolveHostLanguageTag({
+    config: configLanguage,
+    settings: settingsTag(),
+    mirror: mirrorTag(),
+  });
+
+  const describe = (resolved) => Object.freeze({
+    language: normalizeImHostLanguage(resolved.tag),
+    tag: resolved.tag,
+    source: resolved.source,
+    pinned: pinned !== null,
+  });
+
+  const apply = () => {
+    const resolved = resolution();
+    setImHostLanguage(resolved.tag ?? undefined);
+    return describe(resolved);
+  };
+
+  return Object.freeze({
+    apply,
+
+    /** The resolution as it stands, without switching the active language. */
+    snapshot: () => describe(resolution()),
+
+    /** Record the interface locale reported by the settings UI, then re-resolve. */
+    async mirror(value) {
+      if (typeof store?.setLanguageTag !== 'function') return apply();
+      await store.setLanguageTag(value ?? null);
+      return apply();
+    },
+
+    /** Replace the settings-preference reader once the service is injectable. */
+    observeSettings(read) {
+      readPreference = typeof read === 'function' ? read : () => undefined;
+      return apply();
+    },
+
+    /** Observe committed host language changes (see onImHostLanguageChange). */
+    observe: onImHostLanguageChange,
+
+    /** The active host message language, for callers that only need the switch. */
+    language: () => getImHostLanguage(),
+  });
+}
+
+/**
+ * Bind the host message language to DSH's interface language.
+ *
+ * The plugin's own `language` option stays authoritative for operators who set
+ * it. Otherwise the language follows DSH: the explicit Language-row selection
+ * from the Host user-settings document, and — because DSH stores nothing for a
+ * browser-derived locale — the language mirrored by the settings UI.
+ */
+export function installHostLanguage(ctx, config = {}, internals = {}) {
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:language')
+    : (ctx?.logger ?? null);
+  const store = internals.store
+    ?? new InterfaceLanguageStore(interfaceLanguageSettingsPath(config));
+  const controller = createHostLanguageController({
+    store,
+    config: config.language ?? process.env.DSH_IM_LANGUAGE,
+    logger,
+  });
+  // Read an already-attached settings service synchronously: channels start
+  // inside the same activation, and waiting for the injection callback would
+  // let the first bot register its command menu in the previous language and
+  // then need a second push. The injection below keeps it live afterwards and
+  // covers a provider that attaches later.
+  controller.observeSettings(
+    () => ctx?.settings?.get?.(DSH_LOCALE_NAMESPACE)?.[DSH_LOCALE_PREFERENCE_FIELD],
+  );
+  const ready = Promise.resolve()
+    .then(() => store.load?.())
+    .then(() => controller.apply(), (error) => {
+      logger?.error?.(
+        '[dsh-im] could not read the mirrored DSH interface language; falling back to Chinese',
+        error,
+      );
+      return controller.snapshot();
+    });
+  if (typeof ctx?.inject === 'function') {
+    ctx.inject(['settings'], (settingsCtx) => {
+      controller.observeSettings(
+        () => settingsCtx.settings?.get?.(DSH_LOCALE_NAMESPACE)?.[DSH_LOCALE_PREFERENCE_FIELD],
+      );
+      settingsCtx.on('settings/updated', (namespace) => {
+        if (namespace !== DSH_LOCALE_NAMESPACE) return;
+        controller.apply();
+      });
+    });
+  }
+  return Object.freeze({ ...controller, ready });
+}

package/plugin-src/host/index.mjs

@@ -11,7 +11,8 @@ import { apply as applyWeixin } from './channels/weixin/index.mjs';
 import { apply as applyWhatsapp } from './channels/whatsapp/index.mjs';
 import { apply as applyIMessage } from './channels/imessage/index.mjs';
 import { installOutboundArtifactTool } from '../../src/channels/shared/semantic/artifact.mjs';
-import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
+import { installHostLanguage } from './host-language.mjs';
+import { installHostLanguageRpc } from './host-language-rpc.mjs';
 import { installDeliveryRpc } from './delivery-rpc.mjs';
 import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
@@ -36,6 +37,8 @@ function channelConfig(config, name, deliveryService) {
 }
 
 export function createImHostPlugin(internals = {}) {
+  const startHostLanguage = internals.installHostLanguage ?? installHostLanguage;
+  const startHostLanguageRpc = internals.installHostLanguageRpc ?? installHostLanguageRpc;
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
   const startInboundTtl = internals.installInboundTtlRpc ?? installInboundTtlRpc;
   const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
@@ -109,7 +112,10 @@ export function createImHostPlugin(internals = {}) {
   });
 
   async function activateChannels(ctx, config, deliveryService) {
-    setImHostLanguage(config.language ?? process.env.DSH_IM_LANGUAGE);
+    // Bind the bot message language before any channel connects, so the first
+    // command menu a platform stores is already in the interface language.
+    const hostLanguage = startHostLanguage(ctx, config);
+    await hostLanguage?.ready;
     const startTitlePrefix = (titleCtx) => {
       // The installer owns its cleanup through ctx.effect(). Cordis startup
       // callbacks must not return its controller object as an effect.
@@ -134,6 +140,13 @@ export function createImHostPlugin(internals = {}) {
       ? ctx.logger(name)
       : (ctx?.logger ?? console);
     if (ctx?.connection?.fetch) {
+      if (hostLanguage) {
+        try {
+          startHostLanguageRpc(ctx, hostLanguage, config.rpcAuthority);
+        } catch (error) {
+          logger.error?.('[dsh-im] failed to activate interface language mirroring; continuing with channels', error);
+        }
+      }
       try {
         startUpdate(ctx);
       } catch (error) {