chainlesschain 0.37.9 → 0.37.11

package/src/lib/p2p-manager.js

@@ -0,0 +1,317 @@
+/**
+ * P2P Manager — Peer-to-peer messaging and device pairing for CLI.
+ * Uses a bridge protocol to connect to desktop app or runs standalone
+ * with a lightweight signaling mechanism.
+ */
+
+import crypto from "crypto";
+import { EventEmitter } from "events";
+
+const DEFAULT_SIGNALING_PORT = 9001;
+const BRIDGE_TIMEOUT = 5000;
+
+/**
+ * Ensure P2P tables exist.
+ */
+export function ensureP2PTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS p2p_peers (
+      peer_id TEXT PRIMARY KEY,
+      display_name TEXT,
+      did TEXT,
+      public_key TEXT,
+      last_seen TEXT,
+      status TEXT DEFAULT 'offline',
+      device_type TEXT DEFAULT 'unknown',
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS p2p_messages (
+      id TEXT PRIMARY KEY,
+      from_peer TEXT NOT NULL,
+      to_peer TEXT NOT NULL,
+      content TEXT NOT NULL,
+      encrypted INTEGER DEFAULT 0,
+      read INTEGER DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS p2p_paired_devices (
+      device_id TEXT PRIMARY KEY,
+      device_name TEXT,
+      device_type TEXT,
+      pairing_code TEXT,
+      paired_at TEXT DEFAULT (datetime('now')),
+      last_sync TEXT,
+      status TEXT DEFAULT 'active'
+    )
+  `);
+}
+
+/**
+ * Generate a unique peer ID.
+ */
+export function generatePeerId() {
+  return `peer-${crypto.randomBytes(16).toString("hex")}`;
+}
+
+/**
+ * Generate a pairing code (6-digit).
+ */
+export function generatePairingCode() {
+  return String(crypto.randomInt(100000, 999999));
+}
+
+/**
+ * Register a peer in the database.
+ */
+export function registerPeer(
+  db,
+  peerId,
+  displayName,
+  did,
+  publicKey,
+  deviceType,
+) {
+  ensureP2PTables(db);
+  db.prepare(
+    `INSERT OR REPLACE INTO p2p_peers (peer_id, display_name, did, public_key, last_seen, status, device_type)
+     VALUES (?, ?, ?, ?, datetime('now'), ?, ?)`,
+  ).run(
+    peerId,
+    displayName || null,
+    did || null,
+    publicKey || null,
+    "online",
+    deviceType || "cli",
+  );
+  return {
+    peerId,
+    displayName,
+    did,
+    deviceType: deviceType || "cli",
+    status: "online",
+  };
+}
+
+/**
+ * Get a peer by ID.
+ */
+export function getPeer(db, peerId) {
+  ensureP2PTables(db);
+  return db.prepare("SELECT * FROM p2p_peers WHERE peer_id = ?").get(peerId);
+}
+
+/**
+ * Get all peers.
+ */
+export function getAllPeers(db) {
+  ensureP2PTables(db);
+  return db.prepare("SELECT * FROM p2p_peers ORDER BY last_seen DESC").all();
+}
+
+/**
+ * Get online peers.
+ */
+export function getOnlinePeers(db) {
+  ensureP2PTables(db);
+  return db.prepare("SELECT * FROM p2p_peers WHERE status = ?").get("online")
+    ? db.prepare("SELECT * FROM p2p_peers WHERE status = ?").all("online")
+    : [];
+}
+
+/**
+ * Update peer status.
+ */
+export function updatePeerStatus(db, peerId, status) {
+  ensureP2PTables(db);
+  const result = db
+    .prepare(
+      "UPDATE p2p_peers SET status = ?, last_seen = datetime('now') WHERE peer_id = ?",
+    )
+    .run(status, peerId);
+  return result.changes > 0;
+}
+
+/**
+ * Send a message to a peer (store in DB).
+ */
+export function sendMessage(db, fromPeer, toPeer, content, encrypted = false) {
+  ensureP2PTables(db);
+  const id = `msg-${crypto.randomBytes(8).toString("hex")}`;
+
+  // Verify recipient exists
+  const recipient = getPeer(db, toPeer);
+  if (!recipient) {
+    throw new Error(`Peer not found: ${toPeer}`);
+  }
+
+  db.prepare(
+    `INSERT INTO p2p_messages (id, from_peer, to_peer, content, encrypted)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(id, fromPeer, toPeer, content, encrypted ? 1 : 0);
+
+  return {
+    id,
+    fromPeer,
+    toPeer,
+    content,
+    encrypted,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Get inbox messages for a peer.
+ */
+export function getInbox(db, peerId, options = {}) {
+  ensureP2PTables(db);
+  const { unreadOnly = false, limit = 50 } = options;
+
+  let sql = "SELECT * FROM p2p_messages WHERE to_peer = ?";
+  const params = [peerId];
+
+  if (unreadOnly) {
+    sql += " AND read = 0";
+  }
+
+  sql += " ORDER BY created_at DESC LIMIT ?";
+  params.push(limit);
+
+  return db.prepare(sql).all(...params);
+}
+
+/**
+ * Mark a message as read.
+ */
+export function markMessageRead(db, messageId) {
+  ensureP2PTables(db);
+  const result = db
+    .prepare("UPDATE p2p_messages SET read = 1 WHERE id = ?")
+    .run(messageId);
+  return result.changes > 0;
+}
+
+/**
+ * Get message count for a peer.
+ */
+export function getMessageCount(db, peerId) {
+  ensureP2PTables(db);
+  const allMsgs = db
+    .prepare("SELECT * FROM p2p_messages WHERE to_peer = ?")
+    .all(peerId);
+  const total = allMsgs.length;
+  const unread = allMsgs.filter((m) => !m.read || m.read === 0).length;
+  return { total, unread };
+}
+
+/**
+ * Pair a device.
+ */
+export function pairDevice(db, deviceName, deviceType) {
+  ensureP2PTables(db);
+  const deviceId = `device-${crypto.randomBytes(8).toString("hex")}`;
+  const pairingCode = generatePairingCode();
+
+  db.prepare(
+    `INSERT INTO p2p_paired_devices (device_id, device_name, device_type, pairing_code, status)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(deviceId, deviceName, deviceType || "unknown", pairingCode, "pending");
+
+  return { deviceId, deviceName, deviceType, pairingCode, status: "pending" };
+}
+
+/**
+ * Confirm device pairing with code.
+ */
+export function confirmPairing(db, deviceId, code) {
+  ensureP2PTables(db);
+  const device = db
+    .prepare("SELECT * FROM p2p_paired_devices WHERE device_id = ?")
+    .get(deviceId);
+  if (!device) return { success: false, error: "Device not found" };
+  if (device.pairing_code !== code)
+    return { success: false, error: "Invalid pairing code" };
+
+  db.prepare(
+    "UPDATE p2p_paired_devices SET status = ? WHERE device_id = ?",
+  ).run("active", deviceId);
+  return { success: true, deviceId, deviceName: device.device_name };
+}
+
+/**
+ * Get all paired devices.
+ */
+export function getPairedDevices(db) {
+  ensureP2PTables(db);
+  return db
+    .prepare("SELECT * FROM p2p_paired_devices ORDER BY paired_at DESC")
+    .all();
+}
+
+/**
+ * Unpair a device.
+ */
+export function unpairDevice(db, deviceId) {
+  ensureP2PTables(db);
+  const result = db
+    .prepare("DELETE FROM p2p_paired_devices WHERE device_id = ?")
+    .run(deviceId);
+  return result.changes > 0;
+}
+
+/**
+ * Delete a peer.
+ */
+export function deletePeer(db, peerId) {
+  ensureP2PTables(db);
+  const result = db
+    .prepare("DELETE FROM p2p_peers WHERE peer_id = ?")
+    .run(peerId);
+  return result.changes > 0;
+}
+
+/**
+ * P2P Bridge — connects CLI to desktop app via HTTP/WebSocket.
+ */
+export class P2PBridge extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.host = options.host || "localhost";
+    this.port = options.port || DEFAULT_SIGNALING_PORT;
+    this.timeout = options.timeout || BRIDGE_TIMEOUT;
+    this.connected = false;
+  }
+
+  /**
+   * Check if desktop bridge is available.
+   */
+  async checkBridge() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      const response = await fetch(`http://${this.host}:${this.port}/health`, {
+        signal: controller.signal,
+      });
+      clearTimeout(timer);
+      return response.ok;
+    } catch (_err) {
+      // Bridge not available
+      return false;
+    }
+  }
+
+  /**
+   * Get bridge status info.
+   */
+  getStatus() {
+    return {
+      host: this.host,
+      port: this.port,
+      connected: this.connected,
+      endpoint: `http://${this.host}:${this.port}`,
+    };
+  }
+}

package/src/lib/pdf-parser.js

@@ -0,0 +1,96 @@
+/**
+ * Lightweight PDF text extractor.
+ * Uses a simple built-in parser for basic PDF text extraction.
+ * Falls back gracefully if text cannot be extracted.
+ */
+
+import { readFileSync } from "fs";
+import { basename, extname } from "path";
+
+/**
+ * Extract text content from a PDF file.
+ * Uses a basic approach: scan PDF stream for text operators.
+ * This handles simple PDFs without requiring heavy external dependencies.
+ *
+ * @param {string} filePath - Path to the PDF file
+ * @returns {{ title: string, content: string, pages: number|null }}
+ */
+export async function parsePdfText(filePath) {
+  const buffer = readFileSync(filePath);
+  const title = basename(filePath, extname(filePath));
+
+  // Try to extract text from PDF binary
+  const text = extractTextFromPdf(buffer);
+
+  // Count pages by looking for /Type /Page objects
+  const pdfStr = buffer.toString("latin1");
+  const pageMatches = pdfStr.match(/\/Type\s*\/Page[^s]/g);
+  const pages = pageMatches ? pageMatches.length : null;
+
+  return {
+    title,
+    content: text,
+    pages,
+  };
+}
+
+/**
+ * Basic PDF text extraction.
+ * Scans for text between BT/ET operators and decodes common encodings.
+ */
+function extractTextFromPdf(buffer) {
+  const pdfStr = buffer.toString("latin1");
+  const textParts = [];
+
+  // Find all stream sections and decode them
+  const streamRegex = /stream\r?\n([\s\S]*?)\r?\nendstream/g;
+  let match;
+
+  while ((match = streamRegex.exec(pdfStr)) !== null) {
+    const streamContent = match[1];
+
+    // Look for text showing operators: Tj, TJ, ', "
+    const tjRegex = /\(([^)]*)\)\s*Tj/g;
+    let tjMatch;
+    while ((tjMatch = tjRegex.exec(streamContent)) !== null) {
+      const decoded = decodePdfString(tjMatch[1]);
+      if (decoded.trim()) textParts.push(decoded);
+    }
+
+    // TJ operator: array of strings and numbers
+    const tjArrayRegex = /\[((?:\([^)]*\)|[^[\]])*)\]\s*TJ/gi;
+    let tjArrMatch;
+    while ((tjArrMatch = tjArrayRegex.exec(streamContent)) !== null) {
+      const inner = tjArrMatch[1];
+      const strRegex = /\(([^)]*)\)/g;
+      let strMatch;
+      const parts = [];
+      while ((strMatch = strRegex.exec(inner)) !== null) {
+        parts.push(decodePdfString(strMatch[1]));
+      }
+      if (parts.length > 0) textParts.push(parts.join(""));
+    }
+  }
+
+  // Clean up and join
+  const text = textParts
+    .join("\n")
+    .replace(/\r\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+
+  return text;
+}
+
+/**
+ * Decode a PDF string (handle basic escape sequences).
+ */
+function decodePdfString(str) {
+  return str
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+    .replace(/\\\(/g, "(")
+    .replace(/\\\)/g, ")")
+    .replace(/\\\\/g, "\\");
+}