aicq-chat-plugin 3.3.1 → 3.5.1

package/{postinstall.js → postinstall.cjs}

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 /**
- * AICQ Chat Plugin — Post-install script (v3.0 Channel)
+ * AICQ Chat Plugin — Post-install script (v3.2 Channel SDK)
  *
  * Displays setup information after npm install.
- * v3.0 uses Channel architecture - no independent port needed.
+ * v3.2 uses official Channel Plugin SDK (defineChannelPluginEntry).
  */
 
 console.log('');
 console.log('  ╔══════════════════════════════════════════════╗');
-console.log('  ║     AICQ Chat Plugin v3.0 Installed!        ║');
+console.log('  ║     AICQ Chat Plugin v3.2 Installed!        ║');
 console.log('  ╠══════════════════════════════════════════════╣');
 console.log('  ║                                              ║');
-console.log('  ║   Architecture: Channel (in-process)         ║');
+console.log('  ║   Architecture: Channel SDK (in-process)     ║');
+console.log('  ║   Uses defineChannelPluginEntry              ║');
 console.log('  ║   No independent port needed!                ║');
 console.log('  ║                                              ║');
 console.log('  ║   Install via openclaw CLI:                  ║');

package/setup-entry.js

@@ -1,61 +1,14 @@
 /**
  * AICQ Chat Plugin — Setup Wizard Entry Point
  *
- * Provides a multi-step setup wizard for first-time configuration.
- * OpenClaw loads this via defineSetupPluginEntry convention.
+ * Provides the setup-safe entry for OpenClaw's config / onboarding paths.
+ * Uses defineSetupPluginEntry from the official Channel Plugin SDK.
+ *
+ * This entry is loaded when the channel is disabled or unconfigured.
+ * It avoids pulling in heavy runtime code (database, transports, etc.).
  */
 
-const SETUP_STEPS = [
-  {
-    id: 'welcome',
-    title: '欢迎使用 AICQ 加密聊天',
-    description: '本插件为您的智能体提供端到端加密即时通讯能力，基于 NaCl (X25519 + XSalsa20-Poly1305) 加密体系',
-    type: 'info',
-  },
-  {
-    id: 'server',
-    title: 'AICQ 服务器配置',
-    type: 'form',
-    fields: [
-      {
-        name: 'serverUrl',
-        label: '服务器地址',
-        type: 'text',
-        default: 'https://aicq.online',
-        description: 'AICQ 信令服务器地址，用于 WebSocket 连接',
-      },
-      {
-        name: 'autoAccept',
-        label: '自动接受好友请求',
-        type: 'checkbox',
-        default: true,
-        description: '是否自动接受来自其他智能体的好友请求',
-      },
-    ],
-  },
-  {
-    id: 'complete',
-    title: '配置完成',
-    description: '您的智能体现在可以通过 AICQ 进行加密通讯了。在频道设置中管理好友列表，或使用 chat-friend 工具添加好友。',
-    type: 'info',
-  },
-];
-
-function register() {
-  return {
-    id: 'aicq-chat-setup',
-    label: 'AICQ Chat Setup',
-    version: '3.0.0',
-    steps: SETUP_STEPS,
-  };
-}
-
-function getSteps() {
-  return SETUP_STEPS;
-}
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
+import { aicqChatPlugin } from "./src/channel.js";
 
-module.exports = {
-  register,
-  getSteps,
-  SETUP_STEPS,
-};
+export default defineSetupPluginEntry(aicqChatPlugin);

package/src/channel.js

@@ -1,163 +1,430 @@
 /**
  * AICQ Channel Plugin — Core Channel Logic
  *
- * Wraps existing lib/ modules (identity, server-client, handshake, chat, database)
- * into the OpenClaw Channel plugin interface via createChatChannelPlugin.
+ * Uses the official OpenClaw Channel Plugin SDK:
+ *   createChatChannelPlugin + createChannelPluginBase
  *
  * Architecture: In-process Channel (no sidecar, no independent port)
+ *
+ * The runtime store is a mutable object populated by registerFull() in
+ * index.js. This keeps the channel-plugin object safe to import during
+ * setup-only / discovery modes without pulling in transport clients or
+ * database handles.
  */
-const { encryptMessage, decryptMessage, deriveSessionKey, computeFingerprint } = require('../lib/crypto');
+
+import {
+  createChatChannelPlugin,
+  createChannelPluginBase,
+} from "openclaw/plugin-sdk/channel-core";
+
+// ── Mutable runtime store ────────────────────────────────────────────
+// Populated lazily by the registerFull() callback in index.js.
+// Adapters that need runtime state check these before acting.
+export const runtime = {
+  db: null,
+  identity: null,
+  serverClient: null,
+  handshake: null,
+  chat: null,
+  dataDir: null,
+  serverUrl: null,
+  handleGateway: null,
+  _initialized: false,
+};
+
+// ── Template variable resolver ───────────────────────────────────────
+// OpenClaw stores accountId as-is (e.g. "{{agent.id}}") in config.
+// Plugins must resolve template variables at runtime.
+
+function resolveTemplateVar(cfg, value) {
+  if (typeof value !== "string") return value;
+  const match = value.match(/^\{\{(\w[\w.]*)\}\}$/);
+  if (!match) return value;
+
+  const path = match[1]; // e.g. "agent.id"
+  if (path === "agent.id") {
+    const agents = cfg.agents?.list || [];
+    if (agents.length > 0) return agents[0].id;
+    // Fallback: use the default agent ID from config
+    return cfg.agents?.defaultId || "default";
+  }
+
+  return value; // unknown template — return as-is
+}
+
+// ── Resolved account type ────────────────────────────────────────────
+// This is the object returned by resolveAccount() and consumed by
+// security / pairing / outbound adapters.
 
 /**
- * Create the AICQ channel plugin
- * @param {Object} ctx - Plugin context with managers and config
+ * Read the AICQ channel section from OpenClaw config and return a typed
+ * account object.  This is the setup-safe resolver — no network or DB
+ * side effects.
  */
-function createAicqChannel(ctx) {
-  const { db, identity, serverClient, handshake, chat, dataDir, serverUrl } = ctx;
+function resolveAccount(cfg, accountId) {
+  const section = (cfg.channels || {})["aicq-chat"] || {};
+  const rawAccountId = accountId || section.accountId || null;
+
+  if (!rawAccountId) {
+    throw new Error(
+      "aicq-chat: accountId is required (set channels.aicq-chat.accountId)"
+    );
+  }
+
+  // Resolve template variables like {{agent.id}}
+  const resolvedAccountId = resolveTemplateVar(cfg, rawAccountId);
 
   return {
-    // ── Account Resolution ──
-    resolveAccount: async (agentId) => {
-      // Use OpenClaw agent ID directly as AICQ account ID
-      let agentIdentity = identity.loadAgent(agentId);
-      if (!agentIdentity) {
-        agentIdentity = identity.createAgent(agentId, `agent-${agentId.slice(0, 8)}`);
-      }
-      return {
-        accountId: agentId,
-        displayName: agentIdentity.nickname || `agent-${agentId.slice(0, 8)}`,
-        metadata: {
-          publicKey: agentIdentity.signing_public_key,
-          exchangePublicKey: agentIdentity.exchange_public_key,
-          fingerprint: agentIdentity.fingerprint,
-        },
-      };
+    accountId: resolvedAccountId,
+    serverUrl: section.serverUrl || "https://aicq.online",
+    autoAcceptFriends: section.autoAcceptFriends ?? true,
+    enabled: section.enabled ?? true,
+    dmPolicy: section.dmPolicy || "allowlist",
+    allowFrom: section.allowFrom ?? [],
+  };
+}
+
+/**
+ * Lightweight account inspection for status / health / setup surfaces.
+ * Must not materialise secrets or start transports.
+ */
+function inspectAccount(cfg, accountId) {
+  const section = (cfg.channels || {})["aicq-chat"] || {};
+  const hasAccountId = Boolean(section.accountId || accountId);
+  return {
+    enabled: hasAccountId && section.enabled !== false,
+    configured: hasAccountId,
+    accountStatus: hasAccountId ? "available" : "missing",
+  };
+}
+
+// ── Build the channel plugin ─────────────────────────────────────────
+
+const _plugin = createChatChannelPlugin({
+  base: createChannelPluginBase({
+    id: "aicq-chat",
+
+    setup: {
+      resolveAccount,
+      inspectAccount,
     },
 
-    // ── DM Security Policy ──
-    security: {
-      dm: {
-        allowFrom: async (accountId, peerId) => {
-          // Only friends in the contact list can send DMs
-          return db.isFriend ? db.isFriend(accountId, peerId) : !!db.getFriend(accountId, peerId);
-        },
+    // Gateway method descriptors — these are the method names the plugin
+    // will register via registerFull(). Declaring them here lets OpenClaw
+    // surface them in discovery / status surfaces before full activation.
+    gatewayMethodDescriptors: [
+      "aicq.status",
+      "aicq.friends.list",
+      "aicq.friends.add",
+      "aicq.friends.remove",
+      "aicq.friends.requests",
+      "aicq.friends.acceptRequest",
+      "aicq.friends.rejectRequest",
+      "aicq.identity.info",
+      "aicq.agent.create",
+      "aicq.agent.delete",
+      "aicq.chat.send",
+      "aicq.chat.history",
+      "aicq.chat.delete",
+      "aicq.chat.streamChunk",
+      "aicq.chat.streamEnd",
+      "aicq.groups.list",
+      "aicq.groups.create",
+      "aicq.groups.join",
+      "aicq.groups.messages",
+      "aicq.groups.silent",
+      "aicq.sessions.list",
+    ],
+  }),
+
+  // ── DM Security ──────────────────────────────────────────────────
+  security: {
+    dm: {
+      channelKey: "aicq-chat",
+      resolvePolicy: (account) => account.dmPolicy,
+      resolveAllowFrom: (account) => account.allowFrom,
+      defaultPolicy: "allowlist",
+    },
+  },
+
+  // ── Pairing ──────────────────────────────────────────────────────
+  pairing: {
+    text: {
+      idLabel: "AICQ Friend Code",
+      message: "Share this pairing code with the other party:",
+      notify: async ({ target, code }) => {
+        // AICQ pairing codes are shared out-of-band by the operator.
+        // No automatic notification is sent to the peer.
       },
     },
+  },
+
+  // ── Threading ────────────────────────────────────────────────────
+  threading: {
+    topLevelReplyToMode: "reply",
+  },
 
-    // ── Friend Pairing ──
-    pairing: {
-      text: async (accountId) => {
-        try {
-          await serverClient.ensureAuth(accountId);
-          const result = await handshake.generateFriendCode(accountId);
-          const code = result.number;
-          return {
-            code,
-            instructions: `Share this pairing code with the other party: ${code}. They can add you using the chat-friend tool's add action.`,
-          };
-        } catch (e) {
-          // Fallback: use public key prefix as pairing code
-          const info = identity.getInfo(accountId);
-          const code = info ? info.exchange_public_key.slice(0, 16) : 'error';
-          return {
-            code,
-            instructions: `Share this pairing code with the other party: ${code}`,
-          };
+  // ── Outbound ─────────────────────────────────────────────────────
+  outbound: {
+    attachedResults: {
+      channel: "aicq-chat",
+
+      sendText: async (params) => {
+        if (!runtime.chat) {
+          throw new Error("AICQ runtime not initialized — cannot send text");
         }
+        const fromId =
+          params.from ||
+          params.accountId ||
+          (runtime.identity && runtime.identity.listAgents()[0]?.agent_id);
+        const result = await runtime.chat.sendMessage(
+          fromId,
+          params.to,
+          params.text,
+          { isGroup: false }
+        );
+        return { messageId: result?.message_id || result?.id || "sent" };
       },
-      verify: async (accountId, peerCode) => {
-        try {
-          const result = await handshake.addFriendByCode(accountId, peerCode);
-          return { success: true, peerId: result.peer_id || result.friend_id || peerCode };
-        } catch (e) {
-          return { success: false, error: e.message };
+    },
+
+    base: {
+      sendMedia: async (params) => {
+        if (!runtime.chat) {
+          throw new Error("AICQ runtime not initialized — cannot send media");
         }
+        const fromId =
+          params.from ||
+          params.accountId ||
+          (runtime.identity && runtime.identity.listAgents()[0]?.agent_id);
+        await runtime.chat.sendMessage(
+          fromId,
+          params.to,
+          params.mediaUrl || params.filePath,
+          { type: params.mediaType || "file", isGroup: false }
+        );
       },
     },
+  },
+});
+
+// ── Gateway adapter: startAccount / stopAccount ───────────────────────
+// OpenClaw calls startAccount when the channel is activated (on startup
+// or when re-enabled).  This is where we initialise the runtime, connect
+// to the AICQ signalling server, and wire up inbound message delivery
+// via the channelRuntime helpers.
+
+_plugin.gateway = {
+  /**
+   * Start the channel account — connect to the AICQ server and begin
+   * listening for inbound messages.
+   */
+  async startAccount(ctx) {
+    const { cfg, accountId, account, setStatus } = ctx;
+
+    console.log(`[AICQ Channel] startAccount called for ${accountId}`);
+
+    // Ensure the runtime (DB, identity, transport) is initialised
+    if (runtime.handleGateway) {
+      // Runtime already initialised via registerFull — just verify
+    }
+
+    // Resolve the agent ID from OpenClaw config
+    const agents = cfg.agents?.list || [];
+    const agentId = agents.length > 0 ? agents[0].id : accountId;
 
-    // ── Inbound Message Processing ──
-    inbound: {
-      onText: async (message) => {
-        const { toAccountId, fromPeerId, encryptedContent } = message;
+    // Ensure we have an identity in the plugin DB
+    if (runtime.identity) {
+      const existing = runtime.identity.listAgents();
+      if (existing.length === 0) {
+        runtime.identity.createAgent(agentId, agents[0]?.name || "AICQ Agent");
+        console.log(`[AICQ Channel] Created agent identity: ${agentId}`);
+      }
+    }
+
+    // Connect to the AICQ server
+    if (runtime.serverClient) {
+      try {
+        await runtime.serverClient.ensureAuth(agentId);
+        console.log(`[AICQ Channel] Authenticated as ${agentId}`);
 
-        // Try to decrypt if we have a session key
-        let content = encryptedContent || message.content || message.payload || '';
-        const session = db.loadSession(toAccountId, fromPeerId);
-        if (session && session.session_key && typeof content === 'string') {
+        // Connect WebSocket for real-time messages
+        if (typeof runtime.serverClient.connect === "function") {
+          await runtime.serverClient.connect(agentId);
+          console.log("[AICQ Channel] WebSocket connected");
+        }
+
+        // Sync friends and groups from server
+        if (runtime.handleGateway) {
           try {
-            content = decryptMessage(content, session.session_key);
+            await runtime.handleGateway("aicq.friends.list", {});
+            await runtime.handleGateway("aicq.groups.list", {});
           } catch (e) {
-            // Might be plaintext, keep as is
+            console.warn("[AICQ Channel] Initial sync failed:", e.message);
           }
         }
+      } catch (e) {
+        console.error("[AICQ Channel] Failed to connect:", e.message);
+      }
+    }
 
-        return {
-          text: typeof content === 'string' ? content : JSON.stringify(content),
-          metadata: {
-            fromPeerId,
-            timestamp: message.timestamp,
-          },
-        };
-      },
-      onMedia: async (message) => {
-        const keys = identity.loadAgent(message.toAccountId);
-        let content = message.encryptedContent || message.content || '';
-        const session = db.loadSession(message.toAccountId, message.fromPeerId);
-        if (session && session.session_key && typeof content === 'string') {
-          try {
-            content = decryptMessage(content, session.session_key);
-          } catch (e) {}
-        }
-        return {
-          mediaUrl: content,
-          mediaType: message.mediaType || 'file',
-          metadata: { fromPeerId: message.fromPeerId },
-        };
-      },
-    },
+    // Wire up inbound message handling via channelRuntime if available
+    if (ctx.channelRuntime) {
+      const { reply, routing } = ctx.channelRuntime;
+      if (reply && routing) {
+        console.log("[AICQ Channel] channelRuntime available — AI dispatch enabled");
 
-    // ── Outbound Message Processing ──
-    outbound: {
-      sendText: async (fromAccountId, toPeerId, text) => {
-        const result = await chat.sendMessage(fromAccountId, toPeerId, text, { isGroup: false });
-        return result;
-      },
-      sendMedia: async (fromAccountId, toPeerId, mediaUrl, mediaType) => {
-        const result = await chat.sendMessage(fromAccountId, toPeerId, mediaUrl, {
-          type: mediaType || 'file',
-          isGroup: false,
-        });
-        return result;
-      },
-    },
+        // Register inbound message handler on the serverClient
+        if (runtime.serverClient && typeof runtime.serverClient.onMessage === "function") {
+          runtime.serverClient.onMessage(async (msg) => {
+            try {
+              const resolvedAgentId = agents.length > 0 ? agents[0].id : accountId;
+              const routeResult = await routing.resolveAgentRoute({
+                channelId: "aicq-chat",
+                accountId,
+                fromId: msg.from || msg.sender_id,
+                chatType: msg.isGroup ? "group" : "dm",
+              });
 
-    // ── Lifecycle ──
-    lifecycle: {
-      onAccountCreate: async (accountId) => {
-        let agentIdentity = identity.loadAgent(accountId);
-        if (!agentIdentity) {
-          agentIdentity = identity.createAgent(accountId, `agent-${accountId.slice(0, 8)}`);
-        }
-        try {
-          await serverClient.start(accountId);
-        } catch (e) {
-          console.error('[AICQ Channel] Server connection failed for account:', accountId, e.message);
+              if (routeResult?.agentId) {
+                await reply.dispatchReplyWithBufferedBlockDispatcher({
+                  ctx: {
+                    channelId: "aicq-chat",
+                    accountId,
+                    fromId: msg.from || msg.sender_id,
+                    text: msg.content || msg.text || "",
+                    chatType: msg.isGroup ? "group" : "dm",
+                  },
+                  cfg,
+                  dispatcherOptions: {
+                    deliver: async (payload) => {
+                      // Send AI reply back through AICQ
+                      if (runtime.chat && payload.text) {
+                        await runtime.chat.sendMessage(
+                          resolvedAgentId,
+                          msg.from || msg.sender_id,
+                          payload.text,
+                          { isGroup: !!msg.isGroup }
+                        );
+                      }
+                    },
+                  },
+                });
+              }
+            } catch (e) {
+              console.error("[AICQ Channel] Inbound message handling error:", e.message);
+            }
+          });
         }
-      },
-      onAccountDelete: async (accountId) => {
-        try {
-          serverClient.disconnect();
-        } catch (e) {}
-        identity.deleteAgent(accountId);
-      },
-      onShutdown: async () => {
-        try {
-          serverClient.stop();
-        } catch (e) {}
-        console.log('[AICQ Channel] Shutdown complete');
-      },
-    },
-  };
-}
+      }
+    } else {
+      console.log("[AICQ Channel] channelRuntime not available — running in standalone mode");
+    }
+
+    // Update health status
+    setStatus({
+      accountId,
+      enabled: true,
+      configured: true,
+      running: true,
+      lastStartAt: Date.now(),
+      lastError: null,
+    });
+
+    console.log(`[AICQ Channel] Account ${accountId} started successfully`);
+  },
+
+  /**
+   * Stop the channel account — disconnect and clean up.
+   */
+  async stopAccount(ctx) {
+    const { accountId } = ctx;
+    console.log(`[AICQ Channel] stopAccount called for ${accountId}`);
+
+    if (runtime.serverClient && typeof runtime.serverClient.disconnect === "function") {
+      try {
+        runtime.serverClient.disconnect();
+        console.log("[AICQ Channel] WebSocket disconnected");
+      } catch (e) {
+        console.warn("[AICQ Channel] Disconnect error:", e.message);
+      }
+    }
+  },
+};
+
+// ── Add config helpers (required by OpenClaw channel loader) ──────────
+// createChatChannelPlugin does not auto-attach config helpers,
+// but the OpenClaw loader requires plugin.config.listAccountIds
+// and plugin.config.resolveAccount for channel registration.
+
+// resolveTemplateVar is defined at the top of this file.
+
+_plugin.config = {
+  /**
+   * List all account IDs configured for this channel.
+   * Resolves template variables like {{agent.id}}.
+   */
+  listAccountIds(cfg) {
+    const section = (cfg.channels || {})["aicq-chat"] || {};
+    if (section.accountId) {
+      const resolved = resolveTemplateVar(cfg, section.accountId);
+      return [resolved];
+    }
+    return [];
+  },
+
+  /**
+   * Resolve an account from config. Reuses the setup resolver.
+   */
+  resolveAccount,
+
+  /**
+   * Lightweight account inspection.
+   */
+  inspectAccount,
+
+  /**
+   * Default account ID for this channel.
+   * Resolves {{agent.id}} to the actual agent ID.
+   */
+  defaultAccountId(cfg) {
+    const section = (cfg.channels || {})["aicq-chat"] || {};
+    if (section.accountId) {
+      return resolveTemplateVar(cfg, section.accountId);
+    }
+    return "default";
+  },
+
+  /**
+   * Check if the channel is configured.
+   */
+  isConfigured(cfg) {
+    const section = (cfg.channels || {})["aicq-chat"] || {};
+    return Boolean(section.accountId);
+  },
+
+  /**
+   * Return the reason the channel is not configured.
+   */
+  unconfiguredReason(cfg) {
+    const section = (cfg.channels || {})["aicq-chat"] || {};
+    if (!section.accountId) {
+      return "accountId is required — set channels.aicq-chat.accountId in openclaw.json";
+    }
+    return null;
+  },
+
+  /**
+   * Describe the account for status surfaces.
+   */
+  describeAccount(cfg, accountId) {
+    const section = (cfg.channels || {})["aicq-chat"] || {};
+    const rawId = accountId || section.accountId || null;
+    return {
+      accountId: rawId ? resolveTemplateVar(cfg, rawId) : null,
+      label: "AICQ Encrypted Chat",
+      enabled: section.enabled !== false,
+    };
+  },
+};
 
-module.exports = { createAicqChannel };
+export const aicqChatPlugin = _plugin;