aicq-chat-plugin 3.3.1 → 3.4.1

package/index.mjs

@@ -1,70 +0,0 @@
-/**
- * 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/setup-entry.mjs

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,254 +0,0 @@
-/**
- * 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

@@ -1,178 +0,0 @@
-/**
- * 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); }