@xmanrui/dsh-im 0.2.1 → 0.3.0

package/src/channels/slack/config-store.mjs

@@ -0,0 +1,173 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+const EMPTY_DOCUMENT = Object.freeze({ version: 1, bots: Object.freeze([]) });
+const BOT_ID_PATTERN = /^slack_[a-f0-9]{24}$/;
+const BOT_TOKEN_REF_PATTERN = /^DSH_SLACK_BOT_TOKEN_[A-F0-9]{24}$/;
+const APP_TOKEN_REF_PATTERN = /^DSH_SLACK_APP_TOKEN_[A-F0-9]{24}$/;
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+export function deriveSlackBotIdentity(platformId) {
+  const raw = cleanString(platformId);
+  if (!raw) throw new TypeError('platformId is required');
+  const digest = createHash('sha256').update(raw).digest('hex').slice(0, 24);
+  const suffix = digest.toUpperCase();
+  return {
+    botId: `slack_${digest}`,
+    botTokenRef: `DSH_SLACK_BOT_TOKEN_${suffix}`,
+    appTokenRef: `DSH_SLACK_APP_TOKEN_${suffix}`,
+  };
+}
+
+export function maskSlackBotId(platformId) {
+  const value = cleanString(platformId) ?? '';
+  const [teamId, userId] = value.split(':');
+  if (teamId && userId) return `${teamId.slice(0, 5)}••• · ${userId.slice(0, 5)}•••`;
+  return value ? `${value.slice(0, 6)}••••` : 'Slack机器人';
+}
+
+export class SlackConfigStore {
+  #path;
+  #value = EMPTY_DOCUMENT;
+  #writeQueue = Promise.resolve();
+
+  constructor(path) {
+    this.#path = path;
+  }
+
+  async load() {
+    try {
+      const normalized = this.#normalizeDocument(JSON.parse(await readFile(this.#path, 'utf8')));
+      if (!normalized) throw new Error('dsh-im Slack config contains invalid bot data');
+      this.#value = normalized;
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      this.#value = EMPTY_DOCUMENT;
+    }
+    return this;
+  }
+
+  list() {
+    return structuredClone(this.#value.bots);
+  }
+
+  get(botId) {
+    const bot = this.#value.bots.find((candidate) => candidate.botId === botId);
+    return bot ? structuredClone(bot) : null;
+  }
+
+  getByPlatformId(platformId) {
+    const bot = this.#value.bots.find((candidate) => candidate.platformId === platformId);
+    return bot ? structuredClone(bot) : null;
+  }
+
+  async save(value) {
+    const normalized = this.#normalizeBot(value);
+    if (!normalized) throw new Error('Refusing to persist incomplete Slack bot data');
+    return this.#mutate((bots) => {
+      const collision = bots.find((bot) => (
+        bot.botId !== normalized.botId
+        && (bot.platformId === normalized.platformId
+          || bot.botTokenRef === normalized.botTokenRef
+          || bot.appTokenRef === normalized.appTokenRef)
+      ));
+      if (collision) throw new Error('Duplicate Slack bot identity');
+      const index = bots.findIndex((bot) => bot.botId === normalized.botId);
+      if (index === -1) bots.push(normalized);
+      else bots[index] = normalized;
+      return structuredClone(normalized);
+    });
+  }
+
+  async remove(botId) {
+    if (!BOT_ID_PATTERN.test(botId)) throw new TypeError('Invalid Slack bot id');
+    return this.#mutate((bots) => {
+      const index = bots.findIndex((bot) => bot.botId === botId);
+      if (index === -1) return null;
+      return structuredClone(bots.splice(index, 1)[0]);
+    });
+  }
+
+  async clear() {
+    const operation = this.#writeQueue.then(async () => {
+      try {
+        await unlink(this.#path);
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+      }
+      this.#value = EMPTY_DOCUMENT;
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
+  }
+
+  #normalizeBot(value) {
+    if (!value || typeof value !== 'object') return null;
+    const botId = cleanString(value.botId);
+    const platformId = cleanString(value.platformId);
+    const botTokenRef = cleanString(value.botTokenRef);
+    const appTokenRef = cleanString(value.appTokenRef);
+    const name = cleanString(value.name);
+    if (!botId || !platformId || !botTokenRef || !appTokenRef || !name
+      || !BOT_ID_PATTERN.test(botId)
+      || !BOT_TOKEN_REF_PATTERN.test(botTokenRef)
+      || !APP_TOKEN_REF_PATTERN.test(appTokenRef)) return null;
+    const derived = deriveSlackBotIdentity(platformId);
+    if (derived.botId !== botId
+      || derived.botTokenRef !== botTokenRef
+      || derived.appTokenRef !== appTokenRef) return null;
+    return Object.freeze({
+      botId,
+      platformId,
+      botTokenRef,
+      appTokenRef,
+      name,
+      username: cleanString(value.username),
+      teamId: cleanString(value.teamId),
+      teamName: cleanString(value.teamName),
+      createdAt: cleanString(value.createdAt) ?? new Date().toISOString(),
+      connectedAt: cleanString(value.connectedAt),
+    });
+  }
+
+  #normalizeDocument(value) {
+    if (!value || value.version !== 1 || !Array.isArray(value.bots)) return null;
+    const bots = value.bots.map((bot) => this.#normalizeBot(bot));
+    if (bots.some((bot) => bot === null)) return null;
+    const ids = new Set();
+    const platformIds = new Set();
+    const refs = new Set();
+    for (const bot of bots) {
+      if (ids.has(bot.botId) || platformIds.has(bot.platformId)
+        || refs.has(bot.botTokenRef) || refs.has(bot.appTokenRef)) return null;
+      ids.add(bot.botId);
+      platformIds.add(bot.platformId);
+      refs.add(bot.botTokenRef);
+      refs.add(bot.appTokenRef);
+    }
+    return Object.freeze({ version: 1, bots: Object.freeze(bots) });
+  }
+
+  async #mutate(mutator) {
+    let result;
+    const operation = this.#writeQueue.then(async () => {
+      const bots = [...this.#value.bots];
+      result = mutator(bots);
+      const document = Object.freeze({ version: 1, bots: Object.freeze(bots) });
+      await mkdir(dirname(this.#path), { recursive: true, mode: 0o700 });
+      const temporary = `${this.#path}.tmp`;
+      await writeFile(temporary, `${JSON.stringify(document, null, 2)}\n`, {
+        encoding: 'utf8', mode: 0o600,
+      });
+      await rename(temporary, this.#path);
+      this.#value = document;
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
+    return result;
+  }
+}

package/src/channels/slack/harness-client.mjs

@@ -0,0 +1,3 @@
+import { HarnessClient } from '../weixin/harness-client.mjs';
+
+export class SlackHarnessClient extends HarnessClient {}

package/src/channels/slack/manifest.mjs

@@ -0,0 +1,31 @@
+export const SLACK_APP_MANIFEST_YAML = `_metadata:
+  major_version: 1
+display_information:
+  name: DeepSeek Harness
+  description: Connect Slack conversations to a local DeepSeek Harness agent.
+  background_color: "#4A154B"
+features:
+  app_home:
+    home_tab_enabled: false
+    messages_tab_enabled: true
+    messages_tab_read_only_enabled: false
+  bot_user:
+    display_name: DeepSeek Harness
+    always_online: false
+oauth_config:
+  scopes:
+    bot:
+      - app_mentions:read
+      - chat:write
+      - im:history
+settings:
+  event_subscriptions:
+    bot_events:
+      - app_mention
+      - message.im
+  org_deploy_enabled: false
+  socket_mode_enabled: true
+  token_rotation_enabled: false
+`;
+
+export const SLACK_CREATE_APP_URL = 'https://api.slack.com/apps?new_app=1';

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 };