@xmanrui/dsh-im 0.1.0

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

@@ -0,0 +1,119 @@
+import { unlink } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import { WeixinConfigStore } from '../../../../src/channels/weixin/config-store.mjs';
+import { HarnessClient } from '../../../../src/channels/weixin/harness-client.mjs';
+import { WeixinStateStore } from '../../../../src/channels/weixin/state-store.mjs';
+import { createWeixinApi } from '../../../../src/channels/weixin/weixin-api.mjs';
+import { WeixinController } from '../../../../src/channels/weixin/weixin-controller.mjs';
+import { WeixinRuntime } from '../../../../src/channels/weixin/weixin-runtime.mjs';
+import { createConnectionSupervisor } from './connection-supervisor.mjs';
+
+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-weixin 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-weixin'));
+  return {
+    root,
+    config: resolve(config.configPath ?? join(root, 'config.json')),
+    accounts: resolve(config.accountsDir ?? join(root, 'accounts')),
+  };
+}
+
+export async function createProductionController(ctx, config = {}, internals = {}) {
+  if (!ctx?.credentials) throw new TypeError('dsh-weixin requires ctx.credentials');
+  if (!ctx?.webServer) throw new TypeError('dsh-weixin requires ctx.webServer');
+
+  const ConfigStore = internals.ConfigStore ?? WeixinConfigStore;
+  const StateStore = internals.StateStore ?? WeixinStateStore;
+  const Harness = internals.HarnessClient ?? HarnessClient;
+  const Controller = internals.Controller ?? WeixinController;
+  const Runtime = internals.Runtime ?? WeixinRuntime;
+  const api = internals.api ?? createWeixinApi();
+  const createSupervisor = internals.createConnectionSupervisor ?? createConnectionSupervisor;
+  const logger = typeof ctx.logger === 'function'
+    ? ctx.logger('dsh-weixin')
+    : (ctx.logger ?? console);
+  const paths = pluginPaths(config);
+  const configStore = await new ConfigStore(paths.config).load();
+  const stateStores = new Map();
+
+  const statePath = (botId) => resolve(paths.accounts, 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({
+    api,
+    credentials: ctx.credentials,
+    configStore,
+    logger,
+    createRuntime: async ({ botId, config: accountConfig, token }) => {
+      const state = await stateFor(botId);
+      return new Runtime({
+        api,
+        config: accountConfig,
+        token,
+        harness,
+        state,
+        replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+        maxMessageChars: config.maxMessageChars ?? 4_000,
+        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),
+        },
+      });
+    },
+    deleteState: async ({ botId }) => {
+      const state = stateStores.get(botId);
+      stateStores.delete(botId);
+      if (state && typeof state.remove === 'function') {
+        await state.remove();
+        return;
+      }
+      try {
+        await unlink(statePath(botId));
+      } catch (error) {
+        if (error?.code !== 'ENOENT') throw error;
+      }
+    },
+  });
+  const supervisor = createSupervisor({
+    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/weixin/rpc.mjs

@@ -0,0 +1,178 @@
+import QRCode from 'qrcode';
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+
+export const WEIXIN_RPC_CHANNEL = '/weixin';
+export const WEIXIN_ENDPOINTS = Object.freeze({
+  status: 'connection.status',
+  beginProvisioning: 'provision.begin',
+  pollProvisioning: 'provision.poll',
+  submitVerification: 'provision.verify',
+  cancelProvisioning: 'provision.cancel',
+  reconnectBot: 'bot.reconnect',
+  deleteBot: 'bot.delete',
+});
+export const WEIXIN_RPC_ENDPOINTS = Object.freeze(Object.values(WEIXIN_ENDPOINTS));
+
+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 (endpoint === WEIXIN_ENDPOINTS.status) {
+    return exactKeys(payload, []) ? null : 'connection.status does not accept fields.';
+  }
+  if (endpoint === WEIXIN_ENDPOINTS.beginProvisioning) {
+    return exactKeys(payload, ['locale']) && (payload.locale === undefined || payload.locale === 'zh-CN')
+      ? null
+      : 'provision.begin received unsupported fields.';
+  }
+  if ([WEIXIN_ENDPOINTS.pollProvisioning, WEIXIN_ENDPOINTS.cancelProvisioning].includes(endpoint)) {
+    return exactKeys(payload, ['attemptId']) && validId(payload.attemptId)
+      ? null
+      : `${endpoint} requires an attemptId.`;
+  }
+  if (endpoint === WEIXIN_ENDPOINTS.submitVerification) {
+    return exactKeys(payload, ['attemptId', 'verifyCode'])
+      && validId(payload.attemptId)
+      && typeof payload.verifyCode === 'string'
+      && /^\d{4,8}$/.test(payload.verifyCode)
+      ? null
+      : 'provision.verify requires an attemptId and a 4-to-8-digit code.';
+  }
+  if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
+    return exactKeys(payload, ['botId']) && validId(payload.botId)
+      ? null
+      : 'bot.reconnect requires a botId.';
+  }
+  if (endpoint === WEIXIN_ENDPOINTS.deleteBot) {
+    return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
+      ? null
+      : 'bot.delete requires a botId and confirm=true.';
+  }
+  return 'Unknown Weixin endpoint.';
+}
+
+function badRequest(message) {
+  return { ok: false, error: { code: 'bad-request', message } };
+}
+
+function cancelled() {
+  return { ok: false, error: { code: 'cancelled', message: 'The request was cancelled.' } };
+}
+
+function internalFailure() {
+  return {
+    ok: false,
+    error: { code: 'weixin-operation-failed', message: '微信操作失败，请稍后重试。' },
+  };
+}
+
+async function qrDataUrl(value) {
+  return QRCode.toDataURL(value, {
+    type: 'image/png',
+    errorCorrectionLevel: 'M',
+    margin: 2,
+    width: 320,
+  });
+}
+
+async function withEncodedQr(value, encodeQr) {
+  if (!value || !value.verificationUrl) return value;
+  return {
+    ...value,
+    qrCodeDataUrl: await encodeQr(value.verificationUrl),
+  };
+}
+
+async function publicStatus(status, encodeQr) {
+  const safe = structuredClone(status);
+  if (safe.provisioning) safe.provisioning = await withEncodedQr(safe.provisioning, encodeQr);
+  return safe;
+}
+
+function assertController(controller) {
+  if (!controller
+    || typeof controller.status !== 'function'
+    || typeof controller.startProvisioning !== 'function'
+    || typeof controller.registrationStatus !== 'function'
+    || typeof controller.submitVerification !== 'function'
+    || typeof controller.cancelProvisioning !== 'function'
+    || typeof controller.reconnectBot !== 'function'
+    || typeof controller.deleteBot !== 'function') {
+    throw new TypeError('A complete Weixin controller is required');
+  }
+}
+
+export function createWeixinRpcHandler(controller, { encodeQr = qrDataUrl } = {}) {
+  assertController(controller);
+  const qrCache = new Map();
+  const cachedEncode = (url) => {
+    let encoded = qrCache.get(url);
+    if (!encoded) {
+      if (qrCache.size >= 16) qrCache.delete(qrCache.keys().next().value);
+      encoded = Promise.resolve().then(() => encodeQr(url));
+      qrCache.set(url, encoded);
+    }
+    return encoded;
+  };
+
+  return async (endpoint, payload, signal) => {
+    if (signal?.aborted) return cancelled();
+    if (!WEIXIN_RPC_ENDPOINTS.includes(endpoint)) return badRequest('Unknown Weixin endpoint.');
+    const invalid = payloadFailure(endpoint, payload);
+    if (invalid) return badRequest(invalid);
+
+    try {
+      let value;
+      if (endpoint === WEIXIN_ENDPOINTS.status) {
+        value = await publicStatus(await controller.status(), cachedEncode);
+      } else if (endpoint === WEIXIN_ENDPOINTS.beginProvisioning) {
+        const started = await controller.startProvisioning();
+        if (signal?.aborted) {
+          await controller.cancelProvisioning(started.attemptId);
+          return cancelled();
+        }
+        value = await withEncodedQr(started, cachedEncode);
+      } else if (endpoint === WEIXIN_ENDPOINTS.pollProvisioning) {
+        const current = await controller.registrationStatus(payload.attemptId);
+        if (!current) return badRequest('The provisioning attempt no longer exists.');
+        value = await withEncodedQr(current, cachedEncode);
+      } else if (endpoint === WEIXIN_ENDPOINTS.submitVerification) {
+        value = await withEncodedQr(
+          await controller.submitVerification(payload.attemptId, payload.verifyCode),
+          cachedEncode,
+        );
+      } else if (endpoint === WEIXIN_ENDPOINTS.cancelProvisioning) {
+        value = await controller.cancelProvisioning(payload.attemptId);
+        if (!value) return badRequest('The provisioning attempt no longer exists.');
+      } else if (endpoint === WEIXIN_ENDPOINTS.reconnectBot) {
+        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else {
+        value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
+      }
+      return signal?.aborted ? cancelled() : { ok: true, value };
+    } catch {
+      return signal?.aborted ? cancelled() : internalFailure();
+    }
+  };
+}
+
+export function installWeixinRpc(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(
+    WEIXIN_RPC_CHANNEL,
+    createWeixinRpcHandler(controller, options),
+    { authority: resolveRpcAuthority(authority) },
+  );
+}

package/plugin-src/host/index.mjs

@@ -0,0 +1,44 @@
+import { apply as applyDingtalk } from './channels/dingtalk/index.mjs';
+import { apply as applyDiscord } from './channels/discord/index.mjs';
+import { apply as applyFeishu } from './channels/feishu/index.mjs';
+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';
+
+export const name = 'dsh-im-host';
+export const inject = ['connection', 'credentials', 'webServer'];
+
+function channelConfig(config, name) {
+  const channel = config[name] ?? {};
+  return config.rpcAuthority === undefined
+    ? channel
+    : { ...channel, rpcAuthority: config.rpcAuthority };
+}
+
+export function createImHostPlugin(internals = {}) {
+  const startFeishu = internals.applyFeishu ?? applyFeishu;
+  const startWeixin = internals.applyWeixin ?? applyWeixin;
+  const startDingtalk = internals.applyDingtalk ?? applyDingtalk;
+  const startWecom = internals.applyWecom ?? applyWecom;
+  const startQq = internals.applyQq ?? applyQq;
+  const startTelegram = internals.applyTelegram ?? applyTelegram;
+  const startDiscord = internals.applyDiscord ?? applyDiscord;
+  return Object.freeze({
+    name,
+    inject,
+    async apply(ctx, config = {}) {
+      await startFeishu(ctx, channelConfig(config, 'feishu'));
+      await startWeixin(ctx, channelConfig(config, 'weixin'));
+      await startDingtalk(ctx, channelConfig(config, 'dingtalk'));
+      await startWecom(ctx, channelConfig(config, 'wecom'));
+      await startQq(ctx, channelConfig(config, 'qq'));
+      await startTelegram(ctx, channelConfig(config, 'telegram'));
+      await startDiscord(ctx, channelConfig(config, 'discord'));
+    },
+  });
+}
+
+export async function apply(ctx, config = {}) {
+  return createImHostPlugin().apply(ctx, config);
+}

package/plugin-src/host/rpc-authority.mjs

@@ -0,0 +1,11 @@
+const RPC_AUTHORITIES = new Set(['loopback', 'trusted-host']);
+
+/**
+ * Resolve the browser authority accepted by an IM management RPC channel.
+ * The default keeps credential and bot-management operations on loopback.
+ */
+export function resolveRpcAuthority(value) {
+  if (value === undefined) return 'loopback';
+  if (RPC_AUTHORITIES.has(value)) return value;
+  throw new TypeError('dsh-im rpcAuthority must be "loopback" or "trusted-host"');
+}

package/scripts/verify-package.mjs

@@ -0,0 +1,97 @@
+import { access, readFile, stat } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const root = resolve(import.meta.dirname, '..');
+const required = [
+  'lib/index.js',
+  'lib/client.js',
+  'bin/dsh-im.mjs',
+  'cordis.patch.yml',
+  'README.md',
+  'THIRD_PARTY_NOTICES.md',
+  'plugin-src/client/channels/dingtalk/index.js',
+  'plugin-src/host/channels/feishu/index.mjs',
+  'plugin-src/host/channels/weixin/index.mjs',
+  'plugin-src/host/channels/dingtalk/index.mjs',
+  'plugin-src/host/channels/qq/index.mjs',
+  'plugin-src/host/channels/wecom/index.mjs',
+  'plugin-src/host/channels/telegram/index.mjs',
+  'plugin-src/host/channels/discord/index.mjs',
+  'src/channels/feishu/feishu-runtime.mjs',
+  'src/channels/weixin/weixin-runtime.mjs',
+  'src/channels/dingtalk/dingtalk-runtime.mjs',
+  'src/channels/qq/qq-runtime.mjs',
+  'src/channels/wecom/wecom-runtime.mjs',
+  'src/channels/telegram/telegram-runtime.mjs',
+  'src/channels/discord/discord-runtime.mjs',
+];
+await Promise.all(required.map((path) => access(resolve(root, path))));
+
+const [client, host, patch, manifestText, lockText, hostSource, clientSource, executable] = await Promise.all([
+  readFile(resolve(root, 'lib/client.js'), 'utf8'),
+  readFile(resolve(root, 'lib/index.js'), 'utf8'),
+  readFile(resolve(root, 'cordis.patch.yml'), 'utf8'),
+  readFile(resolve(root, 'package.json'), 'utf8'),
+  readFile(resolve(root, 'package-lock.json'), 'utf8'),
+  readFile(resolve(root, 'plugin-src/host/index.mjs'), 'utf8'),
+  readFile(resolve(root, 'plugin-src/client/index.js'), 'utf8'),
+  stat(resolve(root, 'bin/dsh-im.mjs')),
+]);
+const manifest = JSON.parse(manifestText);
+
+if (!client.includes('id: "@xmanrui/dsh-im"')) {
+  throw new Error('client bundle does not register the dsh-im loader id');
+}
+if (!client.includes('id: "im"') || !client.includes('label: "IM\\u673A\\u5668\\u4EBA"')) {
+  throw new Error('client bundle does not register the IM机器人 settings tab');
+}
+if ((client.match(/ctx\.slots\.inject\("settings\.plugins\.tab"/g) ?? []).length !== 1) {
+  throw new Error('client bundle must register exactly one settings tab');
+}
+if (/role:\s*["']switch|type:\s*["']checkbox/.test(client)) {
+  throw new Error('client bundle contains a channel enable switch');
+}
+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']) {
+  if (!host.includes(marker)) {
+    throw new Error(`host bundle does not contain the internal ${marker} RPC provider`);
+  }
+}
+if (/@xmanrui\/dsh-(?:feishu|weixin|dingtalk)/.test(host)) {
+  throw new Error('host bundle still imports an external channel plugin');
+}
+if (/@xmanrui\/dsh-(?:feishu|weixin|dingtalk)/.test(
+  manifestText + lockText + hostSource + clientSource,
+)) {
+  throw new Error('source or package metadata still depends on an external channel plugin');
+}
+if (!patch.includes("name: '@xmanrui/dsh-im'") || /dsh-(?:feishu|weixin|dingtalk)/.test(patch)) {
+  throw new Error('bundle patch must activate only dsh-im');
+}
+for (const name of ['@xmanrui/dsh-feishu', '@xmanrui/dsh-weixin', '@xmanrui/dsh-dingtalk']) {
+  if (manifest.dependencies?.[name]) {
+    throw new Error(`${name} must not remain an external dependency`);
+  }
+}
+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',
+  '@wecom/aibot-node-sdk': '1.0.7',
+  qrcode: '1.5.4',
+};
+for (const [name, version] of Object.entries(directDependencies)) {
+  if (manifest.dependencies?.[name] !== version) {
+    throw new Error(`${name} must be a pinned direct dependency at ${version}`);
+  }
+}
+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');
+}
+
+console.log('Verified dsh-im package artifacts.');