@a-company/paradigm 3.44.0 → 3.46.0

package/dist/{symphony-EYRGGVNE.js → symphony-6K3HD7AW.js}

@@ -25,17 +25,18 @@ import {
   resolveThread,
   routeMessage,
   unregisterAgent
-} from "./chunk-SOBTKFSP.js";
+} from "./chunk-S2HO5MLR.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/symphony/index.ts
 import chalk from "chalk";
-import * as net from "net";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
 async function symphonyJoinCommand(options) {
   const rootDir = process.cwd();
   if (options.remote) {
-    console.log(chalk.yellow(`Remote linking to ${options.remote} \u2014 not yet implemented in Phase 0.`));
-    console.log(chalk.gray("Remote linking will be available in a future Symphony phase."));
+    await symphonyJoinRemote(rootDir, options.remote);
     return;
   }
   const identity = registerAgent(rootDir);
@@ -55,6 +56,88 @@ async function symphonyJoinCommand(options) {
   console.log(chalk.gray(`
   Tip: Set up polling with: /loop 10s paradigm_symphony_poll`));
 }
+async function symphonyJoinRemote(rootDir, remote) {
+  const { SymphonyRelay } = await import("./symphony-relay-GTAJRCVF.js");
+  let address;
+  let embeddedCode;
+  if (remote.includes("#")) {
+    const parts = remote.split("#");
+    address = parts[0];
+    embeddedCode = parts[1];
+  } else {
+    address = remote;
+  }
+  if (!address.includes(":")) {
+    address = `${address}:3939`;
+  }
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+  }
+  let code;
+  if (embeddedCode) {
+    code = embeddedCode;
+    console.log(chalk.cyan(`
+  Connecting to ${address} with embedded pairing code...`));
+  } else {
+    console.log(chalk.cyan(`
+  Connecting to ${address}...`));
+    console.log(chalk.white("  Enter the 6-digit pairing code shown on the host:"));
+    code = await readLineFromStdin("  Code: ");
+    code = code.trim();
+    if (!/^\d{6}$/.test(code)) {
+      console.log(chalk.red("  Invalid code. Must be 6 digits."));
+      return;
+    }
+  }
+  const relay = new SymphonyRelay({
+    mode: "client",
+    peerId: identity.id,
+    events: {
+      onPeerConnected: (peerId, displayName) => {
+        console.log(chalk.green(`  \u2713 Connected to ${chalk.bold(displayName)} (${peerId})`));
+      },
+      onPeerDisconnected: (peerId) => {
+        console.log(chalk.yellow(`  Peer ${peerId} disconnected. Reconnecting...`));
+      },
+      onMessageRelayed: (messageId, from, to) => {
+        console.log(chalk.gray(`  \u2190 Message ${messageId.slice(0, 8)} from ${from} \u2192 ${to}`));
+      },
+      onError: (err) => {
+        console.log(chalk.red(`  Error: ${err.message}`));
+      }
+    }
+  });
+  try {
+    await relay.connectToServer(address, code);
+    console.log(chalk.green("\n  \u2713 Paired and connected!"));
+    console.log(chalk.gray("  Messages from remote agents will appear in your inbox."));
+    console.log(chalk.gray("  Press Ctrl+C to disconnect.\n"));
+    process.on("SIGINT", () => {
+      console.log(chalk.yellow("\n  Disconnecting..."));
+      relay.stop();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.log(chalk.red(`  Failed to connect: ${err.message}`));
+    relay.stop();
+  }
+}
+function readLineFromStdin(prompt) {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.resume();
+    process.stdin.once("data", (chunk) => {
+      data = chunk.toString();
+      process.stdin.pause();
+      resolve(data);
+    });
+  });
+}
 async function symphonyLeaveCommand() {
   const rootDir = process.cwd();
   const agentId = resolveAgentIdentity(rootDir);
@@ -91,16 +174,29 @@ async function symphonyWhoamiCommand() {
 async function symphonyListCommand(options) {
   cleanStaleAgents();
   const agents = listAgents();
+  const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+  const peers = loadPeers();
+  const remoteAgents = [];
+  for (const peer of peers) {
+    if (peer.revoked) continue;
+    for (const agent of peer.agents || []) {
+      remoteAgents.push({ ...agent, peerId: peer.id });
+    }
+  }
+  const totalCount = agents.length + remoteAgents.length;
   if (options.json) {
-    console.log(JSON.stringify(agents, null, 2));
+    console.log(JSON.stringify({
+      local: agents,
+      remote: remoteAgents
+    }, null, 2));
     return;
   }
-  if (agents.length === 0) {
+  if (totalCount === 0) {
     console.log(chalk.yellow('No agents joined. Run "paradigm symphony join" in each terminal.'));
     return;
   }
   console.log(chalk.cyan(`
-  Symphony Agents (${agents.length})
+  Symphony Agents (${totalCount})
 `));
   console.log(chalk.gray(`  ${"AGENT ID".padEnd(30)} ${"PROJECT".padEnd(15)} ${"ROLE".padEnd(10)} STATUS`));
   console.log(chalk.gray(`  ${"\u2500".repeat(30)} ${"\u2500".repeat(15)} ${"\u2500".repeat(10)} ${"\u2500".repeat(8)}`));
@@ -111,6 +207,17 @@ async function symphonyListCommand(options) {
       console.log(`  ${chalk.gray(`  \u2514 ${agent.statusBlurb}`)}`);
     }
   }
+  if (remoteAgents.length > 0) {
+    console.log(chalk.gray(`
+  ${"\u2500".repeat(65)}`));
+    console.log(chalk.cyan(`  Remote Agents (${remoteAgents.length})
+`));
+    for (const agent of remoteAgents) {
+      const status = agent.status === "awake" ? chalk.green("awake") : chalk.yellow("asleep");
+      const tag = chalk.magenta(`(remote: ${agent.peerId})`);
+      console.log(`  ${chalk.white(agent.id.padEnd(30))} ${agent.project.padEnd(15)} ${agent.role.padEnd(10)} ${status} ${tag}`);
+    }
+  }
   console.log();
 }
 async function symphonySendCommand(messageText, options) {
@@ -291,10 +398,14 @@ async function symphonyStatusCommand(options) {
   const threads = listThreads("active");
   const pendingRequests = listFileRequests("pending");
   const unread = identity ? readInbox(identity.id) : [];
+  const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+  const peers = loadPeers();
+  const activePeers = peers.filter((p) => !p.revoked);
   if (options.json) {
     console.log(JSON.stringify({
       identity: identity ? { id: identity.id, project: identity.project, role: identity.role } : null,
       agents: agents.map((a) => ({ id: a.id, status: isAgentAsleep(a) ? "asleep" : "awake", statusBlurb: a.statusBlurb })),
+      peers: activePeers.map((p) => ({ id: p.id, address: p.address, agents: p.agents?.length ?? 0, lastSeen: p.lastSeen })),
       activeThreads: threads.length,
       unreadMessages: unread.length,
       pendingFileRequests: pendingRequests.length
@@ -314,6 +425,16 @@ async function symphonyStatusCommand(options) {
     const blurb = a.statusBlurb ? chalk.gray(` \u2014 ${a.statusBlurb}`) : "";
     console.log(`    ${chalk.white(a.id)} [${st}]${blurb}`);
   }
+  if (activePeers.length > 0) {
+    const totalRemoteAgents = activePeers.reduce((sum, p) => sum + (p.agents?.length ?? 0), 0);
+    console.log(`  ${chalk.white("Peers:")} ${activePeers.length} connected (${totalRemoteAgents} remote agents)`);
+    for (const p of activePeers) {
+      const agentCount = p.agents?.length ?? 0;
+      console.log(`    ${chalk.white(p.id)} at ${p.address} (${agentCount} agent${agentCount !== 1 ? "s" : ""})`);
+    }
+  } else {
+    console.log(`  ${chalk.white("Peers:")} ${chalk.gray('none (run "paradigm symphony serve" to accept connections)')}`);
+  }
   console.log(`  ${chalk.white("Threads:")} ${threads.length} active`);
   console.log(`  ${chalk.white("Unread:")} ${unread.length} note${unread.length !== 1 ? "s" : ""}`);
   console.log(`  ${chalk.white("File Requests:")} ${pendingRequests.length} pending`);
@@ -321,31 +442,88 @@ async function symphonyStatusCommand(options) {
 }
 async function symphonyServeCommand(options) {
   const port = parseInt(options.port || "3939", 10);
-  console.log(chalk.cyan(`
-  Starting Symphony TCP server on port ${port}...`));
-  console.log(chalk.gray("  Phase 0 stub \u2014 remote linking protocol not yet implemented.\n"));
-  const server = net.createServer((socket) => {
-    socket.write(JSON.stringify({ type: "hello", version: "0.1.0" }) + "\n");
-    socket.on("data", (data) => {
-      try {
-        const msg = JSON.parse(data.toString().trim());
-        socket.write(JSON.stringify({ type: "ack", received: msg.type }) + "\n");
-      } catch {
-        socket.write(JSON.stringify({ type: "error", message: "Invalid JSON" }) + "\n");
+  const rootDir = process.cwd();
+  const { SymphonyRelay } = await import("./symphony-relay-GTAJRCVF.js");
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+  }
+  console.log(chalk.cyan("\n  Starting Symphony relay server...\n"));
+  const relay = new SymphonyRelay({
+    mode: "server",
+    peerId: identity.id,
+    port,
+    events: {
+      onPeerConnected: (peerId, displayName) => {
+        console.log(chalk.green(`  \u2713 Peer connected: ${chalk.bold(displayName)} (${peerId})`));
+        const remoteAgents = relay.getRemoteAgents();
+        if (remoteAgents.length > 0) {
+          console.log(chalk.gray(`    Remote agents: ${remoteAgents.map((a) => a.id).join(", ")}`));
+        }
+      },
+      onPeerDisconnected: (peerId) => {
+        console.log(chalk.yellow(`  Peer disconnected: ${peerId}`));
+      },
+      onPeerAuthFailed: (address, reason) => {
+        console.log(chalk.red(`  Auth failed from ${address}: ${reason}`));
+      },
+      onMessageRelayed: (messageId, from, to) => {
+        console.log(chalk.gray(`  \u2194 Relayed ${messageId.slice(0, 8)} from ${from} to ${to}`));
+      },
+      onError: (err) => {
+        console.log(chalk.red(`  Error: ${err.message}`));
       }
+    }
+  });
+  try {
+    const pairing = await relay.startServer();
+    const localIp = getLocalIpAddress();
+    console.log(chalk.green(`  \u2713 Symphony relay listening on port ${port}`));
+    console.log();
+    console.log(chalk.white("  Pairing Code:"));
+    console.log();
+    console.log(chalk.bold.cyan(`      ${pairing.code.slice(0, 3)} ${pairing.code.slice(3)}`));
+    console.log();
+    console.log(chalk.gray("  Share this code with the person connecting."));
+    console.log(chalk.gray(`  Code rotates every 5 minutes.
+`));
+    console.log(chalk.white("  LAN connect:"));
+    console.log(chalk.gray(`    paradigm symphony join --remote ${localIp}:${port}`));
+    if (options.public) {
+      const connectionString = `${localIp}:${port}#${pairing.code}`;
+      console.log();
+      console.log(chalk.white("  Internet connect (connection string):"));
+      console.log(chalk.cyan(`    paradigm symphony join --remote ${connectionString}`));
+      console.log(chalk.gray("  (Requires port 3939 reachable: port forward, VPN, or SSH tunnel)"));
+    }
+    console.log(chalk.gray("\n  Press Ctrl+C to stop.\n"));
+    const rotateInterval = setInterval(() => {
+      const newPairing = relay.rotatePairingCode();
+      console.log(chalk.cyan(`  Code rotated: ${newPairing.code.slice(0, 3)} ${newPairing.code.slice(3)}`));
+    }, 5 * 60 * 1e3);
+    process.on("SIGINT", () => {
+      console.log(chalk.yellow("\n  Shutting down relay..."));
+      clearInterval(rotateInterval);
+      relay.stop();
+      process.exit(0);
     });
-    socket.on("error", () => {
+    await new Promise(() => {
     });
-  });
-  server.listen(port, "0.0.0.0", () => {
-    console.log(chalk.green(`  \u2713 Symphony server listening on 0.0.0.0:${port}`));
-    console.log(chalk.gray(`  Connect from another machine: paradigm symphony join --remote <this-ip>:${port}`));
-  });
-  server.on("error", (err) => {
+  } catch (err) {
     console.log(chalk.red(`  Failed to start server: ${err.message}`));
-  });
-  await new Promise(() => {
-  });
+    relay.stop();
+  }
+}
+function getLocalIpAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name] || []) {
+      if (iface.family === "IPv4" && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return "127.0.0.1";
 }
 async function symphonyRequestCommand(file, options) {
   const rootDir = process.cwd();
@@ -451,6 +629,148 @@ async function symphonyDenyCommand(requestId, options) {
     console.log(chalk.red(`\u2717 File request not found or already resolved: ${requestId}`));
   }
 }
+var INTENT_COLORS = {
+  question: chalk.blue,
+  context: chalk.gray,
+  clarification: chalk.blue,
+  proposal: chalk.cyan,
+  verification: chalk.blue,
+  action: chalk.cyan,
+  decision: chalk.yellow,
+  alert: chalk.red,
+  approval: chalk.green,
+  rejection: chalk.red,
+  reference: chalk.gray,
+  handoff: chalk.magenta,
+  fileRequest: chalk.green,
+  fileApproved: chalk.green,
+  fileDenied: chalk.red,
+  fileDelivery: chalk.green
+};
+function formatWatchMessage(msg) {
+  const time = new Date(msg.timestamp).toLocaleTimeString(void 0, {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const colorFn = INTENT_COLORS[msg.intent] || chalk.white;
+  const intentLabel = colorFn(`[${msg.intent}]`);
+  const sender = chalk.cyan(msg.sender.name);
+  const threadLabel = msg.threadRoot ? chalk.gray(` (${msg.threadRoot})`) : "";
+  const lines = [];
+  lines.push(`  ${chalk.gray(time)} ${sender} ${intentLabel}${threadLabel}`);
+  const textLines = msg.content.text.split("\n");
+  for (const line of textLines) {
+    lines.push(`    ${line}`);
+  }
+  if (msg.symbols.length > 0) {
+    lines.push(`    ${chalk.gray(`Symbols: ${msg.symbols.join(", ")}`)}`);
+  }
+  if (msg.content.decision) {
+    lines.push(`    ${chalk.yellow(`Decision: ${msg.content.decision}`)}`);
+  }
+  if (msg.content.diff) {
+    lines.push(`    ${chalk.gray("[diff attached]")}`);
+  }
+  return lines.join("\n");
+}
+async function symphonyWatchCommand(options) {
+  const rootDir = process.cwd();
+  let identity = getMyIdentity(rootDir);
+  if (!identity) {
+    identity = registerAgent(rootDir);
+    console.log(chalk.gray(`Auto-joined as ${identity.id}`));
+  }
+  const intervalMs = parseInt(options.interval || "2000", 10);
+  const threadFilter = options.thread;
+  const quiet = options.quiet;
+  const scoreDir = path.join(os.homedir(), ".paradigm", "score");
+  const inboxPath = path.join(scoreDir, "agents", ...identity.id.split("/"), "inbox.jsonl");
+  let lastLineCount = 0;
+  let lastSize = 0;
+  if (fs.existsSync(inboxPath)) {
+    const content = fs.readFileSync(inboxPath, "utf-8");
+    lastLineCount = content.split("\n").filter((l) => l.trim().length > 0).length;
+    lastSize = fs.statSync(inboxPath).size;
+  }
+  if (!quiet) {
+    console.log(chalk.cyan("\n  Symphony Watch"));
+    console.log(chalk.gray(`  Agent: ${identity.id}`));
+    console.log(chalk.gray(`  Inbox: ${inboxPath}`));
+    console.log(chalk.gray(`  Poll: ${intervalMs}ms`));
+    if (threadFilter) {
+      console.log(chalk.gray(`  Filter: thread ${threadFilter}`));
+    }
+    console.log(chalk.gray(`  Press Ctrl+C to stop
+`));
+    console.log(chalk.gray(`  ${"\u2500".repeat(60)}
+`));
+  }
+  const threadsDir = path.join(scoreDir, "threads");
+  let knownThreads = /* @__PURE__ */ new Set();
+  if (fs.existsSync(threadsDir)) {
+    for (const f of fs.readdirSync(threadsDir)) {
+      knownThreads.add(f);
+    }
+  }
+  const poll = () => {
+    try {
+      if (fs.existsSync(inboxPath)) {
+        const stat = fs.statSync(inboxPath);
+        if (stat.size > lastSize) {
+          const content = fs.readFileSync(inboxPath, "utf-8");
+          const lines = content.split("\n").filter((l) => l.trim().length > 0);
+          if (lines.length > lastLineCount) {
+            const newLines = lines.slice(lastLineCount);
+            for (const line of newLines) {
+              try {
+                const msg = JSON.parse(line);
+                if (threadFilter && msg.threadRoot !== threadFilter) continue;
+                console.log(formatWatchMessage(msg));
+                console.log();
+              } catch {
+              }
+            }
+            lastLineCount = lines.length;
+          }
+          lastSize = stat.size;
+        }
+      }
+      if (fs.existsSync(threadsDir)) {
+        const currentFiles = fs.readdirSync(threadsDir);
+        for (const f of currentFiles) {
+          if (!knownThreads.has(f)) {
+            knownThreads.add(f);
+            try {
+              const threadData = JSON.parse(
+                fs.readFileSync(path.join(threadsDir, f), "utf-8")
+              );
+              if (!quiet) {
+                console.log(`  ${chalk.green("+")} ${chalk.white("New thread:")} ${threadData.topic || threadData.id}`);
+                console.log(`    ${chalk.gray(`by ${threadData.initiator?.name || "unknown"} \u2014 ${threadData.id}`)}`);
+                console.log();
+              }
+            } catch {
+            }
+          }
+        }
+      }
+      markAgentPollTime(identity.id);
+    } catch {
+    }
+  };
+  poll();
+  const timer = setInterval(poll, intervalMs);
+  process.on("SIGINT", () => {
+    clearInterval(timer);
+    if (!quiet) {
+      console.log(chalk.gray("\n  Watch stopped.\n"));
+    }
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
 export {
   symphonyApproveCommand,
   symphonyDenyCommand,
@@ -466,5 +786,6 @@ export {
   symphonyStatusCommand,
   symphonyThreadCommand,
   symphonyThreadsCommand,
+  symphonyWatchCommand,
   symphonyWhoamiCommand
 };

package/dist/{symphony-QWOEKZMC.js → symphony-YCHBYN3E.js}

@@ -18,7 +18,7 @@ import {
   resolveAgentIdentity,
   resolveThread,
   routeMessage
-} from "./chunk-SOBTKFSP.js";
+} from "./chunk-S2HO5MLR.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/platform-server/routes/symphony.ts
@@ -57,6 +57,24 @@ function createSymphonyRouter(projectDir, broadcast) {
       res.status(500).json({ error: "Failed to get identity", detail: String(err) });
     }
   });
+  router.get("/peers", async (_req, res) => {
+    try {
+      const { loadPeers } = await import("./symphony-peers-HSY3RI3S.js");
+      const peers = loadPeers();
+      const result = peers.map((p) => ({
+        id: p.id,
+        displayName: p.displayName,
+        address: p.address,
+        connectedAt: p.connectedAt,
+        lastSeen: p.lastSeen,
+        revoked: p.revoked,
+        agents: p.agents || []
+      }));
+      res.json({ peers: result });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to list peers", detail: String(err) });
+    }
+  });
   router.get("/threads", (req, res) => {
     try {
       const statusParam = req.query.status;

package/dist/symphony-peers-APOGJPF4.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/utils/symphony-peers.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var SCORE_DIR = path.join(os.homedir(), ".paradigm", "score");
+var PEERS_FILE = path.join(SCORE_DIR, "peers.json");
+var PAIRING_TTL_MS = 5 * 60 * 1e3;
+function loadPeers() {
+  try {
+    if (!fs.existsSync(PEERS_FILE)) return [];
+    const content = fs.readFileSync(PEERS_FILE, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function savePeers(peers) {
+  if (!fs.existsSync(SCORE_DIR)) {
+    fs.mkdirSync(SCORE_DIR, { recursive: true });
+  }
+  fs.writeFileSync(PEERS_FILE, JSON.stringify(peers, null, 2), { mode: 384 });
+}
+function findPeer(id) {
+  const peers = loadPeers();
+  return peers.find((p) => p.id === id) ?? null;
+}
+function addPeer(peer) {
+  const peers = loadPeers();
+  const idx = peers.findIndex((p) => p.id === peer.id);
+  if (idx >= 0) {
+    peers[idx] = peer;
+  } else {
+    peers.push(peer);
+  }
+  savePeers(peers);
+}
+function revokePeer(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return false;
+  peer.revoked = true;
+  savePeers(peers);
+  return true;
+}
+function forgetAllPeers() {
+  const peers = loadPeers();
+  const count = peers.length;
+  if (fs.existsSync(PEERS_FILE)) {
+    fs.unlinkSync(PEERS_FILE);
+  }
+  return count;
+}
+function updatePeerLastSeen(id) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+  savePeers(peers);
+}
+function updatePeerAgents(id, agents) {
+  const peers = loadPeers();
+  const peer = peers.find((p) => p.id === id);
+  if (!peer) return;
+  peer.agents = agents;
+  savePeers(peers);
+}
+function generatePairing() {
+  const sharedSecret = crypto.randomBytes(32).toString("hex");
+  const code = (parseInt(crypto.randomBytes(3).toString("hex"), 16) % 1e6).toString().padStart(6, "0");
+  const codeHash = crypto.createHash("sha256").update(code).digest("hex");
+  return {
+    code,
+    codeHash,
+    sharedSecret,
+    createdAt: Date.now()
+  };
+}
+function verifyPairingCode(state, code) {
+  if (Date.now() - state.createdAt > PAIRING_TTL_MS) {
+    return false;
+  }
+  const hash = crypto.createHash("sha256").update(code).digest("hex");
+  return hash === state.codeHash;
+}
+function computeHmacProof(challenge, codeHash) {
+  return crypto.createHmac("sha256", codeHash).update(challenge).digest("hex");
+}
+function verifyHmacProof(challenge, codeHash, proof) {
+  const expected = computeHmacProof(challenge, codeHash);
+  if (expected.length !== proof.length) return false;
+  try {
+    return crypto.timingSafeEqual(
+      Buffer.from(expected, "hex"),
+      Buffer.from(proof, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+export {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+};

package/dist/symphony-peers-HSY3RI3S.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+} from "./chunk-KVDYJLTC.js";
+import "./chunk-ZXMDA7VB.js";
+export {
+  PAIRING_TTL_MS,
+  PEERS_FILE,
+  addPeer,
+  computeHmacProof,
+  findPeer,
+  forgetAllPeers,
+  generatePairing,
+  loadPeers,
+  revokePeer,
+  savePeers,
+  updatePeerAgents,
+  updatePeerLastSeen,
+  verifyHmacProof,
+  verifyPairingCode
+};