aicq-chat-plugin 3.5.3 → 3.7.0

package/index.js

@@ -132,7 +132,7 @@ async function handleGatewayMethod(method, kwargs = {}) {
       return {
         state: _serverClient.connected ? "connected" : "disconnected",
         agent_id: currentAgentId,
-        version: "3.2.0",
+        version: "3.7.0",
         architecture: "channel",
       };
     case "aicq.friends.list":
@@ -268,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.3",
+  "version": "3.7.0",
   "description": "End-to-end encrypted chat channel via AICQ protocol — in-process Channel plugin using OpenClaw Channel SDK",
   "entry": "index.js",
   "activation": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicq-chat-plugin",
-  "version": "3.5.3",
+  "version": "3.7.0",
   "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

@@ -122,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
@@ -236,7 +274,7 @@ _plugin.gateway = {
    * listening for inbound messages.
    */
   async startAccount(ctx) {
-    const { cfg, accountId, account, setStatus, log } = ctx;
+    const { cfg, accountId, account, setStatus, log, abortSignal } = ctx;
 
     const logger = log || console;
     logger.info?.(`[AICQ Channel] startAccount called for ${accountId}`) || console.log(`[AICQ Channel] startAccount called for ${accountId}`);
@@ -287,7 +325,6 @@ _plugin.gateway = {
         console.log(`[AICQ Channel] Authenticated as ${agentId}`);
 
         // Connect WebSocket for real-time messages
-        // ServerClient.start() does ensureAuth + connectWS
         if (typeof runtime.serverClient.start === "function") {
           await runtime.serverClient.start(agentId);
           console.log("[AICQ Channel] WebSocket connected");
@@ -310,57 +347,112 @@ _plugin.gateway = {
       }
     }
 
-    // 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");
-
-        // Register inbound message handler on the serverClient
-        if (runtime.serverClient && typeof runtime.serverClient.onMessage === "function") {
-          runtime.serverClient.onMessage(async (msg) => {
-            try {
-              const resolvedAgentId = agentId;
-              const routeResult = await routing.resolveAgentRoute({
-                channelId: "aicq-chat",
-                accountId,
-                fromId: msg.from || msg.sender_id,
-                chatType: msg.isGroup ? "group" : "dm",
-              });
+    // Wire up inbound message handling
+    // Register handlers for AICQ message types. When an inbound message arrives,
+    // we try the OpenClaw channelRuntime first; if that fails we fall back to
+    // calling z-ai CLI directly and sending the reply via chat.sendMessage.
+    if (runtime.serverClient && typeof runtime.serverClient.onMessage === "function") {
+      const inboundHandler = async (msg) => {
+        try {
+          // AICQ server wraps message content in msg.data for "message" type,
+          // but "relay" type may have fields at the top level.
+          const data = msg.data || msg;
+          const fromId = data.from || data.fromId || data.sender_id || msg.from || msg.fromId;
+          const isGroup = !!(data.isGroup || data.groupId || msg.isGroup || msg.groupId);
+          const text = data.content || data.text || data.payload || msg.content || msg.text || msg.payload || "";
+
+          console.log(`[AICQ Channel] Inbound message from=${fromId} isGroup=${isGroup} text=${(text || "").substring(0, 80)}`);
+
+          if (!fromId || !text) {
+            return; // Skip system messages (online_ack, presence, etc.)
+          }
 
-              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 }
-                        );
-                      }
-                    },
-                  },
+          // Skip our own messages
+          if (fromId === runtime.serverClient?.serverAccountId || fromId === agentId) {
+            return;
+          }
+
+          // Try channelRuntime (OpenClaw's built-in agent dispatch) first
+          if (ctx.channelRuntime) {
+            const { reply, routing } = ctx.channelRuntime;
+            if (reply && routing) {
+              try {
+                const routeResult = await routing.resolveAgentRoute({
+                  channelId: "aicq-chat",
+                  accountId,
+                  fromId,
+                  chatType: isGroup ? "group" : "dm",
                 });
+
+                if (routeResult?.agentId) {
+                  await reply.dispatchReplyWithBufferedBlockDispatcher({
+                    ctx: {
+                      channelId: "aicq-chat",
+                      accountId,
+                      fromId,
+                      text,
+                      chatType: isGroup ? "group" : "dm",
+                    },
+                    cfg,
+                    dispatcherOptions: {
+                      deliver: async (payload) => {
+                        if (runtime.chat && payload.text) {
+                          await runtime.chat.sendMessage(agentId, fromId, payload.text, { isGroup });
+                        }
+                      },
+                    },
+                  });
+                  return; // Successfully dispatched via channelRuntime
+                }
+              } catch (e) {
+                console.error("[AICQ Channel] channelRuntime dispatch failed, using fallback:", e.message);
               }
-            } catch (e) {
-              console.error("[AICQ Channel] Inbound message handling error:", e.message);
             }
-          });
+          }
+
+          // Fallback: call LLM via z-ai CLI and send reply directly
+          console.log("[AICQ Channel] Using fallback: direct z-ai CLI call");
+          try {
+            const { execFile } = await import('child_process');
+            const llmResult = await new Promise((resolve, reject) => {
+              execFile('z-ai', ['chat', '--prompt', text], { timeout: 60000 }, (err, stdout) => {
+                if (err) reject(err);
+                else resolve(stdout);
+              });
+            });
+            let replyText = '';
+            const jsonStart = llmResult.indexOf('{');
+            if (jsonStart >= 0) {
+              try {
+                const parsed = JSON.parse(llmResult.substring(jsonStart));
+                replyText = parsed.choices?.[0]?.message?.content || llmResult.trim();
+              } catch { replyText = llmResult.trim(); }
+            } else { replyText = llmResult.trim(); }
+
+            if (replyText && runtime.chat) {
+              await runtime.chat.sendMessage(agentId, fromId, replyText, { isGroup });
+              console.log(`[AICQ Channel] Fallback reply sent to ${fromId}: ${replyText.substring(0, 50)}`);
+            }
+          } catch (fallbackErr) {
+            console.error("[AICQ Channel] Fallback LLM also failed:", fallbackErr.message);
+          }
+        } catch (e) {
+          console.error("[AICQ Channel] Inbound message handling error:", e.message);
         }
+      };
+
+      // Register handler for relevant AICQ message types.
+      // ServerClient.onMessage(type, handler) requires a type string.
+      runtime.serverClient.onMessage("relay", inboundHandler);
+      runtime.serverClient.onMessage("message", inboundHandler);
+      runtime.serverClient.onMessage("group_message", inboundHandler);
+      console.log("[AICQ Channel] Inbound message handlers registered (relay, message, group_message)");
+
+      if (ctx.channelRuntime) {
+        console.log("[AICQ Channel] channelRuntime available — AI dispatch enabled (with z-ai CLI fallback)");
+      } else {
+        console.log("[AICQ Channel] channelRuntime not available — using z-ai CLI fallback");
       }
-    } else {
-      console.log("[AICQ Channel] channelRuntime not available — running in standalone mode");
     }
 
     // Update health status
@@ -374,6 +466,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 });
+    });
   },
 
   /**
@@ -409,6 +512,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"] || {};
@@ -421,17 +526,22 @@ _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"] || {};
@@ -442,19 +552,39 @@ _plugin.config = {
   },
 
   /**
-   * 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;
@@ -462,14 +592,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,
     };
   },
 };