aicq-chat-plugin 3.9.0 → 3.9.1

package/lib/handshake.js

@@ -1,147 +1,147 @@
-/**
- * AICQ Handshake Manager — P2P handshake via temp numbers
- */
-const { computeFingerprint } = require('./crypto');
-const crypto = require('crypto');
-
-class HandshakeManager {
-  constructor(identityManager, serverClient, db) {
-    this.identity = identityManager;
-    this.server = serverClient;
-    this.db = db;
-  }
-
-  /**
-   * Generate a temp number and return it for sharing
-   */
-  async generateFriendCode(agentId) {
-    await this.server.ensureAuth(agentId);
-    const result = await this.server.generateTempNumber();
-    if (result.number) {
-      this.db.saveTempNumber({
-        agent_id: agentId,
-        number: result.number,
-        expires_at: result.expiresAt || result.expires_at,
-      });
-    }
-    return result;
-  }
-
-  /**
-   * Add a friend using their temp number / friend code
-   */
-  async addFriendByCode(agentId, tempNumber) {
-    await this.server.ensureAuth(agentId);
-    // Resolve the temp number
-    const resolved = await this.server.resolveTempNumber(tempNumber);
-    if (!resolved) throw new Error('Invalid or expired friend code');
-
-    // Initiate handshake
-    const result = await this.server.initiateHandshake(tempNumber);
-
-    // If we got the peer's public key, derive session and add friend
-    if (resolved.node_id || resolved.public_key) {
-      const peerId = resolved.node_id || resolved.id;
-      const peerPublicKey = resolved.public_key;
-
-      // Derive session key
-      let sessionKey = null;
-      try {
-        const identity = this.identity.loadAgent(agentId);
-        if (identity && peerPublicKey) {
-          const { deriveSessionKey } = require('./crypto');
-          sessionKey = deriveSessionKey(identity.exchange_secret_key, peerPublicKey);
-        }
-      } catch (e) {
-        console.error('[Handshake] Session key derivation failed:', e.message);
-      }
-
-      // Add friend locally
-      if (peerId) {
-        this.db.addFriend({
-          agent_id: agentId,
-          id: peerId,
-          public_key: peerPublicKey || '',
-          fingerprint: peerPublicKey ? computeFingerprint(peerPublicKey) : '',
-          friend_type: 'ai',
-        });
-
-        // Save session if we have a key
-        if (sessionKey) {
-          this.db.saveSession({
-            agent_id: agentId,
-            peer_id: peerId,
-            session_key: sessionKey,
-          });
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * List pending handshake requests
-   */
-  async getPendingRequests(agentId) {
-    return this.db.getPendingRequests(agentId);
-  }
-
-  /**
-   * Accept a pending handshake request
-   */
-  async acceptRequest(agentId, sessionId) {
-    const request = this.db.getPendingRequests(agentId).find(r => r.session_id === sessionId);
-    if (!request) throw new Error('Request not found');
-
-    // Derive session key
-    let sessionKey = null;
-    try {
-      const identity = this.identity.loadAgent(agentId);
-      if (identity && request.requester_public_key) {
-        const { deriveSessionKey } = require('./crypto');
-        sessionKey = deriveSessionKey(identity.exchange_secret_key, request.requester_public_key);
-      }
-    } catch (e) {
-      console.error('[Handshake] Session key derivation failed:', e.message);
-    }
-
-    // Add friend
-    this.db.addFriend({
-      agent_id: agentId,
-      id: request.requester_id,
-      public_key: request.requester_public_key,
-      fingerprint: computeFingerprint(request.requester_public_key),
-      friend_type: 'ai',
-    });
-
-    // Save session
-    if (sessionKey) {
-      this.db.saveSession({
-        agent_id: agentId,
-        peer_id: request.requester_id,
-        session_key: sessionKey,
-      });
-    }
-
-    // Respond to server
-    await this.server.respondHandshake(sessionId, {
-      public_key: this.identity.loadAgent(agentId).exchange_public_key,
-    });
-
-    // Remove pending request
-    this.db.removePendingRequest(agentId, sessionId);
-
-    return { success: true, friend_id: request.requester_id };
-  }
-
-  /**
-   * Reject a pending handshake request
-   */
-  async rejectRequest(agentId, sessionId) {
-    this.db.removePendingRequest(agentId, sessionId);
-    return { success: true };
-  }
-}
-
-module.exports = HandshakeManager;
+/**
+ * AICQ Handshake Manager — P2P handshake via temp numbers
+ */
+const { computeFingerprint } = require('./crypto');
+const crypto = require('crypto');
+
+class HandshakeManager {
+  constructor(identityManager, serverClient, db) {
+    this.identity = identityManager;
+    this.server = serverClient;
+    this.db = db;
+  }
+
+  /**
+   * Generate a temp number and return it for sharing
+   */
+  async generateFriendCode(agentId) {
+    await this.server.ensureAuth(agentId);
+    const result = await this.server.generateTempNumber();
+    if (result.number) {
+      this.db.saveTempNumber({
+        agent_id: agentId,
+        number: result.number,
+        expires_at: result.expiresAt || result.expires_at,
+      });
+    }
+    return result;
+  }
+
+  /**
+   * Add a friend using their temp number / friend code
+   */
+  async addFriendByCode(agentId, tempNumber) {
+    await this.server.ensureAuth(agentId);
+    // Resolve the temp number
+    const resolved = await this.server.resolveTempNumber(tempNumber);
+    if (!resolved) throw new Error('Invalid or expired friend code');
+
+    // Initiate handshake
+    const result = await this.server.initiateHandshake(tempNumber);
+
+    // If we got the peer's public key, derive session and add friend
+    if (resolved.node_id || resolved.public_key) {
+      const peerId = resolved.node_id || resolved.id;
+      const peerPublicKey = resolved.public_key;
+
+      // Derive session key
+      let sessionKey = null;
+      try {
+        const identity = this.identity.loadAgent(agentId);
+        if (identity && peerPublicKey) {
+          const { deriveSessionKey } = require('./crypto');
+          sessionKey = deriveSessionKey(identity.exchange_secret_key, peerPublicKey);
+        }
+      } catch (e) {
+        console.error('[Handshake] Session key derivation failed:', e.message);
+      }
+
+      // Add friend locally
+      if (peerId) {
+        this.db.addFriend({
+          agent_id: agentId,
+          id: peerId,
+          public_key: peerPublicKey || '',
+          fingerprint: peerPublicKey ? computeFingerprint(peerPublicKey) : '',
+          friend_type: 'ai',
+        });
+
+        // Save session if we have a key
+        if (sessionKey) {
+          this.db.saveSession({
+            agent_id: agentId,
+            peer_id: peerId,
+            session_key: sessionKey,
+          });
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * List pending handshake requests
+   */
+  async getPendingRequests(agentId) {
+    return this.db.getPendingRequests(agentId);
+  }
+
+  /**
+   * Accept a pending handshake request
+   */
+  async acceptRequest(agentId, sessionId) {
+    const request = this.db.getPendingRequests(agentId).find(r => r.session_id === sessionId);
+    if (!request) throw new Error('Request not found');
+
+    // Derive session key
+    let sessionKey = null;
+    try {
+      const identity = this.identity.loadAgent(agentId);
+      if (identity && request.requester_public_key) {
+        const { deriveSessionKey } = require('./crypto');
+        sessionKey = deriveSessionKey(identity.exchange_secret_key, request.requester_public_key);
+      }
+    } catch (e) {
+      console.error('[Handshake] Session key derivation failed:', e.message);
+    }
+
+    // Add friend
+    this.db.addFriend({
+      agent_id: agentId,
+      id: request.requester_id,
+      public_key: request.requester_public_key,
+      fingerprint: computeFingerprint(request.requester_public_key),
+      friend_type: 'ai',
+    });
+
+    // Save session
+    if (sessionKey) {
+      this.db.saveSession({
+        agent_id: agentId,
+        peer_id: request.requester_id,
+        session_key: sessionKey,
+      });
+    }
+
+    // Respond to server
+    await this.server.respondHandshake(sessionId, {
+      public_key: this.identity.loadAgent(agentId).exchange_public_key,
+    });
+
+    // Remove pending request
+    this.db.removePendingRequest(agentId, sessionId);
+
+    return { success: true, friend_id: request.requester_id };
+  }
+
+  /**
+   * Reject a pending handshake request
+   */
+  async rejectRequest(agentId, sessionId) {
+    this.db.removePendingRequest(agentId, sessionId);
+    return { success: true };
+  }
+}
+
+module.exports = HandshakeManager;

package/lib/identity.js

@@ -1,165 +1,165 @@
-/**
- * AICQ Identity Manager — Ed25519 + X25519 key management
- */
-const crypto = require('./crypto');
-
-class IdentityManager {
-  constructor(db) {
-    this.db = db;
-    this._cache = {}; // agent_id -> identity
-  }
-
-  /**
-   * Create a new agent identity
-   */
-  createAgent(agentId, nickname = '') {
-    const signing = crypto.generateSigningKeypair();
-    const exchange = crypto.generateExchangeKeypair();
-    const fingerprint = crypto.computeFingerprint(signing.publicKey);
-
-    this.db.saveIdentity({
-      agent_id: agentId,
-      nickname: nickname || agentId,
-      signing_public_key: signing.publicKey,
-      signing_secret_key: signing.secretKey,
-      exchange_public_key: exchange.publicKey,
-      exchange_secret_key: exchange.secretKey,
-    });
-
-    this._cache[agentId] = {
-      agent_id: agentId,
-      nickname: nickname || agentId,
-      signing_public_key: signing.publicKey,
-      signing_secret_key: signing.secretKey,
-      exchange_public_key: exchange.publicKey,
-      exchange_secret_key: exchange.secretKey,
-      fingerprint,
-    };
-
-    return this._cache[agentId];
-  }
-
-  /**
-   * Load an existing identity into cache
-   */
-  loadAgent(agentId) {
-    if (this._cache[agentId]) return this._cache[agentId];
-    const row = this.db.loadIdentity(agentId);
-    if (!row) return null;
-    row.fingerprint = crypto.computeFingerprint(row.signing_public_key);
-    this._cache[agentId] = row;
-    return row;
-  }
-
-  /**
-   * Get current identity (load first one if agentId not specified)
-   */
-  getCurrent(agentId) {
-    if (agentId) return this.loadAgent(agentId);
-    const identities = this.db.listIdentities();
-    if (identities.length === 0) return null;
-    return this.loadAgent(identities[0].agent_id);
-  }
-
-  /**
-   * List all agent identities
-   */
-  listAgents() {
-    return this.db.listIdentities();
-  }
-
-  /**
-   * Delete an agent identity
-   */
-  deleteAgent(agentId) {
-    delete this._cache[agentId];
-    this.db.deleteIdentity(agentId);
-  }
-
-  /**
-   * Update agent nickname
-   */
-  updateNickname(agentId, nickname) {
-    this.db.updateNickname(agentId, nickname);
-    if (this._cache[agentId]) {
-      this._cache[agentId].nickname = nickname;
-    }
-  }
-
-  /**
-   * Sign a message with the agent's signing key
-   */
-  sign(agentId, message) {
-    const identity = this.loadAgent(agentId);
-    if (!identity) throw new Error('Identity not found');
-    return crypto.signMessage(message, identity.signing_secret_key);
-  }
-
-  /**
-   * Derive a session key with a peer
-   */
-  deriveSessionKey(agentId, peerExchangePublicKeyB64) {
-    const identity = this.loadAgent(agentId);
-    if (!identity) throw new Error('Identity not found');
-    return crypto.deriveSessionKey(identity.exchange_secret_key, peerExchangePublicKeyB64);
-  }
-
-  /**
-   * Rotate keys for an agent
-   */
-  rotateKeys(agentId) {
-    const oldIdentity = this.loadAgent(agentId);
-    if (!oldIdentity) throw new Error('Identity not found');
-
-    const signing = crypto.generateSigningKeypair();
-    const exchange = crypto.generateExchangeKeypair();
-
-    this.db.saveIdentity({
-      agent_id: agentId,
-      nickname: oldIdentity.nickname,
-      signing_public_key: signing.publicKey,
-      signing_secret_key: signing.secretKey,
-      exchange_public_key: exchange.publicKey,
-      exchange_secret_key: exchange.secretKey,
-    });
-
-    this._cache[agentId] = {
-      ...oldIdentity,
-      signing_public_key: signing.publicKey,
-      signing_secret_key: signing.secretKey,
-      exchange_public_key: exchange.publicKey,
-      exchange_secret_key: exchange.secretKey,
-      fingerprint: crypto.computeFingerprint(signing.publicKey),
-    };
-
-    return this._cache[agentId];
-  }
-
-  /**
-   * Update agent avatar
-   */
-  updateAvatar(agentId, avatarUrl) {
-    this.db.updateAvatar(agentId, avatarUrl);
-    if (this._cache[agentId]) {
-      this._cache[agentId].avatar = avatarUrl;
-    }
-  }
-
-  /**
-   * Get identity info (public keys only, no secrets)
-   */
-  getInfo(agentId) {
-    const identity = this.loadAgent(agentId);
-    if (!identity) return null;
-    return {
-      agent_id: identity.agent_id,
-      nickname: identity.nickname,
-      avatar: identity.avatar || null,
-      signing_public_key: identity.signing_public_key,
-      exchange_public_key: identity.exchange_public_key,
-      fingerprint: identity.fingerprint,
-    };
-  }
-}
-
-module.exports = IdentityManager;
+/**
+ * AICQ Identity Manager — Ed25519 + X25519 key management
+ */
+const crypto = require('./crypto');
+
+class IdentityManager {
+  constructor(db) {
+    this.db = db;
+    this._cache = {}; // agent_id -> identity
+  }
+
+  /**
+   * Create a new agent identity
+   */
+  createAgent(agentId, nickname = '') {
+    const signing = crypto.generateSigningKeypair();
+    const exchange = crypto.generateExchangeKeypair();
+    const fingerprint = crypto.computeFingerprint(signing.publicKey);
+
+    this.db.saveIdentity({
+      agent_id: agentId,
+      nickname: nickname || agentId,
+      signing_public_key: signing.publicKey,
+      signing_secret_key: signing.secretKey,
+      exchange_public_key: exchange.publicKey,
+      exchange_secret_key: exchange.secretKey,
+    });
+
+    this._cache[agentId] = {
+      agent_id: agentId,
+      nickname: nickname || agentId,
+      signing_public_key: signing.publicKey,
+      signing_secret_key: signing.secretKey,
+      exchange_public_key: exchange.publicKey,
+      exchange_secret_key: exchange.secretKey,
+      fingerprint,
+    };
+
+    return this._cache[agentId];
+  }
+
+  /**
+   * Load an existing identity into cache
+   */
+  loadAgent(agentId) {
+    if (this._cache[agentId]) return this._cache[agentId];
+    const row = this.db.loadIdentity(agentId);
+    if (!row) return null;
+    row.fingerprint = crypto.computeFingerprint(row.signing_public_key);
+    this._cache[agentId] = row;
+    return row;
+  }
+
+  /**
+   * Get current identity (load first one if agentId not specified)
+   */
+  getCurrent(agentId) {
+    if (agentId) return this.loadAgent(agentId);
+    const identities = this.db.listIdentities();
+    if (identities.length === 0) return null;
+    return this.loadAgent(identities[0].agent_id);
+  }
+
+  /**
+   * List all agent identities
+   */
+  listAgents() {
+    return this.db.listIdentities();
+  }
+
+  /**
+   * Delete an agent identity
+   */
+  deleteAgent(agentId) {
+    delete this._cache[agentId];
+    this.db.deleteIdentity(agentId);
+  }
+
+  /**
+   * Update agent nickname
+   */
+  updateNickname(agentId, nickname) {
+    this.db.updateNickname(agentId, nickname);
+    if (this._cache[agentId]) {
+      this._cache[agentId].nickname = nickname;
+    }
+  }
+
+  /**
+   * Sign a message with the agent's signing key
+   */
+  sign(agentId, message) {
+    const identity = this.loadAgent(agentId);
+    if (!identity) throw new Error('Identity not found');
+    return crypto.signMessage(message, identity.signing_secret_key);
+  }
+
+  /**
+   * Derive a session key with a peer
+   */
+  deriveSessionKey(agentId, peerExchangePublicKeyB64) {
+    const identity = this.loadAgent(agentId);
+    if (!identity) throw new Error('Identity not found');
+    return crypto.deriveSessionKey(identity.exchange_secret_key, peerExchangePublicKeyB64);
+  }
+
+  /**
+   * Rotate keys for an agent
+   */
+  rotateKeys(agentId) {
+    const oldIdentity = this.loadAgent(agentId);
+    if (!oldIdentity) throw new Error('Identity not found');
+
+    const signing = crypto.generateSigningKeypair();
+    const exchange = crypto.generateExchangeKeypair();
+
+    this.db.saveIdentity({
+      agent_id: agentId,
+      nickname: oldIdentity.nickname,
+      signing_public_key: signing.publicKey,
+      signing_secret_key: signing.secretKey,
+      exchange_public_key: exchange.publicKey,
+      exchange_secret_key: exchange.secretKey,
+    });
+
+    this._cache[agentId] = {
+      ...oldIdentity,
+      signing_public_key: signing.publicKey,
+      signing_secret_key: signing.secretKey,
+      exchange_public_key: exchange.publicKey,
+      exchange_secret_key: exchange.secretKey,
+      fingerprint: crypto.computeFingerprint(signing.publicKey),
+    };
+
+    return this._cache[agentId];
+  }
+
+  /**
+   * Update agent avatar
+   */
+  updateAvatar(agentId, avatarUrl) {
+    this.db.updateAvatar(agentId, avatarUrl);
+    if (this._cache[agentId]) {
+      this._cache[agentId].avatar = avatarUrl;
+    }
+  }
+
+  /**
+   * Get identity info (public keys only, no secrets)
+   */
+  getInfo(agentId) {
+    const identity = this.loadAgent(agentId);
+    if (!identity) return null;
+    return {
+      agent_id: identity.agent_id,
+      nickname: identity.nickname,
+      avatar: identity.avatar || null,
+      signing_public_key: identity.signing_public_key,
+      exchange_public_key: identity.exchange_public_key,
+      fingerprint: identity.fingerprint,
+    };
+  }
+}
+
+module.exports = IdentityManager;

package/lib/package.json

@@ -1,3 +1,3 @@
-{
-  "type": "commonjs"
-}
+{
+  "type": "commonjs"
+}