@xmanrui/dsh-im 0.1.0

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

@@ -0,0 +1,237 @@
+import QRCode from 'qrcode';
+import { resolveRpcAuthority } from '../../rpc-authority.mjs';
+
+export const DINGTALK_RPC_CHANNEL = '/dingtalk';
+export const DINGTALK_ENDPOINTS = Object.freeze({
+  status: 'connection.status',
+  beginProvisioning: 'provision.begin',
+  pollProvisioning: 'provision.poll',
+  cancelProvisioning: 'provision.cancel',
+  bindCredentials: 'bot.bind-credentials',
+  reconnectBot: 'bot.reconnect',
+  deleteBot: 'bot.delete',
+  approveSender: 'bot.sender.approve',
+  revokeSender: 'bot.sender.revoke',
+});
+export const DINGTALK_RPC_ENDPOINTS = Object.freeze(Object.values(DINGTALK_ENDPOINTS));
+
+const FORBIDDEN_PUBLIC_KEYS = new Set([
+  'clientSecret',
+  'client_secret',
+  'deviceCode',
+  'device_code',
+  'secretRef',
+  'staffId',
+  'senderStaffId',
+  'verificationUrl',
+  'verificationUri',
+  'userCode',
+]);
+
+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 validCredential(value, maxLength) {
+  return typeof value === 'string' && value.trim().length > 0 && value.length <= maxLength;
+}
+
+function payloadFailure(endpoint, payload) {
+  if (!isRecord(payload)) return 'Payload must be an object.';
+  if (endpoint === DINGTALK_ENDPOINTS.status) {
+    return exactKeys(payload, []) ? null : 'connection.status does not accept fields.';
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.beginProvisioning) {
+    return exactKeys(payload, ['locale']) && (payload.locale === undefined || payload.locale === 'zh-CN')
+      ? null
+      : 'provision.begin received unsupported fields.';
+  }
+  if ([DINGTALK_ENDPOINTS.pollProvisioning, DINGTALK_ENDPOINTS.cancelProvisioning].includes(endpoint)) {
+    return exactKeys(payload, ['attemptId']) && validId(payload.attemptId)
+      ? null
+      : `${endpoint} requires an attemptId.`;
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.bindCredentials) {
+    return exactKeys(payload, ['clientId', 'clientSecret'])
+      && validCredential(payload.clientId, 256)
+      && validCredential(payload.clientSecret, 1024)
+      ? null
+      : 'bot.bind-credentials requires Client ID and Client Secret.';
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.reconnectBot) {
+    return exactKeys(payload, ['botId']) && validId(payload.botId)
+      ? null
+      : 'bot.reconnect requires a botId.';
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.deleteBot) {
+    return exactKeys(payload, ['botId', 'confirm']) && validId(payload.botId) && payload.confirm === true
+      ? null
+      : 'bot.delete requires a botId and confirm=true.';
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.approveSender) {
+    return exactKeys(payload, ['botId', 'requestId', 'confirm'])
+      && validId(payload.botId)
+      && validId(payload.requestId)
+      && payload.confirm === true
+      ? null
+      : 'bot.sender.approve requires botId, requestId, and confirm=true.';
+  }
+  if (endpoint === DINGTALK_ENDPOINTS.revokeSender) {
+    return exactKeys(payload, ['botId', 'senderKey', 'confirm'])
+      && validId(payload.botId)
+      && validId(payload.senderKey)
+      && payload.confirm === true
+      ? null
+      : 'bot.sender.revoke requires botId, senderKey, and confirm=true.';
+  }
+  return 'Unknown DingTalk 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: 'dingtalk-operation-failed', message: '钉钉操作失败，请稍后重试。' },
+  };
+}
+
+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 withEncodedQr(value, encodeQr) {
+  if (!value || typeof value.verificationUrl !== 'string') return sanitizePublic(value);
+  return sanitizePublic({
+    ...value,
+    qrCodeDataUrl: await encodeQr(value.verificationUrl),
+  });
+}
+
+async function publicStatus(status, encodeQr) {
+  const value = structuredClone(status);
+  if (value?.provisioning) {
+    value.provisioning = await withEncodedQr(value.provisioning, encodeQr);
+  }
+  return sanitizePublic(value);
+}
+
+function assertController(controller) {
+  for (const method of [
+    'status',
+    'startProvisioning',
+    'registrationStatus',
+    'cancelProvisioning',
+    'bindCredentials',
+    'reconnectBot',
+    'deleteBot',
+    'approveSender',
+    'revokeSender',
+  ]) {
+    if (typeof controller?.[method] !== 'function') {
+      throw new TypeError(`A complete DingTalk controller is required (${method})`);
+    }
+  }
+}
+
+export function createDingtalkRpcHandler(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 (!DINGTALK_RPC_ENDPOINTS.includes(endpoint)) return badRequest('Unknown DingTalk endpoint.');
+    const invalid = payloadFailure(endpoint, payload);
+    if (invalid) return badRequest(invalid);
+
+    try {
+      let value;
+      if (endpoint === DINGTALK_ENDPOINTS.status) {
+        value = await publicStatus(await controller.status(), cachedEncode);
+      } else if (endpoint === DINGTALK_ENDPOINTS.beginProvisioning) {
+        const started = await controller.startProvisioning({ signal });
+        if (signal?.aborted) {
+          await controller.cancelProvisioning(started.attemptId);
+          return cancelled();
+        }
+        value = await withEncodedQr(started, cachedEncode);
+      } else if (endpoint === DINGTALK_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 === DINGTALK_ENDPOINTS.cancelProvisioning) {
+        value = await controller.cancelProvisioning(payload.attemptId);
+        if (!value) return badRequest('The provisioning attempt no longer exists.');
+        value = sanitizePublic(value);
+      } else if (endpoint === DINGTALK_ENDPOINTS.bindCredentials) {
+        value = await publicStatus(await controller.bindCredentials(payload), cachedEncode);
+      } else if (endpoint === DINGTALK_ENDPOINTS.reconnectBot) {
+        value = await publicStatus(await controller.reconnectBot(payload.botId), cachedEncode);
+      } else if (endpoint === DINGTALK_ENDPOINTS.deleteBot) {
+        value = await publicStatus(await controller.deleteBot(payload.botId), cachedEncode);
+      } else if (endpoint === DINGTALK_ENDPOINTS.approveSender) {
+        value = await publicStatus(
+          await controller.approveSender(payload.botId, payload.requestId),
+          cachedEncode,
+        );
+      } else {
+        value = await publicStatus(
+          await controller.revokeSender(payload.botId, payload.senderKey),
+          cachedEncode,
+        );
+      }
+      return signal?.aborted ? cancelled() : { ok: true, value };
+    } catch {
+      return signal?.aborted ? cancelled() : internalFailure();
+    }
+  };
+}
+
+export function installDingtalkRpc(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(
+    DINGTALK_RPC_CHANNEL,
+    createDingtalkRpcHandler(controller, options),
+    { authority: resolveRpcAuthority(authority) },
+  );
+}

package/plugin-src/host/channels/discord/index.mjs

@@ -0,0 +1,30 @@
+import { createProductionController } from './production.mjs';
+import { installDiscordRpc } from './rpc.mjs';
+
+export const name = 'dsh-im-discord-host';
+export const inject = ['connection', 'credentials', 'webServer'];
+
+export async function apply(ctx, config = {}) {
+  if (config?.controller) {
+    return installDiscordRpc(ctx, config.controller, config.rpcAuthority);
+  }
+  const production = await createProductionController(ctx, config, config.internals ?? {});
+  const disposeRpc = installDiscordRpc(ctx, production.controller, config.rpcAuthority);
+  ctx.effect(() => async () => production.close(), 'dsh-im: close Discord bot connections');
+  return disposeRpc;
+}
+
+export function createDiscordHostPlugin(config) {
+  return Object.freeze({ name, inject, apply: (ctx) => apply(ctx, config) });
+}
+
+export { createProductionController } from './production.mjs';
+export {
+  DISCORD_ENDPOINTS,
+  DISCORD_RPC_CHANNEL,
+  DISCORD_RPC_ENDPOINTS,
+  createDiscordRpcHandler,
+  installDiscordRpc,
+} from './rpc.mjs';
+export { DiscordController } from '../../../../src/channels/discord/discord-controller.mjs';
+export { DiscordRuntime } from '../../../../src/channels/discord/discord-runtime.mjs';

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

@@ -0,0 +1,17 @@
+import { DiscordConfigStore } from '../../../../src/channels/discord/config-store.mjs';
+import { DiscordController } from '../../../../src/channels/discord/discord-controller.mjs';
+import { DiscordHarnessClient } from '../../../../src/channels/discord/harness-client.mjs';
+import { DiscordRuntime } from '../../../../src/channels/discord/discord-runtime.mjs';
+import { DiscordStateStore } from '../../../../src/channels/discord/state-store.mjs';
+import { createTokenProductionController } from '../shared/production.mjs';
+
+export function createProductionController(ctx, config = {}, internals = {}) {
+  return createTokenProductionController(ctx, config, internals, {
+    channel: 'discord',
+    ConfigStore: DiscordConfigStore,
+    StateStore: DiscordStateStore,
+    HarnessClient: DiscordHarnessClient,
+    Controller: DiscordController,
+    Runtime: DiscordRuntime,
+  });
+}

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

@@ -0,0 +1,21 @@
+import {
+  TOKEN_BOT_ENDPOINTS,
+  createTokenBotRpcHandler,
+  installTokenBotRpc,
+} from '../shared/rpc.mjs';
+
+export const DISCORD_RPC_CHANNEL = '/discord';
+export const DISCORD_ENDPOINTS = TOKEN_BOT_ENDPOINTS;
+export const DISCORD_RPC_ENDPOINTS = Object.freeze(Object.values(DISCORD_ENDPOINTS));
+
+export function createDiscordRpcHandler(controller) {
+  return createTokenBotRpcHandler(controller, { channel: 'Discord' });
+}
+
+export function installDiscordRpc(ctx, controller, authority) {
+  return installTokenBotRpc(ctx, controller, {
+    channel: 'Discord',
+    rpcChannel: DISCORD_RPC_CHANNEL,
+    authority,
+  });
+}

package/plugin-src/host/channels/feishu/connection-supervisor.mjs

@@ -0,0 +1,167 @@
+const DEFAULT_RETRY_DELAYS_MS = Object.freeze([250, 1_000, 3_000, 5_000, 10_000, 30_000]);
+
+function safeDelay(value, fallback) {
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+
+function safeRetryDelays(value) {
+  if (!Array.isArray(value) || value.length === 0) return [...DEFAULT_RETRY_DELAYS_MS];
+  const delays = value.map((delay) => safeDelay(delay, -1)).filter((delay) => delay >= 0);
+  return delays.length > 0 ? delays : [...DEFAULT_RETRY_DELAYS_MS];
+}
+
+function totals(status) {
+  const configured = Number.isInteger(status?.totals?.configured)
+    ? status.totals.configured
+    : (Array.isArray(status?.bots) ? status.bots.length : 0);
+  const connected = Number.isInteger(status?.totals?.connected)
+    ? status.totals.connected
+    : (Array.isArray(status?.bots)
+      ? status.bots.filter((bot) => bot?.connected === true).length
+      : 0);
+  return { configured, connected };
+}
+
+/**
+ * Starts bot connections only after the in-process Harness HTTP API is ready,
+ * then periodically reconciles failed/offline bots. Timers never keep the Host
+ * alive on their own and shutdown waits for an in-flight reconciliation.
+ */
+export class ConnectionSupervisor {
+  #controller;
+  #harness;
+  #logger;
+  #retryDelaysMs;
+  #healthyIntervalMs;
+  #setTimeout;
+  #clearTimeout;
+  #timer = null;
+  #running = null;
+  #retryIndex = 0;
+  #started = false;
+  #closed = false;
+  #ready;
+  #resolveReady;
+
+  constructor({
+    controller,
+    harness,
+    logger = console,
+    retryDelaysMs,
+    healthyIntervalMs = 15_000,
+    setTimeoutImpl = setTimeout,
+    clearTimeoutImpl = clearTimeout,
+  }) {
+    if (!controller
+      || typeof controller.initialize !== 'function'
+      || typeof controller.status !== 'function') {
+      throw new TypeError('ConnectionSupervisor requires a controller');
+    }
+    if (!harness || typeof harness.ensureRunning !== 'function') {
+      throw new TypeError('ConnectionSupervisor requires a Harness client');
+    }
+    this.#controller = controller;
+    this.#harness = harness;
+    this.#logger = logger;
+    this.#retryDelaysMs = safeRetryDelays(retryDelaysMs);
+    this.#healthyIntervalMs = safeDelay(healthyIntervalMs, 15_000);
+    this.#setTimeout = setTimeoutImpl;
+    this.#clearTimeout = clearTimeoutImpl;
+    this.#ready = new Promise((resolve) => {
+      this.#resolveReady = resolve;
+    });
+  }
+
+  get ready() {
+    return this.#ready;
+  }
+
+  start() {
+    if (this.#started || this.#closed) return this;
+    this.#started = true;
+    this.#schedule(0);
+    return this;
+  }
+
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    if (this.#timer !== null) {
+      this.#clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+    await this.#running?.catch(() => undefined);
+    this.#resolveReady?.(null);
+    this.#resolveReady = null;
+  }
+
+  #schedule(delayMs) {
+    if (this.#closed) return;
+    this.#timer = this.#setTimeout(() => {
+      this.#timer = null;
+      void this.#run();
+    }, delayMs);
+    this.#timer?.unref?.();
+  }
+
+  async #run() {
+    if (this.#closed || this.#running) return;
+    const operation = this.#reconcile();
+    this.#running = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.#running === operation) this.#running = null;
+    }
+  }
+
+  async #reconcile() {
+    try {
+      await this.#harness.ensureRunning();
+    } catch (error) {
+      if (this.#closed) return;
+      this.#retry('Harness Host is not ready', error);
+      return;
+    }
+    if (this.#closed) return;
+
+    try {
+      await this.#controller.initialize();
+      if (this.#closed) return;
+
+      const status = this.#controller.status();
+      this.#resolveReady?.(status);
+      this.#resolveReady = null;
+      const current = totals(status);
+      if (current.connected < current.configured) {
+        const delay = this.#retryDelaysMs[Math.min(this.#retryIndex, this.#retryDelaysMs.length - 1)];
+        this.#retryIndex += 1;
+        this.#logger.warn?.(
+          `[dsh-feishu] ${current.connected}/${current.configured} bots connected; retrying automatically in ${delay}ms`,
+        );
+        this.#schedule(delay);
+        return;
+      }
+
+      this.#retryIndex = 0;
+      this.#schedule(this.#healthyIntervalMs);
+    } catch (error) {
+      if (this.#closed) return;
+      this.#retry('Bot connection reconciliation failed', error);
+    }
+  }
+
+  #retry(message, error) {
+    const delay = this.#retryDelaysMs[Math.min(this.#retryIndex, this.#retryDelaysMs.length - 1)];
+    this.#retryIndex += 1;
+    this.#logger.warn?.(
+      `[dsh-feishu] ${message}; retrying automatically in ${delay}ms`,
+      error,
+    );
+    this.#schedule(delay);
+  }
+}
+
+export function createConnectionSupervisor(options) {
+  return new ConnectionSupervisor(options);
+}

package/plugin-src/host/channels/feishu/controller.mjs

@@ -0,0 +1,172 @@
+const ACTIVE_REGISTRATION_STATES = new Set([
+  'starting',
+  'qr_ready',
+  'polling',
+  'slow_down',
+  'domain_switched',
+]);
+
+function credentialResult(result) {
+  const appId = result?.client_id ?? result?.appId;
+  const appSecret = result?.client_secret ?? result?.appSecret;
+  if (typeof appId !== 'string' || appId.length === 0
+    || typeof appSecret !== 'string' || appSecret.length === 0) {
+    throw new TypeError('Feishu registration returned invalid credentials');
+  }
+  return {
+    appId,
+    appSecret,
+    userInfo: result?.user_info ?? result?.userInfo,
+  };
+}
+
+async function readConnectionStatus(connectionManager) {
+  if (typeof connectionManager.status !== 'function') return {};
+  return await connectionManager.status();
+}
+
+function isConnected(status) {
+  if (status?.connected === true) return true;
+  return status?.ready === true
+    && status?.feishuLongConnectionState === 'connected'
+    && status?.harnessReachable === true;
+}
+
+/**
+ * Minimal orchestration boundary between QR provisioning and the live bot.
+ *
+ * `createProvisioningManager` receives the only callback that can observe the
+ * App Secret.  The callback persists credentials and starts the long-lived
+ * connection before the provisioning manager may report `succeeded`.
+ */
+export class ProvisioningBackedController {
+  #credentialStore;
+  #connectionManager;
+  #registrationOptions;
+  #manager;
+  #knownConfigured = false;
+  #lastError = null;
+
+  constructor({
+    createProvisioningManager,
+    credentialStore,
+    connectionManager,
+    registrationOptions = {},
+  } = {}) {
+    if (typeof createProvisioningManager !== 'function') {
+      throw new TypeError('createProvisioningManager is required');
+    }
+    if (!credentialStore
+      || typeof credentialStore.save !== 'function'
+      || typeof credentialStore.clear !== 'function') {
+      throw new TypeError('credentialStore.save/clear are required');
+    }
+    if (!connectionManager
+      || typeof connectionManager.connect !== 'function'
+      || typeof connectionManager.disconnect !== 'function') {
+      throw new TypeError('connectionManager.connect/disconnect are required');
+    }
+    if (registrationOptions === null
+      || typeof registrationOptions !== 'object'
+      || Array.isArray(registrationOptions)) {
+      throw new TypeError('registrationOptions must be an object');
+    }
+
+    this.#credentialStore = credentialStore;
+    this.#connectionManager = connectionManager;
+    this.#registrationOptions = structuredClone(registrationOptions);
+    this.#manager = createProvisioningManager({
+      onCredentials: (result) => this.#acceptCredentials(result),
+    });
+    if (!this.#manager
+      || typeof this.#manager.start !== 'function'
+      || typeof this.#manager.status !== 'function'
+      || typeof this.#manager.cancel !== 'function') {
+      throw new TypeError('The provisioning manager must implement start/status/cancel');
+    }
+  }
+
+  async startRegistration() {
+    this.#lastError = null;
+    await this.#manager.start(structuredClone(this.#registrationOptions));
+    return this.status();
+  }
+
+  async cancelRegistration() {
+    await this.#manager.cancel();
+    return this.status();
+  }
+
+  async disconnect() {
+    await this.#manager.cancel();
+    await this.#connectionManager.disconnect();
+    try {
+      await this.#credentialStore.clear();
+      this.#knownConfigured = false;
+      this.#lastError = null;
+    } catch {
+      // Do not reflect a credential provider's error text across the RPC
+      // boundary.  It may include a backend path or secret reference detail.
+      this.#lastError = {
+        code: 'credential_removal_failed',
+        message: 'Unable to remove the Feishu credentials.',
+      };
+    }
+    return this.status();
+  }
+
+  async status() {
+    const registration = await this.#manager.status();
+    const connection = await readConnectionStatus(this.#connectionManager);
+    const connected = isConnected(connection);
+    let configured = this.#knownConfigured;
+    if (typeof this.#credentialStore.configured === 'function') {
+      try {
+        configured = await this.#credentialStore.configured();
+      } catch {
+        configured = this.#knownConfigured;
+      }
+    }
+
+    let phase = 'unconfigured';
+    if (connected) phase = 'connected';
+    else if (ACTIVE_REGISTRATION_STATES.has(registration?.state)) phase = 'registering';
+    else if (registration?.state === 'saving') phase = 'connecting';
+    else if (this.#lastError || registration?.state === 'error') phase = 'error';
+    else if (configured) phase = 'disconnected';
+
+    return {
+      phase,
+      connected,
+      configured,
+      registration,
+      connection,
+      error: this.#lastError ?? registration?.error ?? null,
+    };
+  }
+
+  async close() {
+    await this.#manager.cancel();
+    await this.#connectionManager.disconnect();
+  }
+
+  async #acceptCredentials(result) {
+    const credentials = credentialResult(result);
+    try {
+      await this.#credentialStore.save(credentials);
+      this.#knownConfigured = true;
+      await this.#connectionManager.connect(credentials);
+      this.#lastError = null;
+    } catch {
+      this.#lastError = {
+        code: 'connection_failed',
+        message: 'The bot was created, but its connection could not be started.',
+      };
+      throw new Error('Unable to activate the Feishu connection.');
+    }
+  }
+}
+
+export function createProvisioningBackedController(options) {
+  return new ProvisioningBackedController(options);
+}