aicq-chat-plugin 2.6.7 → 3.0.1

package/index.js

@@ -1,671 +1,394 @@
 /**
- * AICQ Chat Plugin — Main Entry Point
- * OpenClaw sidecar plugin providing E2EE chat UI
+ * AICQ Chat Plugin — Channel Plugin Entry Point
  *
- * Uses sql.js (pure WASM SQLite) instead of better-sqlite3
- * to avoid native C++ compilation issues.
+ * Architecture: Channel (in-process, no independent port)
+ * - Runs inside the OpenClaw process
+ * - Uses createChatChannelPlugin for E2EE chat channel
+ * - Provides Gateway HTTP routes for the SPA UI
+ * - No sidecar process needed
  */
-const express = require('express');
-const multer = require('multer');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const QRCode = require('qrcode');
-const PluginDatabase = require('./lib/database');
 
-// ─── Configuration ──────────────────────────────────────────────────
-const PORT = parseInt(process.env.AICQ_PORT || '6109', 10);
-const SERVER_URL = process.env.AICQ_SERVER_URL || 'https://aicq.online';
+// ── Configuration ──────────────────────────────────────────────────
 const DATA_DIR = process.env.AICQ_DATA_DIR || path.join(os.homedir(), '.aicq-plugin');
-const UPLOADS_DIR = path.join(DATA_DIR, 'uploads');
+const SERVER_URL = process.env.AICQ_SERVER_URL || 'https://aicq.online';
 
 fs.mkdirSync(DATA_DIR, { recursive: true });
-fs.mkdirSync(UPLOADS_DIR, { recursive: true });
 
-// ─── Async bootstrap ────────────────────────────────────────────────
-// sql.js requires async init, so we wrap the entire app setup
-(async () => {
-  // Initialize database (async — loads WASM + opens/creates DB file)
-  const db = new PluginDatabase(DATA_DIR);
-  await db.init();
-  console.log('[AICQ] Database initialized');
+// ── Lazy-loaded modules (require db init) ──────────────────────────
+let _db = null;
+let _identity = null;
+let _serverClient = null;
+let _handshake = null;
+let _chat = null;
+let _channel = null;
+let _uiRoutes = null;
+let _initialized = false;
+
+/**
+ * Initialize all plugin components (async, called once)
+ */
+async function ensureInitialized() {
+  if (_initialized) return;
 
-  // Lazy-load modules that depend on db
+  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');
 
-  const identity = new IdentityManager(db);
-  const serverClient = new ServerClient(identity, db, SERVER_URL);
-  const handshake = new HandshakeManager(identity, serverClient, db);
-  const chat = new ChatManager(identity, serverClient, db, UPLOADS_DIR);
+  // 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'));
+
+  // Load channel and UI route creators
+  const { createAicqChannel } = require('./src/channel');
+  const { createUiRoutes } = require('./src/ui-routes');
+
+  _channel = createAicqChannel({
+    db: _db,
+    identity: _identity,
+    serverClient: _serverClient,
+    handshake: _handshake,
+    chat: _chat,
+    dataDir: DATA_DIR,
+    serverUrl: SERVER_URL,
+  });
+
+  _uiRoutes = createUiRoutes({
+    db: _db,
+    identity: _identity,
+    serverClient: _serverClient,
+    handshake: _handshake,
+    chat: _chat,
+    dataDir: DATA_DIR,
+  });
+
+  // Periodic cleanup
+  setInterval(() => _db.cleanup(), 3600000);
+
+  _initialized = true;
+  console.log('[AICQ Channel] Plugin components initialized');
+}
+
+// ── register() — Called by OpenClaw when the plugin is discovered ────
+function register() {
+  return {
+    id: 'aicq-chat',
+    name: 'AICQ Encrypted Chat',
+    version: '3.0.0',
+    description: 'End-to-end encrypted chat channel plugin for OpenClaw agents',
+    kind: 'channel',
+
+    // Channel configuration
+    channel: {
+      id: 'aicq-chat',
+      label: 'AICQ Encrypted Chat',
+    },
 
-  // Auto-create a default agent if none exists
-  const agents = identity.listAgents();
-  let currentAgentId = null;
+    // Tool definitions for OpenClaw agent use
+    tools: {
+      'chat-friend': {
+        description: 'Manage AICQ friends — list, add by friend code, remove, view requests, accept/reject requests',
+        parameters: {
+          type: 'object',
+          properties: {
+            action: {
+              type: 'string',
+              enum: ['list', 'add', 'remove', 'requests', 'accept', 'reject'],
+              description: 'The friend management action to perform',
+            },
+            friend_code: {
+              type: 'string',
+              description: 'Friend code or temp number for adding a friend',
+            },
+            friend_id: {
+              type: 'string',
+              description: 'Friend ID for remove/accept/reject actions',
+            },
+          },
+          required: ['action'],
+        },
+      },
+      'chat-send': {
+        description: 'Send an encrypted message to a friend or group via AICQ',
+        parameters: {
+          type: 'object',
+          properties: {
+            targetId: {
+              type: 'string',
+              description: 'The friend ID or group ID to send the message to',
+            },
+            content: {
+              type: 'string',
+              description: 'The message content to send',
+            },
+            isGroup: {
+              type: 'boolean',
+              description: 'Whether the target is a group (default: false)',
+            },
+          },
+          required: ['targetId', 'content'],
+        },
+      },
+      'chat-export-key': {
+        description: 'Export your AICQ identity public key and fingerprint for sharing',
+        parameters: {
+          type: 'object',
+          properties: {
+            format: {
+              type: 'string',
+              enum: ['json', 'qr'],
+              description: 'Output format: json for key data, qr for QR code image (default: json)',
+            },
+          },
+        },
+      },
+    },
+  };
+}
+
+// ── activate() — Called by OpenClaw when the plugin is enabled ───────
+async function activate(config) {
+  await ensureInitialized();
+
+  // Auto-create default agent if none exists
+  const agents = _identity.listAgents();
+  let currentAgentId;
   if (agents.length === 0) {
-    const defaultAgent = identity.createAgent('agent-' + Date.now(), '默认Agent');
+    const defaultAgent = _identity.createAgent('agent-' + Date.now(), '默认Agent');
     currentAgentId = defaultAgent.agent_id;
-    console.log('[AICQ] Created default agent:', currentAgentId);
+    console.log('[AICQ Channel] Created default agent:', currentAgentId);
   } else {
     currentAgentId = agents[0].agent_id;
   }
 
-  // Connect to server in background
-  (async () => {
-    try {
-      await serverClient.start(currentAgentId);
-      await syncFriendsFromServer(currentAgentId);
-      await syncGroupsFromServer(currentAgentId);
-    } catch (e) {
-      console.error('[AICQ] Initial server connection failed:', e.message);
-    }
-  })();
-
-  // Periodic cleanup + save
-  setInterval(() => db.cleanup(), 3600000);
-
-  // ─── Helper: get current agent ID ──────────────────────────────────
-  function getAgentId(req) {
-    return req.query.agent_id || req.body?.agent_id || currentAgentId;
+  // Connect to AICQ server
+  try {
+    await _serverClient.start(currentAgentId);
+    // Sync friends and groups from server
+    await syncFriendsFromServer(currentAgentId);
+    await syncGroupsFromServer(currentAgentId);
+  } catch (e) {
+    console.error('[AICQ Channel] Initial server connection failed:', e.message);
   }
 
-  // ─── Sync friends/groups from server ────────────────────────────────
-  async function syncFriendsFromServer(agentId) {
-    try {
-      await serverClient.ensureAuth(agentId);
-      const result = await serverClient.listFriends();
-      if (result.friends) {
-        for (const f of result.friends) {
-          const existing = db.getFriend(agentId, f.id);
-          if (!existing) {
-            db.addFriend({
-              agent_id: agentId,
-              id: f.id,
-              public_key: f.public_key || f.publicKey || '',
-              fingerprint: f.fingerprint || '',
-              friend_type: f.type || f.friend_type || 'ai',
-              ai_name: f.agent_name || f.ai_name || f.displayName || '',
-            });
-          } else {
-            db.updateFriendOnline(agentId, f.id, f.is_online || f.isOnline || false);
-          }
-        }
-      }
-    } catch (e) {
-      console.error('[AICQ] Sync friends failed:', e.message);
-    }
-  }
-
-  async function syncGroupsFromServer(agentId) {
-    try {
-      await serverClient.ensureAuth(agentId);
-      const result = await serverClient.listGroups();
-      if (result.groups) {
-        for (const g of result.groups) {
-          db.addGroup({
+  return {
+    handleTool,
+    handleGateway,
+    channel: _channel,
+    gatewayRoutes: _uiRoutes,
+  };
+}
+
+// ── Sync helpers ────────────────────────────────────────────────────
+async function syncFriendsFromServer(agentId) {
+  try {
+    await _serverClient.ensureAuth(agentId);
+    const result = await _serverClient.listFriends();
+    if (result.friends) {
+      for (const f of result.friends) {
+        const existing = _db.getFriend(agentId, f.id);
+        if (!existing) {
+          _db.addFriend({
             agent_id: agentId,
-            id: g.id,
-            name: g.name,
-            owner_id: g.owner_id || g.ownerId || '',
-            members_json: g.members || g.members_json || '[]',
-            description: g.description || '',
+            id: f.id,
+            public_key: f.public_key || f.publicKey || '',
+            fingerprint: f.fingerprint || '',
+            friend_type: f.type || f.friend_type || 'ai',
+            ai_name: f.agent_name || f.ai_name || f.displayName || '',
           });
+        } else {
+          _db.updateFriendOnline(agentId, f.id, f.is_online || f.isOnline || false);
         }
       }
-    } catch (e) {
-      console.error('[AICQ] Sync groups failed:', e.message);
     }
+  } catch (e) {
+    console.error('[AICQ Channel] Sync friends failed:', e.message);
   }
-
-  // ─── Express App ────────────────────────────────────────────────────
-  const app = express();
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
-
-  const upload = multer({
-    storage: multer.memoryStorage(),
-    limits: { fileSize: 50 * 1024 * 1024 }, // 50MB
-  });
-
-  // ─── Serve SPA ──────────────────────────────────────────────────────
-  app.use(express.static(path.join(__dirname, 'public')));
-
-  // ─── API Routes ─────────────────────────────────────────────────────
-
-  // Status
-  app.get('/api/status', (req, res) => {
-    res.json({
-      status: 'running',
-      version: '2.6.0',
-      connected: serverClient.connected,
-      currentAgent: currentAgentId,
-      serverUrl: SERVER_URL,
-    });
-  });
-
-  // Agents
-  app.get('/api/agents', (req, res) => {
-    res.json({ agents: identity.listAgents() });
-  });
-
-  app.post('/api/agents', async (req, res) => {
-    try {
-      const { agent_id, nickname } = req.body;
-      if (!agent_id) return res.status(400).json({ error: 'agent_id is required' });
-      const agent = identity.createAgent(agent_id, nickname);
-      currentAgentId = agent_id;
-      try {
-        await serverClient.start(agent_id);
-      } catch (e) {
-        console.error('Server registration failed:', e.message);
-      }
-      res.json({ success: true, agent });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.delete('/api/agents/:id', (req, res) => {
-    identity.deleteAgent(req.params.id);
-    if (currentAgentId === req.params.id) {
-      const remaining = identity.listAgents();
-      currentAgentId = remaining.length > 0 ? remaining[0].agent_id : null;
-    }
-    res.json({ success: true });
-  });
-
-  app.post('/api/agents/switch', async (req, res) => {
-    try {
-      const { agent_id } = req.body;
-      if (!agent_id) return res.status(400).json({ error: 'agent_id is required' });
-      currentAgentId = agent_id;
-      await serverClient.switchAgent(agent_id);
-      await syncFriendsFromServer(agent_id);
-      await syncGroupsFromServer(agent_id);
-      res.json({ success: true, agent_id });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // Friends
-  app.get('/api/friends', (req, res) => {
-    const agentId = getAgentId(req);
-    res.json({ friends: db.listFriends(agentId) });
-  });
-
-  app.post('/api/friends/add', async (req, res) => {
-    try {
-      const { temp_number, friend_code, agent_id } = req.body;
-      const agentId = agent_id || currentAgentId;
-      const code = temp_number || friend_code;
-      if (!code) return res.status(400).json({ error: 'temp_number or friend_code is required' });
-      const result = await handshake.addFriendByCode(agentId, code);
-      res.json({ success: true, result });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.delete('/api/friends/:id', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      db.removeFriend(agentId, req.params.id);
-      try { await serverClient.removeFriend(req.params.id); } catch (e) {}
-      res.json({ success: true });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.get('/api/friends/requests', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      let serverRequests = [];
-      try {
-        await serverClient.ensureAuth(agentId);
-        const result = await serverClient.listFriendRequests();
-        serverRequests = result.sent || [];
-        serverRequests = serverRequests.concat(result.received || []);
-      } catch (e) {}
-      const localRequests = db.getPendingRequests(agentId);
-      res.json({ requests: [...localRequests, ...serverRequests] });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.post('/api/friends/requests/:id/accept', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      const result = await handshake.acceptRequest(agentId, req.params.id);
-      res.json(result);
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.post('/api/friends/requests/:id/reject', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      const result = await handshake.rejectRequest(agentId, req.params.id);
-      res.json(result);
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // Groups
-  app.get('/api/groups', (req, res) => {
-    const agentId = getAgentId(req);
-    res.json({ groups: db.listGroups(agentId) });
-  });
-
-  app.post('/api/groups', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      const { name, description } = req.body;
-      if (!name) return res.status(400).json({ error: 'name is required' });
-      await serverClient.ensureAuth(agentId);
-      const result = await serverClient.createGroup(name, description);
-      if (result.id) {
-        db.addGroup({
+}
+
+async function syncGroupsFromServer(agentId) {
+  try {
+    await _serverClient.ensureAuth(agentId);
+    const result = await _serverClient.listGroups();
+    if (result.groups) {
+      for (const g of result.groups) {
+        _db.addGroup({
           agent_id: agentId,
-          id: result.id,
-          name,
-          owner_id: agentId,
-          members_json: result.members || '[]',
-          description: description || '',
+          id: g.id,
+          name: g.name,
+          owner_id: g.owner_id || g.ownerId || '',
+          members_json: g.members || g.members_json || '[]',
+          description: g.description || '',
         });
       }
-      res.json({ success: true, group: result });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.post('/api/groups/:id/join', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      await serverClient.ensureAuth(agentId);
-      const result = await serverClient.inviteGroupMember(req.params.id, agentId);
-      res.json({ success: true, result });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
     }
-  });
-
-  app.get('/api/groups/:id/messages', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      const limit = parseInt(req.query.limit || '50', 10);
-      const before = req.query.before || null;
-      try {
-        await serverClient.ensureAuth(agentId);
-        const result = await serverClient.getGroupMessages(req.params.id, limit, before);
-        if (result.messages && result.messages.length > 0) {
-          return res.json({ messages: result.messages });
-        }
-      } catch (e) {}
-      const messages = db.getChatHistory(agentId, req.params.id, { limit, before });
-      res.json({ messages });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.put('/api/groups/:id/silent', (req, res) => {
-    const agentId = getAgentId(req);
-    const { silent } = req.body;
-    db.setGroupSilentMode(agentId, req.params.id, !!silent);
-    res.json({ success: true, silent: !!silent });
-  });
-
-  // Chat
-  app.get('/api/chat/:targetId', (req, res) => {
-    const agentId = getAgentId(req);
-    const limit = parseInt(req.query.limit || '50', 10);
-    const before = req.query.before || null;
-    const messages = db.getChatHistory(agentId, req.params.targetId, { limit, before });
-    res.json({ messages });
-  });
-
-  app.post('/api/chat/send', async (req, res) => {
-    try {
-      const { agent_id, targetId, content, type, isGroup, mentions, file_url, file_name } = req.body;
-      const agentId = agent_id || currentAgentId;
-      if (!targetId || !content) return res.status(400).json({ error: 'targetId and content are required' });
-      const msg = await chat.sendMessage(agentId, targetId, content, {
-        type: type || 'text',
-        isGroup: !!isGroup,
-        mentions: mentions || [],
-        file_url,
-        file_name,
-      });
-      res.json({ success: true, message: msg });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
+  } catch (e) {
+    console.error('[AICQ Channel] Sync groups failed:', e.message);
+  }
+}
+
+// ── Tool handler ────────────────────────────────────────────────────
+async function handleTool(toolName, params) {
+  await ensureInitialized();
+  const agents = _identity.listAgents();
+  const currentAgentId = agents.length > 0 ? agents[0].agent_id : null;
+
+  switch (toolName) {
+    case 'chat-friend': {
+      const { action, friend_code, friend_id } = params || {};
+      switch (action) {
+        case 'list':
+          return { friends: _db.listFriends(currentAgentId) };
+        case 'add':
+          return await _handshake.addFriendByCode(currentAgentId, friend_code);
+        case 'remove':
+          _db.removeFriend(currentAgentId, friend_id);
+          try { await _serverClient.removeFriend(friend_id); } catch (e) {}
+          return { success: true };
+        case 'requests':
+          return { requests: _db.getPendingRequests(currentAgentId) };
+        case 'accept':
+          return await _handshake.acceptRequest(currentAgentId, friend_id);
+        case 'reject':
+          return await _handshake.rejectRequest(currentAgentId, friend_id);
+        default:
+          return { error: `Unknown friend action: ${action}` };
+      }
     }
-  });
-
-  app.delete('/api/chat/:messageId', (req, res) => {
-    const agentId = getAgentId(req);
-    db.deleteMessage(agentId, req.params.messageId);
-    res.json({ success: true });
-  });
-
-  // Streaming endpoints
-  app.post('/api/chat/stream-chunk', (req, res) => {
-    try {
-      const { targetId, friend_id, chunk_type, chunkType, data } = req.body;
-      const streamTarget = targetId || friend_id;
-      if (!streamTarget) return res.status(400).json({ error: 'targetId or friend_id is required' });
-      if (!data) return res.status(400).json({ error: 'data is required' });
-      const type = chunk_type || chunkType || 'text';
-      // Allowed chunk types — extended to include thinking and clear_text
+    case 'chat-send':
+      return await _chat.sendMessage(
+        currentAgentId,
+        params.targetId,
+        params.content,
+        { isGroup: params.isGroup || false }
+      );
+    case 'chat-export-key':
+      return _identity.getInfo(currentAgentId) || {};
+    default:
+      return { error: `Unknown tool: ${toolName}` };
+  }
+}
+
+// ── Gateway handler ─────────────────────────────────────────────────
+async function handleGateway(method, kwargs = {}) {
+  await ensureInitialized();
+  const agents = _identity.listAgents();
+  const currentAgentId = agents.length > 0 ? agents[0].agent_id : null;
+
+  switch (method) {
+    case 'aicq.status':
+      return {
+        state: _serverClient.connected ? 'connected' : 'disconnected',
+        agent_id: currentAgentId,
+        version: '3.0.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.delete':
+      _db.deleteMessage(currentAgentId, kwargs.message_id);
+      return { success: true };
+    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(type)) {
-        return res.status(400).json({ error: `Invalid chunk_type: ${type}. Allowed: ${ALLOWED_CHUNK_TYPES.join(', ')}` });
-      }
-      const sent = serverClient.sendWS({
+      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: type,
-        data: data,
+        chunkType: chunkType,
+        data: kwargs.data,
       });
-      if (!sent) return res.status(503).json({ error: 'Not connected to server', success: false });
-      res.json({ success: true });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
+      if (!sent) return { error: 'Not connected to server', success: false };
+      return { success: true };
     }
-  });
-
-  app.post('/api/chat/stream-end', (req, res) => {
-    try {
-      const { targetId, friend_id, message_id, messageId } = req.body;
-      const streamTarget = targetId || friend_id;
-      if (!streamTarget) return res.status(400).json({ error: 'targetId or friend_id is required' });
-      const msgId = message_id || messageId || ('msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 6));
-      const sent = serverClient.sendWS({
+    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: streamTarget,
+        to: endTarget,
         messageId: msgId,
       });
-      if (!sent) return res.status(503).json({ error: 'Not connected to server', success: false });
-      res.json({ success: true, messageId: msgId });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // File upload
-  app.post('/api/upload', upload.single('file'), async (req, res) => {
-    try {
-      if (!req.file) return res.status(400).json({ error: 'No file uploaded' });
-      const agentId = getAgentId(req);
-      const targetId = req.body.targetId;
-      const isGroup = req.body.isGroup === 'true' || req.body.isGroup === '1';
-      const msg = await chat.handleFileUpload(agentId, targetId, req.file, isGroup);
-      res.json({ success: true, message: msg });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.get('/api/files/:fileId', (req, res) => {
-    const filePath = path.join(UPLOADS_DIR, req.params.fileId);
-    if (fs.existsSync(filePath)) {
-      res.sendFile(filePath);
-    } else {
-      res.status(404).json({ error: 'File not found' });
+      if (!endSent) return { error: 'Not connected to server', success: false };
+      return { success: true, messageId: msgId };
     }
-  });
-
-  // Identity
-  app.get('/api/identity', (req, res) => {
-    const agentId = getAgentId(req);
-    res.json(identity.getInfo(agentId) || {});
-  });
-
-  app.post('/api/identity/nickname', (req, res) => {
-    const { agent_id, nickname } = req.body;
-    const agentId = agent_id || currentAgentId;
-    identity.updateNickname(agentId, nickname);
-    res.json({ success: true });
-  });
-
-  app.post('/api/identity/friend-code', async (req, res) => {
-    try {
-      const agentId = req.body.agent_id || currentAgentId;
-      await serverClient.ensureAuth(agentId);
-      const result = await handshake.generateFriendCode(agentId);
-      res.json({ success: true, code: result.number, expires_at: result.expiresAt || result.expires_at });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.get('/api/identity/qr', async (req, res) => {
-    try {
-      const agentId = getAgentId(req);
-      const info = identity.getInfo(agentId);
-      if (!info) return res.status(404).json({ error: 'Agent not found' });
-      const qrData = JSON.stringify({
-        type: 'aicq-friend',
-        agent_id: info.agent_id,
-        public_key: info.signing_public_key,
-        exchange_public_key: info.exchange_public_key,
-        fingerprint: info.fingerprint,
-      });
-      const qrImage = await QRCode.toDataURL(qrData);
-      res.json({ qr: qrImage, data: qrData, info });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.post('/api/identity/rotate-keys', (req, res) => {
-    try {
-      const agentId = req.body.agent_id || currentAgentId;
-      const newInfo = identity.rotateKeys(agentId);
-      res.json({ success: true, info: identity.getInfo(agentId) });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // Avatar upload
-  const avatarUpload = multer({
-    storage: multer.memoryStorage(),
-    limits: { fileSize: 5 * 1024 * 1024 }, // 5MB max (client should resize before uploading)
-    fileFilter: (req, file, cb) => {
-      if (file.mimetype && file.mimetype.startsWith('image/')) {
-        cb(null, true);
-      } else {
-        cb(new Error('Only image files are allowed'));
-      }
-    },
-  });
-
-  app.post('/api/identity/avatar', avatarUpload.single('avatar'), async (req, res) => {
-    try {
-      if (!req.file) return res.status(400).json({ error: 'No file uploaded' });
-      const agentId = req.body.agent_id || currentAgentId;
-
-      const avatarsDir = path.join(DATA_DIR, 'avatars');
-      fs.mkdirSync(avatarsDir, { recursive: true });
-      const ext = req.file.mimetype.split('/')[1] || 'png';
-      const avatarId = Date.now() + '-' + Math.random().toString(36).slice(2, 8);
-      const filename = `${avatarId}.${ext}`;
-      const filePath = path.join(avatarsDir, filename);
-      fs.writeFileSync(filePath, req.file.buffer);
-
-      const avatarUrl = `/api/identity/avatars/${filename}`;
-      identity.updateAvatar(agentId, avatarUrl);
-
-      try {
-        await serverClient.ensureAuth(agentId);
-        const FormData = (await import('form-data')).default;
-        const form = new FormData();
-        form.append('avatar', req.file.buffer, {
-          filename: req.file.originalname || 'avatar.' + ext,
-          contentType: req.file.mimetype,
-        });
-        const fetch = (await import('node-fetch')).default;
-        const serverUrl = SERVER_URL + '/api/v1/accounts/avatar';
-        const serverResp = await fetch(serverUrl, {
-          method: 'POST',
-          body: form,
-          headers: {
-            ...form.getHeaders(),
-            'Authorization': 'Bearer ' + serverClient.getAccessToken(agentId),
-          },
+    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 || '',
         });
-        if (serverResp.ok) {
-          const serverData = await serverResp.json();
-          if (serverData.avatar) {
-            identity.updateAvatar(agentId, serverData.avatar);
-            return res.json({ success: true, avatar: serverData.avatar });
-          }
-        }
-      } catch (e) {
-        console.error('[AICQ] Server avatar upload failed:', e.message);
       }
-
-      res.json({ success: true, avatar: avatarUrl });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  app.get('/api/identity/avatars/:filename', (req, res) => {
-    const filename = req.params.filename;
-    if (filename.includes('/') || filename.includes('\\') || filename.includes('..')) {
-      return res.status(400).json({ error: 'Invalid filename' });
-    }
-    const filePath = path.join(DATA_DIR, 'avatars', filename);
-    if (fs.existsSync(filePath)) {
-      res.sendFile(filePath);
-    } else {
-      res.status(404).json({ error: 'Avatar not found' });
-    }
-  });
-
-  app.get('/api/identity/keys', (req, res) => {
-    const agentId = getAgentId(req);
-    const info = identity.loadAgent(agentId);
-    if (!info) return res.status(404).json({ error: 'Agent not found' });
-    res.json({
-      agent_id: info.agent_id,
-      nickname: info.nickname,
-      signing_public_key: info.signing_public_key,
-      exchange_public_key: info.exchange_public_key,
-      signing_secret_key: info.signing_secret_key,
-      exchange_secret_key: info.exchange_secret_key,
-      fingerprint: info.fingerprint,
-    });
-  });
-
-  // Sync endpoint
-  app.post('/api/sync', async (req, res) => {
-    try {
-      const agentId = req.body.agent_id || currentAgentId;
-      await syncFriendsFromServer(agentId);
-      await syncGroupsFromServer(agentId);
-      res.json({ success: true });
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // ─── Gateway Proxy Endpoint (for extension.js) ──────────────────────
-  app.post('/api/gateway', async (req, res) => {
-    try {
-      const { method, kwargs } = req.body;
-      if (!method) return res.status(400).json({ error: 'method is required' });
-      const result = await handleGatewayCall(method, kwargs);
-      res.json(result);
-    } catch (e) {
-      res.status(500).json({ error: e.message });
-    }
-  });
-
-  // ─── Start Server ───────────────────────────────────────────────────
-  app.listen(PORT, '0.0.0.0', () => {
-    console.log(`[AICQ Plugin] Running on http://0.0.0.0:${PORT}`);
-    console.log(`[AICQ Plugin] Server: ${SERVER_URL}`);
-    console.log(`[AICQ Plugin] Data dir: ${DATA_DIR}`);
-  });
-
-  // ─── OpenClaw Gateway Integration ───────────────────────────────────
-  process.on('message', (msg) => {
-    if (msg.type === 'gateway_call') {
-      handleGatewayCall(msg.method, msg.kwargs).then(result => {
-        process.send({ type: 'gateway_response', id: msg.id, result });
-      }).catch(err => {
-        process.send({ type: 'gateway_response', id: msg.id, error: err.message });
-      });
+      return { success: true, group: result };
     }
-  });
-
-  async function handleGatewayCall(method, kwargs = {}) {
-    switch (method) {
-      case 'aicq.status':
-        return { state: serverClient.connected ? 'connected' : 'disconnected', agent_id: currentAgentId, version: '2.6.0' };
-      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.identity.info':
-        return identity.getInfo(currentAgentId) || {};
-      case 'aicq.agent.create':
-        identity.createAgent(kwargs.agent_id, kwargs.nickname);
-        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';
-        // Allowed chunk types — extended to include thinking and clear_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 };
-      }
-      default:
-        return { error: `Unknown method: ${method}` };
+    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 };
+    case 'aicq.sessions.list':
+      return { sessions: [] };
+    default:
+      return { error: `Unknown method: ${method}` };
   }
-})().catch(err => {
-  console.error('[AICQ] Fatal startup error:', err);
-  process.exit(1);
-});
+}
+
+// ── Exports ─────────────────────────────────────────────────────────
+module.exports = {
+  register,
+  activate,
+  handleTool,
+  handleGateway,
+  ensureInitialized,
+};