@xmanrui/dsh-im 0.1.0

package/src/channels/dingtalk/state-store.mjs

@@ -0,0 +1,212 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+const EMPTY_STATE = Object.freeze({
+  version: 1,
+  sessions: {},
+  seenMessageIds: [],
+  pendingSenders: {},
+});
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function displayName(value) {
+  return (nonEmptyString(value) ?? '钉钉用户').slice(0, 100);
+}
+
+function normalizePendingSender(value, fallbackRequestId) {
+  if (!value || typeof value !== 'object') return null;
+  const requestId = nonEmptyString(value.requestId) ?? nonEmptyString(fallbackRequestId);
+  const staffId = nonEmptyString(value.staffId);
+  const requestedAt = nonEmptyString(value.requestedAt) ?? nonEmptyString(value.lastSeenAt);
+  const lastSeenAt = nonEmptyString(value.lastSeenAt) ?? requestedAt;
+  if (!requestId || !staffId || !requestedAt || !lastSeenAt) return null;
+  return {
+    requestId,
+    staffId,
+    displayName: displayName(value.displayName ?? value.nick),
+    requestedAt,
+    lastSeenAt,
+  };
+}
+
+function normalizeState(value) {
+  if (!value || typeof value !== 'object') return structuredClone(EMPTY_STATE);
+  const sessions = {};
+  if (value.sessions && typeof value.sessions === 'object' && !Array.isArray(value.sessions)) {
+    for (const [key, sessionId] of Object.entries(value.sessions)) {
+      const normalizedKey = nonEmptyString(key);
+      const normalizedSession = nonEmptyString(sessionId);
+      if (normalizedKey && normalizedSession) sessions[normalizedKey] = normalizedSession;
+    }
+  }
+
+  const pendingSenders = {};
+  const entries = Array.isArray(value.pendingSenders)
+    ? value.pendingSenders.map((entry) => [entry?.requestId, entry])
+    : Object.entries(value.pendingSenders && typeof value.pendingSenders === 'object'
+      ? value.pendingSenders
+      : {});
+  for (const [key, candidate] of entries) {
+    const pending = normalizePendingSender(candidate, key);
+    if (!pending) continue;
+    const duplicate = Object.values(pendingSenders).find((entry) => entry.staffId === pending.staffId);
+    if (!duplicate || duplicate.lastSeenAt < pending.lastSeenAt) {
+      if (duplicate) delete pendingSenders[duplicate.requestId];
+      pendingSenders[pending.requestId] = pending;
+    }
+  }
+
+  return {
+    version: 1,
+    sessions,
+    seenMessageIds: Array.isArray(value.seenMessageIds)
+      ? [...new Set(value.seenMessageIds.map(nonEmptyString).filter(Boolean))].slice(-1_000)
+      : [],
+    pendingSenders,
+  };
+}
+
+export class DingtalkStateStore {
+  #path;
+  #state = structuredClone(EMPTY_STATE);
+  #writeQueue = Promise.resolve();
+  #idFactory;
+  #now;
+
+  constructor(path, { idFactory = randomUUID, now = () => new Date().toISOString() } = {}) {
+    if (!nonEmptyString(path)) throw new TypeError('state path is required');
+    if (typeof idFactory !== 'function' || typeof now !== 'function') {
+      throw new TypeError('idFactory and now must be functions');
+    }
+    this.#path = path;
+    this.#idFactory = idFactory;
+    this.#now = now;
+  }
+
+  async load() {
+    try {
+      this.#state = normalizeState(JSON.parse(await readFile(this.#path, 'utf8')));
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      this.#state = structuredClone(EMPTY_STATE);
+      await this.#persist();
+    }
+    return this;
+  }
+
+  sessionFor(key) {
+    return this.#state.sessions[key] ?? null;
+  }
+
+  async setSession(key, sessionId) {
+    const normalizedKey = nonEmptyString(key);
+    const normalizedSession = nonEmptyString(sessionId);
+    if (!normalizedKey || !normalizedSession) throw new TypeError('key and sessionId are required');
+    this.#state.sessions[normalizedKey] = normalizedSession;
+    await this.#persist();
+  }
+
+  async clearSession(key) {
+    const normalizedKey = nonEmptyString(key);
+    if (!normalizedKey || !(normalizedKey in this.#state.sessions)) return;
+    delete this.#state.sessions[normalizedKey];
+    await this.#persist();
+  }
+
+  hasSeen(messageId) {
+    const id = nonEmptyString(messageId);
+    return Boolean(id && this.#state.seenMessageIds.includes(id));
+  }
+
+  async markSeen(messageId) {
+    const id = nonEmptyString(messageId);
+    if (!id) throw new TypeError('messageId is required');
+    if (this.hasSeen(id)) return;
+    this.#state.seenMessageIds.push(id);
+    if (this.#state.seenMessageIds.length > 1_000) {
+      this.#state.seenMessageIds.splice(0, this.#state.seenMessageIds.length - 1_000);
+    }
+    await this.#persist();
+  }
+
+  pendingSenders() {
+    return Object.values(this.#state.pendingSenders)
+      .sort((left, right) => left.requestedAt.localeCompare(right.requestedAt))
+      .map((entry) => structuredClone(entry));
+  }
+
+  pendingSender(requestId) {
+    const id = nonEmptyString(requestId);
+    const entry = id ? this.#state.pendingSenders[id] : null;
+    return entry ? structuredClone(entry) : null;
+  }
+
+  async recordPendingSender(staffIdOrEntry, name, seenAt) {
+    const input = staffIdOrEntry && typeof staffIdOrEntry === 'object'
+      ? staffIdOrEntry
+      : { staffId: staffIdOrEntry, displayName: name, lastSeenAt: seenAt };
+    const staffId = nonEmptyString(input.staffId);
+    if (!staffId) throw new TypeError('staffId is required');
+    const timestamp = nonEmptyString(input.lastSeenAt) ?? nonEmptyString(input.requestedAt) ?? this.#now();
+    const existing = Object.values(this.#state.pendingSenders)
+      .find((entry) => entry.staffId === staffId);
+    const entry = {
+      requestId: existing?.requestId ?? `ding_sender_${this.#idFactory()}`,
+      staffId,
+      displayName: displayName(input.displayName ?? input.nick ?? name),
+      requestedAt: existing?.requestedAt ?? timestamp,
+      lastSeenAt: timestamp,
+    };
+    this.#state.pendingSenders[entry.requestId] = entry;
+    await this.#persist();
+    return structuredClone(entry);
+  }
+
+  async removePendingSender(requestId) {
+    const id = nonEmptyString(requestId);
+    if (!id || !this.#state.pendingSenders[id]) return false;
+    delete this.#state.pendingSenders[id];
+    await this.#persist();
+    return true;
+  }
+
+  async removePendingSenderByStaffId(staffId) {
+    const id = nonEmptyString(staffId);
+    const pending = id
+      ? Object.values(this.#state.pendingSenders).find((entry) => entry.staffId === id)
+      : null;
+    return pending ? this.removePendingSender(pending.requestId) : false;
+  }
+
+  snapshot() {
+    return structuredClone(this.#state);
+  }
+
+  async remove() {
+    await this.#writeQueue;
+    try {
+      await unlink(this.#path);
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    this.#state = structuredClone(EMPTY_STATE);
+  }
+
+  async #persist() {
+    const snapshot = `${JSON.stringify(this.#state, null, 2)}\n`;
+    const operation = this.#writeQueue.then(async () => {
+      await mkdir(dirname(this.#path), { recursive: true, mode: 0o700 });
+      const temporary = `${this.#path}.tmp`;
+      await writeFile(temporary, snapshot, { encoding: 'utf8', mode: 0o600 });
+      await rename(temporary, this.#path);
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
+  }
+}
+
+export const DingTalkStateStore = DingtalkStateStore;

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

@@ -0,0 +1,24 @@
+import {
+  deriveTokenBotIdentity,
+  maskPlatformId,
+  TokenBotConfigStore,
+} from '../shared/token-config-store.mjs';
+
+const IDENTITY_OPTIONS = Object.freeze({
+  botPrefix: 'discord',
+  tokenRefPrefix: 'DSH_DISCORD_BOT_TOKEN',
+});
+
+export function deriveDiscordBotIdentity(platformId) {
+  return deriveTokenBotIdentity(platformId, IDENTITY_OPTIONS);
+}
+
+export function maskDiscordBotId(platformId) {
+  return maskPlatformId(platformId, 'Discord机器人');
+}
+
+export class DiscordConfigStore extends TokenBotConfigStore {
+  constructor(path) {
+    super(path, { channel: 'Discord', ...IDENTITY_OPTIONS });
+  }
+}

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

@@ -0,0 +1,153 @@
+const DEFAULT_BASE_URL = 'https://discord.com/api/v10/';
+
+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 snowflake(value, name) {
+  const id = cleanString(value);
+  if (!id || !/^\d{5,30}$/.test(id)) throw new TypeError(`Invalid Discord ${name}`);
+  return id;
+}
+
+export function validDiscordToken(value) {
+  return typeof value === 'string'
+    && /^[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{20,}$/.test(value.trim());
+}
+
+export class DiscordApi {
+  #token;
+  #fetch;
+  #baseUrl;
+
+  constructor({ token, fetchImpl = fetch, baseUrl = DEFAULT_BASE_URL }) {
+    if (!validDiscordToken(token)) throw new TypeError('Discord Bot Token is invalid');
+    if (typeof fetchImpl !== 'function') throw new TypeError('DiscordApi requires fetch');
+    this.#token = token.trim();
+    this.#fetch = fetchImpl;
+    this.#baseUrl = new URL(baseUrl);
+  }
+
+  getCurrentUser(options = {}) {
+    return this.#request('users/@me', { ...options, method: 'GET' });
+  }
+
+  getGatewayBot(options = {}) {
+    return this.#request('gateway/bot', { ...options, method: 'GET' });
+  }
+
+  createMessage({ channelId, content, replyToMessageId, signal }) {
+    return this.#request(`channels/${snowflake(channelId, 'channel id')}/messages`, {
+      method: 'POST',
+      signal,
+      body: {
+        content,
+        allowed_mentions: { parse: [], replied_user: false },
+        ...(replyToMessageId ? {
+          message_reference: {
+            message_id: snowflake(replyToMessageId, 'message id'),
+            channel_id: snowflake(channelId, 'channel id'),
+            fail_if_not_exists: false,
+          },
+        } : {}),
+      },
+    });
+  }
+
+  editMessage({ channelId, messageId, content, signal }) {
+    return this.#request(
+      `channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`,
+      {
+        method: 'PATCH',
+        signal,
+        body: { content, allowed_mentions: { parse: [], replied_user: false } },
+      },
+    );
+  }
+
+  sendTyping({ channelId, signal }) {
+    return this.#request(`channels/${snowflake(channelId, 'channel id')}/typing`, {
+      method: 'POST',
+      signal,
+      expectBody: false,
+    });
+  }
+
+  async #request(path, {
+    method,
+    body,
+    signal,
+    timeoutMs = 15_000,
+    expectBody = true,
+    retry = true,
+  }) {
+    let response;
+    try {
+      response = await this.#fetch(new URL(path, this.#baseUrl), {
+        method,
+        headers: {
+          authorization: `Bot ${this.#token}`,
+          'content-type': 'application/json',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.1.0)',
+        },
+        ...(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(`Discord ${method} transport failed`);
+    }
+
+    let parsed = null;
+    if (expectBody || response.status === 429 || !response.ok) {
+      try {
+        parsed = await response.json();
+      } catch {
+        if (expectBody) throw new Error(`Discord ${method} returned invalid JSON`);
+      }
+    }
+    if (response.status === 429 && retry) {
+      const retryAfterMs = Math.min(10_000, Math.max(50, Number(parsed?.retry_after) * 1_000 || 1_000));
+      await delay(retryAfterMs, signal);
+      return this.#request(path, { method, body, signal, timeoutMs, expectBody, retry: false });
+    }
+    if (!response.ok) {
+      const error = new Error(cleanString(parsed?.message) ?? `Discord API failed with HTTP ${response.status}`);
+      error.code = `discord-${response.status}`;
+      throw error;
+    }
+    return expectBody ? parsed : null;
+  }
+}
+
+export async function inspectDiscordToken(token, options = {}) {
+  const api = new DiscordApi({ token, ...options });
+  const bot = await api.getCurrentUser();
+  if (!bot?.id || bot?.bot !== true) throw new Error('Discord token does not belong to a bot');
+  return {
+    platformId: String(bot.id),
+    name: cleanString(bot.global_name) ?? cleanString(bot.username) ?? 'Discord机器人',
+    username: cleanString(bot.username),
+  };
+}

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

@@ -0,0 +1,15 @@
+import { TextHarnessBridge, createTextBridgeStatus } from '../shared/text-harness-bridge.mjs';
+
+export const DISCORD_DESCRIPTOR = Object.freeze({
+  key: 'discord',
+  label: 'Discord',
+  connectionLabel: ' Gateway 长连接',
+});
+
+export class DiscordHarnessBridge extends TextHarnessBridge {
+  constructor(options) {
+    super({ descriptor: DISCORD_DESCRIPTOR, ...options });
+  }
+}
+
+export { createTextBridgeStatus as createDiscordBridgeStatus };

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

@@ -0,0 +1,16 @@
+import { TokenBotController } from '../shared/token-bot-controller.mjs';
+import { deriveDiscordBotIdentity, maskDiscordBotId } from './config-store.mjs';
+import { inspectDiscordToken } from './discord-api.mjs';
+import { DISCORD_DESCRIPTOR } from './discord-bridge.mjs';
+
+export class DiscordController extends TokenBotController {
+  constructor(options) {
+    super({
+      ...options,
+      descriptor: DISCORD_DESCRIPTOR,
+      inspectToken: options.inspectToken ?? inspectDiscordToken,
+      deriveIdentity: deriveDiscordBotIdentity,
+      maskPlatformId: maskDiscordBotId,
+    });
+  }
+}