@imweapp/openclaw-imwe 2026.4.12-alpha.1

package/src/bot-info-cache.ts

@@ -0,0 +1,49 @@
+/**
+ * bot-info-cache.ts — 机器人信息的进程级缓存
+ *
+ * 生命周期：
+ *   - monitor.ts 的 monitorImweAccount 在 getMe 成功后调用 setBotInfo 写入
+ *   - send.ts 的 sendImweText 在发送消息时调用 getBotInfo 读取 botAcctId 作为 fromId
+ *   - monitor.ts 的轮询循环退出时调用 clearBotInfo 清理
+ *
+ * 多账号安全：以 accountId 为 key，每个账号独立缓存，互不干扰。
+ *
+ * 为什么不用 channelRuntime.runtimeContexts：
+ *   outbound 的 sendText 回调签名是 (ctx: ChannelOutboundContext) => ...，
+ *   ChannelOutboundContext 只有 cfg/to/text/accountId，没有 channelRuntime，
+ *   无法调用 runtimeContexts.get()。模块级 Map 是最简单可靠的方案。
+ */
+
+import type { BotInfo } from './api-client.js';
+
+/** accountId → BotInfo，进程级缓存 */
+const cache = new Map<string, BotInfo>();
+
+/**
+ * 缓存机器人信息（monitor 启动时写入）。
+ *
+ * @param accountId 账号 ID（多账号时区分不同机器人）
+ * @param info      getMe 返回的机器人信息
+ */
+export function setBotInfo(accountId: string, info: BotInfo): void {
+  cache.set(accountId, info);
+}
+
+/**
+ * 读取缓存的机器人信息（send / outbound / pairing 读取）。
+ *
+ * @param accountId 账号 ID
+ * @returns 缓存的 BotInfo，未缓存时返回 undefined
+ */
+export function getBotInfo(accountId: string): BotInfo | undefined {
+  return cache.get(accountId);
+}
+
+/**
+ * 清除缓存的机器人信息（monitor 停止时调用）。
+ *
+ * @param accountId 账号 ID
+ */
+export function clearBotInfo(accountId: string): void {
+  cache.delete(accountId);
+}

package/src/channel.runtime.ts

@@ -0,0 +1,29 @@
+/**
+ * channel.runtime.ts — 运行时模块的统一导出入口
+ *
+ * createLazyRuntimeModule 的加载目标，setup-only 模式下不会被加载。
+ *
+ * 导出分三类：
+ *   - monitor：事件箱轮询（monitorImweAccount）
+ *   - send：发送消息（sendImweText）
+ *   - 初始化：getMe（获取机器人信息）、botInfo 缓存管理
+ */
+
+export { monitorImweAccount } from './monitor.js';
+export {
+  sendImweText,
+  sendImweTypingSignal,
+  sendImweMedia,
+  sendImweMarkdown,
+  sendTextToPeer,
+  sendMarkdownToPeer,
+  sendMediaToPeer,
+  sendTypingSignalToPeer,
+  registerE2eeService,
+  unregisterE2eeService,
+} from './send.js';
+export type { OutboundContext } from './send.js';
+export { getMe } from './api-client.js';
+export { getBotInfo, setBotInfo, clearBotInfo } from './bot-info-cache.js';
+export { createE2eeService } from './e2ee/index.js';
+export type { E2eeService, BotInfo } from './e2ee/index.js';

package/src/channel.ts

@@ -0,0 +1,456 @@
+/**
+ * channel.ts — ChannelPlugin 主对象
+ *
+ * 认证方式：AppKey + AppSecret HMAC-SHA256 签名（无需登录流程）
+ * 支持：私聊文字消息、多账号、long polling
+ */
+
+import fs from 'fs';
+import path from 'path';
+import {
+  buildChannelConfigSchema,
+  createChatChannelPlugin,
+  type ChannelPlugin,
+} from 'openclaw/plugin-sdk/channel-core';
+import {
+  adaptScopedAccountAccessor,
+  createScopedChannelConfigAdapter,
+  createScopedDmSecurityResolver,
+} from 'openclaw/plugin-sdk/channel-config-helpers';
+import { createLazyRuntimeModule } from 'openclaw/plugin-sdk/lazy-runtime';
+import { createStaticReplyToModeResolver } from 'openclaw/plugin-sdk/conversation-runtime';
+import {
+  createComputedAccountStatusAdapter,
+  createDefaultChannelRuntimeState,
+} from 'openclaw/plugin-sdk/status-helpers';
+import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
+import { chunkTextForOutbound } from 'openclaw/plugin-sdk/text-chunking';
+import { createRawChannelSendResultAdapter } from 'openclaw/plugin-sdk/channel-send-result';
+import { listImweAccountIds, resolveDefaultImweAccountId, resolveImweAccount } from './accounts.js';
+import { imweSetupAdapter } from './setup-core.js';
+import { ImweConfigSchema } from './config-schema.js';
+import { isMarkdownContent } from './markdown-detect.js';
+import {
+  init as initRecentMessageCache,
+  forceFlushAll as forceFlushRecentMessageCache,
+} from './recent-message-cache.js';
+import { resumePendingUploads, resumePendingDownloads } from './file-transfer/index.js';
+import type { ResolvedImweAccount } from './types.js';
+
+import { resolveStateDir } from 'openclaw/plugin-sdk/state-paths';
+
+const loadImweRuntime = createLazyRuntimeModule(() => import('./channel.runtime.js'));
+
+// E2EE service 实例缓存（按 accountId 索引），通过 runtime module 懒加载创建
+type ImweRuntime = Awaited<ReturnType<typeof loadImweRuntime>>;
+type E2eeServiceInstance = ReturnType<ImweRuntime['createE2eeService']>;
+const e2eeServiceMap = new Map<string, E2eeServiceInstance>();
+
+const meta = {
+  id: 'imwe',
+  label: 'imwe',
+  selectionLabel: 'imwe (AppKey/AppSecret)',
+  docsPath: '/channels/imwe',
+  docsLabel: 'imwe',
+  blurb: 'imwe 即时通讯平台，AppKey/AppSecret 签名认证，支持多账号。',
+  aliases: ['iw'],
+  order: 95,
+  quickstartAllowFrom: true,
+};
+
+const imweConfigAdapter = createScopedChannelConfigAdapter<ResolvedImweAccount>({
+  sectionKey: 'imwe',
+  listAccountIds: listImweAccountIds,
+  resolveAccount: adaptScopedAccountAccessor(resolveImweAccount),
+  defaultAccountId: resolveDefaultImweAccountId,
+  clearBaseFields: ['appKey', 'appSecret', 'name'],
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  formatAllowFrom: (allowFrom) =>
+    allowFrom.map((e) =>
+      String(e)
+        .trim()
+        .replace(/^(imwe|iw):/i, ''),
+    ),
+});
+
+const resolveImweDmPolicy = createScopedDmSecurityResolver<ResolvedImweAccount>({
+  channelKey: 'imwe',
+  resolvePolicy: (account) => account.config.dmPolicy,
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  policyPathSuffix: 'dmPolicy',
+  normalizeEntry: (raw) => raw.trim().replace(/^(imwe|iw):/i, ''),
+});
+
+/**
+ * 检测文本是否为纯本地图片路径。
+ * 当 AI agent 回复的文本内容是一个本地图片路径时，自动识别并作为图片发送。
+ * 参考 feishu 插件的 normalizePossibleLocalImagePath 实现。
+ */
+function detectLocalImagePath(text: string | undefined): string | null {
+  const raw = text?.trim();
+  if (!raw) return null;
+  // 仅当文本是纯路径时才转换，避免误判包含路径的普通句子
+  if (/\s/.test(raw)) return null;
+  // 忽略 URL
+  if (/^(https?:\/\/|data:|file:\/\/)/i.test(raw)) return null;
+  const ext = path.extname(raw).toLowerCase();
+  if (
+    !['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp', '.ico', '.tiff', '.heic', '.heif'].includes(
+      ext,
+    )
+  )
+    return null;
+  if (!path.isAbsolute(raw)) return null;
+  try {
+    if (!fs.existsSync(raw) || !fs.statSync(raw).isFile()) return null;
+  } catch {
+    return null;
+  }
+  return raw;
+}
+
+const imweRawSendResultAdapter = createRawChannelSendResultAdapter({
+  channel: 'imwe',
+  sendText: async ({
+    to,
+    text,
+    accountId,
+    cfg,
+    mediaAccess,
+    mediaLocalRoots,
+    mediaReadFile,
+    replyToId,
+  }) => {
+    // 兼容处理：当 agent 回复纯本地图片路径时，自动作为图片发送
+    const localImagePath = detectLocalImagePath(text);
+    if (localImagePath) {
+      const { sendImweMedia } = await loadImweRuntime();
+      return sendImweMedia({
+        to,
+        mediaUrl: localImagePath,
+        accountId: accountId ?? undefined,
+        cfg,
+        mediaAccess,
+        mediaLocalRoots,
+        mediaReadFile,
+      });
+    }
+    // Markdown 文本分派：命中 markdown 特征走 sendImweMarkdown（优先级低于本地图片路径，高于普通文本兜底）
+    if (isMarkdownContent(text)) {
+      const { sendImweMarkdown } = await loadImweRuntime();
+      return sendImweMarkdown({
+        to,
+        markdown: text,
+        accountId: accountId ?? undefined,
+        cfg,
+      });
+    }
+    const { sendImweText } = await loadImweRuntime();
+    return sendImweText({
+      to,
+      text,
+      accountId: accountId ?? undefined,
+      cfg,
+      replyToId: replyToId ?? undefined,
+    });
+  },
+  sendMedia: async ({
+    to,
+    mediaUrl,
+    mediaType,
+    fileName,
+    caption,
+    text,
+    accountId,
+    cfg,
+    mediaAccess,
+    mediaLocalRoots,
+    mediaReadFile,
+  }) => {
+    const { sendImweMedia } = await loadImweRuntime();
+    return sendImweMedia({
+      to,
+      mediaUrl,
+      mediaType,
+      fileName,
+      caption: caption ?? text,
+      accountId: accountId ?? undefined,
+      cfg,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      log: console,
+    });
+  },
+});
+
+export const imwePlugin: ChannelPlugin<ResolvedImweAccount> = createChatChannelPlugin({
+  base: {
+    id: 'imwe',
+    meta,
+    capabilities: {
+      chatTypes: ['direct'],
+      media: true,
+      reactions: false,
+      threads: false,
+      polls: false,
+      nativeCommands: false,
+    },
+    reload: { configPrefixes: ['channels.imwe'] },
+    configSchema: buildChannelConfigSchema(ImweConfigSchema),
+    config: {
+      ...imweConfigAdapter,
+      isConfigured: (account) => Boolean(account.appKey?.trim() && account.appSecret?.trim()),
+      describeAccount: (account) => ({
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: Boolean(account.appKey?.trim() && account.appSecret?.trim()),
+        credentialSource: account.credentialSource,
+        dmPolicy: account.config.dmPolicy ?? 'open',
+      }),
+    },
+    setup: imweSetupAdapter,
+    status: createComputedAccountStatusAdapter<ResolvedImweAccount>({
+      defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+      resolveAccountSnapshot: ({ account }) => ({
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: Boolean(account.appKey?.trim() && account.appSecret?.trim()),
+        credentialSource: account.credentialSource,
+        dmPolicy: account.config.dmPolicy ?? 'open',
+      }),
+    }),
+    gateway: {
+      /**
+       * 启动账号监听循环。
+       *
+       * 职责分离：
+       *   - startAccount：调用 getMe 获取机器人信息，缓存到 bot-info-cache，然后启动轮询
+       *   - monitorImweAccount：只负责事件箱轮询，不关心初始化
+       *   - stopAccount：清理 bot-info-cache 缓存
+       */
+      startAccount: async (ctx) => {
+        const { monitorImweAccount, getMe, setBotInfo } = await loadImweRuntime();
+        const { account, log } = ctx;
+        const { apiBaseUrl, appKey, appSecret, accountId } = account;
+
+        log?.info(`[${accountId}] imwe 账号启动`);
+
+        // 前置条件：调用 getMe 获取机器人信息（botAcctId）
+        // botAcctId 用于 pullMessages 的 boxId 和 sendMessage 的 fromId
+        if (!appKey || !appSecret) {
+          log?.warn?.(
+            `[${accountId}] imwe AppKey/AppSecret 未配置，请先运行 \`openclaw setup imwe\``,
+          );
+          ctx.setStatus({
+            accountId,
+            enabled: true,
+            configured: false,
+            lastError: 'AppKey/AppSecret 未配置',
+          });
+          return;
+        }
+
+        let botInfo;
+        try {
+          botInfo = await getMe(apiBaseUrl, {
+            apiKey: appKey,
+            apiSecret: appSecret,
+          });
+          log?.info?.(
+            `[${accountId}] imwe getMe 成功：botAcctId=${botInfo.botAcctId}, botMainAcctId=${botInfo.botMainAcctId} botName=${botInfo.botName}`,
+          );
+        } catch (err) {
+          log?.error?.(`[${accountId}] imwe getMe 失败，无法启动监听：${String(err)}`);
+          ctx.setStatus({
+            accountId,
+            enabled: true,
+            configured: false,
+            lastError: `getMe 失败：${String(err)}`,
+          });
+          return;
+        }
+
+        // 缓存 botInfo，供 send.ts / outbound / pairing 读取 botAcctId 作为 fromId
+        setBotInfo(accountId, botInfo);
+
+        // E2EE 本地设备 bootstrap（通过 runtime module 懒加载，不直接 import e2ee/*）
+        let e2eeService: E2eeServiceInstance | undefined;
+        if (botInfo.e2eeEnabled === false) {
+          log?.info?.(`[${accountId}] Bot 未启用 E2EE，跳过 E2EE bootstrap`);
+        } else {
+          try {
+            const { createE2eeService, registerE2eeService } = await loadImweRuntime();
+            e2eeService = createE2eeService({
+              accountId,
+              botAcctId: botInfo.botAcctId,
+              apiBaseUrl,
+              auth: { apiKey: appKey, apiSecret: appSecret },
+              stateDir: resolveStateDir(),
+              log,
+            });
+            await e2eeService.ensureLocalDevice(botInfo);
+            e2eeServiceMap.set(accountId, e2eeService);
+            // 注册到 send.ts 模块级缓存，供顶层 sendImweXxx 函数获取
+            registerE2eeService(accountId, e2eeService);
+            log?.info?.(`[${accountId}] E2EE bootstrap 成功`);
+          } catch (err) {
+            log?.error?.(`[${accountId}] E2EE bootstrap 失败：${String(err)}`);
+            ctx.setStatus({
+              accountId,
+              enabled: true,
+              configured: true,
+              lastError: `E2EE bootstrap 失败：${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+          }
+        }
+
+        // 初始化最近消息缓存持久化（从磁盘恢复，轮询启动之前）
+        initRecentMessageCache(resolveStateDir(), {
+          logInfo: (msg) => log?.info?.(msg),
+          logWarn: (msg) => log?.warn?.(msg),
+        });
+
+        // 断点续传恢复（fire-and-forget，不阻塞轮询启动）
+        const fileTransferStateDir = path.join(
+          resolveStateDir(),
+          'channel-data',
+          'imwe',
+          botInfo.botAcctId,
+          'file-transfer',
+        );
+        const resumeAuth = { apiKey: appKey!, apiSecret: appSecret! };
+
+        // 恢复未完成的上传任务，完成后使用 sendContext 发送消息
+        resumePendingUploads({
+          stateDir: fileTransferStateDir,
+          auth: resumeAuth,
+          apiBaseUrl,
+          onUploadComplete: async (state, result) => {
+            const { sendMediaToPeer } = await loadImweRuntime();
+            const outbound = {
+              apiBaseUrl,
+              auth: resumeAuth,
+              accountId,
+              fromId: state.sendContext.fromId,
+              e2eeService,
+              log,
+            };
+            await sendMediaToPeer(outbound, {
+              to: state.sendContext.to,
+              url: result.url,
+              mediaType: state.sendContext.mediaType,
+              fileKey: result.fileKey,
+              fileIv: result.fileIv,
+              fileDigest: result.fileDigest,
+              plaintextLength: result.plaintextLength,
+              fileName: state.sendContext.fileName,
+              caption: state.sendContext.caption,
+              expireTime: result.expireTime,
+              opCreds: result.opCreds,
+              length: result.plaintextLength,
+            });
+          },
+          log,
+        }).catch((err) => {
+          log?.warn?.(`[${accountId}] 上传恢复调度失败：${String(err)}`);
+        });
+
+        // 恢复未完成的下载任务（通知级别，实际恢复由 monitor 再次遇到消息时触发）
+        resumePendingDownloads({
+          stateDir: fileTransferStateDir,
+          auth: resumeAuth,
+          apiBaseUrl,
+          onDownloadComplete: async (_state, _localPath) => {
+            // 下载恢复由 scheduler 层面仅做通知，实际 saveMediaSource 流程
+            // 在 monitor.ts 再次处理该消息时自动完成
+            log?.info?.(`[${accountId}] 下载恢复任务已通知`);
+          },
+          log,
+        }).catch((err) => {
+          log?.warn?.(`[${accountId}] 下载恢复调度失败：${String(err)}`);
+        });
+
+        // 启动事件箱轮询（monitor 只负责轮询，不负责初始化；注入 e2eeService）
+        return monitorImweAccount(ctx, botInfo, { e2eeService });
+      },
+
+      /**
+       * 停止账号监听时清理 botInfo 缓存。
+       * 注意：monitor 的轮询循环通过 abortSignal 退出，此处做额外的缓存清理保险。
+       */
+      stopAccount: async (ctx) => {
+        const { clearBotInfo, unregisterE2eeService } = await loadImweRuntime();
+        clearBotInfo(ctx.accountId);
+        // 注销 send.ts 模块级缓存中的 E2EE Service
+        unregisterE2eeService(ctx.accountId);
+        // 释放 E2EE WASM handle
+        const e2eeService = e2eeServiceMap.get(ctx.accountId);
+        if (e2eeService) {
+          await e2eeService.dispose();
+          e2eeServiceMap.delete(ctx.accountId);
+        }
+        // 强制刷盘，确保 stop 前缓存已持久化
+        forceFlushRecentMessageCache();
+        ctx.log?.info(`[${ctx.accountId}] imwe 账号已停止，botInfo 缓存已清理`);
+      },
+    },
+    groups: {
+      resolveRequireMention: () => false,
+    },
+    messaging: {
+      normalizeTarget: (raw) =>
+        raw
+          ?.trim()
+          .replace(/^(imwe|iw):/i, '')
+          .trim() || undefined,
+      targetResolver: {
+        looksLikeId: (s) => /^((imwe|iw):)?[A-Za-z0-9_]+$/.test(s.trim()),
+        hint: '<userId>',
+      },
+    },
+  },
+
+  security: {
+    resolveDmPolicy: resolveImweDmPolicy,
+  },
+
+  pairing: {
+    text: {
+      idLabel: 'imweUserId',
+      message: '您的配对请求已通过审批。',
+      normalizeAllowEntry: (entry) => entry.trim().replace(/^(imwe|iw):/i, ''),
+      // notify 参数中接收方字段名为 id（来自 ChannelPairingAdapter.notifyApproval）
+      notify: async (params) => {
+        const { sendImweText } = await loadImweRuntime();
+        const { loadConfig } = await import('openclaw/plugin-sdk/config-runtime');
+        const cfg = loadConfig();
+        const account = resolveImweAccount({
+          cfg,
+          accountId: params.accountId,
+        });
+        await sendImweText({
+          to: String(params.id),
+          text: params.message,
+          accountId: account.accountId,
+          cfg,
+        });
+      },
+    },
+  },
+
+  threading: {
+    resolveReplyToMode: createStaticReplyToModeResolver('first'),
+  },
+
+  outbound: {
+    deliveryMode: 'direct',
+    chunker: chunkTextForOutbound,
+    chunkerMode: 'text',
+    textChunkLimit: 4000,
+    ...imweRawSendResultAdapter,
+  },
+});

package/src/config-schema.ts

@@ -0,0 +1,26 @@
+/**
+ * config-schema.ts — Zod 配置 schema
+ *
+ * 用于运行时验证用户配置，与 openclaw.plugin.json 中的 JSON Schema 保持一致。
+ */
+
+import {
+  AllowFromListSchema,
+  buildCatchallMultiAccountChannelSchema,
+  DmPolicySchema,
+} from 'openclaw/plugin-sdk/channel-config-schema';
+import { z } from 'openclaw/plugin-sdk/zod';
+
+const imweAccountSchema = z.object({
+  name: z.string().optional(),
+  enabled: z.boolean().optional(),
+  apiBaseUrl: z.string().optional(),
+  appKey: z.string().optional(),
+  appSecret: z.string().optional(),
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: AllowFromListSchema,
+  /** 短轮询间隔（毫秒），默认 3000 */
+  pollIntervalMs: z.number().optional(),
+});
+
+export const ImweConfigSchema = buildCatchallMultiAccountChannelSchema(imweAccountSchema);