@xmanrui/dsh-im 0.1.0

package/plugin-src/host/channels/feishu/credential-store.mjs

@@ -0,0 +1,84 @@
+/**
+ * Credential references owned by the Feishu Host plugin.  They deliberately
+ * use DSH's credential provider instead of plugin settings, so the browser's
+ * configuration plane can only observe configured/source metadata.
+ */
+export const FEISHU_APP_ID_REF = 'DSH_FEISHU_APP_ID';
+export const FEISHU_APP_SECRET_REF = 'DSH_FEISHU_APP_SECRET';
+
+function assertNonEmptyString(value, label) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}
+
+async function restore(provider, ref, previous) {
+  try {
+    if (previous?.value) await provider.set(ref, previous.value);
+    else await provider.unset(ref);
+  } catch {
+    // Preserve the original write failure.  The provider remains the source
+    // of truth and will report the partial state through describe().
+  }
+}
+
+/**
+ * Adapt the real DSH `ctx.credentials` seam to the small interface consumed
+ * by the Feishu controller.  Secret values only travel Host-to-Host here.
+ *
+ * @param {{resolve(Function), describe(Function), set(Function), unset(Function)}} provider
+ * @param {{appIdRef?: string, appSecretRef?: string}} options
+ */
+export function createDshCredentialStore(provider, options = {}) {
+  if (!provider
+    || typeof provider.resolve !== 'function'
+    || typeof provider.describe !== 'function'
+    || typeof provider.set !== 'function'
+    || typeof provider.unset !== 'function') {
+    throw new TypeError('A DSH credential provider is required');
+  }
+
+  const appIdRef = options.appIdRef ?? FEISHU_APP_ID_REF;
+  const appSecretRef = options.appSecretRef ?? FEISHU_APP_SECRET_REF;
+
+  return Object.freeze({
+    async save({ appId, appSecret }) {
+      const nextId = assertNonEmptyString(appId, 'Feishu App ID');
+      const nextSecret = assertNonEmptyString(appSecret, 'Feishu App Secret');
+      const [previousId, previousSecret] = await Promise.all([
+        provider.resolve(appIdRef),
+        provider.resolve(appSecretRef),
+      ]);
+
+      try {
+        // Store the secret first.  An App ID without its matching secret must
+        // never be treated as a usable integration.
+        await provider.set(appSecretRef, nextSecret);
+        await provider.set(appIdRef, nextId);
+      } catch {
+        await restore(provider, appSecretRef, previousSecret);
+        await restore(provider, appIdRef, previousId);
+        throw new Error('Unable to store the Feishu credentials.');
+      }
+    },
+
+    async clear() {
+      const outcomes = await Promise.allSettled([
+        provider.unset(appIdRef),
+        provider.unset(appSecretRef),
+      ]);
+      if (outcomes.some((outcome) => outcome.status === 'rejected')) {
+        throw new Error('Unable to remove the Feishu credentials.');
+      }
+    },
+
+    async configured() {
+      const [appId, appSecret] = await Promise.all([
+        provider.describe(appIdRef),
+        provider.describe(appSecretRef),
+      ]);
+      return appId.configured === true && appSecret.configured === true;
+    },
+  });
+}

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

@@ -0,0 +1,73 @@
+import { createProvisioningBackedController } from './controller.mjs';
+import { createProductionController } from './production.mjs';
+import { installFeishuRpc } from './rpc.mjs';
+
+export const name = 'dsh-feishu-host';
+export const inject = ['connection', 'credentials', 'webServer'];
+
+function controllerFrom(ctx, config) {
+  if (config?.controller) return config.controller;
+  if (typeof config?.createController === 'function') return config.createController();
+  if (typeof config?.createProvisioningManager === 'function') {
+    return createProvisioningBackedController(config);
+  }
+  // Cordis deliberately throws when a plugin reads an undeclared service,
+  // even through optional chaining. Production uses the explicit services in
+  // `inject`; test/programmatic controllers must therefore come from config.
+  return undefined;
+}
+
+/**
+ * Cordis/DSH Host plugin entry.  Production composition may supply an owned
+ * controller service; tests and embedded distributions may inject one through
+ * config without changing the Connection RPC boundary.
+ */
+export async function apply(ctx, config = {}) {
+  const controller = controllerFrom(ctx, config);
+  if (controller) {
+    return installFeishuRpc(ctx, controller, config.rpcOptions, config.rpcAuthority);
+  }
+
+  const production = await createProductionController(ctx, config);
+  const disposeRpc = installFeishuRpc(
+    ctx,
+    production.controller,
+    config.rpcOptions,
+    config.rpcAuthority,
+  );
+  ctx.effect(() => async () => {
+    await production.close();
+  }, 'dsh-feishu: close controller and live connection');
+  return disposeRpc;
+}
+
+/** Create a programmatic plugin module with dependencies closed over. */
+export function createFeishuHostPlugin(config) {
+  return Object.freeze({
+    name,
+    inject,
+    apply: (ctx) => apply(ctx, config),
+  });
+}
+
+export {
+  ProvisioningBackedController,
+  createProvisioningBackedController,
+} from './controller.mjs';
+export { createProductionController } from './production.mjs';
+export { ConnectionSupervisor, createConnectionSupervisor } from './connection-supervisor.mjs';
+export { MultiBotDshFeishuController } from '../../../../src/channels/feishu/multi-bot-controller.mjs';
+export {
+  FEISHU_APP_ID_REF,
+  FEISHU_APP_SECRET_REF,
+  createDshCredentialStore,
+} from './credential-store.mjs';
+export {
+  FEISHU_ENDPOINTS,
+  FEISHU_MULTI_ENDPOINTS,
+  FEISHU_RPC_CHANNEL,
+  FEISHU_RPC_ENDPOINTS,
+  createFeishuRpcHandler,
+  installFeishuRpc,
+  toPublicFeishuStatus,
+} from './rpc.mjs';

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

@@ -0,0 +1,138 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { unlink } from 'node:fs/promises';
+import * as Lark from '@larksuiteoapi/node-sdk';
+import { createConnectionSupervisor } from './connection-supervisor.mjs';
+import { verifyFeishuApp } from '../../../../src/channels/feishu/feishu-app.mjs';
+import { FeishuRuntime } from '../../../../src/channels/feishu/feishu-runtime.mjs';
+import { HarnessClient } from '../../../../src/channels/feishu/harness-client.mjs';
+import {
+  LEGACY_FEISHU_SECRET_REF,
+  PluginConfigStore,
+} from '../../../../src/channels/feishu/plugin-config-store.mjs';
+import { MultiBotDshFeishuController } from '../../../../src/channels/feishu/multi-bot-controller.mjs';
+import { StateStore } from '../../../../src/channels/feishu/state-store.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-feishu requires an initialized DSH webServer port');
+  }
+  // Even when DSH listens on all interfaces, its own plugin talks through the
+  // loopback authority accepted by Connection's request-trust fence.
+  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-feishu'));
+  return {
+    root,
+    config: resolve(config.configPath ?? join(root, 'config.json')),
+    legacyState: resolve(config.statePath ?? join(root, 'state.json')),
+    bots: resolve(config.botsDir ?? join(root, 'bots')),
+  };
+}
+
+/**
+ * Assemble the production controller from DSH Host services and local plugin
+ * classes. No bridge process or environment App credentials are required.
+ */
+export async function createProductionController(ctx, config = {}, internals = {}) {
+  if (!ctx?.credentials) throw new TypeError('dsh-feishu requires ctx.credentials');
+  if (!ctx?.webServer) throw new TypeError('dsh-feishu requires ctx.webServer');
+
+  const lark = internals.lark ?? Lark;
+  const Controller = internals.Controller ?? MultiBotDshFeishuController;
+  const ConfigStore = internals.ConfigStore ?? PluginConfigStore;
+  const SessionStateStore = internals.StateStore ?? StateStore;
+  const Harness = internals.HarnessClient ?? HarnessClient;
+  const Runtime = internals.FeishuRuntime ?? FeishuRuntime;
+  const verifyApp = internals.verifyFeishuApp ?? verifyFeishuApp;
+  const createSupervisor = internals.createConnectionSupervisor ?? createConnectionSupervisor;
+  const logger = typeof ctx.logger === 'function'
+    ? ctx.logger('dsh-feishu')
+    : (ctx.logger ?? console);
+  const paths = pluginPaths(config);
+  const configStore = await new ConfigStore(paths.config).load();
+  // State is lazy per bot. A corrupt legacy file can therefore fail only the
+  // migrated bot and cannot prevent healthy v2 bots from starting.
+  const stateStores = new Map();
+  const statePathFor = (botConfig) => !botConfig.id
+    || !botConfig.secretRef
+    || botConfig.secretRef === LEGACY_FEISHU_SECRET_REF
+    ? paths.legacyState
+    : resolve(paths.bots, botConfig.id, 'state.json');
+  const stateFor = async (botConfig) => {
+    const stateKey = botConfig.id ?? '__legacy__';
+    let state = stateStores.get(stateKey);
+    if (!state) {
+      state = await new SessionStateStore(statePathFor(botConfig)).load();
+      stateStores.set(stateKey, state);
+    }
+    return state;
+  };
+  const harness = new Harness({
+    baseUrl: harnessOrigin(ctx.webServer, config.harnessBaseUrl),
+    workspace: resolve(config.workspace ?? process.cwd()),
+    agentPreset: config.agentPreset ?? 'standard',
+    // This plugin is already hosted by a running DSH process. Starting a
+    // second DSH would create a competing server and lifecycle.
+    autostart: false,
+    dshBin: config.dshBin ?? 'dsh',
+  });
+
+  const controller = new Controller({
+    registerApp: (options) => lark.registerApp(options),
+    verifyApp,
+    credentials: ctx.credentials,
+    configStore,
+    createRuntime: async ({ botId, config: botConfig, appSecret }) => {
+      const state = await stateFor(botConfig);
+      return new Runtime({
+        lark,
+        appId: botConfig.appId,
+        appSecret,
+        domain: botConfig.domain,
+        ownerOpenIds: botConfig.ownerOpenIds ?? [botConfig.ownerOpenId],
+        harness,
+        state,
+        replyTimeoutMs: config.replyTimeoutMs ?? 600_000,
+        logger: {
+          error: (...args) => logger.error?.(`[${botId ?? botConfig.id}]`, ...args),
+          warn: (...args) => logger.warn?.(`[${botId ?? botConfig.id}]`, ...args),
+          info: (...args) => logger.info?.(`[${botId ?? botConfig.id}]`, ...args),
+          debug: (...args) => logger.debug?.(`[${botId ?? botConfig.id}]`, ...args),
+        },
+      });
+    },
+    deleteState: async ({ botId, config: botConfig }) => {
+      stateStores.delete(botId);
+      try {
+        await unlink(statePathFor(botConfig));
+      } 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();
+    },
+  };
+}