@xmanrui/dsh-im 0.1.0

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

@@ -0,0 +1,208 @@
+import { QQBot, typingIndicator } from '@tencent-connect/qqbot-nodejs';
+
+import { createQqBridgeStatus, QqHarnessBridge } from './qq-bridge.mjs';
+
+function timeoutError() {
+  const error = new Error('QQ WebSocket did not become ready in time');
+  error.code = 'connect-timeout';
+  return error;
+}
+
+export function createQqRuntimeStatus() {
+  return {
+    startedAt: null,
+    ready: false,
+    qqConnectionState: 'idle',
+    harnessReachable: false,
+    lastCheckedAt: null,
+    lastConnectedAt: null,
+    lastError: null,
+    ...createQqBridgeStatus(),
+  };
+}
+
+export class QqRuntime {
+  #config;
+  #appSecret;
+  #harness;
+  #state;
+  #logger;
+  #replyTimeoutMs;
+  #connectTimeoutMs;
+  #createBot;
+  #typingMiddleware;
+  #status = createQqRuntimeStatus();
+  #bot = null;
+  #bridge = null;
+  #abortController = null;
+  #runTask = null;
+  #starting = null;
+
+  constructor({
+    config,
+    appSecret,
+    harness,
+    state,
+    logger = console,
+    replyTimeoutMs = 600_000,
+    connectTimeoutMs = 20_000,
+    createBot = (options) => new QQBot(options),
+    typingMiddleware = typingIndicator,
+  }) {
+    if (!config || !appSecret || !harness || !state) {
+      throw new TypeError('QqRuntime requires config, app secret, Harness, and state');
+    }
+    this.#config = config;
+    this.#appSecret = appSecret;
+    this.#harness = harness;
+    this.#state = state;
+    this.#logger = logger;
+    this.#replyTimeoutMs = replyTimeoutMs;
+    this.#connectTimeoutMs = connectTimeoutMs;
+    this.#createBot = createBot;
+    this.#typingMiddleware = typingMiddleware;
+  }
+
+  get status() {
+    return structuredClone(this.#status);
+  }
+
+  async start() {
+    if (this.#status.ready && this.#bot) 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.qqConnectionState = 'connecting';
+    this.#status.lastError = null;
+    await this.#harness.ensureRunning();
+    this.#status.harnessReachable = true;
+
+    const sdkLogger = {
+      error: (...args) => this.#logger.error?.(...args),
+      warn: (...args) => this.#logger.warn?.(...args),
+      info: (...args) => this.#logger.info?.(...args),
+      debug: () => {},
+    };
+    const bot = this.#createBot({
+      appId: this.#config.appId,
+      appSecret: this.#appSecret,
+      accountId: this.#config.botId,
+      logger: sdkLogger,
+      transport: 'websocket',
+      tokenPrefetch: 'sync',
+    });
+    if (!bot || typeof bot.start !== 'function' || typeof bot.stop !== 'function') {
+      throw new TypeError('QQ bot factory returned an invalid client');
+    }
+    this.#bot = bot;
+    this.#bridge = new QqHarnessBridge({
+      bot,
+      ownerUserOpenid: this.#config.ownerUserOpenid,
+      harness: this.#harness,
+      state: this.#state,
+      status: this.#status,
+      logger: this.#logger,
+      replyTimeoutMs: this.#replyTimeoutMs,
+    });
+    bot.use?.(this.#typingMiddleware({
+      keepAlive: true,
+      predicate: (ctx) => this.#config.ownerUserOpenid === '*'
+        || ctx?.message?.senderId === this.#config.ownerUserOpenid,
+    }));
+
+    const controller = new AbortController();
+    this.#abortController = controller;
+    let readyResolve;
+    let readyReject;
+    const ready = new Promise((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+    const onReady = () => {
+      const now = Date.now();
+      this.#status.ready = true;
+      this.#status.qqConnectionState = 'connected';
+      this.#status.lastCheckedAt = now;
+      this.#status.lastConnectedAt = now;
+      this.#status.lastError = null;
+      readyResolve();
+    };
+    const onError = (error) => {
+      if (!this.#status.ready) readyReject(error);
+      else {
+        this.#status.lastError = error?.message ?? String(error);
+        this.#logger.warn?.(`[dsh-im:qq] bot ${this.#config.botId} connection error:`, error);
+      }
+    };
+    const onMessage = (_ctx, message) => this.#bridge?.accept(message);
+    bot.on('ready', onReady);
+    bot.on('resumed', onReady);
+    bot.on('error', onError);
+    bot.on('message', onMessage);
+
+    const runTask = Promise.resolve().then(() => bot.start(controller.signal));
+    this.#runTask = runTask;
+    runTask.catch((error) => {
+      if (controller.signal.aborted) return;
+      readyReject(error);
+      this.#status.ready = false;
+      this.#status.qqConnectionState = 'failed';
+      this.#status.lastError = error?.message ?? String(error);
+      this.#logger.error?.(`[dsh-im:qq] bot ${this.#config.botId} connection stopped:`, error);
+    });
+
+    let timer;
+    try {
+      await Promise.race([
+        ready,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(timeoutError()), this.#connectTimeoutMs);
+        }),
+      ]);
+      this.#status.ready = true;
+      this.#status.qqConnectionState = 'connected';
+      this.#status.lastCheckedAt = Date.now();
+      this.#status.lastConnectedAt = Date.now();
+      return this.status;
+    } catch (error) {
+      this.#status.ready = false;
+      this.#status.qqConnectionState = 'failed';
+      this.#status.lastError = error?.message ?? String(error);
+      await this.stop();
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
+  async stop() {
+    const bot = this.#bot;
+    const bridge = this.#bridge;
+    const runTask = this.#runTask;
+    this.#abortController?.abort();
+    this.#abortController = null;
+    this.#bot = null;
+    this.#bridge = null;
+    this.#runTask = null;
+    try {
+      bot?.stop();
+    } catch (error) {
+      this.#logger.warn?.(`[dsh-im:qq] bot ${this.#config.botId} failed to stop cleanly:`, error);
+    }
+    await Promise.race([
+      runTask?.catch(() => undefined) ?? Promise.resolve(),
+      new Promise((resolve) => setTimeout(resolve, 2_000)),
+    ]);
+    await bridge?.waitForIdle();
+    this.#status.ready = false;
+    this.#status.qqConnectionState = 'idle';
+    return this.status;
+  }
+}

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

@@ -0,0 +1,24 @@
+import { startQrConnect } from '@tencent-connect/qqbot-connector';
+
+export class QqQrAuth {
+  #start;
+  #source;
+
+  constructor({ start = startQrConnect, source = 'deepseek-harness' } = {}) {
+    if (typeof start !== 'function') throw new TypeError('QQ QR connector is required');
+    this.#start = start;
+    this.#source = source;
+  }
+
+  start(callbacks, { signal } = {}) {
+    if (!callbacks || typeof callbacks.onSuccess !== 'function'
+      || typeof callbacks.onFailure !== 'function') {
+      throw new TypeError('QQ QR callbacks are required');
+    }
+    return this.#start(callbacks, {
+      displayQrCodeToConsole: false,
+      source: this.#source,
+      signal,
+    });
+  }
+}

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

@@ -0,0 +1,96 @@
+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 QqStateStore {
+  #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();
+  }
+
+  snapshot() {
+    return structuredClone(this.#state);
+  }
+
+  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;
+  }
+}

package/src/channels/shared/conversation-state-store.mjs

@@ -0,0 +1,107 @@
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+const EMPTY_STATE = Object.freeze({ version: 1, sessions: {}, seenMessageIds: [], cursor: null });
+
+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' && key && typeof sessionId === 'string' && sessionId) {
+        sessions[key] = sessionId;
+      }
+    }
+  }
+  return {
+    version: 1,
+    sessions,
+    seenMessageIds: Array.isArray(value.seenMessageIds)
+      ? value.seenMessageIds.filter((id) => typeof id === 'string' && id).slice(-1_000)
+      : [],
+    cursor: Number.isSafeInteger(value.cursor) && value.cursor >= 0 ? value.cursor : null,
+  };
+}
+
+export class ConversationStateStore {
+  #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();
+  }
+
+  cursor() {
+    return this.#state.cursor;
+  }
+
+  async setCursor(cursor) {
+    if (!Number.isSafeInteger(cursor) || cursor < 0) throw new TypeError('Invalid update cursor');
+    this.#state.cursor = cursor;
+    await this.#persist();
+  }
+
+  snapshot() {
+    return structuredClone(this.#state);
+  }
+
+  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;
+  }
+}

package/src/channels/shared/editable-message-stream.mjs

@@ -0,0 +1,81 @@
+export function splitMessageText(value, limit) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  if (!text) return [];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > limit) {
+    let cut = remaining.lastIndexOf('\n', limit);
+    if (cut < Math.floor(limit * 0.55)) cut = remaining.lastIndexOf(' ', limit);
+    if (cut < Math.floor(limit * 0.55)) cut = limit;
+    chunks.push(remaining.slice(0, cut).trim());
+    remaining = remaining.slice(cut).trimStart();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+
+export function createEditableMessageStream({
+  initialText = '正在处理…',
+  limit,
+  updateIntervalMs = 800,
+  create,
+  edit,
+  sendRemainder,
+  logger = console,
+}) {
+  let messageId;
+  let pending = null;
+  let timer = null;
+  let inFlight = null;
+  let closed = false;
+  let lastSent = initialText;
+
+  const schedule = () => {
+    if (closed || timer !== null || inFlight || !pending) return;
+    timer = setTimeout(() => {
+      timer = null;
+      const text = pending;
+      pending = null;
+      const next = splitMessageText(text, limit)[0] ?? initialText;
+      inFlight = Promise.resolve(next === lastSent ? undefined : edit(messageId, next))
+        .then(() => { lastSent = next; })
+        .catch((error) => logger.warn?.('[dsh-im] streamed message update failed:', error))
+        .finally(() => {
+          inFlight = null;
+          schedule();
+        });
+    }, updateIntervalMs);
+    timer?.unref?.();
+  };
+
+  return {
+    async start() {
+      messageId = await create(initialText);
+      return this;
+    },
+    update(text) {
+      if (closed || typeof text !== 'string' || !text.trim()) return;
+      pending = text;
+      schedule();
+    },
+    async finish(text) {
+      if (closed) throw new Error('Message stream is already closed');
+      closed = true;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+      pending = null;
+      await inFlight?.catch(() => undefined);
+      const chunks = splitMessageText(text, limit);
+      const first = chunks[0] ?? '处理完成。';
+      if (first !== lastSent) await edit(messageId, first);
+      lastSent = first;
+      for (const chunk of chunks.slice(1)) await sendRemainder(chunk);
+    },
+    cancel() {
+      closed = true;
+      pending = null;
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+    },
+  };
+}

package/src/channels/shared/text-harness-bridge.mjs

@@ -0,0 +1,180 @@
+function cleanText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+export function createTextBridgeStatus() {
+  return {
+    messagesReceived: 0,
+    messagesReplied: 0,
+    messagesRejected: 0,
+    lastMessageAt: null,
+    lastReplyAt: null,
+    lastRejectedAt: null,
+    lastError: null,
+  };
+}
+
+export class TextHarnessBridge {
+  #descriptor;
+  #bot;
+  #harness;
+  #state;
+  #status;
+  #logger;
+  #replyTimeoutMs;
+  #queues = new Map();
+
+  constructor({
+    descriptor,
+    bot,
+    harness,
+    state,
+    status = createTextBridgeStatus(),
+    logger = console,
+    replyTimeoutMs = 600_000,
+  }) {
+    if (!descriptor?.key || !descriptor?.label) throw new TypeError('A channel descriptor is required');
+    if (!bot || typeof bot.sendText !== 'function') throw new TypeError('A bot client is required');
+    if (!harness || !state) throw new TypeError('Harness client and state store are required');
+    this.#descriptor = descriptor;
+    this.#bot = bot;
+    this.#harness = harness;
+    this.#state = state;
+    this.#status = status;
+    this.#logger = logger;
+    this.#replyTimeoutMs = replyTimeoutMs;
+  }
+
+  get status() {
+    return structuredClone(this.#status);
+  }
+
+  accept(message) {
+    const conversationId = cleanText(message?.conversationId);
+    const kind = message?.kind === 'group' ? 'group' : 'direct';
+    const key = `${kind}:${conversationId}`;
+    const previous = this.#queues.get(key) ?? Promise.resolve();
+    const current = previous
+      .catch(() => undefined)
+      .then(() => this.#process({ ...message, kind, conversationId }))
+      .finally(() => {
+        if (this.#queues.get(key) === current) this.#queues.delete(key);
+      });
+    this.#queues.set(key, current);
+    return current;
+  }
+
+  async waitForIdle() {
+    await Promise.allSettled([...this.#queues.values()]);
+  }
+
+  async #process(message) {
+    const messageId = cleanText(message.messageId);
+    const senderId = cleanText(message.senderId);
+    if (!messageId || !senderId || !message.conversationId || message.senderIsBot === true) return;
+    if (this.#state.hasSeen(messageId)) return;
+
+    this.#status.messagesReceived += 1;
+    this.#status.lastMessageAt = new Date().toISOString();
+    if (message.kind === 'group' && message.addressed !== true) {
+      this.#status.messagesRejected += 1;
+      this.#status.lastRejectedAt = new Date().toISOString();
+      return;
+    }
+
+    const target = message.replyTarget;
+    const text = cleanText(message.content);
+    try {
+      if (!text) {
+        await this.#bot.sendText(target, '目前仅支持文字消息。');
+        await this.#state.markSeen(messageId);
+        return;
+      }
+      const command = text.toLowerCase();
+      if (command === '/help') {
+        await this.#bot.sendText(target, [
+          `${this.#descriptor.label}机器人已连接 DeepSeek Harness。`,
+          '',
+          '直接发送文字即可继续当前会话。',
+          '/new  开启一个全新会话',
+          '/status  检查连接状态',
+          '/help  显示本帮助',
+        ].join('\n'));
+        await this.#state.markSeen(messageId);
+        return;
+      }
+      if (command === '/status') {
+        await this.#harness.ensureRunning();
+        await this.#bot.sendText(target, `${this.#descriptor.label}机器人与 DeepSeek Harness 连接正常。`);
+        await this.#state.markSeen(messageId);
+        return;
+      }
+      const conversationKey = `${message.kind}:${message.conversationId}`;
+      if (command === '/new') {
+        await this.#state.clearSession(conversationKey);
+        await this.#bot.sendText(target, '已开启新会话。请发送你的问题。');
+        await this.#state.markSeen(messageId);
+        return;
+      }
+
+      let sessionId = this.#state.sessionFor(conversationKey);
+      if (!sessionId || !(await this.#harness.sessionExists(sessionId))) {
+        sessionId = await this.#harness.createSession();
+        await this.#state.setSession(conversationKey, sessionId);
+      }
+
+      await this.#bot.sendTyping?.(target).catch((error) => {
+        this.#logger.warn?.(`[dsh-im:${this.#descriptor.key}] typing indicator failed:`, error);
+      });
+      let stream = null;
+      let streamFinished = false;
+      if (typeof this.#bot.openStream === 'function') {
+        try {
+          stream = await this.#bot.openStream(target);
+        } catch (error) {
+          this.#logger.warn?.(
+            `[dsh-im:${this.#descriptor.key}] unable to start a streamed reply; using text:`,
+            error,
+          );
+        }
+      }
+      const answer = await this.#harness.ask(sessionId, text, {
+        timeoutMs: this.#replyTimeoutMs,
+        onUpdate: stream ? async (update) => {
+          const progress = update.type === 'text' ? update.text
+            : update.type === 'tool' ? `正在使用${update.name}…` : update.text;
+          if (progress) await stream.update(progress);
+        } : undefined,
+      });
+      if (stream) {
+        try {
+          await stream.finish(answer);
+          streamFinished = true;
+        } catch (error) {
+          stream.cancel?.();
+          this.#logger.warn?.(
+            `[dsh-im:${this.#descriptor.key}] streamed reply finalization failed; using text:`,
+            error,
+          );
+        }
+      }
+      if (!streamFinished) await this.#bot.sendText(target, answer);
+      await this.#state.markSeen(messageId);
+      this.#status.messagesReplied += 1;
+      this.#status.lastReplyAt = new Date().toISOString();
+      this.#status.lastError = null;
+    } catch (error) {
+      this.#status.lastError = error?.message ?? String(error);
+      this.#logger.error?.(`[dsh-im:${this.#descriptor.key}] failed to process a message:`, error);
+      try {
+        await this.#bot.sendText(target, '消息处理失败，请稍后重试。');
+        await this.#state.markSeen(messageId);
+      } catch (sendError) {
+        this.#logger.error?.(
+          `[dsh-im:${this.#descriptor.key}] failed to send the safe error reply:`,
+          sendError,
+        );
+      }
+    }
+  }
+}