@xmanrui/dsh-im 0.2.2 → 0.3.0

package/src/channels/slack/slack-api.mjs

@@ -0,0 +1,259 @@
+const DEFAULT_BASE_URL = 'https://slack.com/api/';
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function requestSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    timer?.unref?.();
+    signal?.addEventListener('abort', () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+    }, { once: true });
+  });
+}
+
+function slackId(value, name) {
+  const result = cleanString(value);
+  if (!result || !/^[A-Z][A-Z0-9]{4,30}$/i.test(result)) {
+    throw new TypeError(`Invalid Slack ${name}`);
+  }
+  return result;
+}
+
+function requiredString(value, name) {
+  const result = cleanString(value);
+  if (!result) throw new TypeError(`Slack ${name} is required`);
+  return result;
+}
+
+function safeOutgoingText(value, { trim = true } = {}) {
+  const raw = typeof value === 'string' ? value : '';
+  const text = trim ? raw.trim() : raw;
+  if (!text) throw new TypeError('Slack message text is required');
+  return text
+    .replace(/<@([A-Z0-9]+)>/gi, '@$1')
+    .replace(/<!(channel|here|everyone)(?:\^[^>]*)?>/gi, '@$1');
+}
+
+function apiFailure(method, payload, tokenKind) {
+  const reason = cleanString(payload?.error) ?? 'unknown_error';
+  const error = new Error(`Slack ${method} failed: ${reason.replaceAll('_', ' ')}`);
+  if (['invalid_auth', 'not_authed', 'token_revoked', 'account_inactive'].includes(reason)) {
+    error.code = tokenKind === 'app' ? 'slack-invalid-app-token' : 'slack-invalid-bot-token';
+  } else if (reason === 'missing_scope') {
+    error.code = 'slack-missing-scope';
+  } else if (reason === 'method_not_supported_for_channel_type'
+    || reason === 'channel_type_not_supported'
+    || reason === 'deprecated_endpoint') {
+    error.code = 'slack-stream-unavailable';
+  } else {
+    error.code = `slack-${reason}`;
+  }
+  return error;
+}
+
+export function validSlackBotToken(value) {
+  return typeof value === 'string'
+    && /^xoxb-[A-Za-z0-9-]{16,}$/.test(value.trim());
+}
+
+export function validSlackAppToken(value) {
+  return typeof value === 'string'
+    && /^xapp-[A-Za-z0-9-]{16,}$/.test(value.trim());
+}
+
+export class SlackApi {
+  #botToken;
+  #appToken;
+  #fetch;
+  #baseUrl;
+
+  constructor({ botToken, appToken, fetchImpl = fetch, baseUrl = DEFAULT_BASE_URL }) {
+    if (botToken !== undefined && !validSlackBotToken(botToken)) {
+      throw new TypeError('Slack Bot Token is invalid');
+    }
+    if (appToken !== undefined && !validSlackAppToken(appToken)) {
+      throw new TypeError('Slack App Token is invalid');
+    }
+    if (!botToken && !appToken) throw new TypeError('SlackApi requires a token');
+    if (typeof fetchImpl !== 'function') throw new TypeError('SlackApi requires fetch');
+    this.#botToken = botToken?.trim();
+    this.#appToken = appToken?.trim();
+    this.#fetch = fetchImpl;
+    this.#baseUrl = new URL(baseUrl);
+  }
+
+  authTest(options = {}) {
+    return this.#request('auth.test', { ...options, tokenKind: 'bot' });
+  }
+
+  openConnection(options = {}) {
+    return this.#request('apps.connections.open', {
+      ...options,
+      tokenKind: 'app',
+      body: undefined,
+    });
+  }
+
+  postMessage({ channelId, text, threadTs, signal }) {
+    return this.#request('chat.postMessage', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        text: safeOutgoingText(text),
+        ...(threadTs ? { thread_ts: cleanString(threadTs) } : {}),
+        mrkdwn: true,
+        link_names: false,
+        unfurl_links: false,
+        unfurl_media: false,
+      },
+    });
+  }
+
+  updateMessage({ channelId, ts, text, signal }) {
+    return this.#request('chat.update', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        ts: requiredString(ts, 'message timestamp'),
+        text: safeOutgoingText(text),
+        parse: 'none',
+        link_names: false,
+      },
+    });
+  }
+
+  startStream({ channelId, threadTs, recipientTeamId, recipientUserId, markdownText, signal }) {
+    return this.#request('chat.startStream', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        thread_ts: requiredString(threadTs, 'thread timestamp'),
+        ...(recipientTeamId ? { recipient_team_id: slackId(recipientTeamId, 'team id') } : {}),
+        ...(recipientUserId ? { recipient_user_id: slackId(recipientUserId, 'user id') } : {}),
+        ...(cleanString(markdownText) ? { markdown_text: safeOutgoingText(markdownText) } : {}),
+      },
+    });
+  }
+
+  appendStream({ channelId, ts, markdownText, signal }) {
+    return this.#request('chat.appendStream', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        ts: requiredString(ts, 'stream timestamp'),
+        markdown_text: safeOutgoingText(markdownText, { trim: false }),
+      },
+    });
+  }
+
+  stopStream({ channelId, ts, markdownText, signal }) {
+    return this.#request('chat.stopStream', {
+      tokenKind: 'bot',
+      signal,
+      body: {
+        channel: slackId(channelId, 'channel id'),
+        ts: requiredString(ts, 'stream timestamp'),
+        ...(cleanString(markdownText) ? {
+          markdown_text: safeOutgoingText(markdownText, { trim: false }),
+        } : {}),
+      },
+    });
+  }
+
+  async #request(method, {
+    tokenKind,
+    body,
+    signal,
+    timeoutMs = 15_000,
+    retry = true,
+  }) {
+    const token = tokenKind === 'app' ? this.#appToken : this.#botToken;
+    if (!token) throw new TypeError(`Slack ${tokenKind} token is required for ${method}`);
+    let response;
+    try {
+      response = await this.#fetch(new URL(method, this.#baseUrl), {
+        method: 'POST',
+        headers: {
+          authorization: `Bearer ${token}`,
+          'content-type': body === undefined
+            ? 'application/x-www-form-urlencoded;charset=utf-8'
+            : 'application/json;charset=utf-8',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.2.2)',
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        signal: requestSignal(signal, timeoutMs),
+        redirect: 'error',
+      });
+    } catch (error) {
+      if (error?.name === 'AbortError' || error?.name === 'TimeoutError') throw error;
+      throw new Error(`Slack ${method} transport failed`);
+    }
+
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new Error(`Slack ${method} returned invalid JSON`);
+    }
+    if (response.status === 429 && retry) {
+      const seconds = Number(response.headers.get('retry-after')) || 1;
+      await delay(Math.min(10_000, Math.max(100, seconds * 1_000)), signal);
+      return this.#request(method, { tokenKind, body, signal, timeoutMs, retry: false });
+    }
+    if (!response.ok || payload?.ok !== true) throw apiFailure(method, payload, tokenKind);
+    return payload;
+  }
+}
+
+export async function inspectSlackCredentials({ botToken, appToken }, options = {}) {
+  if (!validSlackBotToken(botToken)) {
+    const error = new TypeError('Slack Bot Token 必须以 xoxb- 开头。');
+    error.code = 'slack-invalid-bot-token';
+    throw error;
+  }
+  if (!validSlackAppToken(appToken)) {
+    const error = new TypeError('Slack App Token 必须以 xapp- 开头。');
+    error.code = 'slack-invalid-app-token';
+    throw error;
+  }
+  const api = new SlackApi({ botToken, appToken, ...options });
+  const [identity, connection] = await Promise.all([api.authTest(), api.openConnection()]);
+  if (!identity?.team_id || !identity?.user_id || !identity?.bot_id) {
+    throw new Error('Slack Bot Token 没有返回完整的机器人身份。');
+  }
+  let socketUrl;
+  try {
+    socketUrl = new URL(connection?.url);
+  } catch {
+    socketUrl = null;
+  }
+  if (!socketUrl || socketUrl.protocol !== 'wss:') {
+    const error = new Error('Slack App Token 无法创建 Socket Mode 连接，请确认已启用 Socket Mode 和 connections:write。');
+    error.code = 'slack-socket-mode';
+    throw error;
+  }
+  return {
+    platformId: `${identity.team_id}:${identity.user_id}`,
+    name: cleanString(identity.user) ?? 'DeepSeek Harness',
+    username: cleanString(identity.user),
+    teamId: String(identity.team_id),
+    teamName: cleanString(identity.team),
+  };
+}

package/src/channels/slack/slack-bridge.mjs

@@ -0,0 +1,15 @@
+import { TextHarnessBridge, createTextBridgeStatus } from '../shared/text-harness-bridge.mjs';
+
+export const SLACK_DESCRIPTOR = Object.freeze({
+  key: 'slack',
+  label: 'Slack',
+  connectionLabel: ' Socket Mode 长连接',
+});
+
+export class SlackHarnessBridge extends TextHarnessBridge {
+  constructor(options) {
+    super({ descriptor: SLACK_DESCRIPTOR, ...options });
+  }
+}
+
+export { createTextBridgeStatus as createSlackBridgeStatus };

package/src/channels/slack/slack-controller.mjs

@@ -0,0 +1,318 @@
+import { deriveSlackBotIdentity, maskSlackBotId } from './config-store.mjs';
+import { inspectSlackCredentials } from './slack-api.mjs';
+import { SLACK_DESCRIPTOR } from './slack-bridge.mjs';
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function safeError(code, message) {
+  return Object.freeze({ code, message });
+}
+
+export class SlackController {
+  #credentials;
+  #configStore;
+  #inspectCredentials;
+  #createRuntime;
+  #deleteState;
+  #logger;
+  #runtimes = new Map();
+  #errors = new Map();
+  #transitions = new Map();
+  #revision = 0;
+  #closed = false;
+
+  constructor({
+    credentials,
+    configStore,
+    inspectCredentials = inspectSlackCredentials,
+    createRuntime,
+    deleteState = async () => {},
+    logger = console,
+  }) {
+    if (!credentials || typeof credentials.resolve !== 'function'
+      || typeof credentials.set !== 'function' || typeof credentials.unset !== 'function') {
+      throw new TypeError('Slack requires the DSH credential provider');
+    }
+    if (!configStore || typeof configStore.list !== 'function'
+      || typeof configStore.save !== 'function' || typeof configStore.remove !== 'function') {
+      throw new TypeError('Slack requires a config store');
+    }
+    if (typeof inspectCredentials !== 'function' || typeof createRuntime !== 'function') {
+      throw new TypeError('Slack controller dependencies are incomplete');
+    }
+    this.#credentials = credentials;
+    this.#configStore = configStore;
+    this.#inspectCredentials = inspectCredentials;
+    this.#createRuntime = createRuntime;
+    this.#deleteState = deleteState;
+    this.#logger = logger;
+  }
+
+  async initialize() {
+    if (this.#closed) return this.status();
+    for (const config of this.#configStore.list()) {
+      await this.#withBotTransition(config.botId, async () => {
+        if (this.#closed || this.#runtimes.get(config.botId)?.status?.ready) return;
+        const resolved = await this.#resolveCredentials(config);
+        if (!resolved) {
+          this.#errors.set(config.botId, safeError(
+            'missing-token',
+            'Slack机器人凭据缺失，请移除后重新接入。',
+          ));
+          return;
+        }
+        try {
+          await this.#startRuntime(config, resolved);
+          this.#errors.delete(config.botId);
+        } catch (error) {
+          this.#errors.set(config.botId, safeError(
+            'connection-failed',
+            'Slack Socket Mode 连接未就绪，插件会自动重试。',
+          ));
+          this.#logger.warn?.(
+            `[dsh-im:slack] bot ${config.botId} failed to initialize:`,
+            error,
+          );
+        } finally {
+          this.#touch();
+        }
+      });
+    }
+    return this.status();
+  }
+
+  async bindCredentials({ botToken, appToken } = {}) {
+    if (this.#closed) throw new Error('Slack controller is closed');
+    const normalizedBotToken = cleanString(botToken);
+    const normalizedAppToken = cleanString(appToken);
+    if (!normalizedBotToken || !normalizedAppToken) {
+      throw new TypeError('Slack Bot Token and App Token are required');
+    }
+    const inspected = await this.#inspectCredentials({
+      botToken: normalizedBotToken,
+      appToken: normalizedAppToken,
+    });
+    const platformId = cleanString(inspected?.platformId);
+    const name = cleanString(inspected?.name);
+    if (!platformId || !name) throw new Error('Slack returned an invalid bot identity');
+    const identity = deriveSlackBotIdentity(platformId);
+
+    await this.#withBotTransition(identity.botId, async () => {
+      if (this.#closed) throw new Error('Slack controller is closed');
+      const previousConfig = this.#configStore.getByPlatformId(platformId);
+      const previousBotToken = await this.#credentials.resolve(identity.botTokenRef).catch(() => undefined);
+      const previousAppToken = await this.#credentials.resolve(identity.appTokenRef).catch(() => undefined);
+      const config = {
+        ...identity,
+        platformId,
+        name,
+        username: cleanString(inspected.username),
+        teamId: cleanString(inspected.teamId),
+        teamName: cleanString(inspected.teamName),
+        createdAt: previousConfig?.createdAt ?? new Date().toISOString(),
+        connectedAt: new Date().toISOString(),
+      };
+      try {
+        await this.#credentials.set(identity.botTokenRef, normalizedBotToken);
+        await this.#credentials.set(identity.appTokenRef, normalizedAppToken);
+        await this.#configStore.save(config);
+      } catch (error) {
+        await Promise.all([
+          this.#restoreCredential(identity.botTokenRef, previousBotToken),
+          this.#restoreCredential(identity.appTokenRef, previousAppToken),
+        ]);
+        throw error;
+      }
+      try {
+        await this.#startRuntime(config, {
+          botToken: normalizedBotToken,
+          appToken: normalizedAppToken,
+        });
+        this.#errors.delete(identity.botId);
+      } catch (error) {
+        this.#errors.set(identity.botId, safeError(
+          'connection-failed',
+          'Slack机器人已接入，Socket Mode 连接暂未就绪。',
+        ));
+        this.#logger.warn?.(
+          `[dsh-im:slack] bot ${identity.botId} credential connection failed:`,
+          error,
+        );
+      }
+      this.#touch();
+    });
+    return this.status();
+  }
+
+  async reconnectBot(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Slack bot');
+    await this.#withBotTransition(botId, async () => {
+      const resolved = await this.#resolveCredentials(config);
+      if (!resolved) throw new Error('Slack bot credentials are missing');
+      try {
+        await this.#startRuntime(config, resolved);
+        this.#errors.delete(botId);
+      } catch (error) {
+        this.#errors.set(botId, safeError(
+          'connection-failed',
+          'Slack Socket Mode 连接仍未就绪，请检查两个 Token。',
+        ));
+        throw error;
+      } finally {
+        this.#touch();
+      }
+    });
+    return this.status();
+  }
+
+  async deleteBot(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Slack bot');
+    await this.#withBotTransition(botId, async () => {
+      const previousBotToken = await this.#credentials.resolve(config.botTokenRef).catch(() => undefined);
+      const previousAppToken = await this.#credentials.resolve(config.appTokenRef).catch(() => undefined);
+      await this.#stopRuntime(botId);
+      try {
+        await this.#credentials.unset(config.botTokenRef);
+        await this.#credentials.unset(config.appTokenRef);
+        await this.#configStore.remove(botId);
+      } catch (error) {
+        await Promise.all([
+          this.#restoreCredential(config.botTokenRef, previousBotToken),
+          this.#restoreCredential(config.appTokenRef, previousAppToken),
+        ]);
+        if (previousBotToken?.value && previousAppToken?.value) {
+          await this.#startRuntime(config, {
+            botToken: previousBotToken.value,
+            appToken: previousAppToken.value,
+          }).catch(() => undefined);
+        }
+        throw new Error('Unable to remove the Slack bot safely.', { cause: error });
+      }
+      await this.#deleteState({ botId, config }).catch((error) => {
+        this.#logger.warn?.(`[dsh-im:slack] bot ${botId} state cleanup failed:`, error);
+      });
+      this.#errors.delete(botId);
+      this.#touch();
+    });
+    return this.status();
+  }
+
+  status() {
+    const bots = this.#configStore.list().map((config) => {
+      const runtimeStatus = this.#runtimes.get(config.botId)?.status ?? null;
+      const connected = runtimeStatus?.ready === true
+        && runtimeStatus.connectionState === 'connected'
+        && runtimeStatus.harnessReachable === true;
+      const state = connected ? 'connected'
+        : runtimeStatus?.connectionState === 'connecting' ? 'connecting'
+          : this.#errors.has(config.botId) || runtimeStatus?.connectionState === 'failed'
+            ? 'error' : 'offline';
+      return {
+        botId: config.botId,
+        state,
+        connected,
+        configured: true,
+        bot: {
+          name: config.name,
+          username: config.username,
+          teamName: config.teamName,
+          idMasked: maskSlackBotId(config.platformId),
+        },
+        health: {
+          status: connected ? 'healthy' : state === 'error' ? 'error' : 'offline',
+          summary: connected ? `Slack${SLACK_DESCRIPTOR.connectionLabel}运行正常`
+            : state === 'error' ? 'Slack连接未就绪，插件会自动重试'
+              : 'Slack连接当前离线',
+          lastCheckedAt: runtimeStatus?.lastCheckedAt ?? null,
+          lastConnectedAt: runtimeStatus?.lastConnectedAt ?? null,
+        },
+        stats: {
+          messagesReceived: runtimeStatus?.messagesReceived ?? 0,
+          messagesReplied: runtimeStatus?.messagesReplied ?? 0,
+        },
+        error: structuredClone(this.#errors.get(config.botId) ?? null),
+      };
+    });
+    const connected = bots.filter((bot) => bot.connected).length;
+    return {
+      schemaVersion: 1,
+      revision: this.#revision,
+      state: bots.length === 0 ? 'disconnected'
+        : connected === bots.length ? 'connected'
+          : connected > 0 ? 'degraded' : 'offline',
+      bots,
+      totals: { configured: bots.length, connected },
+    };
+  }
+
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await Promise.allSettled([...this.#transitions.values()]);
+    await Promise.allSettled([...this.#runtimes.keys()].map((botId) => this.#stopRuntime(botId)));
+  }
+
+  async #startRuntime(config, { botToken, appToken }) {
+    if (this.#closed) throw new Error('Slack controller is closed');
+    await this.#stopRuntime(config.botId);
+    if (this.#closed) throw new Error('Slack controller is closed');
+    const runtime = await this.#createRuntime({
+      botId: config.botId,
+      config,
+      botToken,
+      appToken,
+    });
+    if (!runtime || typeof runtime.start !== 'function' || typeof runtime.stop !== 'function') {
+      throw new TypeError('createRuntime returned an invalid Slack runtime');
+    }
+    this.#runtimes.set(config.botId, runtime);
+    try {
+      await runtime.start();
+    } catch (error) {
+      await runtime.stop().catch(() => undefined);
+      this.#runtimes.delete(config.botId);
+      throw error;
+    }
+  }
+
+  async #stopRuntime(botId) {
+    const runtime = this.#runtimes.get(botId);
+    this.#runtimes.delete(botId);
+    await runtime?.stop().catch((error) => {
+      this.#logger.warn?.(`[dsh-im:slack] bot ${botId} failed to stop cleanly:`, error);
+    });
+  }
+
+  async #resolveCredentials(config) {
+    const [bot, app] = await Promise.all([
+      this.#credentials.resolve(config.botTokenRef).catch(() => undefined),
+      this.#credentials.resolve(config.appTokenRef).catch(() => undefined),
+    ]);
+    const botToken = cleanString(bot?.value);
+    const appToken = cleanString(app?.value);
+    return botToken && appToken ? { botToken, appToken } : null;
+  }
+
+  async #restoreCredential(ref, previous) {
+    if (previous?.value) await this.#credentials.set(ref, previous.value).catch(() => undefined);
+    else await this.#credentials.unset(ref).catch(() => undefined);
+  }
+
+  #withBotTransition(botId, operation) {
+    const previous = this.#transitions.get(botId) ?? Promise.resolve();
+    const current = previous.catch(() => undefined).then(operation);
+    const settled = current.finally(() => {
+      if (this.#transitions.get(botId) === settled) this.#transitions.delete(botId);
+    });
+    this.#transitions.set(botId, settled);
+    return settled;
+  }
+
+  #touch() {
+    this.#revision += 1;
+  }
+}