@xmanrui/dsh-im 0.1.0

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

@@ -0,0 +1,358 @@
+import { createDingtalkApi } from './dingtalk-api.mjs';
+import {
+  createDingtalkBridgeStatus,
+  DingtalkHarnessBridge,
+} from './dingtalk-bridge.mjs';
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function approvedSenderIds(config) {
+  const entries = Array.isArray(config?.approvedSenders)
+    ? config.approvedSenders
+    : config?.approvedSenders instanceof Set
+      ? [...config.approvedSenders]
+      : [];
+  return new Set(entries.map((entry) => nonEmptyString(
+    typeof entry === 'string' ? entry : entry?.staffId,
+  )).filter(Boolean));
+}
+
+function approvedSenderCount(config) {
+  return approvedSenderIds(config).size;
+}
+
+function streamIsOpen(client) {
+  return client?.connected === true || client?.socket?.readyState === 1;
+}
+
+function abortable(promise, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
+async function waitForStreamOpen(client, pollIntervalMs, signal) {
+  while (true) {
+    signal?.throwIfAborted();
+    if (streamIsOpen(client)) return;
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+      }, pollIntervalMs);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      };
+      signal?.addEventListener('abort', onAbort, { once: true });
+    });
+  }
+}
+
+async function connectStream(client, timeoutMs, pollIntervalMs, signal) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const connectSignal = AbortSignal.any([signal, timeoutSignal]);
+  let connectSettled = false;
+  const connectTask = Promise.resolve()
+    .then(() => client.connect())
+    .finally(() => { connectSettled = true; });
+  try {
+    await abortable(connectTask, connectSignal);
+    await waitForStreamOpen(client, pollIntervalMs, connectSignal);
+  } catch (error) {
+    if (connectSignal.aborted) {
+      if (!connectSettled) {
+        void connectTask.then(() => client.disconnect()).catch(() => undefined);
+      }
+      if (signal.aborted) throw signal.reason;
+      throw new Error(`DingTalk Stream handshake timed out after ${timeoutMs}ms`);
+    }
+    throw error;
+  }
+}
+
+async function defaultStreamFactory({ clientId, clientSecret }) {
+  const { DWClient, TOPIC_ROBOT } = await import('dingtalk-stream');
+  return {
+    client: new DWClient({
+      clientId,
+      clientSecret,
+      endpoint: 'https://api.dingtalk.com',
+      autoReconnect: false,
+      keepAlive: true,
+      debug: false,
+    }),
+    topic: TOPIC_ROBOT,
+  };
+}
+
+export function createDingtalkRuntimeStatus({
+  pendingSenders = [],
+  approvedSenders = 0,
+} = {}) {
+  return {
+    startedAt: null,
+    ready: false,
+    dingtalkStreamState: 'idle',
+    harnessReachable: false,
+    lastConnectedAt: null,
+    lastCheckedAt: null,
+    lastCallbackAt: null,
+    authorizationMode: 'sender-staff-id-approval',
+    approvedSenderCount: approvedSenders,
+    ...createDingtalkBridgeStatus({ pendingSenders }),
+  };
+}
+
+export class DingtalkRuntime {
+  #config;
+  #clientSecret;
+  #harness;
+  #state;
+  #logger;
+  #replyTimeoutMs;
+  #maxMessageChars;
+  #connectTimeoutMs;
+  #connectPollIntervalMs;
+  #api;
+  #streamFactory;
+  #status;
+  #client = null;
+  #bridge = null;
+  #topic = null;
+  #starting = null;
+  #connectionMonitor = null;
+  #abortController = null;
+  #callbackTasks = new Set();
+
+  constructor({
+    config,
+    clientSecret,
+    harness,
+    state,
+    logger = console,
+    replyTimeoutMs = 600_000,
+    maxMessageChars = 4_000,
+    connectTimeoutMs = 15_000,
+    connectPollIntervalMs = 25,
+    api = createDingtalkApi(),
+    streamFactory = defaultStreamFactory,
+  }) {
+    if (!config || !nonEmptyString(config.clientId) || !nonEmptyString(clientSecret)) {
+      throw new TypeError('DingtalkRuntime requires app credentials');
+    }
+    if (!harness || !state) throw new TypeError('DingtalkRuntime requires Harness and state');
+    if (typeof streamFactory !== 'function') throw new TypeError('streamFactory must be a function');
+    this.#config = config;
+    this.#clientSecret = clientSecret.trim();
+    this.#harness = harness;
+    this.#state = state;
+    this.#logger = logger;
+    this.#replyTimeoutMs = replyTimeoutMs;
+    this.#maxMessageChars = maxMessageChars;
+    this.#connectTimeoutMs = connectTimeoutMs;
+    this.#connectPollIntervalMs = connectPollIntervalMs;
+    this.#api = api;
+    this.#streamFactory = streamFactory;
+    this.#status = createDingtalkRuntimeStatus({
+      pendingSenders: this.#pendingSenders(),
+      approvedSenders: approvedSenderCount(config),
+    });
+  }
+
+  get status() {
+    if (this.#bridge) {
+      const bridgeStatus = this.#bridge.status;
+      Object.assign(this.#status, bridgeStatus);
+    } else {
+      this.#status.pendingSenders = this.#pendingSenders();
+    }
+    return structuredClone(this.#status);
+  }
+
+  pendingSender(requestId) {
+    return typeof this.#state.pendingSender === 'function'
+      ? this.#state.pendingSender(requestId)
+      : null;
+  }
+
+  pendingSenders() {
+    return this.#pendingSenders();
+  }
+
+  async start() {
+    if (this.#client && this.#status.ready) 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();
+    const abortController = new AbortController();
+    this.#abortController = abortController;
+    const { signal } = abortController;
+    this.#status.startedAt = new Date().toISOString();
+    this.#status.dingtalkStreamState = 'connecting';
+    this.#status.lastError = null;
+
+    try {
+      await this.#harness.ensureRunning({ signal });
+      this.#status.harnessReachable = true;
+      if (typeof this.#state.removePendingSenderByStaffId === 'function') {
+        for (const staffId of approvedSenderIds(this.#config)) {
+          await this.#state.removePendingSenderByStaffId(staffId);
+        }
+        this.#status.pendingSenders = this.#pendingSenders();
+      }
+      this.#bridge = new DingtalkHarnessBridge({
+        api: this.#api,
+        clientId: this.#config.clientId,
+        clientSecret: this.#clientSecret,
+        approvedSenders: this.#config.approvedSenders,
+        harness: this.#harness,
+        state: this.#state,
+        status: this.#status,
+        logger: this.#logger,
+        replyTimeoutMs: this.#replyTimeoutMs,
+        maxMessageChars: this.#maxMessageChars,
+        signal,
+      });
+
+      const created = await this.#streamFactory({
+        clientId: this.#config.clientId,
+        clientSecret: this.#clientSecret,
+      });
+      signal.throwIfAborted();
+      this.#client = created?.client ?? created;
+      this.#topic = created?.topic ?? created?.TOPIC_ROBOT ?? '/v1.0/im/bot/messages/get';
+      if (!this.#client
+        || typeof this.#client.registerCallbackListener !== 'function'
+        || typeof this.#client.connect !== 'function'
+        || typeof this.#client.disconnect !== 'function'
+        || typeof this.#client.socketCallBackResponse !== 'function') {
+        throw new TypeError('streamFactory returned an invalid DingTalk Stream client');
+      }
+
+      const client = this.#client;
+      const bridge = this.#bridge;
+      client.registerCallbackListener(this.#topic, (response) => {
+        if (this.#client !== client || this.#bridge !== bridge) return;
+        const callbackMessageId = nonEmptyString(response?.headers?.messageId);
+        if (callbackMessageId) {
+          try {
+            client.socketCallBackResponse(callbackMessageId, { success: true });
+          } catch {
+            this.#logger.warn?.('[dsh-dingtalk] unable to acknowledge an inbound callback');
+          }
+        }
+
+        const task = Promise.resolve().then(async () => {
+          if (this.#bridge !== bridge) return;
+          let message;
+          try {
+            message = typeof response?.data === 'string'
+              ? JSON.parse(response.data)
+              : response?.data;
+          } catch {
+            this.#status.lastError = '钉钉消息格式无效。';
+            this.#logger.warn?.('[dsh-dingtalk] ignored an invalid callback payload');
+            return;
+          }
+          if (!message || typeof message !== 'object') return;
+          this.#status.lastCallbackAt = Date.now();
+          await bridge.accept(message);
+        }).catch(() => {
+          if (signal.aborted || this.#bridge !== bridge) return;
+          this.#status.lastError = '钉钉消息处理失败。';
+          this.#logger.error?.('[dsh-dingtalk] callback processing failed');
+        }).finally(() => this.#callbackTasks.delete(task));
+        this.#callbackTasks.add(task);
+      });
+
+      await connectStream(
+        client,
+        this.#connectTimeoutMs,
+        this.#connectPollIntervalMs,
+        signal,
+      );
+      this.#status.ready = true;
+      this.#status.dingtalkStreamState = 'connected';
+      this.#status.lastConnectedAt = Date.now();
+      this.#status.lastCheckedAt = Date.now();
+      this.#status.lastError = null;
+      this.#connectionMonitor = setInterval(() => {
+        const connected = streamIsOpen(client);
+        this.#status.ready = connected;
+        this.#status.dingtalkStreamState = connected ? 'connected' : 'reconnecting';
+        this.#status.lastCheckedAt = Date.now();
+        if (connected) this.#status.lastError = null;
+      }, 1_000);
+      this.#connectionMonitor.unref?.();
+      return this.status;
+    } catch (error) {
+      const aborted = signal.aborted;
+      this.#status.ready = false;
+      this.#status.dingtalkStreamState = aborted ? 'idle' : 'failed';
+      this.#status.lastError = aborted ? null : (error?.message ?? String(error));
+      await this.stop({ preserveError: !aborted });
+      throw error;
+    }
+  }
+
+  async stop({ preserveError = false } = {}) {
+    const lastError = preserveError ? this.#status.lastError : null;
+    const abortController = this.#abortController;
+    this.#abortController = null;
+    abortController?.abort(new DOMException('DingTalk runtime stopped', 'AbortError'));
+    if (this.#connectionMonitor) clearInterval(this.#connectionMonitor);
+    this.#connectionMonitor = null;
+    this.#status.ready = false;
+
+    const client = this.#client;
+    this.#client = null;
+    this.#topic = null;
+    if (client) {
+      try {
+        await client.disconnect();
+      } catch {
+        this.#logger.warn?.('[dsh-dingtalk] DingTalk Stream disconnect failed');
+      }
+    }
+    await Promise.allSettled([...this.#callbackTasks]);
+    this.#callbackTasks.clear();
+    if (this.#bridge) await this.#bridge.waitForIdle();
+    this.#bridge = null;
+    this.#status.dingtalkStreamState = preserveError ? 'failed' : 'idle';
+    this.#status.lastError = lastError;
+    return this.status;
+  }
+
+  #pendingSenders() {
+    return typeof this.#state.pendingSenders === 'function'
+      ? this.#state.pendingSenders()
+      : [];
+  }
+}
+
+export const DingTalkRuntime = DingtalkRuntime;
+export const createDingTalkRuntimeStatus = createDingtalkRuntimeStatus;

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

@@ -0,0 +1,299 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new DOMException('Aborted', 'AbortError'));
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+function assistantMessageText(event) {
+  return (event?.data?.message?.content ?? [])
+    .filter((part) => part.type === 'text' && typeof part.text === 'string')
+    .map((part) => part.text)
+    .join('\n')
+    .trim();
+}
+
+export class HarnessReplyTracker {
+  #promptRpcId;
+  #lastSeq;
+  #openTurn = null;
+  #targetTurn = null;
+  #stepText = new Map();
+  #latestText = '';
+  #finished = false;
+  #reason = null;
+
+  constructor({ promptRpcId, afterSeq = -1 }) {
+    this.#promptRpcId = promptRpcId;
+    this.#lastSeq = afterSeq;
+  }
+
+  get finished() {
+    return this.#finished;
+  }
+
+  get answer() {
+    return this.#latestText.trim();
+  }
+
+  get reason() {
+    return this.#reason;
+  }
+
+  consume(entries) {
+    let update = null;
+    const ordered = [...entries]
+      .map((entry) => entry?.event ?? entry)
+      .filter(Boolean)
+      .sort((left, right) => (left.seq ?? -1) - (right.seq ?? -1));
+
+    for (const event of ordered) {
+      const seq = event.seq ?? -1;
+      if (seq <= this.#lastSeq) continue;
+      this.#lastSeq = seq;
+
+      if (event.type === 'turn/start') this.#openTurn = event.data?.turn ?? null;
+
+      if (event.type === 'user/message' && event.data?.source?.rpcId === this.#promptRpcId) {
+        this.#targetTurn = this.#openTurn;
+        continue;
+      }
+      if (this.#targetTurn === null) continue;
+
+      if (event.type === 'turn/end') {
+        if (event.data?.turn !== this.#targetTurn) continue;
+        this.#finished = true;
+        this.#reason = event.data?.reason ?? null;
+        this.#openTurn = null;
+        continue;
+      }
+      if (event.data?.turn !== this.#targetTurn) continue;
+
+      if (event.type === 'assistant/chunk' && event.data?.chunk?.type === 'text-delta') {
+        const step = event.data?.step ?? 0;
+        const index = event.data.chunk.index ?? 0;
+        const key = `${step}:${index}`;
+        this.#stepText.set(key, (this.#stepText.get(key) ?? '') + event.data.chunk.text);
+        const prefix = `${step}:`;
+        const text = [...this.#stepText.entries()]
+          .filter(([partKey]) => partKey.startsWith(prefix))
+          .sort(([left], [right]) => Number(left.split(':')[1]) - Number(right.split(':')[1]))
+          .map(([, part]) => part)
+          .join('\n')
+          .trim();
+        if (text && text !== this.#latestText) {
+          this.#latestText = text;
+          update = { type: 'text', text };
+        }
+        continue;
+      }
+
+      if (event.type === 'assistant/message') {
+        const text = assistantMessageText(event);
+        if (text && text !== this.#latestText) {
+          this.#latestText = text;
+          update = { type: 'text', text };
+        }
+        continue;
+      }
+
+      if (event.type === 'tool/call') {
+        update = { type: 'tool', name: event.data?.name ?? '工具' };
+      } else if (event.type === 'tool/result') {
+        update = { type: 'status', text: '正在整理结果…' };
+      }
+    }
+    return update;
+  }
+}
+
+export class HarnessRpcError extends Error {
+  constructor(method, error) {
+    super(`${method}: ${error?.message ?? 'unknown Harness RPC error'}`);
+    this.name = 'HarnessRpcError';
+    this.method = method;
+    this.code = error?.code ?? 'internal';
+    this.details = error?.details ?? {};
+  }
+}
+
+export class HarnessClient {
+  #baseUrl;
+  #workspace;
+  #agentPreset;
+  #autostart;
+  #dshBin;
+  #fetch;
+  #managedProcess = null;
+
+  constructor({
+    baseUrl,
+    workspace,
+    agentPreset = 'standard',
+    autostart = false,
+    dshBin = 'dsh',
+    fetchImpl = fetch,
+  }) {
+    this.#baseUrl = new URL(baseUrl);
+    this.#workspace = workspace;
+    this.#agentPreset = agentPreset;
+    this.#autostart = autostart;
+    this.#dshBin = dshBin;
+    this.#fetch = fetchImpl;
+  }
+
+  async rpc(method, payload = {}, timeoutMs = 30_000, options = {}) {
+    const rpcId = options.rpcId ?? `dingtalk-${randomUUID()}`;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const signal = options.signal
+      ? AbortSignal.any([options.signal, timeoutSignal])
+      : timeoutSignal;
+    const response = await this.#fetch(new URL(`/api/${method}`, this.#baseUrl), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ type: 'client-request', rpcId, method, payload }),
+      signal,
+    });
+    if (!response.ok) throw new Error(`Harness transport ${method} failed: HTTP ${response.status}`);
+    const body = await response.json();
+    if (body?.type !== 'server-response' || body?.rpcId !== rpcId) {
+      throw new Error(`Harness returned an invalid response for ${method}`);
+    }
+    if (!body.result?.ok) throw new HarnessRpcError(method, body.result?.error);
+    return body.result.value;
+  }
+
+  async health(options = {}) {
+    await this.rpc('host.describe', {}, 5_000, options);
+    return true;
+  }
+
+  async ensureRunning(options = {}) {
+    try {
+      return await this.health(options);
+    } catch (firstError) {
+      if (!this.#autostart) throw firstError;
+    }
+
+    if (!this.#managedProcess || this.#managedProcess.exitCode !== null) {
+      const port = this.#baseUrl.port || (this.#baseUrl.protocol === 'https:' ? '443' : '80');
+      this.#managedProcess = spawn(this.#dshBin, [
+        'web', '--host', this.#baseUrl.hostname, '--port', port,
+      ], {
+        cwd: this.#workspace,
+        env: process.env,
+        stdio: ['ignore', 'inherit', 'inherit'],
+      });
+      this.#managedProcess.on('error', (error) => {
+        console.error('[dsh-dingtalk] failed to start Harness:', error.message);
+      });
+    }
+
+    const deadline = Date.now() + 60_000;
+    let lastError;
+    while (Date.now() < deadline) {
+      await sleep(1_000, options.signal);
+      try {
+        return await this.health(options);
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw new Error(`Harness did not become ready: ${lastError?.message ?? 'timeout'}`);
+  }
+
+  async workspaceId(options = {}) {
+    const { items } = await this.rpc('workspace.list', {}, 30_000, options);
+    const existing = items.find((item) => item.path === this.#workspace);
+    if (existing) return existing.workspaceId;
+    const created = await this.rpc('workspace.create', { path: this.#workspace }, 30_000, options);
+    return created.workspace.workspaceId;
+  }
+
+  async createSession(options = {}) {
+    await this.ensureRunning(options);
+    const workspaceId = await this.workspaceId(options);
+    const created = await this.rpc('session.create', {
+      workspaceId,
+      agentPreset: this.#agentPreset,
+    }, 30_000, options);
+    return created.sessionId;
+  }
+
+  async sessionExists(sessionId, options = {}) {
+    try {
+      await this.rpc('session.history', { sessionId, maxMessages: 1 }, 30_000, options);
+      return true;
+    } catch (error) {
+      if (error instanceof HarnessRpcError && error.code === 'session-not-found') return false;
+      throw error;
+    }
+  }
+
+  async ask(sessionId, text, options = {}) {
+    if (typeof options === 'number') options = { timeoutMs: options };
+    const timeoutMs = options.timeoutMs ?? 600_000;
+    const signal = options.signal;
+    const onUpdate = typeof options.onUpdate === 'function' ? options.onUpdate : null;
+    await this.ensureRunning({ signal });
+    const before = await this.rpc(
+      'session.history',
+      { sessionId, maxMessages: 1 },
+      30_000,
+      { signal },
+    );
+    const baselineSeq = Math.max(-1, ...(before.events ?? []).map(({ event }) => event.seq ?? -1));
+    const promptRpcId = `dingtalk-${randomUUID()}`;
+    const tracker = new HarnessReplyTracker({ promptRpcId, afterSeq: baselineSeq });
+
+    await this.rpc('session.prompt', {
+      sessionId,
+      mode: 'queue',
+      content: [{ type: 'text', text }],
+      clientTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    }, 30_000, { rpcId: promptRpcId, signal });
+
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await sleep(300, signal);
+      const history = await this.rpc(
+        'session.history',
+        { sessionId, maxMessages: 50 },
+        30_000,
+        { signal },
+      );
+      const update = tracker.consume(history.events ?? []);
+      if (update && onUpdate) {
+        try {
+          await onUpdate(update);
+        } catch (error) {
+          console.warn('[dsh-dingtalk] ignored a progress update failure:', error.message);
+        }
+      }
+      if (!tracker.finished) continue;
+      if (tracker.answer) return tracker.answer;
+      throw new Error(
+        `Harness turn ended without a text reply${tracker.reason ? ` (${JSON.stringify(tracker.reason)})` : ''}`,
+      );
+    }
+    throw new Error(`Harness reply timed out after ${Math.round(timeoutMs / 1_000)} seconds`);
+  }
+
+  stopManagedProcess() {
+    if (this.#managedProcess?.exitCode === null) this.#managedProcess.kill('SIGTERM');
+  }
+}