feat: add Slack bot integration

plugin-src/host/channels/shared/production.mjs

@@ -4,7 +4,7 @@ import { join, resolve } from 'node:path';
 
 import { createTokenConnectionSupervisor } from './connection-supervisor.mjs';
 
-function harnessOrigin(webServer, configured) {
+export function harnessOrigin(webServer, configured) {
   if (configured !== undefined) return new URL(configured);
   const port = webServer?.port;
   if (!Number.isInteger(port) || port < 1 || port > 65_535) {
@@ -13,7 +13,7 @@ function harnessOrigin(webServer, configured) {
   return new URL(`http://127.0.0.1:${port}`);
 }
 
-function pluginPaths(config, channel) {
+export function pluginPaths(config, channel) {
   const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
   const root = resolve(config.dataDir ?? join(dshHome, 'integrations', `dsh-${channel}`));
   return {

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

@@ -0,0 +1,28 @@
+import { createProductionController } from './production.mjs';
+import { installSlackRpc } from './rpc.mjs';
+
+export const name = 'dsh-im-slack-host';
+export const inject = ['connection', 'credentials', 'webServer'];
+
+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 disposeRpc = installSlackRpc(ctx, production.controller, config.rpcAuthority);
+  ctx.effect(() => async () => production.close(), 'dsh-im: close Slack bot connections');
+  return disposeRpc;
+}
+
+export function createSlackHostPlugin(config) {
+  return Object.freeze({ name, inject, apply: (ctx) => apply(ctx, config) });
+}
+
+export { createProductionController } from './production.mjs';
+export {
+  SLACK_ENDPOINTS,
+  SLACK_RPC_CHANNEL,
+  SLACK_RPC_ENDPOINTS,
+  createSlackRpcHandler,
+  installSlackRpc,
+} from './rpc.mjs';
+export { SlackController } from '../../../../src/channels/slack/slack-controller.mjs';
+export { SlackRuntime } from '../../../../src/channels/slack/slack-runtime.mjs';

plugin-src/host/channels/slack/production.mjs

@@ -0,0 +1,91 @@
+import { unlink } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { SlackConfigStore } from '../../../../src/channels/slack/config-store.mjs';
+import { SlackController } from '../../../../src/channels/slack/slack-controller.mjs';
+import { SlackHarnessClient } from '../../../../src/channels/slack/harness-client.mjs';
+import { SlackRuntime } from '../../../../src/channels/slack/slack-runtime.mjs';
+import { SlackStateStore } from '../../../../src/channels/slack/state-store.mjs';
+import { createTokenConnectionSupervisor } from '../shared/connection-supervisor.mjs';
+import { harnessOrigin, pluginPaths } from '../shared/production.mjs';
+
+export async function createProductionController(ctx, config = {}, internals = {}) {
+  if (!ctx?.credentials) throw new TypeError('dsh-im slack requires ctx.credentials');
+  if (!ctx?.webServer) throw new TypeError('dsh-im slack requires ctx.webServer');
+
+  const ResolvedConfigStore = internals.ConfigStore ?? SlackConfigStore;
+  const ResolvedStateStore = internals.StateStore ?? SlackStateStore;
+  const ResolvedHarness = internals.HarnessClient ?? SlackHarnessClient;
+  const ResolvedController = internals.Controller ?? SlackController;
+  const ResolvedRuntime = internals.Runtime ?? SlackRuntime;
+  const createSupervisor = internals.createConnectionSupervisor ?? createTokenConnectionSupervisor;
+  const logger = typeof ctx.logger === 'function'
+    ? ctx.logger('dsh-im:slack') : (ctx.logger ?? console);
+  const paths = pluginPaths(config, 'slack');
+  const configStore = await new ResolvedConfigStore(paths.config).load();
+  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 ResolvedStateStore(statePath(botId)).load();
+      stateStores.set(botId, state);
+    }
+    return state;
+  };
+  const harness = new ResolvedHarness({
+    baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
+    workspace: resolve(config.workspace ?? process.cwd()),
+    agentPreset: config.agentPreset ?? 'standard',
+    autostart: false,
+    dshBin: config.dshBin ?? 'dsh',
+  });
+  const controller = new ResolvedController({
+    credentials: ctx.credentials,
+    configStore,
+    logger,
+    ...(internals.inspectCredentials ? { inspectCredentials: internals.inspectCredentials } : {}),
+    createRuntime: async ({ botId, config: botConfig, botToken, appToken }) => new ResolvedRuntime({
+      config: botConfig,
+      botToken,
+      appToken,
+      harness,
+      state: await stateFor(botId),
+      replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+      connectTimeoutMs: config.connectTimeoutMs ?? 20_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') return state.remove();
+      try {
+        await unlink(statePath(botId));
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+      }
+    },
+  });
+  const supervisor = createSupervisor({
+    channel: 'slack',
+    controller,
+    harness,
+    logger,
+    retryDelaysMs: config.retryDelaysMs,
+    healthyIntervalMs: config.healthyIntervalMs,
+  }).start();
+  return {
+    controller,
+    ready: supervisor.ready,
+    async close() {
+      await supervisor.close();
+      await controller.close();
+      harness.stopManagedProcess();
+    },
+  };
+}

plugin-src/host/channels/slack/rpc.mjs

@@ -0,0 +1,127 @@
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+
+export const SLACK_RPC_CHANNEL = '/slack';
+export const SLACK_ENDPOINTS = Object.freeze({
+  status: 'connection.status',
+  bindCredentials: 'bot.bind-credentials',
+  reconnectBot: 'bot.reconnect',
+  deleteBot: 'bot.delete',
+});
+export const SLACK_RPC_ENDPOINTS = Object.freeze(Object.values(SLACK_ENDPOINTS));
+
+const FORBIDDEN_PUBLIC_KEYS = new Set([
+  'token', 'botToken', 'appToken', 'botTokenRef', 'appTokenRef',
+  'tokenRef', 'platformId', 'secret', 'secretRef',
+]);
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function exactKeys(value, allowed) {
+  return isRecord(value) && Object.keys(value).every((key) => allowed.includes(key));
+}
+
+function validId(value) {
+  return typeof value === 'string' && /^slack_[a-f0-9]{24}$/.test(value);
+}
+
+function validBotToken(value) {
+  return typeof value === 'string' && /^xoxb-[A-Za-z0-9-]{16,}$/.test(value.trim())
+    && value.length <= 4_096;
+}
+
+function validAppToken(value) {
+  return typeof value === 'string' && /^xapp-[A-Za-z0-9-]{16,}$/.test(value.trim())
+    && value.length <= 4_096;
+}
+
+function payloadFailure(endpoint, payload) {
+  if (!isRecord(payload)) return 'Payload must be an object.';
+  if (endpoint === SLACK_ENDPOINTS.status) {
+    return exactKeys(payload, []) ? null : 'connection.status does not accept fields.';
+  }
+  if (endpoint === SLACK_ENDPOINTS.bindCredentials) {
+    return exactKeys(payload, ['botToken', 'appToken'])
+      && validBotToken(payload.botToken) && validAppToken(payload.appToken)
+      ? null : 'bot.bind-credentials requires xoxb Bot Token and xapp App Token.';
+  }
+  if (endpoint === SLACK_ENDPOINTS.reconnectBot) {
+    return exactKeys(payload, ['botId']) && validId(payload.botId)
+      ? null : 'bot.reconnect requires a botId.';
+  }
+  if (endpoint === SLACK_ENDPOINTS.deleteBot) {
+    return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
+      ? null : 'bot.delete requires a botId and confirm=true.';
+  }
+  return 'Unknown Slack endpoint.';
+}
+
+function sanitizePublic(value) {
+  if (Array.isArray(value)) return value.map(sanitizePublic);
+  if (!isRecord(value)) return value;
+  const safe = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (!FORBIDDEN_PUBLIC_KEYS.has(key)) safe[key] = sanitizePublic(child);
+  }
+  return safe;
+}
+
+function operationError(error) {
+  if (error?.code === 'slack-invalid-bot-token') {
+    return { code: 'invalid-bot-token', message: 'Slack Bot Token 无效，请确认使用以 xoxb- 开头的令牌。' };
+  }
+  if (error?.code === 'slack-invalid-app-token') {
+    return { code: 'invalid-app-token', message: 'Slack App Token 无效，请确认使用以 xapp- 开头的令牌。' };
+  }
+  if (error?.code === 'slack-missing-scope') {
+    return { code: 'missing-scope', message: 'Slack 应用权限不完整，请重新导入 Manifest 并安装到工作区。' };
+  }
+  if (error?.code === 'slack-socket-mode') {
+    return { code: 'socket-mode-unavailable', message: error.message };
+  }
+  return { code: 'slack-operation-failed', message: 'Slack 操作失败，请稍后重试。' };
+}
+
+export function createSlackRpcHandler(controller) {
+  for (const method of ['status', 'bindCredentials', 'reconnectBot', 'deleteBot']) {
+    if (typeof controller?.[method] !== 'function') {
+      throw new TypeError(`A complete Slack controller is required (${method})`);
+    }
+  }
+  return async (endpoint, payload, signal) => {
+    if (signal?.aborted) {
+      return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+    }
+    if (!SLACK_RPC_ENDPOINTS.includes(endpoint)) {
+      return { ok: false, error: { code: 'bad-request', message: 'Unknown Slack endpoint.' } };
+    }
+    const invalid = payloadFailure(endpoint, payload);
+    if (invalid) return { ok: false, error: { code: 'bad-request', message: invalid } };
+    try {
+      let value;
+      if (endpoint === SLACK_ENDPOINTS.status) value = await controller.status();
+      else if (endpoint === SLACK_ENDPOINTS.bindCredentials) value = await controller.bindCredentials(payload);
+      else if (endpoint === SLACK_ENDPOINTS.reconnectBot) value = await controller.reconnectBot(payload.botId);
+      else value = await controller.deleteBot(payload.botId);
+      return signal?.aborted
+        ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
+        : { ok: true, value: sanitizePublic(value) };
+    } catch (error) {
+      return signal?.aborted
+        ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
+        : { ok: false, error: operationError(error) };
+    }
+  };
+}
+
+export function installSlackRpc(ctx, controller, 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(
+    SLACK_RPC_CHANNEL,
+    createSlackRpcHandler(controller),
+    { authority: resolveRpcAuthority(authority) },
+  );
+}

plugin-src/host/index.mjs

@@ -2,6 +2,7 @@ import { apply as applyDingtalk } from './channels/dingtalk/index.mjs';
 import { apply as applyDiscord } from './channels/discord/index.mjs';
 import { apply as applyFeishu } from './channels/feishu/index.mjs';
 import { apply as applyQq } from './channels/qq/index.mjs';
+import { apply as applySlack } from './channels/slack/index.mjs';
 import { apply as applyTelegram } from './channels/telegram/index.mjs';
 import { apply as applyWecom } from './channels/wecom/index.mjs';
 import { apply as applyWeixin } from './channels/weixin/index.mjs';
@@ -23,6 +24,7 @@ export function createImHostPlugin(internals = {}) {
   const startDingtalk = internals.applyDingtalk ?? applyDingtalk;
   const startWecom = internals.applyWecom ?? applyWecom;
   const startQq = internals.applyQq ?? applyQq;
+  const startSlack = internals.applySlack ?? applySlack;
   const startTelegram = internals.applyTelegram ?? applyTelegram;
   const startDiscord = internals.applyDiscord ?? applyDiscord;
   const startWhatsapp = internals.applyWhatsapp ?? applyWhatsapp;
@@ -35,6 +37,7 @@ export function createImHostPlugin(internals = {}) {
       await startDingtalk(ctx, channelConfig(config, 'dingtalk'));
       await startWecom(ctx, channelConfig(config, 'wecom'));
       await startQq(ctx, channelConfig(config, 'qq'));
+      await startSlack(ctx, channelConfig(config, 'slack'));
       await startTelegram(ctx, channelConfig(config, 'telegram'));
       await startDiscord(ctx, channelConfig(config, 'discord'));
       await startWhatsapp(ctx, channelConfig(config, 'whatsapp'));