aicq-chat-plugin 2.1.0

package/lib/database.js

@@ -0,0 +1,319 @@
+/**
+ * AICQ Plugin Database — SQLite via better-sqlite3
+ */
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+
+class PluginDatabase {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    fs.mkdirSync(dataDir, { recursive: true });
+    const dbPath = path.join(dataDir, 'aicq-plugin.db');
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('synchronous = NORMAL');
+    this.db.pragma('foreign_keys = ON');
+    this.db.pragma('busy_timeout = 5000');
+    this._initSchema();
+  }
+
+  _initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS identity (
+        agent_id            TEXT PRIMARY KEY,
+        nickname            TEXT NOT NULL DEFAULT '',
+        signing_public_key  TEXT NOT NULL,
+        signing_secret_key  TEXT NOT NULL,
+        exchange_public_key TEXT NOT NULL,
+        exchange_secret_key TEXT NOT NULL,
+        created_at          TEXT NOT NULL,
+        updated_at          TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS friends (
+        id            TEXT PRIMARY KEY,
+        agent_id      TEXT NOT NULL,
+        public_key    TEXT NOT NULL,
+        fingerprint   TEXT NOT NULL,
+        added_at      TEXT NOT NULL,
+        last_seen     TEXT,
+        is_online     INTEGER NOT NULL DEFAULT 0,
+        permissions   TEXT NOT NULL DEFAULT '["chat"]',
+        friend_type   TEXT NOT NULL DEFAULT 'ai',
+        ai_name       TEXT NOT NULL DEFAULT '',
+        ai_avatar     TEXT NOT NULL DEFAULT ''
+      );
+      CREATE INDEX IF NOT EXISTS idx_friends_agent ON friends(agent_id);
+
+      CREATE TABLE IF NOT EXISTS groups (
+        id            TEXT PRIMARY KEY,
+        agent_id      TEXT NOT NULL,
+        name          TEXT NOT NULL,
+        owner_id      TEXT NOT NULL,
+        members_json  TEXT NOT NULL DEFAULT '[]',
+        description   TEXT,
+        silent_mode   INTEGER NOT NULL DEFAULT 0,
+        created_at    TEXT NOT NULL,
+        updated_at    TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_groups_agent ON groups(agent_id);
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        peer_id          TEXT PRIMARY KEY,
+        agent_id         TEXT NOT NULL,
+        session_key      TEXT NOT NULL,
+        created_at       TEXT NOT NULL,
+        message_count    INTEGER NOT NULL DEFAULT 0,
+        last_rotation    TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS chat_history (
+        id          TEXT PRIMARY KEY,
+        agent_id    TEXT NOT NULL,
+        target_id   TEXT NOT NULL,
+        from_id     TEXT NOT NULL,
+        to_id       TEXT NOT NULL,
+        type        TEXT NOT NULL DEFAULT 'text',
+        content     TEXT NOT NULL DEFAULT '',
+        file_url    TEXT,
+        file_name   TEXT,
+        is_group    INTEGER NOT NULL DEFAULT 0,
+        mentions    TEXT NOT NULL DEFAULT '[]',
+        timestamp   TEXT NOT NULL,
+        status      TEXT NOT NULL DEFAULT 'pending'
+      );
+      CREATE INDEX IF NOT EXISTS idx_chat_agent_target ON chat_history(agent_id, target_id);
+      CREATE INDEX IF NOT EXISTS idx_chat_timestamp ON chat_history(agent_id, target_id, timestamp);
+
+      CREATE TABLE IF NOT EXISTS pending_requests (
+        session_id            TEXT PRIMARY KEY,
+        agent_id              TEXT NOT NULL,
+        requester_id          TEXT NOT NULL,
+        requester_public_key  TEXT NOT NULL,
+        timestamp             TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS temp_numbers (
+        number      TEXT PRIMARY KEY,
+        agent_id    TEXT NOT NULL,
+        expires_at  TEXT NOT NULL,
+        created_at  TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS offline_queue (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        agent_id    TEXT NOT NULL,
+        target_id   TEXT NOT NULL,
+        data        TEXT NOT NULL,
+        created_at  TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_offline_target ON offline_queue(agent_id, target_id);
+
+      CREATE TABLE IF NOT EXISTS group_settings (
+        group_id    TEXT PRIMARY KEY,
+        agent_id    TEXT NOT NULL,
+        silent_mode INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+  }
+
+  // ─── Identity ──────────────────────────────────────────────────────
+
+  saveIdentity({ agent_id, nickname, signing_public_key, signing_secret_key, exchange_public_key, exchange_secret_key }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO identity (agent_id, nickname, signing_public_key, signing_secret_key, exchange_public_key, exchange_secret_key, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(agent_id, nickname || '', signing_public_key, signing_secret_key, exchange_public_key, exchange_secret_key, now, now);
+  }
+
+  loadIdentity(agentId) {
+    return this.db.prepare('SELECT * FROM identity WHERE agent_id = ?').get(agentId);
+  }
+
+  listIdentities() {
+    return this.db.prepare('SELECT agent_id, nickname, signing_public_key, exchange_public_key, created_at FROM identity').all();
+  }
+
+  deleteIdentity(agentId) {
+    this.db.prepare('DELETE FROM identity WHERE agent_id = ?').run(agentId);
+    this.db.prepare('DELETE FROM friends WHERE agent_id = ?').run(agentId);
+    this.db.prepare('DELETE FROM groups WHERE agent_id = ?').run(agentId);
+    this.db.prepare('DELETE FROM chat_history WHERE agent_id = ?').run(agentId);
+    this.db.prepare('DELETE FROM sessions WHERE agent_id = ?').run(agentId);
+  }
+
+  updateNickname(agentId, nickname) {
+    const now = new Date().toISOString();
+    this.db.prepare('UPDATE identity SET nickname = ?, updated_at = ? WHERE agent_id = ?').run(nickname, now, agentId);
+  }
+
+  // ─── Friends ───────────────────────────────────────────────────────
+
+  addFriend({ agent_id, id, public_key, fingerprint, friend_type = 'ai', ai_name = '', permissions = ['chat'] }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO friends (id, agent_id, public_key, fingerprint, added_at, is_online, permissions, friend_type, ai_name, ai_avatar)
+      VALUES (?, ?, ?, ?, ?, 0, ?, ?, ?, '')
+    `).run(id, agent_id, public_key, fingerprint, now, JSON.stringify(permissions), friend_type, ai_name);
+  }
+
+  removeFriend(agentId, friendId) {
+    this.db.prepare('DELETE FROM friends WHERE agent_id = ? AND id = ?').run(agentId, friendId);
+    this.db.prepare('DELETE FROM sessions WHERE agent_id = ? AND peer_id = ?').run(agentId, friendId);
+  }
+
+  getFriend(agentId, friendId) {
+    return this.db.prepare('SELECT * FROM friends WHERE agent_id = ? AND id = ?').get(agentId, friendId);
+  }
+
+  listFriends(agentId) {
+    return this.db.prepare('SELECT * FROM friends WHERE agent_id = ? ORDER BY added_at DESC').all(agentId);
+  }
+
+  updateFriendOnline(agentId, friendId, isOnline) {
+    const now = isOnline ? new Date().toISOString() : null;
+    this.db.prepare('UPDATE friends SET is_online = ?, last_seen = COALESCE(?, last_seen) WHERE agent_id = ? AND id = ?')
+      .run(isOnline ? 1 : 0, now, agentId, friendId);
+  }
+
+  // ─── Groups ────────────────────────────────────────────────────────
+
+  addGroup({ agent_id, id, name, owner_id, members_json = '[]', description = '' }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO groups (id, agent_id, name, owner_id, members_json, description, silent_mode, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
+    `).run(id, agent_id, name, owner_id, typeof members_json === 'string' ? members_json : JSON.stringify(members_json), description, now, now);
+  }
+
+  listGroups(agentId) {
+    return this.db.prepare('SELECT * FROM groups WHERE agent_id = ? ORDER BY created_at DESC').all(agentId);
+  }
+
+  getGroup(agentId, groupId) {
+    return this.db.prepare('SELECT * FROM groups WHERE agent_id = ? AND id = ?').get(agentId, groupId);
+  }
+
+  setGroupSilentMode(agentId, groupId, silent) {
+    this.db.prepare(`
+      INSERT OR REPLACE INTO group_settings (group_id, agent_id, silent_mode) VALUES (?, ?, ?)
+    `).run(groupId, agentId, silent ? 1 : 0);
+  }
+
+  getGroupSilentMode(agentId, groupId) {
+    const row = this.db.prepare('SELECT silent_mode FROM group_settings WHERE group_id = ? AND agent_id = ?').get(groupId, agentId);
+    return row ? !!row.silent_mode : false;
+  }
+
+  // ─── Sessions ──────────────────────────────────────────────────────
+
+  saveSession({ agent_id, peer_id, session_key }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO sessions (peer_id, agent_id, session_key, created_at, message_count, last_rotation)
+      VALUES (?, ?, ?, ?, 0, ?)
+    `).run(peer_id, agent_id, session_key, now, now);
+  }
+
+  loadSession(agentId, peerId) {
+    return this.db.prepare('SELECT * FROM sessions WHERE agent_id = ? AND peer_id = ?').get(agentId, peerId);
+  }
+
+  incrementSessionMessageCount(agentId, peerId) {
+    this.db.prepare('UPDATE sessions SET message_count = message_count + 1 WHERE agent_id = ? AND peer_id = ?').run(agentId, peerId);
+  }
+
+  // ─── Chat History ──────────────────────────────────────────────────
+
+  saveMessage({ agent_id, target_id, from_id, to_id, type = 'text', content = '', file_url = null, file_name = null, is_group = 0, mentions = [], status = 'pending' }) {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO chat_history (id, agent_id, target_id, from_id, to_id, type, content, file_url, file_name, is_group, mentions, timestamp, status)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, agent_id, target_id, from_id, to_id, type, content, file_url, file_name, is_group, JSON.stringify(mentions), now, status);
+    return { id, timestamp: now };
+  }
+
+  getChatHistory(agentId, targetId, { limit = 50, before = null } = {}) {
+    if (before) {
+      return this.db.prepare(
+        'SELECT * FROM chat_history WHERE agent_id = ? AND target_id = ? AND timestamp < ? ORDER BY timestamp DESC LIMIT ?'
+      ).all(agentId, targetId, before, limit);
+    }
+    return this.db.prepare(
+      'SELECT * FROM chat_history WHERE agent_id = ? AND target_id = ? ORDER BY timestamp DESC LIMIT ?'
+    ).all(agentId, targetId, limit);
+  }
+
+  deleteMessage(agentId, messageId) {
+    this.db.prepare('DELETE FROM chat_history WHERE agent_id = ? AND id = ?').run(agentId, messageId);
+  }
+
+  updateMessageStatus(agentId, messageId, status) {
+    this.db.prepare('UPDATE chat_history SET status = ? WHERE agent_id = ? AND id = ?').run(status, agentId, messageId);
+  }
+
+  // ─── Pending Requests ──────────────────────────────────────────────
+
+  savePendingRequest({ agent_id, session_id, requester_id, requester_public_key }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO pending_requests (session_id, agent_id, requester_id, requester_public_key, timestamp)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(session_id, agent_id, requester_id, requester_public_key, now);
+  }
+
+  getPendingRequests(agentId) {
+    return this.db.prepare('SELECT * FROM pending_requests WHERE agent_id = ? ORDER BY timestamp DESC').all(agentId);
+  }
+
+  removePendingRequest(agentId, sessionId) {
+    this.db.prepare('DELETE FROM pending_requests WHERE agent_id = ? AND session_id = ?').run(agentId, sessionId);
+  }
+
+  // ─── Temp Numbers ──────────────────────────────────────────────────
+
+  saveTempNumber({ agent_id, number, expires_at }) {
+    const now = new Date().toISOString();
+    this.db.prepare('INSERT OR REPLACE INTO temp_numbers (number, agent_id, expires_at, created_at) VALUES (?, ?, ?, ?)')
+      .run(number, agent_id, expires_at, now);
+  }
+
+  // ─── Offline Queue ─────────────────────────────────────────────────
+
+  enqueueOffline({ agent_id, target_id, data }) {
+    const now = new Date().toISOString();
+    this.db.prepare('INSERT INTO offline_queue (agent_id, target_id, data, created_at) VALUES (?, ?, ?, ?)')
+      .run(agent_id, target_id, data, now);
+  }
+
+  dequeueOffline(agentId, targetId, limit = 100) {
+    const rows = this.db.prepare('SELECT * FROM offline_queue WHERE agent_id = ? AND target_id = ? ORDER BY created_at ASC LIMIT ?')
+      .all(agentId, targetId, limit);
+    if (rows.length > 0) {
+      const ids = rows.map(r => r.id);
+      const placeholders = ids.map(() => '?').join(',');
+      this.db.prepare(`DELETE FROM offline_queue WHERE id IN (${placeholders})`).run(...ids);
+    }
+    return rows;
+  }
+
+  // ─── Cleanup ───────────────────────────────────────────────────────
+
+  cleanup() {
+    const now = new Date().toISOString();
+    this.db.prepare("DELETE FROM temp_numbers WHERE expires_at < ?").run(now);
+    this.db.prepare("DELETE FROM pending_requests WHERE timestamp < datetime(?, '-48 hours')").run(now);
+    this.db.prepare("DELETE FROM offline_queue WHERE created_at < datetime(?, '-7 days')").run(now);
+  }
+
+  close() {
+    this.db.close();
+  }
+}
+
+module.exports = PluginDatabase;

package/lib/file-transfer.js

@@ -0,0 +1,266 @@
+/**
+ * AICQ File Transfer
+ * ====================
+ * Handles chunked file upload/download via WebSocket.
+ * Files are encrypted with session keys before transmission.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('./crypto');
+const { v4: uuidv4 } = require('uuid');
+const { isoNow } = require('./database');
+
+const CHUNK_SIZE = 65536; // 64KB chunks
+const UPLOADS_DIR = path.join(__dirname, '..', 'uploads');
+
+class FileTransferManager {
+  constructor(db, identity, serverClient) {
+    this.db = db;
+    this.identity = identity;
+    this.serverClient = serverClient;
+
+    // In-progress transfers: fileId -> { chunks, meta }
+    this._incoming = new Map();
+
+    // Ensure uploads directory exists
+    if (!fs.existsSync(UPLOADS_DIR)) {
+      fs.mkdirSync(UPLOADS_DIR, { recursive: true });
+    }
+  }
+
+  /**
+   * Upload a file to a friend.
+   * Reads the file, encrypts chunks, and sends via WebSocket.
+   */
+  uploadFile(targetId, filePath, { isGroup = false } = {}) {
+    const agentId = this.identity.currentAgentId;
+    if (!agentId) throw new Error('No agent selected');
+
+    const identity = this.identity.getCurrent();
+    if (!identity) throw new Error('No identity');
+
+    const fileId = uuidv4();
+    const fileName = path.basename(filePath);
+    const fileBuffer = fs.readFileSync(filePath);
+    const fileSize = fileBuffer.length;
+    const totalChunks = Math.ceil(fileSize / CHUNK_SIZE);
+
+    // Get session key for encryption
+    let sessionKey = null;
+    if (!isGroup) {
+      const session = this.db.loadSession(agentId, targetId);
+      if (session) {
+        sessionKey = session.session_key;
+      } else {
+        const friend = this.db.getFriend(agentId, targetId);
+        if (friend && friend.public_key) {
+          sessionKey = crypto.sha256Hex(crypto.computeSharedSecret(identity.exchangeSecretKey, friend.public_key));
+          this.db.saveSession(agentId, targetId, sessionKey);
+        }
+      }
+    }
+
+    // Save file locally
+    const localPath = path.join(UPLOADS_DIR, fileId);
+    fs.writeFileSync(localPath, fileBuffer);
+
+    // Send file info message first
+    const fileInfo = {
+      fileId,
+      fileName,
+      fileSize,
+      totalChunks,
+      mimeType: this._getMimeType(fileName),
+    };
+
+    // Save file-info message to chat history
+    this.db.saveMessage({
+      agentId,
+      targetId,
+      fromId: identity.agentId,
+      toId: targetId,
+      type: 'file',
+      content: JSON.stringify(fileInfo),
+      status: 'sent',
+      isGroup,
+    });
+
+    // Send file info via WS
+    if (!isGroup) {
+      this.serverClient.sendWs({
+        type: 'message',
+        to: targetId,
+        data: JSON.stringify({ type: 'file-info', ...fileInfo }),
+      });
+    } else {
+      this.serverClient.sendWs({
+        type: 'group_message',
+        groupId: targetId,
+        content: JSON.stringify({ type: 'file-info', ...fileInfo }),
+        msgType: 'file',
+      });
+    }
+
+    // Send chunks
+    for (let i = 0; i < totalChunks; i++) {
+      const start = i * CHUNK_SIZE;
+      const end = Math.min(start + CHUNK_SIZE, fileSize);
+      let chunkData = fileBuffer.slice(start, end);
+
+      const chunk = {
+        fileId,
+        index: i,
+        total: totalChunks,
+        data: chunkData.toString('base64'),
+      };
+
+      if (sessionKey && !isGroup) {
+        // Encrypt chunk
+        const encrypted = crypto.encryptFileChunk(sessionKey, chunkData, i);
+        chunk.data = encrypted.ciphertext;
+        chunk.nonce = encrypted.nonce;
+        chunk.encrypted = true;
+      }
+
+      if (!isGroup) {
+        this.serverClient.sendWs({
+          type: 'file_chunk',
+          to: targetId,
+          data: chunk,
+        });
+      } else {
+        this.serverClient.sendWs({
+          type: 'group_message',
+          groupId: targetId,
+          content: JSON.stringify(chunk),
+          msgType: 'file_chunk',
+        });
+      }
+    }
+
+    return { fileId, fileName, fileSize, totalChunks };
+  }
+
+  /**
+   * Handle incoming file chunk.
+   */
+  handleFileChunk(data) {
+    const chunkData = data.data || data;
+    const fileId = chunkData.fileId;
+
+    if (!fileId) return;
+
+    // Initialize incoming transfer if needed
+    if (!this._incoming.has(fileId)) {
+      this._incoming.set(fileId, {
+        chunks: new Map(),
+        meta: null,
+      });
+    }
+
+    const transfer = this._incoming.get(fileId);
+
+    // If this is a file-info message
+    if (chunkData.type === 'file-info') {
+      transfer.meta = chunkData;
+      return;
+    }
+
+    // Store the chunk
+    transfer.chunks.set(chunkData.index, chunkData);
+
+    // Check if all chunks received
+    if (transfer.meta && transfer.chunks.size >= transfer.meta.totalChunks) {
+      this._assembleFile(fileId, transfer);
+    }
+  }
+
+  /**
+   * Assemble received chunks into a complete file.
+   */
+  _assembleFile(fileId, transfer) {
+    const { meta, chunks } = transfer;
+
+    try {
+      const sortedChunks = Array.from(chunks.entries())
+        .sort((a, b) => a[0] - b[0]);
+
+      const buffers = [];
+      for (const [index, chunk] of sortedChunks) {
+        if (chunk.encrypted) {
+          // Decrypt chunk
+          const agentId = this.identity.currentAgentId;
+          const session = this.db.loadSession(agentId, transfer.fromId);
+          if (session) {
+            const decrypted = crypto.decryptFileChunk(
+              session.session_key, chunk.nonce, chunk.data, index
+            );
+            buffers.push(decrypted);
+          }
+        } else {
+          buffers.push(Buffer.from(chunk.data, 'base64'));
+        }
+      }
+
+      const fileBuffer = Buffer.concat(buffers);
+
+      // Save to uploads directory
+      const localPath = path.join(UPLOADS_DIR, fileId);
+      fs.writeFileSync(localPath, fileBuffer);
+
+      // Save message to chat history
+      const agentId = this.identity.currentAgentId;
+      if (agentId) {
+        this.db.saveMessage({
+          agentId,
+          targetId: meta.fromId || '',
+          fromId: meta.fromId || '',
+          toId: agentId,
+          type: 'file',
+          content: JSON.stringify({
+            fileId,
+            fileName: meta.fileName,
+            fileSize: meta.fileSize,
+            localPath,
+          }),
+          status: 'delivered',
+          isGroup: false,
+        });
+      }
+
+      console.log(`[FileTransfer] Assembled file ${meta.fileName} (${meta.fileSize} bytes)`);
+    } catch (e) {
+      console.error(`[FileTransfer] Assembly failed for ${fileId}:`, e.message);
+    } finally {
+      this._incoming.delete(fileId);
+    }
+  }
+
+  /**
+   * Serve an uploaded file.
+   */
+  serveFile(fileId) {
+    const filePath = path.join(UPLOADS_DIR, fileId);
+    if (fs.existsSync(filePath)) {
+      return fs.readFileSync(filePath);
+    }
+    return null;
+  }
+
+  /**
+   * Get MIME type from filename.
+   */
+  _getMimeType(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeTypes = {
+      '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+      '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+      '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json',
+      '.zip': 'application/zip', '.mp3': 'audio/mpeg', '.mp4': 'video/mp4',
+    };
+    return mimeTypes[ext] || 'application/octet-stream';
+  }
+}
+
+module.exports = FileTransferManager;