aicq-codex 0.1.0

package/lib/handshake.js

@@ -0,0 +1,200 @@
+/**
+ * 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.
+   *
+   * Tries the server first (aicq.me-style friend_requests table).
+   * Falls back to local pending_requests table for legacy mode.
+   */
+  async getPendingRequests(agentId) {
+    try {
+      await this.server.ensureAuth(agentId);
+      const result = await this.server.listFriendRequests();
+      const received = Array.isArray(result?.received) ? result.received : [];
+      // Normalise to the same shape as local pending_requests rows.
+      return received
+        .filter((r) => r.status === 'pending')
+        .map((r) => ({
+          agent_id: agentId,
+          session_id: r.id, // server request id
+          requester_id: r.from_id,
+          requester_public_key: r.from_public_key || '',
+          timestamp: r.created_at,
+          message: r.message || '',
+          _source: 'server',
+        }));
+    } catch (e) {
+      console.warn('[Handshake] getPendingRequests: server query failed, falling back to local DB:', e.message);
+      return this.db.getPendingRequests(agentId);
+    }
+  }
+
+  /**
+   * Accept a pending friend request.
+   *
+   * Acceptance goes through the server's
+   * POST /friends/requests/:id/accept endpoint so that the server
+   * creates the bidirectional friendship and notifies the requester.
+   * After acceptance we also add the friend locally.
+   */
+  async acceptRequest(agentId, requestId) {
+    if (!requestId) throw new Error('request_id is required');
+
+    // Try to fetch the requester's public key from server response
+    let requesterPublicKey = '';
+    let requesterId = '';
+    try {
+      const pending = await this.getPendingRequests(agentId);
+      const found = pending.find((r) => r.session_id === requestId);
+      if (found) {
+        requesterPublicKey = found.requester_public_key || '';
+        requesterId = found.requester_id || '';
+      }
+    } catch (e) {
+      console.warn('[Handshake] acceptRequest: failed to look up pending request:', e.message);
+    }
+
+    // Call server accept API
+    await this.server.ensureAuth(agentId);
+    await this.server.acceptFriendRequest(requestId);
+
+    // Derive session key (best-effort — only if we have the peer's public key)
+    let sessionKey = null;
+    try {
+      const identity = this.identity.loadAgent(agentId);
+      if (identity && requesterPublicKey) {
+        const { deriveSessionKey } = require('./crypto');
+        sessionKey = deriveSessionKey(identity.exchange_secret_key, requesterPublicKey);
+      }
+    } catch (e) {
+      console.warn('[Handshake] Session key derivation failed:', e.message);
+    }
+
+    // Add friend locally (server already added bidirectionally)
+    if (requesterId) {
+      const { computeFingerprint } = require('./crypto');
+      // Don't duplicate
+      const exists = this.db.listFriends(agentId).find((f) => f.id === requesterId);
+      if (!exists) {
+        this.db.addFriend({
+          agent_id: agentId,
+          id: requesterId,
+          public_key: requesterPublicKey,
+          fingerprint: requesterPublicKey ? computeFingerprint(requesterPublicKey) : '',
+          friend_type: 'human',
+        });
+      }
+      if (sessionKey) {
+        this.db.saveSession({
+          agent_id: agentId,
+          peer_id: requesterId,
+          session_key: sessionKey,
+        });
+      }
+    }
+
+    // Remove from local pending_requests (if it was stored there)
+    this.db.removePendingRequest(agentId, requestId);
+
+    return { success: true, friend_id: requesterId };
+  }
+
+  /**
+   * Reject a pending friend request.
+   *
+   * Calls server's POST /friends/requests/:id/reject endpoint.
+   */
+  async rejectRequest(agentId, requestId) {
+    if (!requestId) throw new Error('request_id is required');
+    try {
+      await this.server.ensureAuth(agentId);
+      await this.server.rejectFriendRequest(requestId);
+    } catch (e) {
+      console.warn('[Handshake] rejectRequest: server call failed:', e.message);
+    }
+    this.db.removePendingRequest(agentId, requestId);
+    return { success: true };
+  }
+}
+
+module.exports = HandshakeManager;

package/lib/identity.js

@@ -0,0 +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;

package/lib/package.json

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