@xmanrui/dsh-im 4.22.0 → 4.23.0

package/plugin-src/client/index.js

@@ -14,6 +14,7 @@ import {
   WeixinLogoGlyph,
   WhatsappLogoGlyph,
   IMessageLogoGlyph,
+  EmailLogoGlyph,
 } from './channel-logos.js';
 import { DINGTALK_RPC_CHANNEL } from './channels/dingtalk/api.js';
 import { DingtalkSettingsTab } from './channels/dingtalk/index.js';
@@ -48,8 +49,11 @@ import { WHATSAPP_RPC_CHANNEL } from './channels/whatsapp/api.js';
 import { WhatsappSettingsTab } from './channels/whatsapp/index.js';
 import { installWhatsappStyles } from './channels/whatsapp/styles.js';
 import { IMESSAGE_RPC_CHANNEL } from './channels/imessage/api.js';
+import { EMAIL_RPC_CHANNEL } from './channels/email/api.js';
 import { IMessageSettingsTab } from './channels/imessage/index.js';
+import { EmailSettingsTab, useEmailChannelEnabled } from './channels/email/index.js';
 import { installIMessageStyles } from './channels/imessage/styles.js';
+import { installEmailStyles } from './channels/email/styles.js';
 import { en, h, IM_LOCALE_NAMESPACE, setImTranslator, zh } from './i18n.js';
 import {
   HOST_LANGUAGE_RPC_CHANNEL,
@@ -102,6 +106,7 @@ const CHANNELS = Object.freeze([
   { id: 'whatsapp', label: 'WhatsApp' },
   { id: 'wecomApp', label: '企业微信应用', note: '（实验功能）' },
   { id: 'imessage', label: 'iMessage', note: '（实验功能）' },
+  { id: 'email', label: '邮箱', note: '（实验功能）' },
   { id: 'office', label: 'AI Office', note: '（实验功能）' },
 ]);
 
@@ -157,6 +162,11 @@ function IMessageLogo() {
     h(IMessageLogoGlyph));
 }
 
+function EmailLogo() {
+  return h('span', { className: 'dim-logo dim-logoEmail', 'aria-hidden': 'true' },
+    h(EmailLogoGlyph));
+}
+
 function OfficeLogo() {
   return h('span', { className: 'dim-logo dim-logoOffice', 'aria-hidden': 'true' },
     h(OfficeLogoGlyph));
@@ -174,6 +184,7 @@ function ChannelLogo({ channel }) {
   if (channel === 'discord') return h(DiscordLogo);
   if (channel === 'whatsapp') return h(WhatsappLogo);
   if (channel === 'imessage') return h(IMessageLogo);
+  if (channel === 'email') return h(EmailLogo);
   return h(OfficeLogo);
 }
 
@@ -198,6 +209,7 @@ export function IMSettingsTab({
   discordRpcCall,
   feishuRpcCall,
   imessageRpcCall,
+  emailRpcCall,
   qqRpcCall,
   slackRpcCall,
   telegramRpcCall,
@@ -222,10 +234,18 @@ export function IMSettingsTab({
   const [loopbackRecovery, setLoopbackRecovery] = React.useState(null);
   const [runningVersion, setRunningVersion] = React.useState(IM_PLUGIN_VERSION);
   const [deliverySettings, setDeliverySettings] = React.useState(null);
+  // The Host owns email availability and reports it over RPC. The
+  // mailbox entry point is omitted entirely while it is closed, and the visible
+  // channel list is what every later lookup (active tab, rail) reads from.
+  const emailEnabled = useEmailChannelEnabled(emailRpcCall);
+  const visibleChannels = React.useMemo(
+    () => CHANNELS.filter((channel) => channel.id !== 'email' || emailEnabled),
+    [emailEnabled],
+  );
   const githubTooltipId = React.useId();
   const generalSettingsTooltipId = React.useId();
   const globalSettingsSelected = selected === GLOBAL_SETTINGS_TAB_ID;
-  const active = CHANNELS.find((channel) => channel.id === selected) ?? CHANNELS[0];
+  const active = visibleChannels.find((channel) => channel.id === selected) ?? visibleChannels[0];
   const activeTabId = globalSettingsSelected
     ? 'dim-general-settings-trigger'
     : `dim-tab-${active.id}`;
@@ -254,6 +274,7 @@ export function IMSettingsTab({
     deliveryRpcCall,
     globalSettingsRpcCall,
     imessageRpcCall,
+    emailRpcCall,
   }, {
     location: browserLocation,
     onRecovery: reportLoopbackRecovery,
@@ -265,6 +286,7 @@ export function IMSettingsTab({
     feishuRpcCall,
     globalSettingsRpcCall,
     imessageRpcCall,
+    emailRpcCall,
     officeRpcCall,
     qqRpcCall,
     reportLoopbackRecovery,
@@ -331,7 +353,7 @@ export function IMSettingsTab({
     ),
     h('div', { className: 'dim-layout' },
       h('nav', { className: 'dim-rail', role: 'tablist', 'aria-label': 'IM 设置导航' },
-        CHANNELS.map((channel) => h('button', {
+        visibleChannels.map((channel) => h('button', {
           key: channel.id,
           type: 'button',
           role: 'tab',
@@ -395,6 +417,8 @@ export function IMSettingsTab({
                           ? h(WhatsappSettingsTab, { rpcCall: rpcCalls.whatsappRpcCall })
                           : active.id === 'imessage'
                             ? h(IMessageSettingsTab, { rpcCall: rpcCalls.imessageRpcCall })
+                          : active.id === 'email'
+                            ? h(EmailSettingsTab, { rpcCall: rpcCalls.emailRpcCall })
                           : h(OfficeSettingsTab, { rpcCall: rpcCalls.officeRpcCall }))),
     ),
   ));
@@ -433,6 +457,7 @@ export function apply(ctx) {
       installDiscordStyles(),
       installWhatsappStyles(),
       installIMessageStyles(),
+      installEmailStyles(),
       installOfficeStyles(),
       installImStyles(),
     ];
@@ -461,6 +486,8 @@ export function apply(ctx) {
     callManagementRpc(ctx.connection, WHATSAPP_RPC_CHANNEL, endpoint, payload, signal);
   const imessageRpcCall = (endpoint, payload, signal) =>
     callManagementRpc(ctx.connection, IMESSAGE_RPC_CHANNEL, endpoint, payload, signal);
+  const emailRpcCall = (endpoint, payload, signal) =>
+    callManagementRpc(ctx.connection, EMAIL_RPC_CHANNEL, endpoint, payload, signal);
   const slackRpcCall = (endpoint, payload, signal) =>
     callManagementRpc(ctx.connection, SLACK_RPC_CHANNEL, endpoint, payload, signal);
   const officeRpcCall = (endpoint, payload, signal) =>
@@ -490,6 +517,7 @@ export function apply(ctx) {
     whatsappRpcCall,
     imessageRpcCall,
     officeRpcCall,
+    emailRpcCall,
     updateRpcCall,
     deliveryRpcCall,
     globalSettingsRpcCall,

package/plugin-src/client/last-message-error.js

@@ -1,3 +1,4 @@
+import { diagnosticFields } from '../../src/channels/shared/diagnostic-details.mjs';
 function text(value, maxLength) {
   if (typeof value !== 'string') return null;
   const trimmed = value.trim();
@@ -12,6 +13,6 @@ export function normalizeLastMessageError(value) {
   const referenceId = text(value.referenceId, 40);
   const at = Number.isFinite(value.at) ? value.at : null;
   return code && reason && message && referenceId && at !== null
-    ? { code, reason, message, referenceId, at }
+    ? { code, reason, message, referenceId, at, ...(value.details ? diagnosticFields(value) : {}) }
     : null;
 }

package/plugin-src/client/styles.js

@@ -1,6 +1,12 @@
 export const IM_STYLE_ID = 'xmanrui-dsh-im-settings';
 
 const CSS = String.raw`
+.dim-connectionDiagnostic { min-width: 0; width: 100%; color: var(--dsw-alias-label-secondary, #646a73); overflow-wrap: anywhere; font-size: 13px; line-height: 1.6; }
+.dim-connectionDiagnostic[data-warning="true"] { color: var(--dsw-alias-state-warn-primary, #d97706); }
+.dim-connectionDiagnostic p { margin: 4px 0; }
+.dim-connectionDiagnostic button { border: 1px solid var(--dsw-alias-border-l2, #dfe1e5); border-radius: 6px; padding: 6px 10px; color: inherit; background: var(--dsw-alias-bg-layer-1, #fff); font: inherit; cursor: pointer; }
+.dim-connectionDiagnostic button:focus-visible, .dim-connectionDiagnostic summary:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #3370ff); outline-offset: 2px; }
+
 .dim-aliasName { display: flex; align-items: center; gap: 4px; min-width: 0; }
 .dim-aliasName h3 { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .dim-aliasName h3:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #3370ff); outline-offset: 2px; border-radius: 3px; }

package/plugin-src/host/build.mjs

@@ -14,7 +14,11 @@ const externalRuntimePackages = [
   '@tencent-connect/qqbot-nodejs',
   '@wecom/aibot-node-sdk',
   'dingtalk-stream',
+  'imapflow',
+  'mailparser',
+  'nodemailer',
   'qrcode',
+  'sharp',
   'undici',
 ];
 const external = externalRuntimePackages.flatMap((name) => [name, `${name}/*`]);

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

@@ -1,3 +1,4 @@
+import { getImageInputSettingsStore } from '../../../../src/channels/shared/image-input-settings-store.mjs';
 import { unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
@@ -113,6 +114,7 @@ export async function createProductionController(ctx, config = {}, internals = {
     ...(controlExecutor ? { controlExecutor } : {}),
     ...(sessionMaintenanceExecutor ? { sessionMaintenanceExecutor } : {}),
     ...(fileIngressExecutor ? { fileIngressExecutor } : {}),
+    imageInputPolicy: () => getImageInputSettingsStore(config).get(),
   });
   const modelCatalog = () => listModelCatalog(harness);
   const coreController = new Controller({

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

@@ -1,3 +1,5 @@
+import { diagnosticFields } from '../../../../src/channels/shared/diagnostic-details.mjs';
+import { createConnectionDiagnostics, diagnosticRpcResult } from '../../../../src/channels/shared/connection-error.mjs';
 import { SET_ALIAS_ENDPOINT, validAliasPayload } from '../shared/bot-alias-rpc.mjs';
 import { registerManagementRpc } from '../../../management-rpc.mjs';
 import QRCode from 'qrcode';
@@ -169,7 +171,7 @@ function publicConnectionFailure(error) {
       ? source.referenceId
       : null;
   return code && message && hint && referenceId
-    ? { code, message, hint, referenceId }
+    ? { code, message, hint, referenceId, ...diagnosticFields(source) }
     : null;
 }
 
@@ -227,6 +229,7 @@ function assertController(controller) {
 }
 
 export function createDingtalkRpcHandler(controller, { encodeQr = qrDataUrl } = {}) {
+  const diagnostics = controller.diagnostics ?? createConnectionDiagnostics({ channel: 'dingtalk' });
   assertController(controller);
   const qrCache = new Map();
   const cachedEncode = (url) => {
@@ -283,7 +286,7 @@ export function createDingtalkRpcHandler(controller, { encodeQr = qrDataUrl } =
               await controller.sendConnectionTest(payload.botId);
               testMessage = publicConnectionTestResult();
             } catch (error) {
-              testMessage = publicConnectionTestResult(error);
+              testMessage = publicConnectionTestResult(error, { diagnostics, botId: payload.botId });
             }
           }
         }
@@ -338,11 +341,11 @@ export function createDingtalkRpcHandler(controller, { encodeQr = qrDataUrl } =
     } catch (error) {
       const workspaceError = publicWorkspaceError(error);
       const connectionError = publicConnectionFailure(error);
-      return signal?.aborted ? cancelled() : workspaceError
+      return diagnosticRpcResult(diagnostics, error, signal?.aborted ? cancelled() : workspaceError
         ? { ok: false, error: workspaceError }
         : connectionError
           ? { ok: false, error: connectionError }
-        : internalFailure();
+        : internalFailure(), { operation: endpoint, botId: payload?.botId });
     }
   };
 }

package/plugin-src/host/channels/email/availability.mjs

@@ -0,0 +1,60 @@
+/**
+ * The single switch that opens or closes the email channel.
+ *
+ * Email is enabled by default. A deployment can opt out with
+ * `EMAIL_CHANNEL_ENABLED=0` or `emailChannelEnabled: false` in the channel config.
+ * Setting either option to true enables the entry point, runtime and config
+ * restore again without a code change.
+ *
+ * Closing is deliberately non-destructive: it never deletes a mailbox config or
+ * a credential. It only refuses to expose the entry point and to start the
+ * runtime, so every existing mailbox is still there when the switch reopens.
+ */
+
+/** Environment variable that controls the email channel. */
+export const EMAIL_CHANNEL_ENABLED_ENV = 'EMAIL_CHANNEL_ENABLED';
+
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+const FALSY = new Set(['0', 'false', 'no', 'off', '']);
+
+function readBoolean(value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (TRUTHY.has(normalized)) return true;
+    if (FALSY.has(normalized)) return false;
+  }
+  return null;
+}
+
+/**
+ * Decide whether the email channel is open.
+ *
+ * An explicit config value wins over the environment so a deployment can pin
+ * the channel without changing its environment; an unreadable value falls back
+ * to the environment, and an absent one keeps the channel enabled.
+ */
+export function isEmailChannelEnabled(config = {}, env = process.env) {
+  return readBoolean(config.emailChannelEnabled)
+    ?? readBoolean(env?.[EMAIL_CHANNEL_ENABLED_ENV])
+    ?? true;
+}
+
+/**
+ * The single host-side gate.
+ *
+ * Returns `null` when email is open, or a public "not available" result when it
+ * is closed. Both the management RPC and the production startup consult this so
+ * a closed channel can neither be configured nor connected.
+ */
+export function emailChannelGate(config = {}, env = process.env) {
+  if (isEmailChannelEnabled(config, env)) return null;
+  return Object.freeze({
+    ok: false,
+    error: Object.freeze({
+      code: 'email-channel-disabled',
+      message: 'Email is not available yet.',
+      details: Object.freeze({}),
+    }),
+  });
+}

package/plugin-src/host/channels/email/index.mjs

@@ -0,0 +1,36 @@
+import { createProductionController } from './production.mjs';
+import { createEmailRpcHandler, installEmailRpc, EMAIL_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
+import { emailChannelGate } from './availability.mjs';
+
+export const name = 'dsh-im-email-host';
+export const inject = ['connection', 'credentials', 'typertGateway'];
+
+/**
+ * Cordis/DSH Host plugin entry. The management RPC is mounted before the
+ * fallible production initialization so the channel's settings page stays
+ * reachable (and can report why the mailbox failed) even when startup throws.
+ * Tests and embedded distributions may inject a controller through config.
+ *
+ * While `EMAIL_CHANNEL_ENABLED` is off this mounts the management RPC only and
+ * returns: no mailbox runtime is started and no configured mailbox is restored,
+ * so a machine that already holds mailboxes sends no network request for them.
+ * Nothing is deleted — reopening the switch restores every mailbox untouched.
+ */
+export async function apply(ctx, config = {}) {
+  if (config?.controller) {
+    return installEmailRpc(ctx, config.controller, config.rpcAuthority);
+  }
+  const closed = emailChannelGate(config);
+  if (closed) return installEmailRpc(ctx, { disabled: () => closed }, config.rpcAuthority);
+  return installProductionChannel(ctx, config, {
+    channel: 'email',
+    rpcChannel: EMAIL_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals ?? {}),
+    createHandler: controller => createEmailRpcHandler(controller),
+  });
+}
+
+export { createProductionController } from './production.mjs';
+export { EMAIL_ENDPOINTS, EMAIL_RPC_CHANNEL, EMAIL_RPC_ENDPOINTS,
+  createEmailRpcHandler, installEmailRpc } from './rpc.mjs';

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

@@ -0,0 +1,58 @@
+import { EmailConfigStore } from '../../../../src/channels/email/config-store.mjs';
+import { EmailHarnessClient } from '../../../../src/channels/email/harness-client.mjs';
+import { EmailStateStore } from '../../../../src/channels/email/state-store.mjs';
+import { EmailController } from '../../../../src/channels/email/email-controller.mjs';
+import { EmailRuntime } from '../../../../src/channels/email/email-runtime.mjs';
+import {
+  createAccessPolicy,
+  createAccessPolicyScope,
+} from '../../../../src/channels/shared/access-policy.mjs';
+import { createTokenProductionController } from '../shared/production.mjs';
+
+/**
+ * Email has no group concept, and a mail address is trivially forgeable, so
+ * both scopes start as an allowlist seeded from the mailbox's configured
+ * senders instead of the open baseline other token channels use. With no
+ * senders configured the allowlist is empty, which denies everyone until the
+ * user adds one — the channel fails closed.
+ */
+function emailAccessPolicyFor(bot) {
+  const senders = Array.isArray(bot?.allowedSenders) ? bot.allowedSenders : [];
+  const scope = createAccessPolicyScope({
+    mode: 'allowlist',
+    open: { defaultCanExecuteCommands: false, commandPermissionOverrides: [] },
+    // Every policy user entry carries its command permission alongside the id.
+    allowlist: { users: senders.map((id) => ({ id, canExecuteCommands: true })) },
+  });
+  return createAccessPolicy({ direct: scope, group: scope });
+}
+
+/**
+ * Email is a token-shaped channel: one mailbox identity plus one secret. It
+ * reuses the shared token production assembly, which wires the workspace
+ * scope, access policy, delivery adapter, and connection supervisor.
+ */
+export function createProductionController(ctx, config = {}, internals = {}) {
+  return createTokenProductionController(ctx, config, internals, {
+    channel: 'email',
+    ConfigStore: EmailConfigStore,
+    StateStore: EmailStateStore,
+    HarnessClient: EmailHarnessClient,
+    Controller: EmailController,
+    Runtime: EmailRuntime,
+    runtimeOptions: (channelConfig) => ({
+      ...(channelConfig.pollIntervalMs === undefined
+        ? {} : { pollIntervalMs: channelConfig.pollIntervalMs }),
+    }),
+    initialAccessPolicyForBot: emailAccessPolicyFor,
+    // Declares that this channel keeps its allowlist in its own config and
+    // pushes the derived policy into the workspace store on change.
+    accessPolicyForBot: emailAccessPolicyFor,
+    // The mailbox settings page can pin the chat to an existing session.
+    supportsSessionBinding: true,
+    // The Agent mailbox rotates its refresh token on every refresh, so the new
+    // pair must be written back through the controller.
+    persistBotCredential: ({ botId, tokens, controller }) =>
+      controller?.persistTokens?.(botId, tokens) ?? Promise.resolve(false),
+  });
+}

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

@@ -0,0 +1,163 @@
+import { createConnectionDiagnostics, diagnosticRpcResult } from '../../../../src/channels/shared/connection-error.mjs';
+import { createTokenBotRpcHandler } from '../shared/rpc.mjs';
+import { registerManagementRpc } from '../../../management-rpc.mjs';
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+
+export const EMAIL_RPC_CHANNEL = '/email';
+export const EMAIL_ENDPOINTS = Object.freeze({
+  status: 'connection.status',
+  // Lets the client hide the mailbox entry point while the channel is closed,
+  // instead of offering a form whose submissions the Host would refuse.
+  availability: 'channel.availability',
+  bindMailbox: 'bot.bind-mailbox',
+  updateMailbox: 'bot.mailbox.update',
+  reconnectBot: 'bot.reconnect',
+  deleteBot: 'bot.delete',
+  setWorkspace: 'bot.workspace.set',
+  setModel: 'bot.model.set',
+  setAgentPreset: 'bot.agent-preset.set',
+  setContextEnhancement: 'bot.context-enhancement.set',
+  setAccessPolicy: 'bot.access-policy.set',
+  setAlias: 'bot.alias.set',
+  // Session binding: read the current bindings, change them, and list the
+  // candidate sessions for the picker.
+  // QR device flow for transports that authorize out of band (Agent mailbox).
+  startAuth: 'bot.auth.start',
+  pollAuth: 'bot.auth.poll',
+  getBinding: 'bot.session-binding.get',
+  setBinding: 'bot.session-binding.set',
+  listSessions: 'bot.session.list',
+});
+export const EMAIL_RPC_ENDPOINTS = Object.freeze(Object.values(EMAIL_ENDPOINTS));
+
+/** The mailbox fields, with the addressing field removed. */
+function stripBotId(payload) {
+  if (!payload || typeof payload !== 'object') return {};
+  const { botId, update, ...rest } = payload;
+  return rest;
+}
+
+function failure(code, error) {
+  return {
+    ok: false,
+    error: {
+      code: error?.code ?? code,
+      message: error?.message ?? String(error),
+      details: error?.details ?? {},
+    },
+  };
+}
+
+function withRpcDetails(result) {
+  if (result?.ok !== false) return result;
+  return { ...result, error: { ...result.error, details: result.error?.details ?? {} } };
+}
+
+/**
+ * Mailbox-specific endpoints are handled here; everything else (status,
+ * reconnect, delete, workspace, model, preset, alias, access policy) goes
+ * through the shared token-bot handler, which already knows the endpoint
+ * payload shapes.
+ */
+export function createEmailRpcHandler(controller) {
+  const diagnostics = controller.diagnostics ?? createConnectionDiagnostics({ channel: 'email' });
+  // Availability is answered before anything else, including the controller
+  // shape check: the client asks this endpoint to decide whether to show the
+  // mailbox entry point at all, so it must work even while the channel is
+  // closed and no controller is wired.
+  //
+  // While the channel is closed the settings page must still get a clear,
+  // non-throwing answer rather than a crash from an unwired controller; every
+  // other endpoint fails closed through `controller.disabled()`.
+  const disabled = typeof controller?.disabled === 'function';
+  const closed = disabled ? controller.disabled() : null;
+  const shared = disabled ? null : createTokenBotRpcHandler(controller, { channel: 'Email' });
+  return async (endpoint, payload, signal) => {
+    if (endpoint === EMAIL_ENDPOINTS.availability) {
+      return { ok: true, value: { enabled: !disabled } };
+    }
+    if (disabled) return closed;
+    if (endpoint === EMAIL_ENDPOINTS.bindMailbox) {
+      try {
+        return { ok: true, value: await controller.bindMailbox(payload ?? {}) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, withRpcDetails({
+          ok: false,
+          error: {
+            code: error?.code ?? 'email-bind-failed',
+            message: error?.message ?? String(error),
+            details: error?.details ?? {},
+          },
+        }), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.startAuth) {
+      try {
+        return { ok: true, value: await controller.startAuthorization(payload ?? {}) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, failure('email-auth-failed', error), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.pollAuth) {
+      try {
+        return { ok: true, value: await controller.pollAuthorization(payload ?? {}) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, failure('email-auth-failed', error), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.getBinding) {
+      try {
+        return { ok: true, value: await controller.getSessionBinding(payload?.botId) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, failure('email-binding-failed', error), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.setBinding) {
+      try {
+        return { ok: true, value: await controller.setSessionBinding(payload?.botId, payload ?? {}) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, failure('email-binding-failed', error), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.listSessions) {
+      try {
+        return { ok: true, value: await controller.listSessions(payload?.botId) };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, failure('email-sessions-failed', error), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    if (endpoint === EMAIL_ENDPOINTS.updateMailbox) {
+      try {
+        return {
+          ok: true,
+          // The client sends the mailbox fields flat alongside botId (as every
+          // other endpoint here does). Reading a nested `update` silently
+          // discarded the whole change: the call succeeded and nothing moved.
+          value: await controller.updateMailboxSettings(
+            payload?.botId,
+            payload?.update ?? stripBotId(payload),
+          ),
+        };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, withRpcDetails({
+          ok: false,
+          error: {
+            code: error?.code ?? 'email-update-failed',
+            message: error?.message ?? String(error),
+            details: error?.details ?? {},
+          },
+        }), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
+      }
+    }
+    return withRpcDetails(await shared(endpoint, payload, signal));
+  };
+}
+
+export function installEmailRpc(ctx, controller, authority) {
+  return registerManagementRpc(
+    ctx,
+    EMAIL_RPC_CHANNEL,
+    createEmailRpcHandler(controller),
+    { authority: resolveRpcAuthority(authority) },
+  );
+}

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

@@ -1,3 +1,4 @@
+import { getImageInputSettingsStore } from '../../../../src/channels/shared/image-input-settings-store.mjs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { unlink } from 'node:fs/promises';
@@ -211,12 +212,14 @@ export async function createProductionController(ctx, config = {}, internals = {
     ...(controlExecutor ? { controlExecutor } : {}),
     ...(sessionMaintenanceExecutor ? { sessionMaintenanceExecutor } : {}),
     ...(fileIngressExecutor ? { fileIngressExecutor } : {}),
+    imageInputPolicy: () => getImageInputSettingsStore(config).get(),
   });
   const proxyEnv = internals.proxyEnv ?? process.env;
   const wsAgent = createFeishuWebSocketAgent(proxyEnv, internals.createProxyAgent);
 
   const modelCatalog = () => listModelCatalog(harness);
   const coreController = new Controller({
+    logger,
     registerApp: (options) => lark.registerApp(options),
     verifyApp,
     credentials: ctx.credentials,

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

@@ -1,3 +1,5 @@
+import { diagnosticFields } from '../../../../src/channels/shared/diagnostic-details.mjs';
+import { createConnectionDiagnostics, diagnosticRpcResult } from '../../../../src/channels/shared/connection-error.mjs';
 import { normalizeBotAlias } from '../../../../src/channels/shared/bot-alias.mjs';
 import { SET_ALIAS_ENDPOINT, validAliasPayload } from '../shared/bot-alias-rpc.mjs';
 import { registerManagementRpc } from '../../../management-rpc.mjs';
@@ -137,7 +139,7 @@ function publicError(error) {
   const code = typeof error.code === 'string' && Object.hasOwn(PUBLIC_ERROR_MESSAGES, error.code)
     ? error.code
     : 'registration_failed';
-  return { code, message: PUBLIC_ERROR_MESSAGES[code] };
+  return { code, message: PUBLIC_ERROR_MESSAGES[code], ...diagnosticFields(error) };
 }
 
 function publicRegistration(registration) {
@@ -560,6 +562,7 @@ function assertController(controller) {
 
 /** DSH rc.6 handler: (endpoint, payload, signal) => Promise<RpcResult>. */
 export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl } = {}) {
+  const diagnostics = controller.diagnostics ?? createConnectionDiagnostics({ channel: 'feishu' });
   assertController(controller);
   const qrCache = new Map();
   const attemptQr = new Map();
@@ -721,7 +724,7 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
               testError = error;
             }
           }
-          value = { ...value, testMessage: publicConnectionTestResult(testError) };
+          value = { ...value, testMessage: publicConnectionTestResult(testError, { diagnostics, botId: payload.botId }) };
         }
       } else if (endpoint === FEISHU_MULTI_ENDPOINTS.disconnectBot) {
         if (typeof controller.disconnectBot !== 'function') throw new Error('Multi-bot disconnect is unavailable');
@@ -802,9 +805,9 @@ export function createFeishuRpcHandler(controller, { encodeQr = qrCodeDataUrl }
       return { ok: true, value };
     } catch (error) {
       const workspaceError = publicWorkspaceError(error);
-      return signal?.aborted ? cancelled() : workspaceError
+      return diagnosticRpcResult(diagnostics, error, signal?.aborted ? cancelled() : workspaceError
         ? { ok: false, error: { ...workspaceError, details: {} } }
-        : internalFailure();
+        : internalFailure(), { operation: endpoint, botId: payload?.botId });
     }
   };
 }

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

@@ -1,3 +1,4 @@
+import { createConnectionDiagnostics, diagnosticRpcResult } from '../../../../src/channels/shared/connection-error.mjs';
 import { createTokenBotRpcHandler } from '../shared/rpc.mjs';
 import { registerManagementRpc } from '../../../management-rpc.mjs';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
@@ -28,32 +29,38 @@ function withRpcDetails(result) {
 }
 
 export function createIMessageRpcHandler(controller) {
+  const diagnostics = controller.diagnostics ?? createConnectionDiagnostics({ channel: 'imessage' });
   const tokenHandler = createTokenBotRpcHandler(controller, {
     channel: 'iMessage',
   });
   return async (endpoint, payload, signal) => {
     if (endpoint === IMESSAGE_ENDPOINTS.status) {
-      const value = await controller.status();
-      return { ok: true, value: { ...value, permissions: await controller.permissions() } };
+      try {
+        const value = await controller.status();
+        return { ok: true, value: { ...value, permissions: await controller.permissions() } };
+      } catch (error) {
+        return diagnosticRpcResult(diagnostics, error, { ok: false, error: { code: 'status-failed' } },
+          { operation: endpoint, untrustedPublicError: true });
+      }
     }
     if (endpoint === IMESSAGE_ENDPOINTS.permissions) {
       try {
         return { ok: true, value: await controller.permissions() };
       } catch (error) {
-        return withRpcDetails({
+        return diagnosticRpcResult(diagnostics, error, withRpcDetails({
           ok: false,
           error: { code: 'permissions-check-failed', message: error.message },
-        });
+        }), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
       }
     }
     if (endpoint === IMESSAGE_ENDPOINTS.bindNative) {
       try {
         return { ok: true, value: await controller.bindNative() };
       } catch (error) {
-        return withRpcDetails({
+        return diagnosticRpcResult(diagnostics, error, withRpcDetails({
           ok: false,
           error: { code: error.code ?? 'imessage-bind-failed', message: error.message },
-        });
+        }), { operation: endpoint, botId: payload?.botId, untrustedPublicError: true });
       }
     }
     const translated = endpoint === IMESSAGE_ENDPOINTS.setModel ? 'bot.model.set' : endpoint;