@xmanrui/dsh-im 0.1.0 → 0.2.0

package/plugin-src/host/channels/whatsapp/production.mjs

@@ -0,0 +1,121 @@
+import { rm, unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { WhatsappConfigStore } from '../../../../src/channels/whatsapp/config-store.mjs';
+import { WhatsappHarnessClient } from '../../../../src/channels/whatsapp/harness-client.mjs';
+import { WhatsappStateStore } from '../../../../src/channels/whatsapp/state-store.mjs';
+import { WhatsappController } from '../../../../src/channels/whatsapp/whatsapp-controller.mjs';
+import { WhatsappRuntime } from '../../../../src/channels/whatsapp/whatsapp-runtime.mjs';
+import { createWhatsappWebSession } from '../../../../src/channels/whatsapp/whatsapp-web-session.mjs';
+import { createTokenConnectionSupervisor } from '../shared/connection-supervisor.mjs';
+
+const AUTH_DIRECTORY_PATTERN = /^[a-f0-9-]{36}$/;
+
+function harnessOrigin(webServer, configured) {
+  if (configured !== undefined) return new URL(configured);
+  const port = webServer?.port;
+  if (!Number.isInteger(port) || port < 1 || port > 65_535) {
+    throw new Error('dsh-im WhatsApp requires an initialized DSH webServer port');
+  }
+  return new URL(`http://127.0.0.1:${port}`);
+}
+
+function pluginPaths(config) {
+  const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
+  const root = resolve(config.dataDir ?? join(dshHome, 'integrations', 'dsh-whatsapp'));
+  const authRoot = resolve(config.authDir ?? join(root, 'auth'));
+  const authPath = (name) => {
+    if (!AUTH_DIRECTORY_PATTERN.test(name ?? '')) throw new TypeError('Invalid WhatsApp auth directory');
+    return resolve(authRoot, name);
+  };
+  return {
+    config: resolve(config.configPath ?? join(root, 'config.json')),
+    bots: resolve(config.botsDir ?? join(root, 'bots')),
+    authPath,
+  };
+}
+
+export async function createProductionController(ctx, config = {}, internals = {}) {
+  if (!ctx?.webServer) throw new TypeError('dsh-im WhatsApp requires ctx.webServer');
+  const logger = typeof ctx.logger === 'function'
+    ? ctx.logger('dsh-im:whatsapp') : (ctx.logger ?? console);
+  const ConfigStore = internals.ConfigStore ?? WhatsappConfigStore;
+  const StateStore = internals.StateStore ?? WhatsappStateStore;
+  const Harness = internals.HarnessClient ?? WhatsappHarnessClient;
+  const Controller = internals.Controller ?? WhatsappController;
+  const Runtime = internals.Runtime ?? WhatsappRuntime;
+  const createSession = internals.createSession ?? createWhatsappWebSession;
+  const createSupervisor = internals.createConnectionSupervisor ?? createTokenConnectionSupervisor;
+  const paths = pluginPaths(config);
+  const configStore = await new ConfigStore(paths.config).load();
+  const stateStores = new Map();
+  const statePath = (botId) => resolve(paths.bots, botId, 'state.json');
+  const stateFor = async (botId) => {
+    let state = stateStores.get(botId);
+    if (!state) {
+      state = await new StateStore(statePath(botId)).load();
+      stateStores.set(botId, state);
+    }
+    return state;
+  };
+  const harness = new Harness({
+    baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
+    workspace: resolve(config.workspace ?? process.cwd()),
+    agentPreset: config.agentPreset ?? 'standard',
+    autostart: false,
+    dshBin: config.dshBin ?? 'dsh',
+  });
+  const controller = new Controller({
+    configStore,
+    authPath: paths.authPath,
+    createSession,
+    logger,
+    createRuntime: async ({ botId, config: botConfig, authDir }) => new Runtime({
+      config: botConfig,
+      authDir,
+      harness,
+      state: await stateFor(botId),
+      replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+      connectTimeoutMs: config.connectTimeoutMs ?? 30_000,
+      createSession,
+      logger: {
+        error: (...args) => logger.error?.(`[${botId}]`, ...args),
+        warn: (...args) => logger.warn?.(`[${botId}]`, ...args),
+        info: (...args) => logger.info?.(`[${botId}]`, ...args),
+        debug: (...args) => logger.debug?.(`[${botId}]`, ...args),
+      },
+    }),
+    deleteAuth: (authDirectory) => rm(paths.authPath(authDirectory), {
+      recursive: true,
+      force: true,
+    }),
+    deleteState: async ({ botId }) => {
+      const state = stateStores.get(botId);
+      stateStores.delete(botId);
+      if (state && typeof state.remove === 'function') return state.remove();
+      try {
+        await unlink(statePath(botId));
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+      }
+    },
+  });
+  const supervisor = createSupervisor({
+    channel: 'whatsapp',
+    controller,
+    harness,
+    logger,
+    retryDelaysMs: config.retryDelaysMs,
+    healthyIntervalMs: config.healthyIntervalMs,
+  }).start();
+  return {
+    controller,
+    ready: supervisor.ready,
+    async close() {
+      await supervisor.close();
+      await controller.close();
+      harness.stopManagedProcess();
+    },
+  };
+}

package/plugin-src/host/channels/whatsapp/rpc.mjs

@@ -0,0 +1,140 @@
+import QRCode from 'qrcode';
+
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+
+export const WHATSAPP_RPC_CHANNEL = '/whatsapp';
+export const WHATSAPP_ENDPOINTS = Object.freeze({
+  status: 'connection.status',
+  beginProvisioning: 'provision.begin',
+  pollProvisioning: 'provision.poll',
+  cancelProvisioning: 'provision.cancel',
+  reconnectBot: 'bot.reconnect',
+  deleteBot: 'bot.delete',
+});
+export const WHATSAPP_RPC_ENDPOINTS = Object.freeze(Object.values(WHATSAPP_ENDPOINTS));
+
+const FORBIDDEN_PUBLIC_KEYS = new Set(['qrValue', 'accountJid', 'authDirectory']);
+
+function isRecord(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function exactKeys(value, allowed) {
+  return isRecord(value) && Object.keys(value).every((key) => allowed.includes(key));
+}
+
+function validId(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value);
+}
+
+function payloadFailure(endpoint, payload) {
+  if (!isRecord(payload)) return 'Payload must be an object.';
+  if ([WHATSAPP_ENDPOINTS.status, WHATSAPP_ENDPOINTS.beginProvisioning].includes(endpoint)) {
+    return exactKeys(payload, []) ? null : `${endpoint} does not accept fields.`;
+  }
+  if ([WHATSAPP_ENDPOINTS.pollProvisioning, WHATSAPP_ENDPOINTS.cancelProvisioning].includes(endpoint)) {
+    return exactKeys(payload, ['attemptId']) && validId(payload.attemptId)
+      ? null : `${endpoint} requires an attemptId.`;
+  }
+  if (endpoint === WHATSAPP_ENDPOINTS.reconnectBot) {
+    return exactKeys(payload, ['botId']) && validId(payload.botId)
+      ? null : 'bot.reconnect requires a botId.';
+  }
+  if (endpoint === WHATSAPP_ENDPOINTS.deleteBot) {
+    return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId)
+      && payload.confirm === true ? null : 'bot.delete requires a botId and confirm=true.';
+  }
+  return 'Unknown WhatsApp endpoint.';
+}
+
+function sanitizePublic(value) {
+  if (Array.isArray(value)) return value.map(sanitizePublic);
+  if (!isRecord(value)) return value;
+  const safe = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (!FORBIDDEN_PUBLIC_KEYS.has(key)) safe[key] = sanitizePublic(child);
+  }
+  return safe;
+}
+
+async function qrDataUrl(value) {
+  return QRCode.toDataURL(value, {
+    type: 'image/png',
+    errorCorrectionLevel: 'M',
+    margin: 2,
+    width: 320,
+  });
+}
+
+async function encodeAttempt(value, encodeQr) {
+  if (!value || typeof value.qrValue !== 'string') return sanitizePublic(value);
+  return sanitizePublic({ ...value, qrCodeDataUrl: await encodeQr(value.qrValue) });
+}
+
+async function publicStatus(value, encodeQr) {
+  const snapshot = structuredClone(value);
+  if (snapshot?.provisioning) snapshot.provisioning = await encodeAttempt(snapshot.provisioning, encodeQr);
+  return sanitizePublic(snapshot);
+}
+
+export function createWhatsappRpcHandler(controller, { encodeQr = qrDataUrl } = {}) {
+  for (const method of ['status', 'startProvisioning', 'registrationStatus', 'cancelProvisioning', 'reconnectBot', 'deleteBot']) {
+    if (typeof controller?.[method] !== 'function') {
+      throw new TypeError(`A complete WhatsApp controller is required (${method})`);
+    }
+  }
+  const qrCache = new Map();
+  const cachedEncode = (value) => {
+    let encoded = qrCache.get(value);
+    if (!encoded) {
+      if (qrCache.size >= 16) qrCache.delete(qrCache.keys().next().value);
+      encoded = Promise.resolve().then(() => encodeQr(value));
+      qrCache.set(value, encoded);
+    }
+    return encoded;
+  };
+  return async (endpoint, payload, signal) => {
+    if (signal?.aborted) return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+    if (!WHATSAPP_RPC_ENDPOINTS.includes(endpoint)) {
+      return { ok: false, error: { code: 'bad-request', message: 'Unknown WhatsApp endpoint.' } };
+    }
+    const invalid = payloadFailure(endpoint, payload);
+    if (invalid) return { ok: false, error: { code: 'bad-request', message: invalid } };
+    try {
+      let value;
+      if (endpoint === WHATSAPP_ENDPOINTS.status) {
+        value = await publicStatus(await controller.status(), cachedEncode);
+      } else if (endpoint === WHATSAPP_ENDPOINTS.beginProvisioning) {
+        value = await encodeAttempt(await controller.startProvisioning(), cachedEncode);
+      } else if (endpoint === WHATSAPP_ENDPOINTS.pollProvisioning) {
+        const attempt = await controller.registrationStatus(payload.attemptId);
+        if (!attempt) return { ok: false, error: { code: 'bad-request', message: 'The provisioning attempt no longer exists.' } };
+        value = await encodeAttempt(attempt, cachedEncode);
+      } else if (endpoint === WHATSAPP_ENDPOINTS.cancelProvisioning) {
+        value = sanitizePublic(await controller.cancelProvisioning(payload.attemptId));
+      } else if (endpoint === WHATSAPP_ENDPOINTS.reconnectBot) {
+        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else {
+        value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
+      }
+      return signal?.aborted
+        ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
+        : { ok: true, value };
+    } catch {
+      return signal?.aborted
+        ? { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } }
+        : { ok: false, error: { code: 'whatsapp-operation-failed', message: 'WhatsApp 操作失败，请稍后重试。' } };
+    }
+  };
+}
+
+export function installWhatsappRpc(ctx, controller, options, authority) {
+  if (!ctx?.connection?.rpc || typeof ctx.connection.rpc.handle !== 'function') {
+    throw new TypeError('DSH Host Connection RPC is required');
+  }
+  return ctx.connection.rpc.handle(
+    WHATSAPP_RPC_CHANNEL,
+    createWhatsappRpcHandler(controller, options),
+    { authority: resolveRpcAuthority(authority) },
+  );
+}

package/plugin-src/host/index.mjs

@@ -5,6 +5,7 @@ import { apply as applyQq } from './channels/qq/index.mjs';
 import { apply as applyTelegram } from './channels/telegram/index.mjs';
 import { apply as applyWecom } from './channels/wecom/index.mjs';
 import { apply as applyWeixin } from './channels/weixin/index.mjs';
+import { apply as applyWhatsapp } from './channels/whatsapp/index.mjs';
 
 export const name = 'dsh-im-host';
 export const inject = ['connection', 'credentials', 'webServer'];
@@ -24,6 +25,7 @@ export function createImHostPlugin(internals = {}) {
   const startQq = internals.applyQq ?? applyQq;
   const startTelegram = internals.applyTelegram ?? applyTelegram;
   const startDiscord = internals.applyDiscord ?? applyDiscord;
+  const startWhatsapp = internals.applyWhatsapp ?? applyWhatsapp;
   return Object.freeze({
     name,
     inject,
@@ -35,6 +37,7 @@ export function createImHostPlugin(internals = {}) {
       await startQq(ctx, channelConfig(config, 'qq'));
       await startTelegram(ctx, channelConfig(config, 'telegram'));
       await startDiscord(ctx, channelConfig(config, 'discord'));
+      await startWhatsapp(ctx, channelConfig(config, 'whatsapp'));
     },
   });
 }

package/scripts/verify-package.mjs

@@ -1,5 +1,6 @@
 import { access, readFile, stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 const root = resolve(import.meta.dirname, '..');
 const required = [
@@ -17,6 +18,7 @@ const required = [
   'plugin-src/host/channels/wecom/index.mjs',
   'plugin-src/host/channels/telegram/index.mjs',
   'plugin-src/host/channels/discord/index.mjs',
+  'plugin-src/host/channels/whatsapp/index.mjs',
   'src/channels/feishu/feishu-runtime.mjs',
   'src/channels/weixin/weixin-runtime.mjs',
   'src/channels/dingtalk/dingtalk-runtime.mjs',
@@ -24,6 +26,8 @@ const required = [
   'src/channels/wecom/wecom-runtime.mjs',
   'src/channels/telegram/telegram-runtime.mjs',
   'src/channels/discord/discord-runtime.mjs',
+  'src/channels/whatsapp/whatsapp-runtime.mjs',
+  'src/channels/whatsapp/whatsapp-web-session.mjs',
 ];
 await Promise.all(required.map((path) => access(resolve(root, path))));
 
@@ -38,6 +42,7 @@ const [client, host, patch, manifestText, lockText, hostSource, clientSource, ex
   stat(resolve(root, 'bin/dsh-im.mjs')),
 ]);
 const manifest = JSON.parse(manifestText);
+const lock = JSON.parse(lockText);
 
 if (!client.includes('id: "@xmanrui/dsh-im"')) {
   throw new Error('client bundle does not register the dsh-im loader id');
@@ -55,7 +60,7 @@ if (!client.includes('container-type: inline-size')
   || !client.includes('@container (max-width: 680px)')) {
   throw new Error('client bundle does not contain the narrow-panel DingTalk QR layout');
 }
-for (const marker of ['/feishu', '/weixin', '/dingtalk', '/wecom', '/qq', '/telegram', '/discord']) {
+for (const marker of ['/feishu', '/weixin', '/dingtalk', '/wecom', '/qq', '/telegram', '/discord', '/whatsapp']) {
   if (!host.includes(marker)) {
     throw new Error(`host bundle does not contain the internal ${marker} RPC provider`);
   }
@@ -77,7 +82,6 @@ for (const name of ['@xmanrui/dsh-feishu', '@xmanrui/dsh-weixin', '@xmanrui/dsh-
   }
 }
 const directDependencies = {
-  '@larksuiteoapi/node-sdk': '1.73.0',
   'dingtalk-stream': '2.1.4',
   '@tencent-connect/qqbot-connector': '1.2.0',
   '@tencent-connect/qqbot-nodejs': '1.0.4',
@@ -89,9 +93,31 @@ for (const [name, version] of Object.entries(directDependencies)) {
     throw new Error(`${name} must be a pinned direct dependency at ${version}`);
   }
 }
+const bundledBuildDependencies = {
+  '@larksuiteoapi/node-sdk': '1.73.0',
+  '@whiskeysockets/baileys': '7.0.0-rc14',
+};
+for (const [name, version] of Object.entries(bundledBuildDependencies)) {
+  if (manifest.dependencies?.[name] !== undefined) {
+    throw new Error(`${name} must not remain a runtime dependency`);
+  }
+  if (manifest.devDependencies?.[name] !== version) {
+    throw new Error(`${name} must be a pinned build dependency at ${version}`);
+  }
+}
+if (lock.packages?.['node_modules/protobufjs']?.dev !== true) {
+  throw new Error('protobufjs must remain build-only in the package lock');
+}
+if (manifest.bin?.['dsh-im'] !== 'bin/dsh-im.mjs') {
+  throw new Error('package manifest must publish the dsh-im executable');
+}
+if (/(?:from\s*|import\s*\(|require\s*\()\s*["'](?:@larksuiteoapi\/node-sdk|@whiskeysockets\/baileys|protobufjs)(?:\/[^"']*)?["']/.test(host)) {
+  throw new Error('host bundle must not import a bundled SDK or protobufjs at runtime');
+}
 if ((executable.mode & 0o111) === 0) throw new Error('dsh-im CLI is not executable');
 if (/private-bot-token|must-be-rolled-back|DEEPSEEK_API_KEY=/.test(client + host)) {
   throw new Error('built artifacts contain a test or environment secret marker');
 }
+await import(pathToFileURL(resolve(root, 'lib/index.js')).href);
 
 console.log('Verified dsh-im package artifacts.');

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

@@ -108,7 +108,7 @@ export class DiscordApi {
         headers: {
           authorization: `Bot ${this.#token}`,
           'content-type': 'application/json',
-          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.1.0)',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.2.0)',
         },
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),

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

@@ -92,7 +92,7 @@ function authenticatedHeaders(token) {
 function baseInfo() {
   return {
     channel_version: WEIXIN_PROTOCOL_VERSION,
-    bot_agent: 'DeepSeekHarness/0.1.0',
+    bot_agent: 'DeepSeekHarness/0.2.0',
   };
 }
 

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

@@ -0,0 +1,165 @@
+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: 2, bots: Object.freeze([]) });
+const BOT_ID_PATTERN = /^whatsapp_[a-f0-9]{24}$/;
+const AUTH_DIRECTORY_PATTERN = /^[a-f0-9-]{36}$/;
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+export function normalizeWhatsappAccountJid(value) {
+  const jid = cleanString(value)?.toLowerCase();
+  return /^\d{5,32}@(s\.whatsapp\.net|lid)$/.test(jid ?? '') ? jid : null;
+}
+
+export function deriveWhatsappBotId(accountJid) {
+  const normalized = normalizeWhatsappAccountJid(accountJid);
+  if (!normalized) throw new TypeError('A valid WhatsApp account JID is required');
+  return `whatsapp_${createHash('sha256').update(normalized).digest('hex').slice(0, 24)}`;
+}
+
+export function maskWhatsappAccount(accountJid) {
+  const digits = normalizeWhatsappAccountJid(accountJid)?.split('@')[0] ?? '';
+  if (!digits) return 'WhatsApp账号';
+  if (digits.length <= 7) return `${digits.slice(0, 2)}•••${digits.slice(-2)}`;
+  return `${digits.slice(0, 4)}••••${digits.slice(-4)}`;
+}
+
+export class WhatsappConfigStore {
+  #path;
+  #value = EMPTY_DOCUMENT;
+  #writeQueue = Promise.resolve();
+
+  constructor(path) {
+    this.#path = path;
+  }
+
+  async load() {
+    try {
+      const normalized = this.#normalizeDocument(JSON.parse(await readFile(this.#path, 'utf8')));
+      if (!normalized) throw new Error('dsh-im WhatsApp 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.bots);
+  }
+
+  get(botId) {
+    const bot = this.#value.bots.find((candidate) => candidate.botId === botId);
+    return bot ? structuredClone(bot) : null;
+  }
+
+  getByAccountJid(accountJid) {
+    const normalized = normalizeWhatsappAccountJid(accountJid);
+    const bot = this.#value.bots.find((candidate) => candidate.accountJid === normalized);
+    return bot ? structuredClone(bot) : null;
+  }
+
+  async save(value) {
+    const normalized = this.#normalizeBot(value);
+    if (!normalized) throw new Error('Refusing to persist incomplete WhatsApp account data');
+    return this.#mutate((bots) => {
+      const duplicate = bots.find((bot) => bot.accountJid === normalized.accountJid
+        && bot.botId !== normalized.botId);
+      const authCollision = bots.find((bot) => bot.authDirectory === normalized.authDirectory
+        && bot.botId !== normalized.botId);
+      if (duplicate || authCollision) throw new Error('Duplicate WhatsApp account 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 (!BOT_ID_PATTERN.test(botId)) throw new TypeError('Invalid WhatsApp 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;
+  }
+
+  #normalizeBot(value) {
+    if (!value || typeof value !== 'object') return null;
+    const accountJid = normalizeWhatsappAccountJid(value.accountJid);
+    const botId = cleanString(value.botId);
+    const authDirectory = cleanString(value.authDirectory);
+    const name = cleanString(value.name);
+    if (!accountJid || !botId || !authDirectory || !name
+      || !BOT_ID_PATTERN.test(botId) || !AUTH_DIRECTORY_PATTERN.test(authDirectory)
+      || deriveWhatsappBotId(accountJid) !== botId) return null;
+    return Object.freeze({
+      botId,
+      accountJid,
+      authDirectory,
+      name,
+      createdAt: cleanString(value.createdAt) ?? new Date().toISOString(),
+      connectedAt: cleanString(value.connectedAt),
+    });
+  }
+
+  #normalizeDocument(value) {
+    if (!value || value.version !== 2 || !Array.isArray(value.bots)) return null;
+    const bots = value.bots.map((bot) => this.#normalizeBot(bot));
+    if (bots.some((bot) => bot === null)) return null;
+    const botIds = new Set();
+    const accountJids = new Set();
+    const authDirectories = new Set();
+    for (const bot of bots) {
+      if (botIds.has(bot.botId) || accountJids.has(bot.accountJid)
+        || authDirectories.has(bot.authDirectory)) return null;
+      botIds.add(bot.botId);
+      accountJids.add(bot.accountJid);
+      authDirectories.add(bot.authDirectory);
+    }
+    return Object.freeze({ version: 2, bots: Object.freeze(bots) });
+  }
+
+  async #mutate(mutator) {
+    let result;
+    const operation = this.#writeQueue.then(async () => {
+      const bots = [...this.#value.bots];
+      result = mutator(bots);
+      const document = Object.freeze({ version: 2, 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/whatsapp/harness-client.mjs

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

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

@@ -0,0 +1,3 @@
+import { ConversationStateStore } from '../shared/conversation-state-store.mjs';
+
+export class WhatsappStateStore extends ConversationStateStore {}

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

@@ -0,0 +1,15 @@
+import { createTextBridgeStatus, TextHarnessBridge } from '../shared/text-harness-bridge.mjs';
+
+export const WHATSAPP_DESCRIPTOR = Object.freeze({
+  key: 'whatsapp',
+  label: 'WhatsApp',
+  connectionLabel: ' Web 关联设备',
+});
+
+export class WhatsappHarnessBridge extends TextHarnessBridge {
+  constructor(options) {
+    super({ ...options, descriptor: WHATSAPP_DESCRIPTOR });
+  }
+}
+
+export { createTextBridgeStatus as createWhatsappBridgeStatus };