aicq-chat-plugin 3.5.1 → 3.6.1

package/index.js

@@ -65,6 +65,7 @@ async function ensureInitialized() {
   runtime.dataDir = DATA_DIR;
   runtime.serverUrl = SERVER_URL;
   runtime.handleGateway = handleGatewayMethod;
+  runtime.ensureInitialized = ensureInitialized;
 
   // Periodic cleanup
   setInterval(() => _db.cleanup(), 3600000);
@@ -131,7 +132,7 @@ async function handleGatewayMethod(method, kwargs = {}) {
       return {
         state: _serverClient.connected ? "connected" : "disconnected",
         agent_id: currentAgentId,
-        version: "3.2.0",
+        version: "3.6.0",
         architecture: "channel",
       };
     case "aicq.friends.list":
@@ -267,6 +268,11 @@ function registerCliMetadata(api) {
 
 // ── Full runtime registration ────────────────────────────────────────
 async function registerFull(api) {
+  // Expose ensureInitialized on the runtime store immediately so that
+  // startAccount (called by the channel loader) can trigger init even
+  // if no gateway method has been invoked yet.
+  runtime.ensureInitialized = ensureInitialized;
+
   // Register gateway RPC methods — each wraps handleGatewayMethod
   const GATEWAY_METHODS = [
     "aicq.status",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "kind": "channel",
   "id": "aicq-chat",
   "name": "AICQ Encrypted Chat",
-  "version": "3.5.1",
+  "version": "3.6.1",
   "description": "End-to-end encrypted chat channel via AICQ protocol — in-process Channel plugin using OpenClaw Channel SDK",
   "entry": "index.js",
   "activation": {
@@ -49,6 +49,14 @@
               "open",
               "disabled"
             ]
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": [],
+            "description": "允许发消息的好友 ID 列表（dmPolicy 为 allowlist 时生效）"
           }
         },
         "required": [
@@ -71,6 +79,10 @@
         "dmPolicy": {
           "label": "DM Policy",
           "help": "Who can send direct messages: allowlist (friends only), open, or disabled"
+        },
+        "allowFrom": {
+          "label": "Allow From",
+          "help": "Friend IDs allowed to send DMs (used when dmPolicy is allowlist)"
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicq-chat-plugin",
-  "version": "3.5.1",
+  "version": "3.6.1",
   "description": "AICQ End-to-end Encrypted Chat Channel Plugin for OpenClaw — In-process Channel SDK architecture with friend management, group chat, file transfer, and AI agent communication",
   "type": "module",
   "main": "index.js",

package/src/channel.js

@@ -35,18 +35,29 @@ export const runtime = {
 // ── Template variable resolver ───────────────────────────────────────
 // OpenClaw stores accountId as-is (e.g. "{{agent.id}}") in config.
 // Plugins must resolve template variables at runtime.
+//
+// The default agent ID in OpenClaw is "main" (DEFAULT_AGENT_ID).
+// When cfg.agents.list is empty/undefined (no explicit agent config),
+// the implicit default agent "main" is used.
+
+const OPENCLAW_DEFAULT_AGENT_ID = "main";
 
 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";
+  const tmplPath = match[1]; // e.g. "agent.id"
+  if (tmplPath === "agent.id") {
+    // Strategy: look for explicit agents in config first
+    const agents = cfg.agents?.list;
+    if (Array.isArray(agents) && agents.length > 0) {
+      // Use the default=true agent, or the first one
+      const defaultAgent = agents.find((a) => a.default) || agents[0];
+      if (defaultAgent?.id) return defaultAgent.id;
+    }
+    // Fallback: OpenClaw's implicit default agent ID
+    return OPENCLAW_DEFAULT_AGENT_ID;
   }
 
   return value; // unknown template — return as-is
@@ -74,13 +85,19 @@ function resolveAccount(cfg, accountId) {
   // Resolve template variables like {{agent.id}}
   const resolvedAccountId = resolveTemplateVar(cfg, rawAccountId);
 
+  // Resolve allowFrom entries (may contain {{agent.id}} or friend IDs)
+  const rawAllowFrom = section.allowFrom || [];
+  const resolvedAllowFrom = Array.isArray(rawAllowFrom)
+    ? rawAllowFrom.map((entry) => resolveTemplateVar(cfg, entry))
+    : rawAllowFrom;
+
   return {
     accountId: resolvedAccountId,
     serverUrl: section.serverUrl || "https://aicq.online",
     autoAcceptFriends: section.autoAcceptFriends ?? true,
     enabled: section.enabled ?? true,
     dmPolicy: section.dmPolicy || "allowlist",
-    allowFrom: section.allowFrom ?? [],
+    allowFrom: resolvedAllowFrom,
   };
 }
 
@@ -105,8 +122,46 @@ const _plugin = createChatChannelPlugin({
     id: "aicq-chat",
 
     setup: {
-      resolveAccount,
-      inspectAccount,
+      /**
+       * Resolve the account ID from setup input.
+       * Called by the setup wizard when a user configures the channel.
+       */
+      resolveAccountId(params) {
+        const { cfg, accountId, input } = params;
+        return accountId || input?.accountId || resolveTemplateVar(cfg, "{{agent.id}}");
+      },
+
+      /**
+       * Apply the account config after the setup wizard completes.
+       * Must return the updated OpenClawConfig.
+       */
+      applyAccountConfig(params) {
+        const { cfg, accountId, input } = params;
+        const section = (cfg.channels || {})["aicq-chat"] || {};
+        return {
+          ...cfg,
+          channels: {
+            ...(cfg.channels || {}),
+            "aicq-chat": {
+              ...section,
+              accountId: accountId || input?.accountId || "{{agent.id}}",
+              serverUrl: input?.serverUrl || section.serverUrl || "https://aicq.online",
+              autoAcceptFriends: input?.autoAcceptFriends ?? section.autoAcceptFriends ?? true,
+              enabled: true,
+              dmPolicy: input?.dmPolicy || section.dmPolicy || "allowlist",
+              allowFrom: input?.allowFrom || section.allowFrom || [],
+            },
+          },
+        };
+      },
+
+      /**
+       * Validate setup input before applying.
+       * Return an error message string or null if valid.
+       */
+      validateInput(params) {
+        return null;
+      },
     },
 
     // Gateway method descriptors — these are the method names the plugin
@@ -219,24 +274,46 @@ _plugin.gateway = {
    * listening for inbound messages.
    */
   async startAccount(ctx) {
-    const { cfg, accountId, account, setStatus } = ctx;
+    const { cfg, accountId, account, setStatus, log, abortSignal } = ctx;
 
-    console.log(`[AICQ Channel] startAccount called for ${accountId}`);
+    const logger = log || console;
+    logger.info?.(`[AICQ Channel] startAccount called for ${accountId}`) || 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
+    // Ensure the runtime (DB, identity, transport) is initialised.
+    // The runtime is populated by registerFull() in index.js, but startAccount
+    // may be called before any gateway method is invoked, so we must ensure
+    // initialization here too.
+    if (!runtime._initialized && typeof runtime.ensureInitialized === "function") {
+      try {
+        await runtime.ensureInitialized();
+        logger.info?.("[AICQ Channel] Runtime initialized via startAccount") || console.log("[AICQ Channel] Runtime initialized via startAccount");
+      } catch (e) {
+        console.error("[AICQ Channel] Runtime initialization failed:", e.message);
+        setStatus({
+          accountId,
+          enabled: true,
+          configured: true,
+          running: false,
+          lastError: `Initialization failed: ${e.message}`,
+        });
+        return;
+      }
     }
 
-    // Resolve the agent ID from OpenClaw config
-    const agents = cfg.agents?.list || [];
-    const agentId = agents.length > 0 ? agents[0].id : accountId;
+    // Resolve the agent ID: prefer the resolved accountId from
+    // resolveAccount (which already handles {{agent.id}}), then
+    // fall back to the OpenClaw default agent ID.
+    const agents = cfg.agents?.list;
+    const agentId = account?.accountId || accountId || OPENCLAW_DEFAULT_AGENT_ID;
 
     // 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");
+        const agentName = (Array.isArray(agents) && agents.length > 0 && agents[0]?.name)
+          ? agents[0].name
+          : "AICQ Agent";
+        runtime.identity.createAgent(agentId, agentName);
         console.log(`[AICQ Channel] Created agent identity: ${agentId}`);
       }
     }
@@ -248,9 +325,12 @@ _plugin.gateway = {
         console.log(`[AICQ Channel] Authenticated as ${agentId}`);
 
         // Connect WebSocket for real-time messages
-        if (typeof runtime.serverClient.connect === "function") {
-          await runtime.serverClient.connect(agentId);
+        if (typeof runtime.serverClient.start === "function") {
+          await runtime.serverClient.start(agentId);
           console.log("[AICQ Channel] WebSocket connected");
+        } else if (typeof runtime.serverClient.connectWS === "function") {
+          runtime.serverClient.connectWS();
+          console.log("[AICQ Channel] WebSocket connecting");
         }
 
         // Sync friends and groups from server
@@ -273,11 +353,10 @@ _plugin.gateway = {
       if (reply && routing) {
         console.log("[AICQ Channel] channelRuntime available — AI dispatch enabled");
 
-        // 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 resolvedAgentId = agentId;
               const routeResult = await routing.resolveAgentRoute({
                 channelId: "aicq-chat",
                 accountId,
@@ -297,7 +376,6 @@ _plugin.gateway = {
                   cfg,
                   dispatcherOptions: {
                     deliver: async (payload) => {
-                      // Send AI reply back through AICQ
                       if (runtime.chat && payload.text) {
                         await runtime.chat.sendMessage(
                           resolvedAgentId,
@@ -331,6 +409,17 @@ _plugin.gateway = {
     });
 
     console.log(`[AICQ Channel] Account ${accountId} started successfully`);
+
+    // ── Keep startAccount alive until abort signal ──────────────────
+    // OpenClaw expects startAccount to be a long-lived task. If it
+    // resolves immediately, the gateway treats it as an unexpected
+    // exit and enters a restart loop. We wait on the abort signal.
+    await new Promise((resolve) => {
+      if (abortSignal?.aborted) { resolve(); return; }
+      const onAbort = () => { cleanup(); resolve(); };
+      const cleanup = () => { abortSignal?.removeEventListener("abort", onAbort); };
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+    });
   },
 
   /**
@@ -340,9 +429,13 @@ _plugin.gateway = {
     const { accountId } = ctx;
     console.log(`[AICQ Channel] stopAccount called for ${accountId}`);
 
-    if (runtime.serverClient && typeof runtime.serverClient.disconnect === "function") {
+    if (runtime.serverClient) {
       try {
-        runtime.serverClient.disconnect();
+        if (typeof runtime.serverClient.stop === "function") {
+          runtime.serverClient.stop();
+        } else if (typeof runtime.serverClient.disconnect === "function") {
+          runtime.serverClient.disconnect();
+        }
         console.log("[AICQ Channel] WebSocket disconnected");
       } catch (e) {
         console.warn("[AICQ Channel] Disconnect error:", e.message);
@@ -362,6 +455,8 @@ _plugin.config = {
   /**
    * List all account IDs configured for this channel.
    * Resolves template variables like {{agent.id}}.
+   *
+   * Signature: (cfg: OpenClawConfig) => string[]
    */
   listAccountIds(cfg) {
     const section = (cfg.channels || {})["aicq-chat"] || {};
@@ -374,40 +469,65 @@ _plugin.config = {
 
   /**
    * Resolve an account from config. Reuses the setup resolver.
+   *
+   * Signature: (cfg: OpenClawConfig, accountId?: string | null) => ResolvedAccount
    */
   resolveAccount,
 
   /**
    * Lightweight account inspection.
+   *
+   * Signature: (cfg: OpenClawConfig, accountId?: string | null) => unknown
    */
   inspectAccount,
 
   /**
    * Default account ID for this channel.
-   * Resolves {{agent.id}} to the actual agent ID.
+   *
+   * Signature: (cfg: OpenClawConfig) => string
    */
   defaultAccountId(cfg) {
     const section = (cfg.channels || {})["aicq-chat"] || {};
     if (section.accountId) {
       return resolveTemplateVar(cfg, section.accountId);
     }
-    return "default";
+    return OPENCLAW_DEFAULT_AGENT_ID;
   },
 
   /**
-   * Check if the channel is configured.
+   * Check if the account is enabled.
+   *
+   * IMPORTANT: OpenClaw calls this with (account, cfg) where `account`
+   * is the RESOLVED account object from resolveAccount(), not the config.
+   *
+   * Signature: (account: ResolvedAccount, cfg: OpenClawConfig) => boolean
    */
-  isConfigured(cfg) {
-    const section = (cfg.channels || {})["aicq-chat"] || {};
-    return Boolean(section.accountId);
+  isEnabled(account, cfg) {
+    return account.enabled !== false;
+  },
+
+  /**
+   * Check if the channel account is configured.
+   *
+   * IMPORTANT: OpenClaw calls this with (account, cfg) where `account`
+   * is the RESOLVED account object from resolveAccount(), not the config.
+   * Our old code had isConfigured(cfg) which received the account object
+   * as `cfg`, causing it to always return false — this was the root cause
+   * of the "not-running" bug.
+   *
+   * Signature: (account: ResolvedAccount, cfg: OpenClawConfig) => boolean
+   */
+  isConfigured(account, cfg) {
+    return Boolean(account && account.accountId);
   },
 
   /**
    * Return the reason the channel is not configured.
+   *
+   * Signature: (account: ResolvedAccount, cfg: OpenClawConfig) => string
    */
-  unconfiguredReason(cfg) {
-    const section = (cfg.channels || {})["aicq-chat"] || {};
-    if (!section.accountId) {
+  unconfiguredReason(account, cfg) {
+    if (!account || !account.accountId) {
       return "accountId is required — set channels.aicq-chat.accountId in openclaw.json";
     }
     return null;
@@ -415,14 +535,17 @@ _plugin.config = {
 
   /**
    * Describe the account for status surfaces.
+   *
+   * IMPORTANT: OpenClaw calls this with (account, cfg) where `account`
+   * is the RESOLVED account object, not the config.
+   *
+   * Signature: (account: ResolvedAccount, cfg: OpenClawConfig) => ChannelAccountSnapshot
    */
-  describeAccount(cfg, accountId) {
-    const section = (cfg.channels || {})["aicq-chat"] || {};
-    const rawId = accountId || section.accountId || null;
+  describeAccount(account, cfg) {
     return {
-      accountId: rawId ? resolveTemplateVar(cfg, rawId) : null,
+      accountId: account?.accountId || null,
       label: "AICQ Encrypted Chat",
-      enabled: section.enabled !== false,
+      enabled: account?.enabled !== false,
     };
   },
 };