@xmanrui/dsh-im 0.1.0

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

@@ -0,0 +1,182 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+import { normalizeWeixinApiBaseUrl } from './weixin-api.mjs';
+
+const EMPTY_DOCUMENT = Object.freeze({ version: 1, accounts: Object.freeze([]) });
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function safeBotId(value) {
+  const id = cleanString(value);
+  return id && /^wx_[a-f0-9]{24}$/.test(id) ? id : null;
+}
+
+function safeTokenRef(value) {
+  const ref = cleanString(value);
+  return ref && /^DSH_WEIXIN_BOT_TOKEN_[A-F0-9]{24}$/.test(ref) ? ref : null;
+}
+
+export function deriveWeixinBotIdentity(accountId) {
+  const raw = cleanString(accountId);
+  if (!raw) throw new TypeError('accountId is required');
+  const digest = createHash('sha256').update(raw).digest('hex').slice(0, 24);
+  return {
+    botId: `wx_${digest}`,
+    tokenRef: `DSH_WEIXIN_BOT_TOKEN_${digest.toUpperCase()}`,
+  };
+}
+
+export function maskWeixinAccountId(accountId) {
+  const value = cleanString(accountId) ?? '';
+  if (value.length <= 10) return value ? `${value.slice(0, 3)}•••` : '微信机器人';
+  return `${value.slice(0, 6)}••••${value.slice(-4)}`;
+}
+
+function normalizeAccount(value) {
+  if (!value || typeof value !== 'object') return null;
+  const accountId = cleanString(value.accountId);
+  const ownerUserId = cleanString(value.ownerUserId);
+  const botId = safeBotId(value.botId);
+  const tokenRef = safeTokenRef(value.tokenRef);
+  if (!accountId || !ownerUserId || !botId || !tokenRef) return null;
+  const derived = deriveWeixinBotIdentity(accountId);
+  if (derived.botId !== botId || derived.tokenRef !== tokenRef) return null;
+  let baseUrl;
+  try {
+    baseUrl = normalizeWeixinApiBaseUrl(value.baseUrl);
+  } catch {
+    return null;
+  }
+  return Object.freeze({
+    botId,
+    accountId,
+    tokenRef,
+    ownerUserId,
+    baseUrl,
+    createdAt: cleanString(value.createdAt) ?? new Date().toISOString(),
+    connectedAt: cleanString(value.connectedAt),
+  });
+}
+
+function normalizeDocument(value) {
+  if (!value || value.version !== 1 || !Array.isArray(value.accounts)) return null;
+  const accounts = value.accounts.map(normalizeAccount);
+  if (accounts.some((account) => account === null)) return null;
+  const ids = new Set();
+  const accountIds = new Set();
+  const refs = new Set();
+  for (const account of accounts) {
+    if (ids.has(account.botId) || accountIds.has(account.accountId) || refs.has(account.tokenRef)) {
+      return null;
+    }
+    ids.add(account.botId);
+    accountIds.add(account.accountId);
+    refs.add(account.tokenRef);
+  }
+  return Object.freeze({ version: 1, accounts: Object.freeze(accounts) });
+}
+
+export class WeixinConfigStore {
+  #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-weixin config contains invalid account data');
+      this.#value = normalized;
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+      this.#value = EMPTY_DOCUMENT;
+    }
+    return this;
+  }
+
+  list() {
+    return structuredClone(this.#value.accounts);
+  }
+
+  get(botId) {
+    const account = this.#value.accounts.find((candidate) => candidate.botId === botId);
+    return account ? structuredClone(account) : null;
+  }
+
+  getByAccountId(accountId) {
+    const account = this.#value.accounts.find((candidate) => candidate.accountId === accountId);
+    return account ? structuredClone(account) : null;
+  }
+
+  async save(value) {
+    const normalized = normalizeAccount(value);
+    if (!normalized) throw new Error('Refusing to persist incomplete dsh-weixin account data');
+    return this.#mutate((accounts) => {
+      const accountCollision = accounts.find(
+        (account) => account.accountId === normalized.accountId && account.botId !== normalized.botId,
+      );
+      const refCollision = accounts.find(
+        (account) => account.tokenRef === normalized.tokenRef && account.botId !== normalized.botId,
+      );
+      if (accountCollision || refCollision) throw new Error('Duplicate Weixin account identity');
+      const index = accounts.findIndex((account) => account.botId === normalized.botId);
+      if (index === -1) accounts.push(normalized);
+      else accounts[index] = normalized;
+      return structuredClone(normalized);
+    });
+  }
+
+  async remove(botId) {
+    if (!safeBotId(botId)) throw new TypeError('Invalid Weixin bot id');
+    return this.#mutate((accounts) => {
+      const index = accounts.findIndex((account) => account.botId === botId);
+      if (index === -1) return null;
+      const [removed] = accounts.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 accounts = [...this.#value.accounts];
+      result = mutator(accounts);
+      const document = Object.freeze({ version: 1, accounts: Object.freeze(accounts) });
+      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/weixin/harness-client.mjs

@@ -0,0 +1,259 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+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;
+  #managedProcess = null;
+
+  constructor({ baseUrl, workspace, agentPreset = 'standard', autostart = false, dshBin = 'dsh' }) {
+    this.#baseUrl = new URL(baseUrl);
+    this.#workspace = workspace;
+    this.#agentPreset = agentPreset;
+    this.#autostart = autostart;
+    this.#dshBin = dshBin;
+  }
+
+  async rpc(method, payload = {}, timeoutMs = 30_000, options = {}) {
+    const rpcId = options.rpcId ?? `weixin-${randomUUID()}`;
+    const response = await fetch(new URL(`/api/${method}`, this.#baseUrl), {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ type: 'client-request', rpcId, method, payload }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    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() {
+    await this.rpc('host.describe', {}, 5_000);
+    return true;
+  }
+
+  async ensureRunning() {
+    try {
+      return await this.health();
+    } 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-weixin] failed to start Harness:', error.message);
+      });
+    }
+
+    const deadline = Date.now() + 60_000;
+    let lastError;
+    while (Date.now() < deadline) {
+      await sleep(1_000);
+      try {
+        return await this.health();
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw new Error(`Harness did not become ready: ${lastError?.message ?? 'timeout'}`);
+  }
+
+  async workspaceId() {
+    const { items } = await this.rpc('workspace.list', {});
+    const existing = items.find((item) => item.path === this.#workspace);
+    if (existing) return existing.workspaceId;
+    const created = await this.rpc('workspace.create', { path: this.#workspace });
+    return created.workspace.workspaceId;
+  }
+
+  async createSession() {
+    await this.ensureRunning();
+    const workspaceId = await this.workspaceId();
+    const created = await this.rpc('session.create', {
+      workspaceId,
+      agentPreset: this.#agentPreset,
+    });
+    return created.sessionId;
+  }
+
+  async sessionExists(sessionId) {
+    try {
+      await this.rpc('session.history', { sessionId, maxMessages: 1 });
+      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 onUpdate = typeof options.onUpdate === 'function' ? options.onUpdate : null;
+    await this.ensureRunning();
+    const before = await this.rpc('session.history', { sessionId, maxMessages: 1 });
+    const baselineSeq = Math.max(-1, ...(before.events ?? []).map(({ event }) => event.seq ?? -1));
+    const promptRpcId = `weixin-${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 });
+
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await sleep(300);
+      const history = await this.rpc('session.history', { sessionId, maxMessages: 50 });
+      const update = tracker.consume(history.events ?? []);
+      if (update && onUpdate) {
+        try {
+          await onUpdate(update);
+        } catch (error) {
+          console.warn('[dsh-weixin] 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');
+  }
+}

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

@@ -0,0 +1,112 @@
+import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+const EMPTY_STATE = Object.freeze({
+  version: 1,
+  sessions: {},
+  seenMessageIds: [],
+  getUpdatesBuf: '',
+});
+
+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)
+      : [],
+    getUpdatesBuf: typeof value.getUpdatesBuf === 'string' ? value.getUpdatesBuf : '',
+  };
+}
+
+export class WeixinStateStore {
+  #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();
+  }
+
+  getUpdatesBuf() {
+    return this.#state.getUpdatesBuf;
+  }
+
+  async setGetUpdatesBuf(value) {
+    if (typeof value !== 'string' || value === this.#state.getUpdatesBuf) return;
+    this.#state.getUpdatesBuf = value;
+    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;
+  }
+}