@xmanrui/dsh-im 0.1.0

package/src/channels/telegram/telegram-runtime.mjs

@@ -0,0 +1,278 @@
+import { createEditableMessageStream, splitMessageText } from '../shared/editable-message-stream.mjs';
+import { TelegramApi } from './telegram-api.mjs';
+import { createTelegramBridgeStatus, TelegramHarnessBridge } from './telegram-bridge.mjs';
+
+function escaped(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function mentionedUsername(message, username) {
+  if (!username || typeof message?.text !== 'string' || !Array.isArray(message.entities)) return false;
+  return message.entities.some((entity) => {
+    if (entity?.type !== 'mention' || !Number.isInteger(entity.offset) || !Number.isInteger(entity.length)) {
+      return false;
+    }
+    return message.text.slice(entity.offset, entity.offset + entity.length).toLowerCase()
+      === `@${username.toLowerCase()}`;
+  });
+}
+
+function withoutBotMention(text, username) {
+  if (!username || typeof text !== 'string') return text;
+  return text.replace(new RegExp(`@${escaped(username)}\\b`, 'ig'), '').trim();
+}
+
+export function normalizeTelegramUpdate(update, { botId, username }) {
+  const message = update?.message;
+  const chatId = message?.chat?.id;
+  const senderId = message?.from?.id;
+  const messageId = message?.message_id;
+  if (!Number.isSafeInteger(update?.update_id) || chatId === undefined || senderId === undefined
+    || !Number.isSafeInteger(messageId)) return null;
+  if (!['private', 'group', 'supergroup'].includes(message.chat?.type)) return null;
+  const direct = message.chat.type === 'private';
+  const addressed = direct
+    || String(message.reply_to_message?.from?.id ?? '') === String(botId)
+    || mentionedUsername(message, username);
+  return {
+    messageId: String(update.update_id),
+    senderId: String(senderId),
+    senderIsBot: message.from?.is_bot === true,
+    kind: direct ? 'direct' : 'group',
+    conversationId: String(chatId),
+    content: withoutBotMention(message.text ?? message.caption ?? '', username),
+    addressed,
+    replyTarget: {
+      chatId,
+      replyToMessageId: messageId,
+      messageThreadId: Number.isSafeInteger(message.message_thread_id)
+        ? message.message_thread_id : undefined,
+    },
+  };
+}
+
+class TelegramBotClient {
+  #api;
+  #signal;
+
+  constructor({ api, signal }) {
+    this.#api = api;
+    this.#signal = signal;
+  }
+
+  async sendText(target, text) {
+    const chunks = splitMessageText(text, 4_000);
+    let result = null;
+    for (const [index, chunk] of chunks.entries()) {
+      result = await this.#api.sendMessage({
+        chatId: target.chatId,
+        text: chunk,
+        replyToMessageId: index === 0 ? target.replyToMessageId : undefined,
+        messageThreadId: target.messageThreadId,
+        signal: this.#signal,
+      });
+    }
+    return result;
+  }
+
+  sendTyping(target) {
+    return this.#api.sendChatAction({
+      chatId: target.chatId,
+      messageThreadId: target.messageThreadId,
+      signal: this.#signal,
+    });
+  }
+
+  async openStream(target) {
+    const stream = createEditableMessageStream({
+      limit: 4_000,
+      create: async (text) => {
+        const message = await this.#api.sendMessage({
+          chatId: target.chatId,
+          text,
+          replyToMessageId: target.replyToMessageId,
+          messageThreadId: target.messageThreadId,
+          signal: this.#signal,
+        });
+        return message.message_id;
+      },
+      edit: (messageId, text) => this.#api.editMessageText({
+        chatId: target.chatId,
+        messageId,
+        text,
+        signal: this.#signal,
+      }),
+      sendRemainder: (text) => this.#api.sendMessage({
+        chatId: target.chatId,
+        text,
+        messageThreadId: target.messageThreadId,
+        signal: this.#signal,
+      }),
+    });
+    return stream.start();
+  }
+}
+
+export function createTelegramRuntimeStatus() {
+  return {
+    startedAt: null,
+    ready: false,
+    connectionState: 'idle',
+    harnessReachable: false,
+    lastCheckedAt: null,
+    lastConnectedAt: null,
+    lastError: null,
+    ...createTelegramBridgeStatus(),
+  };
+}
+
+export class TelegramRuntime {
+  #config;
+  #token;
+  #harness;
+  #state;
+  #logger;
+  #replyTimeoutMs;
+  #createApi;
+  #status = createTelegramRuntimeStatus();
+  #api = null;
+  #bridge = null;
+  #abortController = null;
+  #pollTask = null;
+  #starting = null;
+
+  constructor({
+    config,
+    token,
+    harness,
+    state,
+    logger = console,
+    replyTimeoutMs = 600_000,
+    createApi = (options) => new TelegramApi(options),
+  }) {
+    if (!config || !token || !harness || !state) {
+      throw new TypeError('TelegramRuntime requires config, token, Harness, and state');
+    }
+    this.#config = config;
+    this.#token = token;
+    this.#harness = harness;
+    this.#state = state;
+    this.#logger = logger;
+    this.#replyTimeoutMs = replyTimeoutMs;
+    this.#createApi = createApi;
+  }
+
+  get status() {
+    return structuredClone(this.#status);
+  }
+
+  async start() {
+    if (this.#status.ready && this.#pollTask) return this.status;
+    if (this.#starting) return this.#starting;
+    this.#starting = this.#start().finally(() => {
+      this.#starting = null;
+    });
+    return this.#starting;
+  }
+
+  async #start() {
+    await this.stop();
+    this.#status.startedAt = new Date().toISOString();
+    this.#status.connectionState = 'connecting';
+    this.#status.lastError = null;
+    await this.#harness.ensureRunning();
+    this.#status.harnessReachable = true;
+
+    const controller = new AbortController();
+    this.#abortController = controller;
+    const api = this.#createApi({ token: this.#token });
+    this.#api = api;
+    try {
+      const bot = await api.getMe({ signal: controller.signal });
+      if (String(bot?.id ?? '') !== this.#config.platformId || bot?.is_bot !== true) {
+        throw new Error('Telegram token identity does not match the saved bot');
+      }
+      const webhook = await api.getWebhookInfo({ signal: controller.signal });
+      if (typeof webhook?.url === 'string' && webhook.url) {
+        const error = new Error('该 Telegram 机器人已配置 Webhook，请先在原服务中移除 Webhook 后重试。');
+        error.code = 'webhook-configured';
+        throw error;
+      }
+      const client = new TelegramBotClient({ api, signal: controller.signal });
+      this.#bridge = new TelegramHarnessBridge({
+        bot: client,
+        harness: this.#harness,
+        state: this.#state,
+        status: this.#status,
+        logger: this.#logger,
+        replyTimeoutMs: this.#replyTimeoutMs,
+      });
+
+      let cursor = this.#state.cursor();
+      if (cursor === null) {
+        const latest = await api.getUpdates({ offset: -1, timeout: 0, signal: controller.signal });
+        cursor = latest.length > 0 ? latest.at(-1).update_id + 1 : 0;
+        await this.#state.setCursor(cursor);
+      }
+      const now = Date.now();
+      this.#status.ready = true;
+      this.#status.connectionState = 'connected';
+      this.#status.lastCheckedAt = now;
+      this.#status.lastConnectedAt = now;
+      this.#pollTask = this.#poll(cursor, controller.signal);
+      this.#pollTask.catch((error) => {
+        if (controller.signal.aborted) return;
+        this.#status.ready = false;
+        this.#status.connectionState = 'failed';
+        this.#status.lastError = error?.message ?? String(error);
+        this.#logger.error?.(`[dsh-im:telegram] bot ${this.#config.botId} polling stopped:`, error);
+      });
+      return this.status;
+    } catch (error) {
+      this.#status.ready = false;
+      this.#status.connectionState = 'failed';
+      this.#status.lastError = error?.message ?? String(error);
+      await this.stop();
+      throw error;
+    }
+  }
+
+  async #poll(initialCursor, signal) {
+    let cursor = initialCursor;
+    while (!signal.aborted) {
+      const updates = await this.#api.getUpdates({ offset: cursor, timeout: 25, signal });
+      this.#status.lastCheckedAt = Date.now();
+      for (const update of updates) {
+        if (signal.aborted) return;
+        const message = normalizeTelegramUpdate(update, {
+          botId: this.#config.platformId,
+          username: this.#config.username,
+        });
+        if (message) await this.#bridge.accept(message);
+        cursor = update.update_id + 1;
+        await this.#state.setCursor(cursor);
+      }
+    }
+  }
+
+  async stop() {
+    const pollTask = this.#pollTask;
+    const bridge = this.#bridge;
+    this.#abortController?.abort();
+    this.#abortController = null;
+    this.#pollTask = null;
+    this.#api = null;
+    this.#bridge = null;
+    await Promise.race([
+      pollTask?.catch(() => undefined) ?? Promise.resolve(),
+      new Promise((resolve) => setTimeout(resolve, 2_000)),
+    ]);
+    await Promise.race([
+      bridge?.waitForIdle() ?? Promise.resolve(),
+      new Promise((resolve) => setTimeout(resolve, 2_000)),
+    ]);
+    this.#status.ready = false;
+    this.#status.connectionState = 'idle';
+    return this.status;
+  }
+}

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

@@ -0,0 +1,170 @@
+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([]) });
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function safeIntegrationId(value) {
+  const id = cleanString(value);
+  return id && /^wecom_[a-f0-9]{24}$/.test(id) ? id : null;
+}
+
+function safeSecretRef(value) {
+  const ref = cleanString(value);
+  return ref && /^DSH_WECOM_BOT_SECRET_[A-F0-9]{24}$/.test(ref) ? ref : null;
+}
+
+export function deriveWecomBotIdentity(remoteBotId) {
+  const raw = cleanString(remoteBotId);
+  if (!raw) throw new TypeError('Enterprise WeChat bot ID is required');
+  const digest = createHash('sha256').update(raw).digest('hex').slice(0, 24);
+  return {
+    botId: `wecom_${digest}`,
+    secretRef: `DSH_WECOM_BOT_SECRET_${digest.toUpperCase()}`,
+  };
+}
+
+export function maskWecomBotId(remoteBotId) {
+  const value = cleanString(remoteBotId) ?? '';
+  if (!value) return '企业微信机器人';
+  if (value.length <= 10) return `${value.slice(0, 3)}•••`;
+  return `${value.slice(0, 6)}••••${value.slice(-4)}`;
+}
+
+function normalizeBot(value) {
+  if (!value || typeof value !== 'object') return null;
+  const botId = safeIntegrationId(value.botId);
+  const remoteBotId = cleanString(value.remoteBotId);
+  const secretRef = safeSecretRef(value.secretRef);
+  if (!botId || !remoteBotId || !secretRef) return null;
+  const derived = deriveWecomBotIdentity(remoteBotId);
+  if (derived.botId !== botId || derived.secretRef !== secretRef) return null;
+  return Object.freeze({
+    botId,
+    remoteBotId,
+    secretRef,
+    createdAt: cleanString(value.createdAt) ?? new Date().toISOString(),
+    connectedAt: cleanString(value.connectedAt),
+  });
+}
+
+function normalizeDocument(value) {
+  if (!value || value.version !== 1 || !Array.isArray(value.bots)) return null;
+  const bots = value.bots.map(normalizeBot);
+  if (bots.some((bot) => bot === null)) return null;
+  const ids = new Set();
+  const remoteIds = new Set();
+  const refs = new Set();
+  for (const bot of bots) {
+    if (ids.has(bot.botId) || remoteIds.has(bot.remoteBotId) || refs.has(bot.secretRef)) return null;
+    ids.add(bot.botId);
+    remoteIds.add(bot.remoteBotId);
+    refs.add(bot.secretRef);
+  }
+  return Object.freeze({ version: 1, bots: Object.freeze(bots) });
+}
+
+export class WecomConfigStore {
+  #path;
+  #value = EMPTY_DOCUMENT;
+  #writeQueue = Promise.resolve();
+
+  constructor(path) {
+    this.#path = path;
+  }
+
+  async load() {
+    try {
+      const normalized = normalizeDocument(JSON.parse(await readFile(this.#path, 'utf8')));
+      if (!normalized) throw new Error('dsh-im Enterprise WeChat 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;
+  }
+
+  getByRemoteBotId(remoteBotId) {
+    const bot = this.#value.bots.find((candidate) => candidate.remoteBotId === remoteBotId);
+    return bot ? structuredClone(bot) : null;
+  }
+
+  async save(value) {
+    const normalized = normalizeBot(value);
+    if (!normalized) throw new Error('Refusing to persist incomplete Enterprise WeChat bot data');
+    return this.#mutate((bots) => {
+      const remoteCollision = bots.find(
+        (bot) => bot.remoteBotId === normalized.remoteBotId && bot.botId !== normalized.botId,
+      );
+      const refCollision = bots.find(
+        (bot) => bot.secretRef === normalized.secretRef && bot.botId !== normalized.botId,
+      );
+      if (remoteCollision || refCollision) throw new Error('Duplicate Enterprise WeChat 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 (!safeIntegrationId(botId)) throw new TypeError('Invalid Enterprise WeChat bot ID');
+    return this.#mutate((bots) => {
+      const index = bots.findIndex((bot) => bot.botId === botId);
+      if (index === -1) return null;
+      const [removed] = bots.splice(index, 1);
+      return structuredClone(removed);
+    });
+  }
+
+  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;
+  }
+
+  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 this.#write(document);
+      this.#value = document;
+    });
+    this.#writeQueue = operation.then(() => undefined, () => undefined);
+    await operation;
+    return result;
+  }
+
+  async #write(document) {
+    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);
+  }
+}

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

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

package/src/channels/wecom/qr-auth.mjs

@@ -0,0 +1,95 @@
+const GENERATE_URL = 'https://work.weixin.qq.com/ai/qc/generate';
+const POLL_URL = 'https://work.weixin.qq.com/ai/qc/query_result';
+const QR_TTL_MS = 5 * 60_000;
+const POLL_INTERVAL_MS = 3_000;
+
+function defaultPlatform() {
+  if (process.platform === 'win32') return 2;
+  if (process.platform === 'linux') return 3;
+  return 1;
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function safeVerificationUrl(value) {
+  const raw = cleanString(value);
+  if (!raw) return null;
+  try {
+    const url = new URL(raw);
+    return url.protocol === 'https:' && url.hostname === 'work.weixin.qq.com' && (!url.port || url.port === '443')
+      ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+
+function combinedSignal(signal, timeoutMs) {
+  return signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
+}
+
+async function requestJson(fetchImpl, url, signal) {
+  const response = await fetchImpl(url, {
+    method: 'GET',
+    redirect: 'error',
+    signal: combinedSignal(signal, 10_000),
+    headers: { accept: 'application/json' },
+  });
+  if (!response.ok) throw new Error(`Enterprise WeChat QR service returned HTTP ${response.status}`);
+  return response.json();
+}
+
+export class WecomQrAuth {
+  #fetch;
+  #clock;
+  #source;
+  #platform;
+
+  constructor({
+    fetch: fetchImpl = globalThis.fetch,
+    clock = () => Date.now(),
+    source = 'deepseek-harness',
+    platform = defaultPlatform(),
+  } = {}) {
+    if (typeof fetchImpl !== 'function') throw new TypeError('A fetch implementation is required');
+    this.#fetch = fetchImpl;
+    this.#clock = clock;
+    this.#source = source;
+    this.#platform = [1, 2, 3].includes(platform) ? platform : defaultPlatform();
+  }
+
+  async start({ signal } = {}) {
+    const url = new URL(GENERATE_URL);
+    url.searchParams.set('source', this.#source);
+    url.searchParams.set('plat', String(this.#platform));
+    const body = await requestJson(this.#fetch, url, signal);
+    const scode = cleanString(body?.data?.scode);
+    const verificationUrl = safeVerificationUrl(body?.data?.auth_url);
+    if (!scode || !verificationUrl) throw new Error('Enterprise WeChat QR service returned invalid data');
+    return {
+      scode,
+      verificationUrl,
+      expiresAt: this.#clock() + QR_TTL_MS,
+      pollIntervalMs: POLL_INTERVAL_MS,
+    };
+  }
+
+  async poll({ scode, signal } = {}) {
+    const code = cleanString(scode);
+    if (!code) throw new TypeError('Enterprise WeChat QR poll code is required');
+    const url = new URL(POLL_URL);
+    url.searchParams.set('scode', code);
+    const body = await requestJson(this.#fetch, url, signal);
+    const state = cleanString(body?.data?.status)?.toLowerCase();
+    if (state === 'success') {
+      const remoteBotId = cleanString(body?.data?.bot_info?.botid);
+      const secret = cleanString(body?.data?.bot_info?.secret);
+      if (!remoteBotId || !secret) throw new Error('Enterprise WeChat QR result omitted bot credentials');
+      return { status: 'success', remoteBotId, secret };
+    }
+    if (['expired', 'timeout'].includes(state)) return { status: 'expired' };
+    if (['fail', 'failed', 'error'].includes(state)) return { status: 'failed' };
+    return { status: 'waiting' };
+  }
+}

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

@@ -0,0 +1,90 @@
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+const EMPTY_STATE = Object.freeze({ version: 1, sessions: {}, seenMessageIds: [] });
+
+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)) {
+      if (typeof key === 'string' && typeof sessionId === 'string' && sessionId) sessions[key] = sessionId;
+    }
+  }
+  return {
+    version: 1,
+    sessions,
+    seenMessageIds: Array.isArray(value.seenMessageIds)
+      ? value.seenMessageIds.filter((id) => typeof id === 'string').slice(-1_000)
+      : [],
+  };
+}
+
+export class WecomStateStore {
+  #path;
+  #state = structuredClone(EMPTY_STATE);
+  #writeQueue = Promise.resolve();
+
+  constructor(path) {
+    this.#path = path;
+  }
+
+  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) {
+    this.#state.sessions[key] = sessionId;
+    await this.#persist();
+  }
+
+  async clearSession(key) {
+    delete this.#state.sessions[key];
+    await this.#persist();
+  }
+
+  hasSeen(messageId) {
+    return this.#state.seenMessageIds.includes(messageId);
+  }
+
+  async markSeen(messageId) {
+    if (this.hasSeen(messageId)) return;
+    this.#state.seenMessageIds.push(messageId);
+    if (this.#state.seenMessageIds.length > 1_000) {
+      this.#state.seenMessageIds.splice(0, this.#state.seenMessageIds.length - 1_000);
+    }
+    await this.#persist();
+  }
+
+  async remove() {
+    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;
+  }
+}