@annals/agent-mesh 0.17.5 → 0.17.7

package/dist/index.js

@@ -290,6 +290,7 @@ import { existsSync, copyFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 var ICE_SERVERS = ["stun:stun.l.google.com:19302"];
 var CHUNK_SIZE = 64 * 1024;
+var CONNECT_TIMEOUT_MS = 1e4;
 var ndcModule;
 function ensurePrebuilt() {
   try {
@@ -410,6 +411,126 @@ var FileSender = class {
     this.peer = null;
   }
 };
+var FileReceiver = class {
+  peer = null;
+  dc = null;
+  expectedSize;
+  expectedSha256;
+  chunks = [];
+  receivedBytes = 0;
+  resolveComplete = null;
+  rejectComplete = null;
+  signalCallback = null;
+  pendingCandidates = [];
+  closed = false;
+  constructor(expectedSize, expectedSha256) {
+    this.expectedSize = expectedSize;
+    this.expectedSha256 = expectedSha256;
+  }
+  onSignal(cb) {
+    this.signalCallback = cb;
+  }
+  async createOffer() {
+    const ndc = await loadNdc();
+    if (!ndc) return null;
+    this.peer = new ndc.PeerConnection("receiver", {
+      iceServers: ICE_SERVERS
+    });
+    return new Promise((resolve2) => {
+      this.peer.onLocalDescription((sdp, type) => {
+        if (type === "offer") {
+          resolve2(sdp);
+        }
+        this.signalCallback?.({ signal_type: type, payload: sdp });
+      });
+      this.peer.onLocalCandidate((candidate, mid) => {
+        this.signalCallback?.({
+          signal_type: "candidate",
+          payload: JSON.stringify({ candidate, mid })
+        });
+      });
+      this.dc = this.peer.createDataChannel("file-transfer");
+      this.dc.onMessage((msg) => {
+        if (typeof msg === "string") {
+          try {
+            const ctrl = JSON.parse(msg);
+            if (ctrl.type === "complete") {
+              this.finalizeReceive();
+            }
+          } catch {
+          }
+          return;
+        }
+        const buf = Buffer.isBuffer(msg) ? msg : Buffer.from(msg);
+        this.chunks.push(buf);
+        this.receivedBytes += buf.length;
+      });
+    });
+  }
+  async handleSignal(signal) {
+    if (!this.peer || this.closed) return;
+    if (signal.signal_type === "answer" || signal.signal_type === "offer") {
+      this.peer.setRemoteDescription(signal.payload, signal.signal_type);
+      for (const c of this.pendingCandidates) {
+        this.peer.addRemoteCandidate(c.candidate, c.mid);
+      }
+      this.pendingCandidates = [];
+    } else if (signal.signal_type === "candidate") {
+      const { candidate, mid } = JSON.parse(signal.payload);
+      if (this.peer.remoteDescription()) {
+        this.peer.addRemoteCandidate(candidate, mid);
+      } else {
+        this.pendingCandidates.push({ candidate, mid });
+      }
+    }
+  }
+  waitForCompletion(timeoutMs = CONNECT_TIMEOUT_MS) {
+    return new Promise((resolve2, reject) => {
+      this.resolveComplete = resolve2;
+      this.rejectComplete = reject;
+      setTimeout(() => {
+        if (!this.closed) {
+          reject(new Error(`WebRTC file transfer timed out after ${timeoutMs}ms`));
+          this.close();
+        }
+      }, timeoutMs);
+    });
+  }
+  finalizeReceive() {
+    const zipBuffer = Buffer.concat(this.chunks);
+    const actualSha256 = createHash("sha256").update(zipBuffer).digest("hex");
+    if (zipBuffer.length !== this.expectedSize) {
+      this.rejectComplete?.(
+        new Error(`Size mismatch: expected ${this.expectedSize}, got ${zipBuffer.length}`)
+      );
+      this.close();
+      return;
+    }
+    if (actualSha256 !== this.expectedSha256) {
+      this.rejectComplete?.(
+        new Error(`SHA-256 mismatch: expected ${this.expectedSha256}, got ${actualSha256}`)
+      );
+      this.close();
+      return;
+    }
+    log.info(`[WebRTC] Received ${zipBuffer.length} bytes, SHA-256 verified`);
+    this.resolveComplete?.(zipBuffer);
+    this.close();
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.dc?.close();
+    } catch {
+    }
+    try {
+      this.peer?.close();
+    } catch {
+    }
+    this.peer = null;
+    this.dc = null;
+  }
+};
 function sha256Hex(data) {
   return createHash("sha256").update(data).digest("hex");
 }
@@ -1045,9 +1166,6 @@ var BridgeManager = class {
       const attachments = payload?.attachments;
       const fileTransferOffer = payload?.fileTransferOffer;
       const zipBuffer = payload?.zipBuffer;
-      if (fileTransferOffer && zipBuffer) {
-        this.registerPendingTransfer(fileTransferOffer, zipBuffer);
-      }
       const done = {
         type: "done",
         session_id: sessionId,
@@ -1060,6 +1178,9 @@ var BridgeManager = class {
       this.wsClient.send(done);
       fullResponseBuffer = "";
       this.sessionLastSeenAt.set(sessionId, Date.now());
+      if (fileTransferOffer && zipBuffer) {
+        this.registerPendingTransfer(fileTransferOffer, zipBuffer);
+      }
       const fileInfo = fileTransferOffer ? ` (${fileTransferOffer.file_count} files, transfer=${fileTransferOffer.transfer_id.slice(0, 8)}...)` : "";
       log.info(`Request done: session=${sessionId.slice(0, 8)}... request=${requestRef.requestId.slice(0, 8)}...${fileInfo}`);
     });
@@ -1265,32 +1386,7 @@ var BridgeManager = class {
     }, 5 * 6e4);
     timer.unref?.();
     this.pendingTransfers.set(offer.transfer_id, { sender, timer });
-    this.pushZipToWorker(offer.transfer_id, zipBuffer);
-  }
-  /** Push ZIP buffer to Worker DO via chunked transfer_upload messages */
-  pushZipToWorker(transferId, zipBuffer) {
-    const CHUNK_SIZE2 = 64 * 1024;
-    const totalChunks = Math.ceil(zipBuffer.length / CHUNK_SIZE2);
-    log.debug(`Pushing ZIP to Worker: transfer=${transferId.slice(0, 8)}... size=${zipBuffer.length} chunks=${totalChunks}`);
-    for (let i = 0; i < totalChunks; i++) {
-      const start = i * CHUNK_SIZE2;
-      const end = Math.min(start + CHUNK_SIZE2, zipBuffer.length);
-      const chunk = zipBuffer.subarray(start, end);
-      const msg = {
-        type: "transfer_upload",
-        transfer_id: transferId,
-        chunk_index: i,
-        total_chunks: totalChunks,
-        data: chunk.toString("base64")
-      };
-      this.wsClient.send(msg);
-    }
-    const complete = {
-      type: "transfer_upload_complete",
-      transfer_id: transferId
-    };
-    this.wsClient.send(complete);
-    log.info(`ZIP pushed to Worker: transfer=${transferId.slice(0, 8)}... (${totalChunks} chunks)`);
+    log.info(`WebRTC transfer registered: transfer=${offer.transfer_id.slice(0, 8)}... (${(zipBuffer.length / 1024).toFixed(1)} KB in memory)`);
   }
   handleRtcSignalRelay(msg) {
     const entry = this.pendingTransfers.get(msg.transfer_id);
@@ -1666,8 +1762,18 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
 ]);
 async function collectRealFiles(dir, maxFiles = Infinity) {
   const files = [];
+  const visited = /* @__PURE__ */ new Set();
   const walk = async (d) => {
     if (files.length >= maxFiles) return;
+    let realDir;
+    try {
+      const { realpath } = await import("fs/promises");
+      realDir = await realpath(d);
+    } catch {
+      return;
+    }
+    if (visited.has(realDir)) return;
+    visited.add(realDir);
     let entries;
     try {
       entries = await readdir(d, { withFileTypes: true });
@@ -1676,11 +1782,19 @@ async function collectRealFiles(dir, maxFiles = Infinity) {
     }
     for (const entry of entries) {
       if (files.length >= maxFiles) return;
-      if (entry.isSymbolicLink()) continue;
       const fullPath = join5(d, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         await walk(fullPath);
+      } else if (entry.isSymbolicLink()) {
+        try {
+          const s = await stat(fullPath);
+          if (s.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name)) continue;
+            await walk(fullPath);
+          }
+        } catch {
+        }
       } else if (entry.isFile()) {
         files.push(fullPath);
       }
@@ -4543,7 +4657,6 @@ function registerDiscoverCommand(program2) {
 
 // src/commands/call.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync5 } from "fs";
-import { createHash as createHash2 } from "crypto";
 import { execSync as execSync4 } from "child_process";
 import { join as join11 } from "path";
 var DEFAULT_BASE_URL4 = "https://agents.hot";
@@ -4577,74 +4690,101 @@ function handleError2(err) {
   }
   process.exit(1);
 }
-async function downloadTransferFiles(agentId, offer, token, outputDir, json) {
-  const url = `${DEFAULT_BASE_URL4}/api/agents/${agentId}/transfer/${offer.transfer_id}`;
+async function webrtcDownload(agentId, offer, token, outputDir, json) {
   if (!json) {
-    log.info(`Downloading ${offer.file_count} file(s) (${(offer.zip_size / 1024).toFixed(1)} KB)...`);
+    log.info(`[WebRTC] Downloading ${offer.file_count} file(s) (${(offer.zip_size / 1024).toFixed(1)} KB)...`);
   }
-  await sleep6(1e3);
-  let lastError = null;
-  for (let attempt = 0; attempt < 5; attempt++) {
+  const receiver = new FileReceiver(offer.zip_size, offer.zip_sha256);
+  const exchangeSignals = async (signal) => {
     try {
-      const res = await fetch(url, {
-        headers: { Authorization: `Bearer ${token}` }
+      const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${agentId}/rtc-signal`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          transfer_id: offer.transfer_id,
+          signal_type: signal.signal_type,
+          payload: signal.payload
+        })
       });
-      if (res.status === 202) {
-        await sleep6(2e3);
-        continue;
-      }
-      if (res.status === 404) {
-        if (attempt < 4) {
-          await sleep6(2e3);
-          continue;
+      if (res.ok) {
+        const { signals } = await res.json();
+        for (const s of signals) {
+          await receiver.handleSignal(s);
         }
-        log.warn("Transfer expired or not found");
-        return;
       }
-      if (!res.ok) {
-        log.warn(`Download failed: HTTP ${res.status}`);
-        return;
-      }
-      const arrayBuffer = await res.arrayBuffer();
-      const zipBuffer = Buffer.from(arrayBuffer);
-      const hash = createHash2("sha256").update(zipBuffer).digest("hex");
-      if (hash !== offer.zip_sha256) {
-        log.warn(`SHA-256 mismatch: expected ${offer.zip_sha256.slice(0, 12)}... got ${hash.slice(0, 12)}...`);
-        return;
-      }
-      mkdirSync5(outputDir, { recursive: true });
-      const zipPath = join11(outputDir, `.transfer-${offer.transfer_id.slice(0, 8)}.zip`);
-      writeFileSync3(zipPath, zipBuffer);
+    } catch {
+    }
+  };
+  receiver.onSignal(exchangeSignals);
+  await receiver.createOffer();
+  const poll = async () => {
+    for (let i = 0; i < 20; i++) {
+      await sleep6(500);
       try {
-        execSync4(`unzip -o -q "${zipPath}" -d "${outputDir}"`);
-        try {
-          execSync4(`rm "${zipPath}"`);
-        } catch {
+        const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${agentId}/rtc-signal`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            transfer_id: offer.transfer_id,
+            signal_type: "poll",
+            payload: ""
+          })
+        });
+        if (res.ok) {
+          const { signals } = await res.json();
+          for (const s of signals) {
+            await receiver.handleSignal(s);
+          }
         }
       } catch {
-        log.warn(`Failed to extract ZIP. Saved to: ${zipPath}`);
-        return;
       }
-      if (json) {
-        console.log(JSON.stringify({
-          type: "files_downloaded",
-          file_count: offer.file_count,
-          output_dir: outputDir,
-          zip_size: zipBuffer.length,
-          sha256_verified: true
-        }));
-      } else {
-        log.success(`${offer.file_count} file(s) extracted to ${outputDir}`);
+    }
+  };
+  try {
+    const [zipBuffer] = await Promise.all([
+      receiver.waitForCompletion(3e4),
+      poll()
+    ]);
+    mkdirSync5(outputDir, { recursive: true });
+    const zipPath = join11(outputDir, ".transfer.zip");
+    writeFileSync3(zipPath, zipBuffer);
+    try {
+      execSync4(`unzip -o -q "${zipPath}" -d "${outputDir}"`);
+      try {
+        execSync4(`rm "${zipPath}"`);
+      } catch {
       }
+    } catch {
+      log.warn(`Failed to extract ZIP. Saved to: ${zipPath}`);
       return;
-    } catch (err) {
-      lastError = err;
-      if (attempt < 4) {
-        await sleep6(2e3);
-      }
     }
+    if (json) {
+      console.log(JSON.stringify({
+        type: "files_downloaded",
+        file_count: offer.file_count,
+        output_dir: outputDir,
+        zip_size: zipBuffer.length,
+        sha256_verified: true
+      }));
+    } else {
+      log.success(`[WebRTC] ${offer.file_count} file(s) extracted to ${outputDir}`);
+    }
+  } catch (err) {
+    const msg = err.message;
+    if (json) {
+      console.log(JSON.stringify({ type: "file_transfer_failed", error: msg }));
+    } else {
+      log.warn(`[WebRTC] File transfer failed: ${msg}`);
+    }
+  } finally {
+    receiver.close();
   }
-  log.warn(`Download failed after retries: ${lastError?.message || "unknown error"}`);
 }
 async function asyncCall(opts) {
   const selfAgentId = process.env.AGENT_BRIDGE_AGENT_ID;
@@ -4739,7 +4879,7 @@ async function asyncCall(opts) {
       }
       if (offer && opts.withFiles) {
         const outputDir = opts.outputFile ? join11(opts.outputFile, "..", "files") : join11(process.cwd(), "agent-output");
-        await downloadTransferFiles(opts.id, offer, opts.token, outputDir, opts.json);
+        await webrtcDownload(opts.id, offer, opts.token, outputDir, opts.json);
       }
       if (!opts.json) {
         log.info(`${GRAY}Rate this call: agent-mesh rate ${call_id} <1-5> --agent ${opts.id}${RESET}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-mesh",
-  "version": "0.17.5",
+  "version": "0.17.7",
   "description": "CLI bridge connecting local AI agents to the Agents.Hot platform",
   "type": "module",
   "bin": {