@xmanrui/dsh-im 4.19.1 → 4.20.0

package/plugin-src/host/channels/weixin/production.mjs

@@ -11,6 +11,7 @@ import {
 } from '../../../../src/channels/weixin/weixin-api.mjs';
 import { WeixinController } from '../../../../src/channels/weixin/weixin-controller.mjs';
 import { WeixinRuntime } from '../../../../src/channels/weixin/weixin-runtime.mjs';
+import { createWeixinDiagnostics, knownWeixinErrorCode, weixinStageError } from '../../../../src/channels/weixin/connection-error.mjs';
 import {
   BotWorkspaceStore,
   createBotWorkspaceScope,
@@ -44,6 +45,33 @@ function pluginPaths(config) {
   };
 }
 
+// Keep shared workspace lifecycle semantics; expose its fallible persistence only to Weixin.
+function diagnosticWorkspaces(store) {
+  const writes = new Set(['ensure', 'setWorkspace', 'setModel', 'setAgentPreset', 'setAlias', 'setContextEnhancement', 'setAccessPolicy', 'flushPendingRemoval']);
+  const removals = new Set(['retireAfterConfigCommit', 'finishRemoval']);
+  return new Proxy(store, {
+    get(target, property) {
+      const value = Reflect.get(target, property, target);
+      if (typeof value !== 'function') return value;
+      if (!writes.has(property) && !removals.has(property)) return value.bind(target);
+      return (...args) => {
+        const failure = error => {
+          throw knownWeixinErrorCode(error?.code) ? error
+            : weixinStageError(removals.has(property) ? 'workspace-cleanup-failed' : 'workspace-save-failed', error);
+        };
+        try {
+          const result = value.apply(target, args);
+          // flushPendingRemoval must remain synchronous when no cleanup is pending.
+          return result?.then ? result.then(value => {
+            if (removals.has(property) && value?.error) failure(value.error);
+            return value;
+          }, failure) : result;
+        } catch (error) { return failure(error); }
+      };
+    },
+  });
+}
+
 export async function createProductionController(ctx, config = {}, internals = {}) {
   if (!ctx?.credentials) throw new TypeError('dsh-weixin requires ctx.credentials');
   const connection = harnessConnection(ctx, config);
@@ -58,13 +86,14 @@ export async function createProductionController(ctx, config = {}, internals = {
   const logger = typeof ctx.logger === 'function'
     ? ctx.logger('dsh-weixin')
     : (ctx.logger ?? console);
+  const diagnostics = internals.diagnostics ?? createWeixinDiagnostics({ logger });
   const agentPresetCatalog = () => listAgentPresetCatalog(ctx);
   const paths = pluginPaths(config);
   const configStore = await new ConfigStore(paths.config).load();
   const defaultWorkspace = resolve(config.workspace ?? process.cwd());
   const WorkspaceStore = internals.WorkspaceStore ?? BotWorkspaceStore;
-  const workspaces = internals.workspaces
-    ?? await new WorkspaceStore(paths.workspaces, { defaultWorkspace }).load();
+  const workspaces = diagnosticWorkspaces(internals.workspaces
+    ?? await new WorkspaceStore(paths.workspaces, { defaultWorkspace }).load());
   const configuredBots = configStore.list();
   await workspaces.reconcile(configuredBots.map((bot) => bot.botId));
   await Promise.all(configuredBots.map((bot) => workspaces.ensure(bot.botId, {
@@ -115,6 +144,7 @@ export async function createProductionController(ctx, config = {}, internals = {
     credentials: ctx.credentials,
     configStore: observedConfigStore,
     logger,
+    diagnostics,
     createRuntime: async ({ botId, config: accountConfig, token }) => {
       const state = await stateFor(botId);
       await workspaces.ensure(botId, {
@@ -125,6 +155,7 @@ export async function createProductionController(ctx, config = {}, internals = {
         botId, workspaces, state, agentPresetCatalog,
       });
       return new Runtime({
+        diagnostics,
         api,
         config: accountConfig,
         token,
@@ -158,16 +189,35 @@ export async function createProductionController(ctx, config = {}, internals = {
       }
     },
   });
-  const controller = createWorkspaceAwareController(coreController, {
+  const workspaceController = createWorkspaceAwareController(coreController, {
     workspaces,
     stateFor,
     agentPresetCatalog,
     modelCatalog,
   });
+  const controller = new Proxy(workspaceController, {
+    get(target, property) {
+      if (property === 'deleteBot') return async (...args) => {
+        const existed = Boolean(configStore.get(args[0]));
+        try { return await target.deleteBot(...args); }
+        catch (error) {
+          if (!existed || configStore.get(args[0])) throw error;
+          // The shared workspace wrapper can fail cleaning up after the account commit.
+          const warning = diagnostics.report(weixinStageError('workspace-cleanup-failed', error), {
+            operation: 'bot.delete', botId: args[0], warning: true,
+          }).publicError;
+          try { return { ...await target.status(), warnings: [warning] }; }
+          catch (readError) { throw weixinStageError('status-read-failed', readError, 'status.read'); }
+        }
+      };
+      return Reflect.get(target, property);
+    },
+  });
   const supervisor = createSupervisor({
     controller,
     harness,
     logger,
+    diagnostics,
     retryDelaysMs: config.retryDelaysMs,
     healthyIntervalMs: config.healthyIntervalMs,
   }).start();

package/plugin-src/host/channels/weixin/rpc.mjs

@@ -1,11 +1,11 @@
 import { SET_ALIAS_ENDPOINT, validAliasPayload } from '../shared/bot-alias-rpc.mjs';
 import { registerManagementRpc } from '../../../management-rpc.mjs';
 import QRCode from 'qrcode';
+import { createWeixinDiagnostics, weixinStageError } from '../../../../src/channels/weixin/connection-error.mjs';
 import { SET_CONTEXT_ENHANCEMENT_ENDPOINT, validContextEnhancementPayload } from '../shared/context-enhancement-rpc.mjs';
 import { SET_ACCESS_POLICY_ENDPOINT, validAccessPolicyPayload } from '../shared/access-policy-rpc.mjs';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
 import {
-  publicWorkspaceError,
   SET_WORKSPACE_ENDPOINT,
   validWorkspacePayload,
 } from '../shared/workspace-rpc.mjs';
@@ -118,13 +118,6 @@ function cancelled() {
   return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
 }
 
-function internalFailure() {
-  return {
-    ok: false,
-    error: { code: 'weixin-operation-failed', message: '微信操作失败，请稍后重试。' },
-  };
-}
-
 async function qrDataUrl(value) {
   return QRCode.toDataURL(value, {
     type: 'image/png',
@@ -143,7 +136,9 @@ async function withEncodedQr(value, encodeQr) {
 }
 
 async function publicStatus(status, encodeQr) {
-  const safe = structuredClone(status);
+  let safe;
+  try { safe = structuredClone(status); }
+  catch (error) { throw weixinStageError('status-read-failed', error); }
   if (safe.provisioning) safe.provisioning = await withEncodedQr(safe.provisioning, encodeQr);
   return safe;
 }
@@ -161,14 +156,17 @@ function assertController(controller) {
   }
 }
 
-export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}) {
+export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl, logger = console, diagnostics = createWeixinDiagnostics({ logger }) } = {}) {
   assertController(controller);
   const qrCache = new Map();
   const cachedEncode = (url) => {
     let encoded = qrCache.get(url);
     if (!encoded) {
       if (qrCache.size >= 16) qrCache.delete(qrCache.keys().next().value);
-      encoded = Promise.resolve().then(() => encodeQr(url));
+      encoded = Promise.resolve().then(() => encodeQr(url)).catch(error => {
+        qrCache.delete(url);
+        throw weixinStageError('qr-encode-failed', error);
+      });
       qrCache.set(url, encoded);
     }
     return encoded;
@@ -193,7 +191,7 @@ export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}
         value = await withEncodedQr(started, cachedEncode);
       } else if (endpoint === WEIXIN_ENDPOINTS.pollProvisioning) {
         const current = await controller.registrationStatus(payload.attemptId);
-        if (!current) return badRequest('The provisioning attempt no longer exists.');
+        if (!current) throw weixinStageError('provision-attempt-not-found', undefined, 'qr.poll');
         value = await withEncodedQr(current, cachedEncode);
       } else if (endpoint === WEIXIN_ENDPOINTS.submitVerification) {
         value = await withEncodedQr(
@@ -202,7 +200,7 @@ export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}
         );
       } else if (endpoint === WEIXIN_ENDPOINTS.cancelProvisioning) {
         value = await controller.cancelProvisioning(payload.attemptId);
-        if (!value) return badRequest('The provisioning attempt no longer exists.');
+        if (!value) throw weixinStageError('provision-attempt-not-found', undefined, 'qr.cancel');
       } else if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
         const snapshot = await controller.reconnectBot(payload.botId);
         if (signal?.aborted) return cancelled();
@@ -263,10 +261,17 @@ export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}
       }
       return signal?.aborted ? cancelled() : { ok: true, value };
     } catch (error) {
-      const workspaceError = publicWorkspaceError(error);
-      return signal?.aborted ? cancelled() : workspaceError
-        ? { ok: false, error: workspaceError }
-        : internalFailure();
+      if (signal?.aborted) return cancelled();
+      const context = {
+        'connection.status': ['status.read', 'status-read-failed'],
+        'provision.begin': ['qr.begin', 'qr-start-failed'],
+        'provision.poll': ['qr.poll'], 'provision.verify': ['qr.verify'], 'provision.cancel': ['qr.cancel'],
+        'bot.reconnect': ['connection.start', 'connection-start-failed'],
+        'bot.delete': ['account.remove'], 'bot.workspace.set': ['workspace.write', 'workspace-save-failed'],
+      }[endpoint] ?? ['workspace.write', 'workspace-save-failed'];
+      return { ok: false, error: diagnostics.report(error, {
+        operation: endpoint, stage: context[0], code: context[1], botId: payload.botId,
+      }).publicError };
     }
   };
 }

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) {