aicq-chat-plugin 3.2.2 → 3.3.1

package/index.mjs

@@ -0,0 +1,70 @@
+/**
+ * AICQ Chat Plugin — Channel Plugin Entry Point (ESM)
+ *
+ * Uses OpenClaw Channel Plugin SDK:
+ *   - defineChannelPluginEntry from openclaw/plugin-sdk/channel-core
+ *   - createChatChannelPlugin from openclaw/plugin-sdk/channel-core
+ *
+ * Architecture: In-process Channel (no sidecar, no independent port)
+ */
+import { defineChannelPluginEntry } from 'openclaw/plugin-sdk/channel-core';
+import { aicqChatPlugin } from './src/channel.mjs';
+
+export default defineChannelPluginEntry({
+  id: 'aicq-chat',
+  name: 'AICQ Encrypted Chat',
+  description: 'End-to-end encrypted chat channel via AICQ protocol — in-process Channel plugin',
+  plugin: aicqChatPlugin,
+
+  registerCliMetadata(api) {
+    api.registerCli(
+      ({ program }) => {
+        program
+          .command('aicq-chat')
+          .description('AICQ Encrypted Chat management');
+      },
+      {
+        descriptors: [
+          {
+            name: 'aicq-chat',
+            description: 'AICQ Encrypted Chat management',
+            hasSubcommands: false,
+          },
+        ],
+      },
+    );
+  },
+
+  registerFull(api) {
+    // Register gateway HTTP routes for the SPA UI
+    const gatewayMethods = [
+      '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.streamChunk',
+      'aicq.chat.streamEnd',
+      'aicq.groups.list',
+      'aicq.groups.create',
+      'aicq.groups.join',
+      'aicq.groups.messages',
+      'aicq.groups.silent',
+      'aicq.sessions.list',
+    ];
+
+    for (const method of gatewayMethods) {
+      api.registerGatewayMethod(method, async (kwargs, ctx) => {
+        const { handleGateway } = await import('./src/gateway-handlers.mjs');
+        return handleGateway(method, kwargs, ctx);
+      });
+    }
+  },
+});

package/openclaw.plugin.json

@@ -2,9 +2,9 @@
   "kind": "channel",
   "id": "aicq-chat",
   "name": "AICQ Encrypted Chat",
-  "version": "3.2.2",
-  "description": "End-to-end encrypted chat channel via AICQ protocol — in-process Channel plugin",
-  "entry": "index.js",
+  "version": "3.3.1",
+  "description": "End-to-end encrypted chat channel via AICQ protocol — in-process Channel plugin using OpenClaw Channel SDK",
+  "entry": "index.mjs",
   "activation": {
     "onStartup": true
   },
@@ -17,7 +17,6 @@
       "label": "AICQ Encrypted Chat",
       "description": "End-to-end encrypted chat channel via AICQ protocol",
       "schema": {
-        "$schema": "http://json-schema.org/draft-07/schema#",
         "type": "object",
         "additionalProperties": false,
         "properties": {

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "aicq-chat-plugin",
-  "version": "3.2.2",
-  "description": "AICQ End-to-end Encrypted Chat Channel Plugin for OpenClaw — In-process Channel architecture with friend management, group chat, file transfer, and AI agent communication",
-  "main": "index.js",
+  "version": "3.3.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.mjs",
   "bin": {
     "aicq-plugin": "cli.js"
   },
   "files": [
+    "index.mjs",
     "index.js",
+    "setup-entry.mjs",
     "setup-entry.js",
     "cli.js",
     "postinstall.js",
@@ -19,7 +22,8 @@
     "README.md"
   ],
   "scripts": {
-    "start": "node index.js",
+    "start": "node index.mjs",
+    "start:cjs": "node index.js",
     "postinstall": "node postinstall.js",
     "install-deps": "npm install"
   },
@@ -62,8 +66,9 @@
   },
   "openclaw": {
     "extensions": [
-      "./index.js"
+      "./index.mjs"
     ],
+    "setupEntry": "./setup-entry.mjs",
     "channel": {
       "id": "aicq-chat",
       "label": "AICQ Encrypted Chat",

package/setup-entry.mjs

@@ -0,0 +1,9 @@
+/**
+ * AICQ Setup Entry — Setup Wizard for first-time configuration
+ *
+ * Uses defineSetupPluginEntry from the OpenClaw Channel SDK
+ */
+import { defineSetupPluginEntry } from 'openclaw/plugin-sdk/channel-core';
+import { aicqChatPlugin } from './src/channel.mjs';
+
+export default defineSetupPluginEntry(aicqChatPlugin);

package/src/channel.mjs

@@ -0,0 +1,254 @@
+/**
+ * AICQ Channel Plugin — Core Channel Logic (ESM)
+ *
+ * Uses OpenClaw Channel Plugin SDK:
+ *   - createChatChannelPlugin from openclaw/plugin-sdk/channel-core
+ *   - createChannelPluginBase from openclaw/plugin-sdk/channel-core
+ *
+ * Wraps existing lib/ modules (identity, server-client, handshake, chat, database)
+ * into the proper OpenClaw Channel plugin interface.
+ */
+import { createChatChannelPlugin, createChannelPluginBase } from 'openclaw/plugin-sdk/channel-core';
+import { createRequire } from 'module';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const require = createRequire(import.meta.url);
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+// ── Configuration ──────────────────────────────────────────────────
+const DATA_DIR = process.env.AICQ_DATA_DIR || path.join(os.homedir(), '.aicq-plugin');
+const SERVER_URL = process.env.AICQ_SERVER_URL || 'https://aicq.online';
+
+fs.mkdirSync(DATA_DIR, { recursive: true });
+
+// ── Lazy-loaded CommonJS modules ───────────────────────────────────
+let _db = null;
+let _identity = null;
+let _serverClient = null;
+let _handshake = null;
+let _chat = null;
+let _initialized = false;
+
+/**
+ * Initialize all plugin components (async, called once)
+ */
+async function ensureInitialized() {
+  if (_initialized) return;
+
+  const PluginDatabase = require('../lib/database');
+  const IdentityManager = require('../lib/identity');
+  const ServerClient = require('../lib/server-client');
+  const HandshakeManager = require('../lib/handshake');
+  const ChatManager = require('../lib/chat');
+
+  // Initialize database
+  _db = new PluginDatabase(DATA_DIR);
+  await _db.init();
+  console.log('[AICQ Channel] Database initialized');
+
+  // Initialize managers
+  _identity = new IdentityManager(_db);
+  _serverClient = new ServerClient(_identity, _db, SERVER_URL);
+  _handshake = new HandshakeManager(_identity, _serverClient, _db);
+  _chat = new ChatManager(_identity, _serverClient, _db, path.join(DATA_DIR, 'uploads'));
+
+  // Periodic cleanup
+  setInterval(() => _db.cleanup(), 3600000);
+
+  _initialized = true;
+  console.log('[AICQ Channel] Plugin components initialized');
+}
+
+/**
+ * Resolve account from OpenClaw config
+ * Reads channels.<channel-id> section and returns a resolved account object
+ */
+function resolveAccount(cfg, accountId) {
+  const section = (cfg.channels || {})[ 'aicq-chat' ];
+  const token = section?.accountId || accountId || null;
+  return {
+    accountId: token,
+    serverUrl: section?.serverUrl || SERVER_URL,
+    autoAcceptFriends: section?.autoAcceptFriends ?? true,
+    dmPolicy: section?.dmPolicy || 'allowlist',
+    enabled: section?.enabled ?? true,
+  };
+}
+
+/**
+ * Inspect account without materializing secrets
+ */
+function inspectAccount(cfg, accountId) {
+  const section = (cfg.channels || {})[ 'aicq-chat' ];
+  return {
+    enabled: section?.enabled ?? true,
+    configured: Boolean(section?.accountId || accountId),
+    hasAccountId: Boolean(section?.accountId || accountId),
+  };
+}
+
+// ── Build the Channel Plugin using SDK ──────────────────────────────
+export const aicqChatPlugin = createChatChannelPlugin({
+  base: createChannelPluginBase({
+    id: 'aicq-chat',
+    setup: {
+      resolveAccount,
+      inspectAccount,
+    },
+  }),
+
+  // DM security: who can message the bot
+  security: {
+    dm: {
+      channelKey: 'aicq-chat',
+      resolvePolicy: (account) => account.dmPolicy || 'allowlist',
+      resolveAllowFrom: async (account) => {
+        // Only friends in the contact list can send DMs
+        await ensureInitialized();
+        if (!_identity || !account.accountId) return [];
+        const friends = _db.listFriends(account.accountId);
+        return friends.map(f => f.id || f.friend_id);
+      },
+      defaultPolicy: 'allowlist',
+    },
+  },
+
+  // Pairing: DM approval flow for new contacts
+  pairing: {
+    text: {
+      idLabel: 'AICQ Account ID',
+      message: 'Share this pairing code with the other party to verify your identity:',
+      generate: async ({ target, code }) => {
+        await ensureInitialized();
+        if (_handshake && target) {
+          try {
+            await _serverClient.ensureAuth(target);
+            const result = await _handshake.generateFriendCode(target);
+            return { code: result.number, instructions: `Share this pairing code: ${result.number}` };
+          } catch (e) {
+            // Fallback to the generated code
+          }
+        }
+        return { code, instructions: `Share this pairing code: ${code}` };
+      },
+      verify: async ({ accountId, peerCode }) => {
+        await ensureInitialized();
+        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 };
+        }
+      },
+    },
+  },
+
+  // Threading: how replies are delivered
+  threading: {
+    topLevelReplyToMode: 'reply',
+  },
+
+  // Outbound: send messages to the platform
+  outbound: {
+    attachedResults: {
+      sendText: async (params) => {
+        await ensureInitialized();
+        const result = await _chat.sendMessage(
+          params.fromAccountId || params.accountId,
+          params.to,
+          params.text,
+          { isGroup: false }
+        );
+        return { messageId: result?.message_id || result?.id || `msg_${Date.now()}` };
+      },
+    },
+    base: {
+      sendMedia: async (params) => {
+        await ensureInitialized();
+        const result = await _chat.sendMessage(
+          params.fromAccountId || params.accountId,
+          params.to,
+          params.mediaUrl || params.filePath,
+          { type: params.mediaType || 'file', isGroup: false }
+        );
+        return { messageId: result?.message_id || result?.id || `msg_${Date.now()}` };
+      },
+    },
+  },
+
+  // Lifecycle: account management
+  lifecycle: {
+    onAccountCreate: async (accountId) => {
+      await ensureInitialized();
+      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);
+      }
+    },
+    onAccountDelete: async (accountId) => {
+      try {
+        _serverClient.disconnect();
+      } catch (e) {}
+      _identity.deleteAgent(accountId);
+    },
+    onShutdown: async () => {
+      try {
+        _serverClient.stop();
+      } catch (e) {}
+      console.log('[AICQ Channel] Shutdown complete');
+    },
+  },
+
+  // Inbound: process incoming messages (used when AICQ server pushes messages)
+  inbound: {
+    onText: async (message) => {
+      const { toAccountId, fromPeerId, encryptedContent } = message;
+      await ensureInitialized();
+
+      let content = encryptedContent || message.content || message.payload || '';
+      const session = _db.loadSession(toAccountId, fromPeerId);
+      if (session && session.session_key && typeof content === 'string') {
+        try {
+          const { decryptMessage } = require('../lib/crypto');
+          content = decryptMessage(content, session.session_key);
+        } catch (e) {
+          // Might be plaintext, keep as is
+        }
+      }
+
+      return {
+        text: typeof content === 'string' ? content : JSON.stringify(content),
+        metadata: {
+          fromPeerId,
+          timestamp: message.timestamp,
+        },
+      };
+    },
+    onMedia: async (message) => {
+      await ensureInitialized();
+      let content = message.encryptedContent || message.content || '';
+      const session = _db.loadSession(message.toAccountId, message.fromPeerId);
+      if (session && session.session_key && typeof content === 'string') {
+        try {
+          const { decryptMessage } = require('../lib/crypto');
+          content = decryptMessage(content, session.session_key);
+        } catch (e) {}
+      }
+      return {
+        mediaUrl: content,
+        mediaType: message.mediaType || 'file',
+        metadata: { fromPeerId: message.fromPeerId },
+      };
+    },
+  },
+});
+
+// Export for gateway handlers to access managers
+export { ensureInitialized, _db, _identity, _serverClient, _handshake, _chat };

package/src/gateway-handlers.mjs

@@ -0,0 +1,178 @@
+/**
+ * AICQ Gateway Handlers — Gateway method implementations
+ *
+ * Handles all aicq.* gateway methods for the SPA UI.
+ * Lazy-initializes the plugin components on first call.
+ */
+
+let _handlersInitialized = false;
+let _db = null;
+let _identity = null;
+let _serverClient = null;
+let _handshake = null;
+let _chat = null;
+
+async function ensureHandlersInitialized() {
+  if (_handlersInitialized) return;
+
+  try {
+    const channelModule = await import('./channel.mjs');
+    await channelModule.ensureInitialized();
+    // Access the lazy-loaded managers through the module's exports
+    _db = channelModule._db;
+    _identity = channelModule._identity;
+    _serverClient = channelModule._serverClient;
+    _handshake = channelModule._handshake;
+    _chat = channelModule._chat;
+    _handlersInitialized = true;
+  } catch (e) {
+    console.error('[AICQ Gateway] Failed to initialize handlers:', e.message);
+    throw e;
+  }
+}
+
+function getCurrentAgentId() {
+  if (!_identity) return null;
+  const agents = _identity.listAgents();
+  return agents.length > 0 ? agents[0].agent_id : null;
+}
+
+/**
+ * Main gateway method dispatcher
+ */
+export async function handleGateway(method, kwargs = {}, ctx = {}) {
+  await ensureHandlersInitialized();
+  const currentAgentId = getCurrentAgentId();
+
+  switch (method) {
+    case 'aicq.status':
+      return {
+        state: _serverClient?.connected ? 'connected' : 'disconnected',
+        agent_id: currentAgentId,
+        version: '3.3.0',
+        architecture: 'channel',
+      };
+
+    case 'aicq.friends.list':
+      return { friends: _db?.listFriends(currentAgentId) || [] };
+
+    case 'aicq.friends.add':
+      return await _handshake?.addFriendByCode(currentAgentId, kwargs.temp_number);
+
+    case 'aicq.friends.remove':
+      _db?.removeFriend(currentAgentId, kwargs.friend_id);
+      return { success: true };
+
+    case 'aicq.friends.requests':
+      return { requests: _db?.getPendingRequests(currentAgentId) || [] };
+
+    case 'aicq.friends.acceptRequest':
+      return await _handshake?.acceptRequest(currentAgentId, kwargs.request_id);
+
+    case 'aicq.friends.rejectRequest':
+      return await _handshake?.rejectRequest(currentAgentId, kwargs.request_id);
+
+    case 'aicq.identity.info':
+      return _identity?.getInfo(currentAgentId) || {};
+
+    case 'aicq.agent.create':
+      _identity?.createAgent(kwargs.agent_id, kwargs.nickname);
+      return { success: true };
+
+    case 'aicq.agent.delete':
+      _identity?.deleteAgent(kwargs.agent_id);
+      return { success: true };
+
+    case 'aicq.chat.send':
+      return await _chat?.sendMessage(currentAgentId, kwargs.targetId, kwargs.content, { isGroup: kwargs.isGroup });
+
+    case 'aicq.chat.history':
+      return { messages: _db?.getChatHistory(currentAgentId, kwargs.targetId, { limit: kwargs.limit || 50 }) || [] };
+
+    case 'aicq.chat.streamChunk': {
+      if (!kwargs.friend_id && !kwargs.targetId) return { error: 'friend_id or targetId is required' };
+      if (!kwargs.data) return { error: 'data is required' };
+      const chunkType = kwargs.chunk_type || kwargs.chunkType || 'text';
+      const ALLOWED_CHUNK_TYPES = ['text', 'reasoning', 'thinking', 'clear_text', 'tool_call', 'tool_result'];
+      if (!ALLOWED_CHUNK_TYPES.includes(chunkType)) return { error: `Invalid chunk_type: ${chunkType}. Allowed: ${ALLOWED_CHUNK_TYPES.join(', ')}` };
+      const streamTarget = kwargs.friend_id || kwargs.targetId;
+      const sent = _serverClient?.sendWS({
+        type: 'stream_chunk',
+        to: streamTarget,
+        chunkType: chunkType,
+        data: kwargs.data,
+      });
+      if (!sent) return { error: 'Not connected to server', success: false };
+      return { success: true };
+    }
+
+    case 'aicq.chat.streamEnd': {
+      if (!kwargs.friend_id && !kwargs.targetId) return { error: 'friend_id or targetId is required' };
+      const endTarget = kwargs.friend_id || kwargs.targetId;
+      const msgId = kwargs.message_id || kwargs.messageId || ('msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 6));
+      const endSent = _serverClient?.sendWS({
+        type: 'stream_end',
+        to: endTarget,
+        messageId: msgId,
+      });
+      if (!endSent) return { error: 'Not connected to server', success: false };
+      return { success: true, messageId: msgId };
+    }
+
+    case 'aicq.groups.list':
+      return { groups: _db?.listGroups(currentAgentId) || [] };
+
+    case 'aicq.groups.create': {
+      await _serverClient?.ensureAuth(currentAgentId);
+      const result = await _serverClient?.createGroup(kwargs.name, kwargs.description);
+      if (result?.id) {
+        _db?.addGroup({
+          agent_id: currentAgentId,
+          id: result.id,
+          name: kwargs.name,
+          owner_id: currentAgentId,
+          members_json: result.members || '[]',
+          description: kwargs.description || '',
+        });
+      }
+      return { success: true, group: result };
+    }
+
+    case 'aicq.groups.join':
+      await _serverClient?.ensureAuth(currentAgentId);
+      return await _serverClient?.inviteGroupMember(kwargs.group_id, currentAgentId);
+
+    case 'aicq.groups.messages': {
+      await _serverClient?.ensureAuth(currentAgentId);
+      return await _serverClient?.getGroupMessages(kwargs.group_id, kwargs.limit || 50);
+    }
+
+    case 'aicq.groups.silent':
+      _db?.setGroupSilentMode(currentAgentId, kwargs.group_id, !!kwargs.silent);
+      return { success: true, silent: !!kwargs.silent };
+
+    default:
+      return { error: `Unknown method: ${method}` };
+  }
+}
+
+// Individual method exports (for direct registration)
+export async function getStatus(kwargs, ctx) { return handleGateway('aicq.status', kwargs, ctx); }
+export async function listFriends(kwargs, ctx) { return handleGateway('aicq.friends.list', kwargs, ctx); }
+export async function addFriend(kwargs, ctx) { return handleGateway('aicq.friends.add', kwargs, ctx); }
+export async function removeFriend(kwargs, ctx) { return handleGateway('aicq.friends.remove', kwargs, ctx); }
+export async function listFriendRequests(kwargs, ctx) { return handleGateway('aicq.friends.requests', kwargs, ctx); }
+export async function acceptFriendRequest(kwargs, ctx) { return handleGateway('aicq.friends.acceptRequest', kwargs, ctx); }
+export async function rejectFriendRequest(kwargs, ctx) { return handleGateway('aicq.friends.rejectRequest', kwargs, ctx); }
+export async function getIdentityInfo(kwargs, ctx) { return handleGateway('aicq.identity.info', kwargs, ctx); }
+export async function createAgent(kwargs, ctx) { return handleGateway('aicq.agent.create', kwargs, ctx); }
+export async function deleteAgent(kwargs, ctx) { return handleGateway('aicq.agent.delete', kwargs, ctx); }
+export async function chatSend(kwargs, ctx) { return handleGateway('aicq.chat.send', kwargs, ctx); }
+export async function chatHistory(kwargs, ctx) { return handleGateway('aicq.chat.history', kwargs, ctx); }
+export async function chatStreamChunk(kwargs, ctx) { return handleGateway('aicq.chat.streamChunk', kwargs, ctx); }
+export async function chatStreamEnd(kwargs, ctx) { return handleGateway('aicq.chat.streamEnd', kwargs, ctx); }
+export async function listGroups(kwargs, ctx) { return handleGateway('aicq.groups.list', kwargs, ctx); }
+export async function createGroup(kwargs, ctx) { return handleGateway('aicq.groups.create', kwargs, ctx); }
+export async function joinGroup(kwargs, ctx) { return handleGateway('aicq.groups.join', kwargs, ctx); }
+export async function getGroupMessages(kwargs, ctx) { return handleGateway('aicq.groups.messages', kwargs, ctx); }
+export async function setGroupSilent(kwargs, ctx) { return handleGateway('aicq.groups.silent', kwargs, ctx); }