@xmanrui/dsh-im 4.15.0 → 4.16.0

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

@@ -1,5 +1,6 @@
 import { createProductionController } from './production.mjs';
-import { installQqRpc } from './rpc.mjs';
+import { createQqRpcHandler, installQqRpc, QQ_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
 
 export const name = 'dsh-im-qq-host';
 export const inject = ['connection', 'credentials', 'typertGateway'];
@@ -8,20 +9,12 @@ export async function apply(ctx, config = {}) {
   if (config?.controller) {
     return installQqRpc(ctx, config.controller, config.rpcOptions, config.rpcAuthority);
   }
-  const production = await createProductionController(ctx, config, config.internals);
-  const unregisterDelivery = config.deliveryService && production.deliveryAdapter
-    ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
-  const disposeRpc = installQqRpc(
-    ctx,
-    production.controller,
-    config.rpcOptions,
-    config.rpcAuthority,
-  );
-  ctx.effect(() => async () => {
-    await unregisterDelivery?.();
-    await production.close();
-  }, 'dsh-im: close QQ bot connections');
-  return disposeRpc;
+  return installProductionChannel(ctx, config, {
+    channel: 'qq',
+    rpcChannel: QQ_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals),
+    createHandler: controller => createQqRpcHandler(controller, config.rpcOptions),
+  });
 }
 
 export function createQqHostPlugin(config) {

package/plugin-src/host/channels/shared/access-policy-production.mjs

@@ -91,7 +91,7 @@ export function initialAccessPolicyFor(channel, config = {}) {
       group: allowlistScope(),
     });
   }
-  if (['dingtalk', 'wecom', 'slack', 'discord'].includes(key)) {
+  if (['dingtalk', 'wecom', 'wecom-app', 'slack', 'discord'].includes(key)) {
     return createAccessPolicy({ direct: openScope(), group: openScope() });
   }
   throw new TypeError(`Unsupported access-policy channel: ${channel}`);

package/plugin-src/host/channels/shared/model-setting-rpc.mjs

@@ -13,7 +13,6 @@ export function validModelPayload(payload) {
     || !/^[A-Za-z0-9_-]{1,128}$/.test(payload.botId)) return false;
   if (payload.model === null) return true;
   return isRecord(payload.model)
-    && Object.keys(payload.model).length === 2
-    && Object.keys(payload.model).every((key) => ['provider', 'model'].includes(key))
+    && Object.keys(payload.model).every((key) => ['provider', 'model', 'reasoningEffort'].includes(key))
     && normalizeModelSelection(payload.model) !== null;
 }

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

@@ -0,0 +1,53 @@
+import { t } from '../../../../src/channels/shared/i18n.mjs';
+
+const CHANNEL_NAMES = {
+  weixin: '微信', feishu: '飞书', dingtalk: '钉钉', wecom: '企业微信',
+  'wecom-app': '企业微信应用', qq: 'QQ', slack: 'Slack', telegram: 'Telegram',
+  discord: 'Discord', whatsapp: 'WhatsApp', office: 'AI Office',
+};
+const INVALID_CONFIG_MESSAGES = new Set([
+  'dsh-weixin config contains invalid account data',
+  'dsh-feishu config contains an invalid bot entry',
+  'dsh-feishu config contains duplicate bot identities',
+  'dsh-feishu config is incomplete or invalid',
+  'dsh-dingtalk config contains invalid bot data',
+  ...['Enterprise WeChat', 'Enterprise WeChat app', 'QQ', 'Slack', 'Telegram', 'Discord']
+    .map(channel => `dsh-im ${channel} config contains invalid bot data`),
+  'dsh-im WhatsApp config contains invalid account data',
+  'dsh-im AI Office config is invalid',
+  'dsh-im workspace config is invalid',
+]);
+
+export function publicChannelInitializing(channel) {
+  return {
+    code: `${channel}-initializing`,
+    message: t('{channel}正在初始化，请稍后重新读取。', { channel: t(CHANNEL_NAMES[channel]) }),
+    details: {},
+  };
+}
+
+/** Only public guidance crosses RPC; parser excerpts, paths and secrets stay in logs. */
+export function publicChannelStartupError(channel, error) {
+  const params = { channel: t(CHANNEL_NAMES[channel]), id: channel };
+  if (error instanceof SyntaxError || INVALID_CONFIG_MESSAGES.has(error?.message)) {
+    return {
+      code: `${channel}-startup-config-invalid`,
+      message: channel === 'office'
+        ? t('{channel}配置格式错误。请检查其数据目录中的 config.json，修复后重启 DSH。详细原因请查看启动日志。', params)
+        : t('{channel}配置格式错误。请检查其数据目录中的 config.json 和 workspaces.json，修复后重启 DSH。详细原因请查看启动日志。', params),
+      details: {},
+    };
+  }
+  if (error?.code === 'EACCES' || error?.code === 'EPERM') {
+    return {
+      code: `${channel}-startup-permission-denied`,
+      message: t('无法读取或写入{channel}配置。请检查其数据目录的访问权限，修复后重启 DSH。详细原因请查看启动日志。', params),
+      details: {},
+    };
+  }
+  return {
+    code: `${channel}-startup-failed`,
+    message: t('{channel}初始化失败。请查看 DSH 启动日志中 failed to activate {id} 后的错误，修复后重启 DSH。', params),
+    details: {},
+  };
+}

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

@@ -0,0 +1,47 @@
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+import { publicChannelInitializing, publicChannelStartupError } from './startup-error.mjs';
+
+/** Mount the native management RPC before any fallible production initialization. */
+export async function installProductionChannel(ctx, config, {
+  channel, rpcChannel, createProduction, createHandler,
+}) {
+  if (!ctx?.connection?.rpc || typeof ctx.connection.rpc.handle !== 'function') {
+    throw new TypeError('DSH Host Connection RPC is required');
+  }
+  let startupError = publicChannelInitializing(channel);
+  let handler = async () => ({ ok: false, error: startupError });
+  const disposeRpc = ctx.connection.rpc.handle(rpcChannel, (endpoint, payload, signal) => {
+    if (signal?.aborted) {
+      return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.', details: {} } };
+    }
+    return handler(endpoint, payload, signal);
+  }, { authority: resolveRpcAuthority(config.rpcAuthority) });
+  const logger = typeof ctx.logger === 'function' ? ctx.logger(`dsh-im:${channel}`) : (ctx.logger ?? console);
+  let production;
+  let unregisterDelivery;
+  let closing;
+  const closeProduction = () => (closing ??= (async () => {
+    try {
+      await unregisterDelivery?.();
+    } finally {
+      await production?.close();
+    }
+  })());
+  try {
+    production = await createProduction();
+    unregisterDelivery = config.deliveryService && production.deliveryAdapter
+      ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
+    const readyHandler = createHandler(production.controller);
+    ctx.effect(() => closeProduction, `dsh-im: close ${channel} connections`);
+    handler = readyHandler;
+  } catch (error) {
+    startupError = publicChannelStartupError(channel, error);
+    logger.error?.(`[dsh-im] failed to activate ${channel}; management RPC remains available`, error);
+    try {
+      await closeProduction();
+    } catch (cleanupError) {
+      logger.error?.(`[dsh-im] failed to close partially initialized ${channel} resources`, cleanupError);
+    }
+  }
+  return disposeRpc;
+}

package/plugin-src/host/channels/shared/workspace-rpc.mjs

@@ -24,6 +24,7 @@ export function publicWorkspaceError(error) {
     'agent-preset-unavailable',
     'model-selection-invalid',
     'model-selection-unavailable',
+    'model-reasoning-unavailable',
     'context-enhancement-invalid',
   ].includes(error?.code)) return null;
   return { code: error.code, message: error.message };

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

@@ -1,20 +1,18 @@
 import { createProductionController } from './production.mjs';
-import { installSlackRpc } from './rpc.mjs';
+import { createSlackRpcHandler, installSlackRpc, SLACK_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
 
 export const name = 'dsh-im-slack-host';
 export const inject = ['connection', 'credentials', 'typertGateway'];
 
 export async function apply(ctx, config = {}) {
   if (config?.controller) return installSlackRpc(ctx, config.controller, config.rpcAuthority);
-  const production = await createProductionController(ctx, config, config.internals ?? {});
-  const unregisterDelivery = config.deliveryService && production.deliveryAdapter
-    ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
-  const disposeRpc = installSlackRpc(ctx, production.controller, config.rpcAuthority);
-  ctx.effect(() => async () => {
-    await unregisterDelivery?.();
-    await production.close();
-  }, 'dsh-im: close Slack bot connections');
-  return disposeRpc;
+  return installProductionChannel(ctx, config, {
+    channel: 'slack',
+    rpcChannel: SLACK_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals ?? {}),
+    createHandler: controller => createSlackRpcHandler(controller),
+  });
 }
 
 export function createSlackHostPlugin(config) {

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

@@ -1,5 +1,6 @@
 import { createProductionController } from './production.mjs';
-import { installTelegramRpc } from './rpc.mjs';
+import { createTelegramRpcHandler, installTelegramRpc, TELEGRAM_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
 
 export const name = 'dsh-im-telegram-host';
 export const inject = ['connection', 'credentials', 'typertGateway'];
@@ -8,15 +9,12 @@ export async function apply(ctx, config = {}) {
   if (config?.controller) {
     return installTelegramRpc(ctx, config.controller, config.rpcAuthority);
   }
-  const production = await createProductionController(ctx, config, config.internals ?? {});
-  const unregisterDelivery = config.deliveryService && production.deliveryAdapter
-    ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
-  const disposeRpc = installTelegramRpc(ctx, production.controller, config.rpcAuthority);
-  ctx.effect(() => async () => {
-    await unregisterDelivery?.();
-    await production.close();
-  }, 'dsh-im: close Telegram bot connections');
-  return disposeRpc;
+  return installProductionChannel(ctx, config, {
+    channel: 'telegram',
+    rpcChannel: TELEGRAM_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals ?? {}),
+    createHandler: controller => createTelegramRpcHandler(controller),
+  });
 }
 
 export function createTelegramHostPlugin(config) {

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

@@ -1,5 +1,6 @@
 import { createProductionController } from './production.mjs';
-import { installWecomRpc } from './rpc.mjs';
+import { createWecomRpcHandler, installWecomRpc, WECOM_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
 
 export const name = 'dsh-im-wecom-host';
 export const inject = ['connection', 'credentials', 'typertGateway'];
@@ -8,20 +9,12 @@ export async function apply(ctx, config = {}) {
   if (config?.controller) {
     return installWecomRpc(ctx, config.controller, config.rpcOptions, config.rpcAuthority);
   }
-  const production = await createProductionController(ctx, config, config.internals);
-  const unregisterDelivery = config.deliveryService && production.deliveryAdapter
-    ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
-  const disposeRpc = installWecomRpc(
-    ctx,
-    production.controller,
-    config.rpcOptions,
-    config.rpcAuthority,
-  );
-  ctx.effect(() => async () => {
-    await unregisterDelivery?.();
-    await production.close();
-  }, 'dsh-im: close Enterprise WeChat bot connections');
-  return disposeRpc;
+  return installProductionChannel(ctx, config, {
+    channel: 'wecom',
+    rpcChannel: WECOM_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals),
+    createHandler: controller => createWecomRpcHandler(controller, config.rpcOptions),
+  });
 }
 
 export function createWecomHostPlugin(config) {

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

@@ -228,12 +228,17 @@ export function createWecomRpcHandler(controller, { encodeQr = qrDataUrl } = {})
 }
 
 export function installWecomRpc(ctx, controller, options, authority) {
+  return installWecomRpcHandler(ctx, createWecomRpcHandler(controller, options), authority);
+}
+
+/** Mount the existing Connection transport before the production controller is ready. */
+export function installWecomRpcHandler(ctx, handler, authority) {
   if (!ctx?.connection?.rpc || typeof ctx.connection.rpc.handle !== 'function') {
     throw new TypeError('DSH Host Connection RPC is required');
   }
   return ctx.connection.rpc.handle(
     WECOM_RPC_CHANNEL,
-    createWecomRpcHandler(controller, options),
+    handler,
     { authority: resolveRpcAuthority(authority) },
   );
 }

package/plugin-src/host/channels/wecom-app/index.mjs

@@ -0,0 +1,33 @@
+import { createProductionController } from './production.mjs';
+import { createWecomAppRpcHandler, installWecomAppRpc, WECOM_APP_RPC_CHANNEL } from './rpc.mjs';
+import { installProductionChannel } from '../shared/startup.mjs';
+
+export const name = 'dsh-im-wecom-app-host';
+export const inject = ['connection', 'credentials', 'typertGateway'];
+
+export async function apply(ctx, config = {}) {
+  if (config?.controller) {
+    return installWecomAppRpc(ctx, config.controller, config.rpcOptions, config.rpcAuthority);
+  }
+  return installProductionChannel(ctx, config, {
+    channel: 'wecom-app',
+    rpcChannel: WECOM_APP_RPC_CHANNEL,
+    createProduction: () => createProductionController(ctx, config, config.internals),
+    createHandler: controller => createWecomAppRpcHandler(controller, config.rpcOptions),
+  });
+}
+
+export function createWecomAppHostPlugin(config) {
+  return Object.freeze({ name, inject, apply: (ctx) => apply(ctx, config) });
+}
+
+export { createProductionController } from './production.mjs';
+export {
+  WECOM_APP_ENDPOINTS,
+  WECOM_APP_RPC_CHANNEL,
+  WECOM_APP_RPC_ENDPOINTS,
+  createWecomAppRpcHandler,
+  installWecomAppRpc,
+} from './rpc.mjs';
+export { WecomAppController } from '../../../../src/channels/wecom-app/wecom-app-controller.mjs';
+export { WecomAppRuntime } from '../../../../src/channels/wecom-app/wecom-app-runtime.mjs';

package/plugin-src/host/channels/wecom-app/production.mjs

@@ -0,0 +1,217 @@
+import { unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { WecomAppConfigStore } from '../../../../src/channels/wecom-app/config-store.mjs';
+import { WecomAppHarnessClient } from '../../../../src/channels/wecom-app/harness-client.mjs';
+import { WecomAppStateStore } from '../../../../src/channels/wecom-app/state-store.mjs';
+import { WecomAppController } from '../../../../src/channels/wecom-app/wecom-app-controller.mjs';
+import { WecomAppRuntime } from '../../../../src/channels/wecom-app/wecom-app-runtime.mjs';
+import { WecomAppCallbackServer } from '../../../../src/channels/wecom-app/callback-server.mjs';
+import {
+  BotWorkspaceStore,
+  createBotWorkspaceScope,
+  createWorkspaceAwareController,
+  observeBotWorkspaceRemovals,
+} from '../../../../src/channels/shared/bot-workspace-store.mjs';
+import { listAgentPresetCatalog } from '../../../../src/channels/shared/agent-preset.mjs';
+import { listModelCatalog } from '../../../../src/channels/shared/model-setting.mjs';
+import { createDeliveryAdapter } from '../../delivery-adapter.mjs';
+import { createConnectionSupervisor } from '../wecom/connection-supervisor.mjs';
+import { createHarnessCommandExecutor } from '../../harness-command-executor.mjs';
+import { harnessConnection } from '../../harness-connection.mjs';
+import { createHarnessSessionExecutors } from '../../harness-session-coordinator.mjs';
+import {
+  getInboundTtlRuntime,
+  registerInboundTtlWorkspaces,
+} from '../../inbound-ttl-runtime.mjs';
+import {
+  accessPolicyProvider,
+  initialAccessPolicyFor,
+} from '../shared/access-policy-production.mjs';
+
+function pluginPaths(config) {
+  const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
+  const root = resolve(config.dataDir ?? join(dshHome, 'integrations', 'dsh-wecom-app'));
+  return {
+    config: resolve(config.configPath ?? join(root, 'config.json')),
+    bots: resolve(config.botsDir ?? join(root, 'bots')),
+    workspaces: resolve(config.workspacesPath ?? join(root, 'workspaces.json')),
+  };
+}
+
+function normalizeOrigin(value) {
+  const raw = typeof value === 'string' ? value.trim() : '';
+  return raw ? raw.replace(/\/+$/u, '') : null;
+}
+
+export async function createProductionController(ctx, config = {}, internals = {}) {
+  if (!ctx?.credentials) throw new TypeError('dsh-im Enterprise WeChat app requires ctx.credentials');
+  const connection = harnessConnection(ctx, config);
+
+  const ConfigStore = internals.ConfigStore ?? WecomAppConfigStore;
+  const StateStore = internals.StateStore ?? WecomAppStateStore;
+  const Harness = internals.HarnessClient ?? WecomAppHarnessClient;
+  const Controller = internals.Controller ?? WecomAppController;
+  const Runtime = internals.Runtime ?? WecomAppRuntime;
+  const CallbackServer = internals.CallbackServer ?? WecomAppCallbackServer;
+  const createSupervisor = internals.createConnectionSupervisor ?? createConnectionSupervisor;
+  const baseLogger = typeof ctx.logger === 'function' ? ctx.logger('dsh-im:wecom-app') : (ctx.logger ?? console);
+  // The cordis logger never surfaces in the web profile journal; tee every
+  // level to the process console so callback verification attempts stay
+  // observable (journald captures the dsh web process stdout).
+  const logger = {
+    log: (...args) => { baseLogger.log?.(...args); console.log('[dsh-im:wecom-app]', ...args); },
+    info: (...args) => { baseLogger.info?.(...args); console.info('[dsh-im:wecom-app]', ...args); },
+    warn: (...args) => { baseLogger.warn?.(...args); console.warn('[dsh-im:wecom-app]', ...args); },
+    error: (...args) => { baseLogger.error?.(...args); console.error('[dsh-im:wecom-app]', ...args); },
+  };
+  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 configuredBots = configStore.list();
+  await workspaces.reconcile(configuredBots.map((bot) => bot.botId));
+  await Promise.all(configuredBots.map((bot) => workspaces.ensure(bot.botId, {
+    defaultAgentPreset: config.agentPreset,
+    initialAccessPolicy: initialAccessPolicyFor('wecom-app', bot),
+  })));
+  const observedConfigStore = typeof configStore.remove === 'function'
+    ? observeBotWorkspaceRemovals(configStore, { workspaces })
+    : configStore;
+  const callbackServer = internals.callbackServer ?? new CallbackServer({
+    host: config.callbackListenHost ?? '127.0.0.1',
+    port: config.callbackListenPort ?? 30987,
+    logger,
+  });
+  // The callback listener starts on demand with the first bound app and
+  // stops once the last app is removed, so hosts that never use this channel
+  // do not keep port 30987 occupied.
+  const ensureCallbackListener = async () => {
+    if (callbackServer.listening !== true) await callbackServer.start();
+    return callbackServer;
+  };
+  const baseRegisterRoute = callbackServer.registerRoute.bind(callbackServer);
+  callbackServer.registerRoute = (route) => ensureCallbackListener().then(() => baseRegisterRoute(route));
+  const baseUnregisterRoute = callbackServer.unregisterRoute.bind(callbackServer);
+  callbackServer.unregisterRoute = (botId) => {
+    baseUnregisterRoute(botId);
+    if (callbackServer.routeCount() === 0 && callbackServer.listening) return callbackServer.stop();
+  };
+  const publicOrigin = normalizeOrigin(config.callbackBaseUrl);
+  const buildCallbackUrl = (bot) => {
+    const origin = normalizeOrigin(bot?.callbackBaseUrl) ?? publicOrigin;
+    return origin ? `${origin}${callbackServer.routePath(bot)}` : null;
+  };
+  const stateStores = new Map();
+  const statePath = (botId) => resolve(paths.bots, botId, 'state.json');
+  const stateFor = async (botId) => {
+    let state = stateStores.get(botId);
+    if (!state) {
+      state = await new StateStore(statePath(botId)).load();
+      stateStores.set(botId, state);
+    }
+    return state;
+  };
+  const commandExecutor = createHarnessCommandExecutor(ctx, internals.commandExecutor);
+  const inboundTtl = internals.inboundTtl ?? getInboundTtlRuntime(ctx, config);
+  const inboundTtlService = inboundTtl?.service ?? inboundTtl;
+  registerInboundTtlWorkspaces(ctx, inboundTtlService, {
+    workspaces,
+    configStore: observedConfigStore,
+    defaultWorkspace,
+  });
+  const { controlExecutor, sessionMaintenanceExecutor, fileIngressExecutor } = createHarnessSessionExecutors(ctx, {
+    controlExecutor: internals.controlExecutor,
+    sessionMaintenanceExecutor: internals.sessionMaintenanceExecutor,
+    fileIngressExecutor: internals.fileIngressExecutor,
+    inboundTtlService,
+  });
+  const harness = new Harness({
+    ...connection,
+    workspace: defaultWorkspace,
+    autostart: false,
+    dshBin: config.dshBin ?? 'dsh',
+    ...(commandExecutor ? { commandExecutor } : {}),
+    ...(controlExecutor ? { controlExecutor } : {}),
+    ...(sessionMaintenanceExecutor ? { sessionMaintenanceExecutor } : {}),
+    ...(fileIngressExecutor ? { fileIngressExecutor } : {}),
+  });
+  const modelCatalog = () => listModelCatalog(harness);
+  const coreController = new Controller({
+    credentials: ctx.credentials,
+    configStore: observedConfigStore,
+    buildCallbackUrl,
+    logger,
+    createRuntime: async ({ botId, config: botConfig, secrets }) => {
+      const state = await stateFor(botId);
+      await workspaces.ensure(botId, {
+        defaultAgentPreset: config.agentPreset,
+        initialAccessPolicy: initialAccessPolicyFor('wecom-app', botConfig),
+      });
+      const workspaceScope = createBotWorkspaceScope(harness, {
+        botId, workspaces, state, agentPresetCatalog,
+      });
+      return new Runtime({
+        config: botConfig,
+        secrets,
+        harness: workspaceScope.harness,
+        state: workspaceScope.state,
+        contextEnhancement: { botId, getSettings: () => workspaces.contextEnhancementFor(botId) },
+        accessPolicy: accessPolicyProvider(workspaces, botId, {
+          channel: 'wecom-app', config: botConfig,
+        }),
+        callbackServer,
+        replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+        logger: {
+          error: (...args) => logger.error?.(`[${botId}]`, ...args),
+          warn: (...args) => logger.warn?.(`[${botId}]`, ...args),
+          info: (...args) => logger.info?.(`[${botId}]`, ...args),
+          debug: (...args) => logger.debug?.(`[${botId}]`, ...args),
+        },
+      });
+    },
+    deleteState: async ({ botId }) => {
+      const state = stateStores.get(botId);
+      stateStores.delete(botId);
+      if (state && typeof state.remove === 'function') {
+        await state.remove();
+      } else {
+        try {
+          await unlink(statePath(botId));
+        } catch (error) {
+          if (error?.code !== 'ENOENT') throw error;
+        }
+      }
+    },
+  });
+  const controller = createWorkspaceAwareController(coreController, {
+    workspaces,
+    stateFor,
+    agentPresetCatalog,
+    modelCatalog,
+  });
+  const supervisor = createSupervisor({
+    controller,
+    harness,
+    logger,
+    retryDelaysMs: config.retryDelaysMs,
+    healthyIntervalMs: config.healthyIntervalMs,
+  }).start();
+  return {
+    controller,
+    deliveryAdapter: createDeliveryAdapter({
+      channel: 'wecom-app', workspaces, coreController, stateFor,
+    }),
+    ready: supervisor.ready,
+    async close() {
+      await supervisor.close();
+      await controller.close();
+      await callbackServer.stop();
+      harness.stopManagedProcess();
+    },
+  };
+}