@annals/agent-mesh 0.16.13 → 0.17.2

package/dist/index.js

@@ -33,7 +33,7 @@ import {
 } from "./chunk-KEUGYA3L.js";
 
 // src/index.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import { program } from "commander";
 
 // src/platform/auth.ts
@@ -269,6 +269,137 @@ var BridgeWSClient = class extends EventEmitter {
 // src/bridge/manager.ts
 import { BridgeErrorCode } from "@annals/bridge-protocol";
 
+// src/utils/webrtc-transfer.ts
+import { createHash } from "crypto";
+import { createRequire } from "module";
+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 ndcModule;
+function ensurePrebuilt() {
+  try {
+    const require3 = createRequire(import.meta.url);
+    const ndcMain = require3.resolve("node-datachannel");
+    let ndcRoot = dirname(ndcMain);
+    for (let i = 0; i < 5; i++) {
+      if (existsSync(join(ndcRoot, "package.json"))) break;
+      ndcRoot = dirname(ndcRoot);
+    }
+    const target = join(ndcRoot, "build", "Release", "node_datachannel.node");
+    if (existsSync(target)) return true;
+    const platform = process.platform;
+    const arch = process.arch;
+    const ourPkgRoot = join(dirname(import.meta.url.replace("file://", "")), "..", "..");
+    const prebuiltSrc = join(ourPkgRoot, "prebuilds", `${platform}-${arch}`, "node_datachannel.node");
+    if (!existsSync(prebuiltSrc)) {
+      log.warn(`No prebuilt binary for ${platform}-${arch}`);
+      return false;
+    }
+    mkdirSync(join(ndcRoot, "build", "Release"), { recursive: true });
+    copyFileSync(prebuiltSrc, target);
+    log.info(`Installed node-datachannel prebuilt for ${platform}-${arch}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadNdc() {
+  if (ndcModule !== void 0) return ndcModule;
+  try {
+    ensurePrebuilt();
+    ndcModule = await import("node-datachannel");
+    return ndcModule;
+  } catch {
+    log.warn("node-datachannel not available \u2014 WebRTC file transfer disabled");
+    ndcModule = null;
+    return null;
+  }
+}
+var FileSender = class {
+  peer = null;
+  transferId;
+  zipBuffer;
+  pendingCandidates = [];
+  signalCallback = null;
+  closed = false;
+  constructor(transferId, zipBuffer) {
+    this.transferId = transferId;
+    this.zipBuffer = zipBuffer;
+  }
+  onSignal(cb) {
+    this.signalCallback = cb;
+  }
+  async handleSignal(signal) {
+    const ndc = await loadNdc();
+    if (!ndc || this.closed) return;
+    if (!this.peer) {
+      this.peer = new ndc.PeerConnection(`sender-${this.transferId}`, {
+        iceServers: ICE_SERVERS
+      });
+      this.peer.onLocalDescription((sdp, type) => {
+        this.signalCallback?.({ signal_type: type, payload: sdp });
+      });
+      this.peer.onLocalCandidate((candidate, mid) => {
+        this.signalCallback?.({
+          signal_type: "candidate",
+          payload: JSON.stringify({ candidate, mid })
+        });
+      });
+      this.peer.onDataChannel((dc) => {
+        dc.onOpen(() => {
+          void this.sendZip(dc);
+        });
+      });
+    }
+    if (signal.signal_type === "offer" || signal.signal_type === "answer") {
+      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 });
+      }
+    }
+  }
+  async sendZip(dc) {
+    try {
+      dc.sendMessage(JSON.stringify({
+        type: "header",
+        transfer_id: this.transferId,
+        zip_size: this.zipBuffer.length
+      }));
+      let offset = 0;
+      while (offset < this.zipBuffer.length) {
+        const end = Math.min(offset + CHUNK_SIZE, this.zipBuffer.length);
+        const chunk = this.zipBuffer.subarray(offset, end);
+        dc.sendMessageBinary(chunk);
+        offset = end;
+      }
+      dc.sendMessage(JSON.stringify({ type: "complete" }));
+      log.info(`[WebRTC] Sent ${this.zipBuffer.length} bytes in ${Math.ceil(this.zipBuffer.length / CHUNK_SIZE)} chunks`);
+    } catch (err) {
+      log.error(`[WebRTC] Send failed: ${err}`);
+    }
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.peer?.close();
+    } catch {
+    }
+    this.peer = null;
+  }
+};
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
 // src/bridge/session-pool.ts
 var SessionPool = class {
   sessions = /* @__PURE__ */ new Map();
@@ -311,15 +442,15 @@ var SessionPool = class {
 
 // src/utils/local-runtime-queue.ts
 import {
-  existsSync,
-  mkdirSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
   readFileSync,
   renameSync,
   rmSync,
   statSync,
   writeFileSync
 } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import { homedir } from "os";
 var DEFAULT_LOCK_STALE_MS = 3e4;
 var DEFAULT_LOCK_WAIT_MS = 1e4;
@@ -376,10 +507,10 @@ var LocalRuntimeQueue = class {
   leaseHeartbeatMs;
   constructor(config, opts = {}) {
     this.config = config;
-    const baseDir = opts.baseDir || join(homedir(), ".agent-mesh");
-    this.runtimeRoot = join(baseDir, "runtime");
-    this.statePath = join(this.runtimeRoot, "queue-state.json");
-    this.lockPath = join(this.runtimeRoot, "queue.lock");
+    const baseDir = opts.baseDir || join2(homedir(), ".agent-mesh");
+    this.runtimeRoot = join2(baseDir, "runtime");
+    this.statePath = join2(this.runtimeRoot, "queue-state.json");
+    this.lockPath = join2(this.runtimeRoot, "queue.lock");
     this.lockStaleMs = opts.lockStaleMs ?? DEFAULT_LOCK_STALE_MS;
     this.lockWaitMs = opts.lockWaitMs ?? DEFAULT_LOCK_WAIT_MS;
     this.lockRetryMs = opts.lockRetryMs ?? DEFAULT_LOCK_RETRY_MS;
@@ -551,8 +682,8 @@ var LocalRuntimeQueue = class {
     }
   }
   ensureRuntimeDir() {
-    if (!existsSync(this.runtimeRoot)) {
-      mkdirSync(this.runtimeRoot, { recursive: true, mode: 448 });
+    if (!existsSync2(this.runtimeRoot)) {
+      mkdirSync2(this.runtimeRoot, { recursive: true, mode: 448 });
     }
   }
   defaultState() {
@@ -607,7 +738,7 @@ var LocalRuntimeQueue = class {
     const acquiredAt = Date.now();
     while (true) {
       try {
-        mkdirSync(this.lockPath, { mode: 448 });
+        mkdirSync2(this.lockPath, { mode: 448 });
         break;
       } catch (err) {
         const e = err;
@@ -688,6 +819,8 @@ var BridgeManager = class {
   requestDispatches = /* @__PURE__ */ new Map();
   cleanupTimer = null;
   runtimeQueue;
+  /** Pending WebRTC file transfers: transfer_id → FileSender + cleanup timer */
+  pendingTransfers = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.wsClient = opts.wsClient;
     this.adapter = opts.adapter;
@@ -715,6 +848,7 @@ var BridgeManager = class {
     this.wiredSessions.clear();
     this.sessionLastSeenAt.clear();
     this.cleanupRequestDispatches("shutdown");
+    this.cleanupPendingTransfers();
     log.info("Bridge manager stopped");
   }
   /**
@@ -746,6 +880,9 @@ var BridgeManager = class {
         break;
       case "registered":
         break;
+      case "rtc_signal_relay":
+        this.handleRtcSignalRelay(msg);
+        break;
       default:
         log.warn(`Unknown message type from worker: ${msg.type}`);
     }
@@ -811,7 +948,7 @@ var BridgeManager = class {
   }
   async dispatchWithLocalQueue(opts) {
     const { msg, handle, requestKey } = opts;
-    const { session_id, request_id, content, attachments, upload_url, upload_token, client_id, platform_task } = msg;
+    const { session_id, request_id, content, attachments, client_id, with_files } = msg;
     const state = this.requestDispatches.get(requestKey);
     if (!state) return;
     try {
@@ -830,9 +967,8 @@ var BridgeManager = class {
         await this.releaseRequestLease(session_id, request_id, "cancel");
         return;
       }
-      const uploadCredentials = upload_url && upload_token ? { uploadUrl: upload_url, uploadToken: upload_token } : void 0;
       try {
-        handle.send(content, attachments, uploadCredentials, client_id, platform_task);
+        handle.send(content, attachments, client_id, with_files);
         this.sessionLastSeenAt.set(session_id, Date.now());
       } catch (err) {
         log.error(`Failed to send to adapter: ${err}`);
@@ -893,20 +1029,24 @@ var BridgeManager = class {
     handle.onDone((payload) => {
       void this.releaseRequestLease(sessionId, requestRef.requestId, "done");
       const attachments = payload?.attachments;
-      const fileManifest = payload?.fileManifest;
+      const fileTransferOffer = payload?.fileTransferOffer;
+      const zipBuffer = payload?.zipBuffer;
+      if (fileTransferOffer && zipBuffer) {
+        this.registerPendingTransfer(fileTransferOffer, zipBuffer);
+      }
       const done = {
         type: "done",
         session_id: sessionId,
         request_id: requestRef.requestId,
         ...attachments && attachments.length > 0 && { attachments },
-        ...fileManifest && fileManifest.length > 0 && { file_manifest: fileManifest },
+        ...fileTransferOffer && { file_transfer_offer: fileTransferOffer },
         ...fullResponseBuffer && { result: fullResponseBuffer }
       };
       this.trackRequest(sessionId, requestRef.requestId, "done");
       this.wsClient.send(done);
       fullResponseBuffer = "";
       this.sessionLastSeenAt.set(sessionId, Date.now());
-      const fileInfo = attachments && attachments.length > 0 ? ` (${attachments.length} files)` : "";
+      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}`);
     });
     handle.onError((err) => {
@@ -1087,6 +1227,50 @@ var BridgeManager = class {
       }
     }
   }
+  // ========================================================
+  // WebRTC signaling relay
+  // ========================================================
+  registerPendingTransfer(offer, zipBuffer) {
+    const sender = new FileSender(offer.transfer_id, zipBuffer);
+    sender.onSignal((signal) => {
+      const entry = this.pendingTransfers.get(offer.transfer_id);
+      if (!entry) return;
+      const rtcSignal = {
+        type: "rtc_signal",
+        transfer_id: offer.transfer_id,
+        target_agent_id: entry.targetAgentId || "",
+        signal_type: signal.signal_type,
+        payload: signal.payload
+      };
+      this.wsClient.send(rtcSignal);
+    });
+    const timer = setTimeout(() => {
+      sender.close();
+      this.pendingTransfers.delete(offer.transfer_id);
+      log.debug(`Transfer ${offer.transfer_id.slice(0, 8)}... expired`);
+    }, 5 * 6e4);
+    timer.unref?.();
+    this.pendingTransfers.set(offer.transfer_id, { sender, timer });
+  }
+  handleRtcSignalRelay(msg) {
+    const entry = this.pendingTransfers.get(msg.transfer_id);
+    if (!entry) {
+      log.debug(`No pending transfer for ${msg.transfer_id.slice(0, 8)}...`);
+      return;
+    }
+    entry.targetAgentId = msg.from_agent_id;
+    void entry.sender.handleSignal({
+      signal_type: msg.signal_type,
+      payload: msg.payload
+    });
+  }
+  cleanupPendingTransfers() {
+    for (const [id, entry] of this.pendingTransfers) {
+      clearTimeout(entry.timer);
+      entry.sender.close();
+    }
+    this.pendingTransfers.clear();
+  }
   updateSessionCount() {
     this.wsClient.setActiveSessions(this.pool.size);
   }
@@ -1101,7 +1285,7 @@ import { spawn } from "child_process";
 
 // src/utils/sandbox.ts
 import { execSync } from "child_process";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 var SRT_PACKAGE = "@anthropic-ai/sandbox-runtime";
 var SENSITIVE_PATHS = [
   // SSH & crypto keys
@@ -1160,7 +1344,7 @@ var sandboxInitialized = false;
 async function importSandboxManager() {
   try {
     const globalRoot = execSync("npm root -g", { encoding: "utf-8" }).trim();
-    const srtPath = join2(globalRoot, "@anthropic-ai/sandbox-runtime/dist/index.js");
+    const srtPath = join3(globalRoot, "@anthropic-ai/sandbox-runtime/dist/index.js");
     const mod = await import(srtPath);
     return mod.SandboxManager;
   } catch {
@@ -1366,8 +1550,8 @@ function which(command) {
 }
 
 // src/utils/client-workspace.ts
-import { mkdirSync as mkdirSync2, readdirSync, symlinkSync, existsSync as existsSync2, lstatSync } from "fs";
-import { join as join3, relative } from "path";
+import { mkdirSync as mkdirSync3, readdirSync, symlinkSync, existsSync as existsSync3, lstatSync } from "fs";
+import { join as join4, relative } from "path";
 var SYMLINK_ALLOW = /* @__PURE__ */ new Set([
   "CLAUDE.md",
   ".claude",
@@ -1396,19 +1580,19 @@ function shouldInclude(name) {
   return false;
 }
 function createClientWorkspace(projectPath, clientId) {
-  const wsDir = join3(projectPath, ".bridge-clients", clientId);
-  const isNew = !existsSync2(wsDir);
-  mkdirSync2(wsDir, { recursive: true });
+  const wsDir = join4(projectPath, ".bridge-clients", clientId);
+  const isNew = !existsSync3(wsDir);
+  mkdirSync3(wsDir, { recursive: true });
   const entries = readdirSync(projectPath, { withFileTypes: true });
   for (const entry of entries) {
     if (!shouldInclude(entry.name)) continue;
-    const link = join3(wsDir, entry.name);
+    const link = join4(wsDir, entry.name);
     try {
       lstatSync(link);
       continue;
     } catch {
     }
-    const target = join3(projectPath, entry.name);
+    const target = join4(projectPath, entry.name);
     const relTarget = relative(wsDir, target);
     try {
       symlinkSync(relTarget, link);
@@ -1423,12 +1607,12 @@ function createClientWorkspace(projectPath, clientId) {
 }
 
 // src/adapters/claude.ts
-import { readFile as readFile2, writeFile, mkdir, stat as stat2 } from "fs/promises";
-import { join as join5, relative as relative3, basename } from "path";
+import { writeFile, mkdir, stat as stat2 } from "fs/promises";
+import { join as join6, relative as relative3, basename } from "path";
 
 // src/utils/auto-upload.ts
 import { readdir, readFile, stat } from "fs/promises";
-import { join as join4, relative as relative2 } from "path";
+import { join as join5, relative as relative2 } from "path";
 var MAX_AUTO_UPLOAD_FILE_SIZE = 10 * 1024 * 1024;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
@@ -1440,23 +1624,6 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "coverage",
   ".turbo"
 ]);
-var MIME_MAP = {
-  md: "text/markdown",
-  txt: "text/plain",
-  json: "application/json",
-  js: "text/javascript",
-  ts: "text/typescript",
-  py: "text/x-python",
-  html: "text/html",
-  css: "text/css",
-  csv: "text/csv",
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  svg: "image/svg+xml",
-  pdf: "application/pdf"
-};
 async function collectRealFiles(dir, maxFiles = Infinity) {
   const files = [];
   const walk = async (d) => {
@@ -1470,7 +1637,7 @@ async function collectRealFiles(dir, maxFiles = Infinity) {
     for (const entry of entries) {
       if (files.length >= maxFiles) return;
       if (entry.isSymbolicLink()) continue;
-      const fullPath = join4(d, entry.name);
+      const fullPath = join5(d, entry.name);
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name)) continue;
         await walk(fullPath);
@@ -1641,7 +1808,6 @@ var CLAUDE_RUNTIME_ALLOW_WRITE_PATHS = [
   `${HOME_DIR}/.claude.json.tmp`,
   `${HOME_DIR}/.local/state/claude`
 ];
-var MAX_UPLOAD_FILE_SIZE = 200 * 1024 * 1024;
 var MAX_COLLECT_FILES = 5e3;
 var DEFAULT_ZIP_MAX_BYTES = 200 * 1024 * 1024;
 function resolveIdleTimeoutMs() {
@@ -1675,29 +1841,23 @@ var ClaudeSession = class {
   activeToolName = null;
   /** Track current content block type to distinguish thinking vs text deltas */
   currentBlockType = null;
-  /** Upload credentials provided by the platform for auto-uploading output files */
-  uploadCredentials = null;
   /** Per-client workspace path (symlink-based), set on each send() */
   currentWorkspace;
-  send(message, attachments, uploadCredentials, clientId, platformTask) {
+  /** Whether caller requested file transfer */
+  withFiles = false;
+  send(message, attachments, clientId, withFiles) {
     this.resetIdleTimer();
     this.doneFired = false;
     this.chunksEmitted = false;
     this.activeToolCallId = null;
     this.activeToolName = null;
     this.currentBlockType = null;
-    if (uploadCredentials) {
-      this.uploadCredentials = uploadCredentials;
-    }
+    this.withFiles = withFiles || false;
     if (clientId && this.config.project) {
       this.currentWorkspace = createClientWorkspace(this.config.project, clientId);
     } else {
       this.currentWorkspace = void 0;
     }
-    if (platformTask) {
-      void this.runPlatformTask(platformTask);
-      return;
-    }
     const args = ["-p", message, "--continue", "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--dangerously-skip-permissions"];
     void this.downloadAttachments(attachments).then(() => {
       this.launchProcess(args);
@@ -1714,7 +1874,7 @@ var ClaudeSession = class {
     await mkdir(workspaceRoot, { recursive: true });
     for (const att of attachments) {
       const safeName = basename(att.name).replace(/[^a-zA-Z0-9._-]/g, "_") || "attachment";
-      const destPath = join5(workspaceRoot, safeName);
+      const destPath = join6(workspaceRoot, safeName);
       try {
         const res = await fetch(att.url);
         if (!res.ok) {
@@ -1786,145 +1946,64 @@ var ClaudeSession = class {
   getWorkspaceRoot() {
     return this.currentWorkspace || this.config.project || process.cwd();
   }
-  normalizeRelativePath(inputPath) {
-    const normalized = inputPath.replace(/\\/g, "/").replace(/^\/+/, "");
-    if (!normalized || normalized.includes("\0")) return null;
-    if (normalized.split("/").some((seg) => seg === "..")) return null;
-    return normalized;
-  }
-  async runPlatformTask(task) {
-    try {
-      if (!this.uploadCredentials) {
-        throw new Error("Missing upload credentials for platform task");
-      }
-      if (task.type === "upload_file") {
-        await this.runUploadFileTask(task.path);
-      } else if (task.type === "upload_all_zip") {
-        await this.runUploadAllZipTask(task.zip_name, task.max_bytes);
-      } else {
-        throw new Error(`Unsupported platform task: ${task.type || "unknown"}`);
-      }
-      this.doneFired = true;
-    } catch (error) {
-      this.emitError(new Error(`Platform task failed: ${error instanceof Error ? error.message : String(error)}`));
-    }
-  }
-  async runUploadFileTask(path) {
-    const workspaceRoot = this.getWorkspaceRoot();
-    const relPath = this.normalizeRelativePath(path);
-    if (!relPath) {
-      throw new Error("Invalid file path");
-    }
-    const absPath = join5(workspaceRoot, relPath);
-    const info = await stat2(absPath);
-    if (!info.isFile()) {
-      throw new Error("Path is not a regular file");
-    }
-    const buffer = await readFile2(absPath);
-    if (buffer.length === 0 || buffer.length > MAX_UPLOAD_FILE_SIZE) {
-      throw new Error(`File size out of bounds: ${buffer.length}`);
-    }
-    const uploaded = await this.uploadBuffer(relPath, buffer);
-    for (const cb of this.doneCallbacks) cb({ attachments: [uploaded] });
-  }
-  async runUploadAllZipTask(zipName, maxBytes) {
-    const workspaceRoot = this.getWorkspaceRoot();
-    const files = await this.collectWorkspaceFiles(workspaceRoot);
-    if (files.length === 0) {
-      throw new Error("No files found");
-    }
-    const maxZipBytes = typeof maxBytes === "number" && Number.isFinite(maxBytes) && maxBytes > 0 ? Math.floor(maxBytes) : DEFAULT_ZIP_MAX_BYTES;
-    const entries = [];
-    let totalBytes = 0;
-    for (const absPath of files) {
-      this.resetIdleTimer();
-      const relPath = relative3(workspaceRoot, absPath).replace(/\\/g, "/");
-      if (!relPath || relPath.startsWith("..")) continue;
-      const buffer = await readFile2(absPath);
-      if (buffer.length === 0) continue;
-      totalBytes += buffer.length;
-      if (totalBytes > maxZipBytes) {
-        throw new Error(`ZIP_TOO_LARGE:${totalBytes}`);
-      }
-      entries.push({ path: relPath, data: buffer });
-    }
-    const zipBuffer = createZipBuffer(entries);
-    if (zipBuffer.length > maxZipBytes) {
-      throw new Error(`ZIP_TOO_LARGE:${zipBuffer.length}`);
-    }
-    const safeZipName = this.normalizeRelativePath(zipName || "") || `workspace-${this.sessionId.slice(0, 8)}.zip`;
-    const uploaded = await this.uploadBuffer(safeZipName.endsWith(".zip") ? safeZipName : `${safeZipName}.zip`, zipBuffer);
-    for (const cb of this.doneCallbacks) cb({ attachments: [uploaded] });
-  }
-  async uploadBuffer(filename, buffer) {
-    const creds = this.uploadCredentials;
-    if (!creds) {
-      throw new Error("Upload credentials missing");
-    }
-    const response = await fetch(creds.uploadUrl, {
-      method: "POST",
-      headers: {
-        "X-Upload-Token": creds.uploadToken,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        filename,
-        content: buffer.toString("base64")
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Upload failed (${response.status}) for ${filename}`);
-    }
-    const payload = await response.json();
-    if (typeof payload.url !== "string" || payload.url.length === 0) {
-      throw new Error(`Upload response missing url for ${filename}`);
-    }
-    const ext = filename.split(".").pop()?.toLowerCase() || "";
-    return {
-      name: filename,
-      url: payload.url,
-      type: MIME_MAP[ext] || "application/octet-stream"
-    };
-  }
   async collectWorkspaceFiles(workspaceRoot) {
     return collectRealFiles(workspaceRoot, MAX_COLLECT_FILES);
   }
-  async collectWorkspaceManifest(workspaceRoot) {
+  /**
+   * Collect workspace files into a ZIP buffer + compute SHA-256.
+   * Only called when with_files is true.
+   */
+  async createWorkspaceZip(workspaceRoot) {
     const files = await this.collectWorkspaceFiles(workspaceRoot);
-    const manifest = [];
+    if (files.length === 0) return null;
+    const entries = [];
+    let totalBytes = 0;
     for (const absPath of files) {
       const relPath = relative3(workspaceRoot, absPath).replace(/\\/g, "/");
       if (!relPath || relPath.startsWith("..")) continue;
       try {
         const fileStat = await stat2(absPath);
         if (!fileStat.isFile()) continue;
-        const ext = relPath.split(".").pop()?.toLowerCase() || "";
-        manifest.push({
-          path: relPath,
-          size: fileStat.size,
-          mtime_ms: Math.floor(fileStat.mtimeMs),
-          type: MIME_MAP[ext] || "application/octet-stream"
-        });
+        const { readFile: readFile4 } = await import("fs/promises");
+        const buffer = await readFile4(absPath);
+        if (buffer.length === 0) continue;
+        totalBytes += buffer.length;
+        if (totalBytes > DEFAULT_ZIP_MAX_BYTES) {
+          log.warn(`Workspace exceeds ${DEFAULT_ZIP_MAX_BYTES / 1024 / 1024}MB limit, truncating`);
+          break;
+        }
+        entries.push({ path: relPath, data: buffer });
       } catch {
       }
     }
-    manifest.sort((a, b) => a.path.localeCompare(b.path));
-    return manifest;
+    if (entries.length === 0) return null;
+    const zipBuffer = createZipBuffer(entries);
+    return { zipBuffer, fileCount: entries.length };
   }
   async finalizeDone(attachments) {
-    const workspaceRoot = this.getWorkspaceRoot();
-    let fileManifest;
-    try {
-      fileManifest = await this.collectWorkspaceManifest(workspaceRoot);
-    } catch (error) {
-      log.warn(`Manifest collection failed: ${error}`);
-    }
     const payload = {};
     if (attachments && attachments.length > 0) {
       payload.attachments = attachments;
     }
-    if (fileManifest) {
-      payload.fileManifest = fileManifest;
+    if (this.withFiles) {
+      const workspaceRoot = this.getWorkspaceRoot();
+      try {
+        const result = await this.createWorkspaceZip(workspaceRoot);
+        if (result) {
+          const transferId = crypto.randomUUID();
+          const zipSha256 = sha256Hex(result.zipBuffer);
+          payload.fileTransferOffer = {
+            transfer_id: transferId,
+            zip_size: result.zipBuffer.length,
+            zip_sha256: zipSha256,
+            file_count: result.fileCount
+          };
+          payload.zipBuffer = result.zipBuffer;
+          log.info(`[WebRTC] ZIP ready: ${result.fileCount} files, ${result.zipBuffer.length} bytes, transfer=${transferId.slice(0, 8)}...`);
+        }
+      } catch (error) {
+        log.warn(`ZIP creation failed: ${error}`);
+      }
     }
     for (const cb of this.doneCallbacks) cb(payload);
   }
@@ -2071,34 +2150,28 @@ var ClaudeSession = class {
       return;
     }
   }
-  stripWorkspacePaths(text) {
-    const root = this.getWorkspaceRoot();
-    if (!root) return text;
-    const prefix = root.endsWith("/") ? root : root + "/";
-    return text.replaceAll(prefix, "");
-  }
   emitChunk(text) {
     this.chunksEmitted = true;
-    for (const cb of this.chunkCallbacks) cb(this.stripWorkspacePaths(text));
+    for (const cb of this.chunkCallbacks) cb(text);
   }
   emitToolEvent(event) {
-    for (const cb of this.toolCallbacks) cb({ ...event, delta: this.stripWorkspacePaths(event.delta) });
+    for (const cb of this.toolCallbacks) cb(event);
   }
   emitTextAsChunks(text) {
-    const CHUNK_SIZE = 60;
-    if (text.length <= CHUNK_SIZE) {
+    const CHUNK_SIZE2 = 60;
+    if (text.length <= CHUNK_SIZE2) {
       this.emitChunk(text);
       return;
     }
     let pos = 0;
     while (pos < text.length) {
-      let end = Math.min(pos + CHUNK_SIZE, text.length);
+      let end = Math.min(pos + CHUNK_SIZE2, text.length);
       if (end < text.length) {
         const slice = text.slice(pos, end + 20);
         const breakPoints = ["\n", "\u3002", "\uFF01", "\uFF1F", ". ", "! ", "? ", "\uFF0C", ", ", " "];
         for (const bp of breakPoints) {
-          const idx = slice.indexOf(bp, CHUNK_SIZE - 20);
-          if (idx >= 0 && idx < CHUNK_SIZE + 20) {
+          const idx = slice.indexOf(bp, CHUNK_SIZE2 - 20);
+          if (idx >= 0 && idx < CHUNK_SIZE2 + 20) {
             end = pos + idx + bp.length;
             break;
           }
@@ -2718,7 +2791,7 @@ function registerRestartCommand(program2) {
 
 // src/commands/logs.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 function registerLogsCommand(program2) {
   program2.command("logs <name>").description("View agent logs (follows in real-time)").option("-n, --lines <number>", "Number of lines to show", "50").action((name, opts) => {
     const entry = getAgent(name);
@@ -2727,7 +2800,7 @@ function registerLogsCommand(program2) {
       process.exit(1);
     }
     const logPath = getLogPath(name);
-    if (!existsSync3(logPath)) {
+    if (!existsSync4(logPath)) {
       log.error(`No log file found for "${name}". Has this agent been started before?`);
       process.exit(1);
     }
@@ -2808,14 +2881,14 @@ function registerOpenCommand(program2) {
 }
 
 // src/commands/install.ts
-import { writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { writeFileSync as writeFileSync2, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
+import { join as join7 } from "path";
 import { homedir as homedir4 } from "os";
 import { execSync as execSync2 } from "child_process";
 var LABEL = "com.agents-hot.agent-mesh";
-var PLIST_DIR = join6(homedir4(), "Library", "LaunchAgents");
-var PLIST_PATH = join6(PLIST_DIR, `${LABEL}.plist`);
-var LOG_PATH = join6(homedir4(), ".agent-mesh", "logs", "launchd.log");
+var PLIST_DIR = join7(homedir4(), "Library", "LaunchAgents");
+var PLIST_PATH = join7(PLIST_DIR, `${LABEL}.plist`);
+var LOG_PATH = join7(homedir4(), ".agent-mesh", "logs", "launchd.log");
 function detectPaths() {
   return {
     node: process.execPath,
@@ -2862,7 +2935,7 @@ function registerInstallCommand(program2) {
       log.error("LaunchAgent is macOS only. On Linux, use systemd user service instead.");
       process.exit(1);
     }
-    if (existsSync4(PLIST_PATH) && !opts.force) {
+    if (existsSync5(PLIST_PATH) && !opts.force) {
       console.log(`
   ${YELLOW}\u2298${RESET} LaunchAgent already installed at:`);
       console.log(`    ${GRAY}${PLIST_PATH}${RESET}`);
@@ -2872,10 +2945,10 @@ function registerInstallCommand(program2) {
       return;
     }
     const { node, script } = detectPaths();
-    if (!existsSync4(PLIST_DIR)) {
-      mkdirSync3(PLIST_DIR, { recursive: true });
+    if (!existsSync5(PLIST_DIR)) {
+      mkdirSync4(PLIST_DIR, { recursive: true });
     }
-    if (existsSync4(PLIST_PATH)) {
+    if (existsSync5(PLIST_PATH)) {
       try {
         execSync2(`launchctl bootout gui/$(id -u) "${PLIST_PATH}" 2>/dev/null`, { stdio: "ignore" });
       } catch {
@@ -2908,19 +2981,19 @@ function registerInstallCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync6, unlinkSync as unlinkSync2 } from "fs";
+import { join as join8 } from "path";
 import { homedir as homedir5 } from "os";
 import { execSync as execSync3 } from "child_process";
 var LABEL2 = "com.agents-hot.agent-mesh";
-var PLIST_PATH2 = join7(homedir5(), "Library", "LaunchAgents", `${LABEL2}.plist`);
+var PLIST_PATH2 = join8(homedir5(), "Library", "LaunchAgents", `${LABEL2}.plist`);
 function registerUninstallCommand(program2) {
   program2.command("uninstall").description("Remove macOS LaunchAgent (agents will no longer auto-start)").action(async () => {
     if (process.platform !== "darwin") {
       log.error("LaunchAgent is macOS only.");
       process.exit(1);
     }
-    if (!existsSync5(PLIST_PATH2)) {
+    if (!existsSync6(PLIST_PATH2)) {
       console.log(`
   ${YELLOW}\u2298${RESET} No LaunchAgent found at ${GRAY}${PLIST_PATH2}${RESET}
 `);
@@ -3399,8 +3472,8 @@ async function asyncChat(opts) {
 `);
         }
       }
-      if (task.file_manifest) {
-        process.stdout.write(`${GRAY}[manifest: ${task.file_manifest.length} files]${RESET}
+      if (task.file_transfer_offer) {
+        process.stdout.write(`${GRAY}[files: ${task.file_transfer_offer.file_count} available via WebRTC]${RESET}
 `);
       }
       return;
@@ -3605,12 +3678,12 @@ function registerChatCommand(program2) {
 }
 
 // src/commands/skills.ts
-import { readFile as readFile4, writeFile as writeFile3, readdir as readdir2, mkdir as mkdir2, rm, symlink, unlink } from "fs/promises";
-import { join as join9, resolve, relative as relative4 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, readdir as readdir2, mkdir as mkdir2, rm, symlink, unlink } from "fs/promises";
+import { join as join10, resolve, relative as relative4 } from "path";
 
 // src/utils/skill-parser.ts
-import { readFile as readFile3, writeFile as writeFile2, stat as stat3 } from "fs/promises";
-import { join as join8 } from "path";
+import { readFile as readFile2, writeFile as writeFile2, stat as stat3 } from "fs/promises";
+import { join as join9 } from "path";
 function parseSkillMd(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -3692,9 +3765,9 @@ function parseSkillMd(raw) {
   return { frontmatter, content };
 }
 async function loadSkillManifest(dir) {
-  const skillMdPath = join8(dir, "SKILL.md");
+  const skillMdPath = join9(dir, "SKILL.md");
   try {
-    const raw = await readFile3(skillMdPath, "utf-8");
+    const raw = await readFile2(skillMdPath, "utf-8");
     const { frontmatter } = parseSkillMd(raw);
     const name = frontmatter.name;
     if (!name) {
@@ -3727,7 +3800,7 @@ async function pathExists(p) {
   }
 }
 async function updateFrontmatterField(filePath, field, value) {
-  const raw = await readFile3(filePath, "utf-8");
+  const raw = await readFile2(filePath, "utf-8");
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
     throw new Error("SKILL.md has no frontmatter block");
@@ -3797,13 +3870,13 @@ function skillApiPath(authorLogin, slug) {
 }
 async function resolveSkillsRootAsync(pathArg) {
   const projectRoot = pathArg ? resolve(pathArg) : process.cwd();
-  const skillsDir = join9(projectRoot, ".agents", "skills");
-  const claudeSkillsDir = join9(projectRoot, ".claude", "skills");
+  const skillsDir = join10(projectRoot, ".agents", "skills");
+  const claudeSkillsDir = join10(projectRoot, ".claude", "skills");
   return { projectRoot, skillsDir, claudeSkillsDir };
 }
 async function ensureClaudeSymlink(claudeSkillsDir, slug) {
   await mkdir2(claudeSkillsDir, { recursive: true });
-  const linkPath = join9(claudeSkillsDir, slug);
+  const linkPath = join10(claudeSkillsDir, slug);
   try {
     await unlink(linkPath);
   } catch {
@@ -3823,7 +3896,7 @@ async function collectPackFiles(dir, manifest) {
   }
   const mainFile = manifest.main || "SKILL.md";
   if (!results.includes(mainFile)) {
-    const mainPath = join9(dir, mainFile);
+    const mainPath = join10(dir, mainFile);
     if (await pathExists(mainPath)) {
       results.unshift(mainFile);
     }
@@ -3840,7 +3913,7 @@ async function walkDir(dir) {
   }
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
-    const fullPath = join9(dir, entry.name);
+    const fullPath = join10(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
       const sub = await walkDir(fullPath);
@@ -3858,9 +3931,9 @@ async function packSkill(dir, manifest) {
   }
   const entries = [];
   for (const relPath of fileList) {
-    const absPath = join9(dir, relPath);
+    const absPath = join10(dir, relPath);
     try {
-      const data = await readFile4(absPath);
+      const data = await readFile3(absPath);
       entries.push({ path: relPath.replace(/\\/g, "/"), data });
     } catch {
       slog.warn(`Skipping unreadable file: ${relPath}`);
@@ -3892,7 +3965,7 @@ function bumpVersion(current, bump) {
 }
 async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
   const meta = await client.get(skillApiPath(authorLogin, slug));
-  const targetDir = join9(skillsDir, slug);
+  const targetDir = join10(skillsDir, slug);
   await mkdir2(targetDir, { recursive: true });
   if (meta.has_files) {
     const res = await client.getRaw(`${skillApiPath(authorLogin, slug)}/download`);
@@ -3900,8 +3973,8 @@ async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
     const buf = Buffer.from(arrayBuf);
     const entries = extractZipBuffer(buf);
     for (const entry of entries) {
-      const filePath = join9(targetDir, entry.path);
-      const dir = join9(filePath, "..");
+      const filePath = join10(targetDir, entry.path);
+      const dir = join10(filePath, "..");
       await mkdir2(dir, { recursive: true });
       await writeFile3(filePath, entry.data);
     }
@@ -3914,7 +3987,7 @@ async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
   } else {
     const res = await client.getRaw(`${skillApiPath(authorLogin, slug)}/raw`);
     const content = await res.text();
-    await writeFile3(join9(targetDir, "SKILL.md"), content);
+    await writeFile3(join10(targetDir, "SKILL.md"), content);
     return {
       slug,
       name: meta.name,
@@ -3943,9 +4016,9 @@ function registerSkillsCommand(program2) {
     try {
       const dir = resolveSkillDir(pathArg);
       await mkdir2(dir, { recursive: true });
-      const skillMdPath = join9(dir, "SKILL.md");
+      const skillMdPath = join10(dir, "SKILL.md");
       if (await pathExists(skillMdPath)) {
-        const raw = await readFile4(skillMdPath, "utf-8");
+        const raw = await readFile3(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
         if (frontmatter.name) {
           slog.info(`SKILL.md already exists with name: ${frontmatter.name}`);
@@ -3972,7 +4045,7 @@ function registerSkillsCommand(program2) {
       const dir = resolveSkillDir(pathArg);
       const manifest = await loadSkillManifest(dir);
       const result = await packSkill(dir, manifest);
-      const outPath = join9(dir, result.filename);
+      const outPath = join10(dir, result.filename);
       await writeFile3(outPath, result.buffer);
       slog.info(`Packed ${result.files.length} files \u2192 ${result.filename} (${result.size} bytes)`);
       outputJson({
@@ -4018,7 +4091,7 @@ function registerSkillsCommand(program2) {
         if (opts.name) manifest.name = opts.name;
         if (opts.version) manifest.version = opts.version;
         if (opts.private !== void 0) manifest.private = opts.private;
-        content = await readFile4(join9(dir, manifest.main || "SKILL.md"), "utf-8");
+        content = await readFile3(join10(dir, manifest.main || "SKILL.md"), "utf-8");
         packResult = await packSkill(dir, manifest);
         slog.info(`Packed ${packResult.files.length} files (${packResult.size} bytes)`);
       }
@@ -4155,11 +4228,11 @@ function registerSkillsCommand(program2) {
   skills.command("version <bump> [path]").description("Bump skill version (patch | minor | major | x.y.z)").action(async (bump, pathArg) => {
     try {
       const dir = resolveSkillDir(pathArg);
-      const skillMdPath = join9(dir, "SKILL.md");
+      const skillMdPath = join10(dir, "SKILL.md");
       if (!await pathExists(skillMdPath)) {
         outputError("not_found", "No SKILL.md found. Run `agent-mesh skills init` first.");
       }
-      const raw = await readFile4(skillMdPath, "utf-8");
+      const raw = await readFile3(skillMdPath, "utf-8");
       const { frontmatter } = parseSkillMd(raw);
       const oldVersion = frontmatter.version || "0.0.0";
       const newVersion = bumpVersion(oldVersion, bump);
@@ -4175,7 +4248,7 @@ function registerSkillsCommand(program2) {
     try {
       const { authorLogin, slug } = parseSkillRef(ref);
       const { skillsDir, claudeSkillsDir } = await resolveSkillsRootAsync(pathArg);
-      const targetDir = join9(skillsDir, slug);
+      const targetDir = join10(skillsDir, slug);
       if (await pathExists(targetDir)) {
         if (!opts.force) {
           outputError("already_installed", `Skill "${slug}" is already installed at ${targetDir}. Use --force to overwrite.`);
@@ -4214,14 +4287,14 @@ function registerSkillsCommand(program2) {
       const failed = [];
       if (ref) {
         const { authorLogin, slug } = parseSkillRef(ref);
-        const targetDir = join9(skillsDir, slug);
+        const targetDir = join10(skillsDir, slug);
         if (!await pathExists(targetDir)) {
           outputError("not_installed", `Skill "${slug}" is not installed. Use "skills install ${ref}" first.`);
         }
-        const skillMdPath = join9(targetDir, "SKILL.md");
+        const skillMdPath = join10(targetDir, "SKILL.md");
         let localVersion = "0.0.0";
         if (await pathExists(skillMdPath)) {
-          const raw = await readFile4(skillMdPath, "utf-8");
+          const raw = await readFile3(skillMdPath, "utf-8");
           const { frontmatter } = parseSkillMd(raw);
           localVersion = frontmatter.version || "0.0.0";
         }
@@ -4245,12 +4318,12 @@ function registerSkillsCommand(program2) {
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           const slug = entry.name;
-          const skillMdPath = join9(skillsDir, slug, "SKILL.md");
+          const skillMdPath = join10(skillsDir, slug, "SKILL.md");
           if (!await pathExists(skillMdPath)) {
             skipped.push({ slug, reason: "no_skill_md" });
             continue;
           }
-          const raw = await readFile4(skillMdPath, "utf-8");
+          const raw = await readFile3(skillMdPath, "utf-8");
           const { frontmatter } = parseSkillMd(raw);
           const localVersion = frontmatter.version || "0.0.0";
           const authorLogin = frontmatter.author;
@@ -4265,7 +4338,7 @@ function registerSkillsCommand(program2) {
               skipped.push({ slug, reason: "up_to_date" });
             } else {
               slog.info(`Updating ${slug}: v${localVersion} \u2192 v${remoteVersion}...`);
-              await rm(join9(skillsDir, slug), { recursive: true, force: true });
+              await rm(join10(skillsDir, slug), { recursive: true, force: true });
               await downloadAndInstallSkill(client, authorLogin, slug, skillsDir);
               updated.push({ slug, name: remote.name, old_version: localVersion, new_version: remoteVersion });
             }
@@ -4286,13 +4359,13 @@ function registerSkillsCommand(program2) {
   skills.command("remove <slug> [path]").description("Remove a locally installed skill").action(async (slug, pathArg) => {
     try {
       const { skillsDir, claudeSkillsDir } = await resolveSkillsRootAsync(pathArg);
-      const targetDir = join9(skillsDir, slug);
+      const targetDir = join10(skillsDir, slug);
       if (!await pathExists(targetDir)) {
         outputError("not_installed", `Skill "${slug}" is not installed at ${targetDir}`);
       }
       await rm(targetDir, { recursive: true, force: true });
       try {
-        await unlink(join9(claudeSkillsDir, slug));
+        await unlink(join10(claudeSkillsDir, slug));
       } catch {
       }
       slog.success(`Removed skill: ${slug}`);
@@ -4317,9 +4390,9 @@ function registerSkillsCommand(program2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const slug = entry.name;
-        const skillMdPath = join9(skillsDir, slug, "SKILL.md");
+        const skillMdPath = join10(skillsDir, slug, "SKILL.md");
         if (!await pathExists(skillMdPath)) continue;
-        const raw = await readFile4(skillMdPath, "utf-8");
+        const raw = await readFile3(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
         const skillInfo = {
           slug,
@@ -4470,7 +4543,11 @@ async function asyncCall(opts) {
       "Content-Type": "application/json",
       ...selfAgentId ? { "X-Caller-Agent-Id": selfAgentId } : {}
     },
-    body: JSON.stringify({ task_description: opts.taskDescription, mode: "async" }),
+    body: JSON.stringify({
+      task_description: opts.taskDescription,
+      mode: "async",
+      ...opts.withFiles ? { with_files: true } : {}
+    }),
     signal: opts.signal
   });
   if (!res.ok) {
@@ -4529,7 +4606,7 @@ async function asyncCall(opts) {
           status: "completed",
           result,
           ...task.attachments?.length ? { attachments: task.attachments } : {},
-          ...Array.isArray(task.file_manifest) ? { file_manifest: task.file_manifest } : {},
+          ...task.file_transfer_offer ? { file_transfer_offer: task.file_transfer_offer } : {},
           rate_hint: `POST /api/agents/${opts.id}/rate  body: { call_id: "${call_id}", rating: 1-5 }`
         }));
       } else {
@@ -4539,9 +4616,9 @@ async function asyncCall(opts) {
             log.info(`  ${GRAY}File:${RESET} ${att.name}  ${GRAY}${att.url}${RESET}`);
           }
         }
-        const manifest = task.file_manifest;
-        if (Array.isArray(manifest)) {
-          log.info(`  ${GRAY}Manifest:${RESET} ${manifest.length} file(s)`);
+        const offer = task.file_transfer_offer;
+        if (offer) {
+          log.info(`  ${GRAY}Files:${RESET} ${offer.file_count} file(s) available via WebRTC`);
         }
         if (session_key) {
           log.info(`  ${GRAY}Session:${RESET} ${session_key}`);
@@ -4585,7 +4662,10 @@ async function streamCall(opts) {
       Accept: "text/event-stream",
       ...selfAgentId ? { "X-Caller-Agent-Id": selfAgentId } : {}
     },
-    body: JSON.stringify({ task_description: opts.taskDescription }),
+    body: JSON.stringify({
+      task_description: opts.taskDescription,
+      ...opts.withFiles ? { with_files: true } : {}
+    }),
     signal: opts.signal
   });
   if (!res.ok) {
@@ -4668,13 +4748,15 @@ async function streamCall(opts) {
                 outputBuffer += delta;
               }
             }
-          } else if (event.type === "done" && event.attachments?.length) {
-            console.log("");
-            for (const att of event.attachments) {
-              log.info(`  ${GRAY}File:${RESET} ${att.name}  ${GRAY}${att.url}${RESET}`);
+          } else if (event.type === "done") {
+            if (event.attachments?.length) {
+              console.log("");
+              for (const att of event.attachments) {
+                log.info(`  ${GRAY}File:${RESET} ${att.name}  ${GRAY}${att.url}${RESET}`);
+              }
             }
-            if (Array.isArray(event.file_manifest)) {
-              log.info(`  ${GRAY}Manifest:${RESET} ${event.file_manifest.length} file(s)`);
+            if (event.file_transfer_offer) {
+              log.info(`  ${GRAY}Files:${RESET} ${event.file_transfer_offer.file_count} file(s) available via WebRTC`);
             }
           } else if (event.type === "error") {
             process.stderr.write(`
@@ -4724,7 +4806,7 @@ Error: ${event.message}
   return { callId, ...sessionKey ? { sessionKey } : {} };
 }
 function registerCallCommand(program2) {
-  program2.command("call <agent>").description("Call an agent on the A2A network (default: async polling)").requiredOption("--task <description>", "Task description").option("--input-file <path>", "Read file and append to task description").option("--output-file <path>", "Save response text to file").option("--stream", "Use SSE streaming instead of async polling").option("--json", "Output JSONL events").option("--timeout <seconds>", "Timeout in seconds", "300").option("--rate <rating>", "Rate the agent after call (1-5)", parseInt).action(async (agentInput, opts) => {
+  program2.command("call <agent>").description("Call an agent on the A2A network (default: async polling)").requiredOption("--task <description>", "Task description").option("--input-file <path>", "Read file and append to task description").option("--output-file <path>", "Save response text to file").option("--stream", "Use SSE streaming instead of async polling").option("--with-files", "Request file transfer via WebRTC after task completion").option("--json", "Output JSONL events").option("--timeout <seconds>", "Timeout in seconds", "300").option("--rate <rating>", "Rate the agent after call (1-5)", parseInt).action(async (agentInput, opts) => {
     try {
       const token = loadToken();
       if (!token) {
@@ -4753,7 +4835,8 @@ ${content}`;
         timeoutMs,
         json: opts.json,
         outputFile: opts.outputFile,
-        signal: abortController.signal
+        signal: abortController.signal,
+        withFiles: opts.withFiles
       };
       let result;
       if (opts.stream) {
@@ -5220,21 +5303,11 @@ function registerProfileCommand(program2) {
 }
 
 // src/commands/files.ts
-import { writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename2 } from "path";
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
-function defaultOutputPath(filePath) {
-  const name = basename2(filePath || "") || "file";
-  return name;
-}
-function defaultZipOutputPath(sessionKey) {
-  const suffix = sessionKey.split(":").at(-1) || "session";
-  return `session-${suffix}.zip`;
-}
 function handleError7(err) {
   if (err instanceof PlatformApiError) {
     log.error(err.message);
@@ -5247,16 +5320,8 @@ async function resolveTargetAgent(agentInput) {
   const client = createClient();
   return resolveAgentId(agentInput, client);
 }
-async function downloadToFile(url, outputPath) {
-  const res = await fetch(url);
-  if (!res.ok) {
-    throw new Error(`Download failed: HTTP ${res.status}`);
-  }
-  const buf = Buffer.from(await res.arrayBuffer());
-  writeFileSync4(outputPath, buf);
-}
 function registerFilesCommand(program2) {
-  const files = program2.command("files").description("Session file manifest and on-demand upload/download commands");
+  const files = program2.command("files").description("Session file commands (WebRTC P2P transfer)");
   files.command("list").requiredOption("--agent <agent>", "Target agent ID or name").requiredOption("--session <session_key>", "Session key").option("--json", "Output raw JSON").action(async (opts) => {
     try {
       const { id, name } = await resolveTargetAgent(opts.agent);
@@ -5279,90 +5344,7 @@ function registerFilesCommand(program2) {
         console.log(`  ${f.path}  ${GRAY}${formatBytes(f.size)}${RESET}`);
       }
       console.log("");
-    } catch (err) {
-      handleError7(err);
-    }
-  });
-  files.command("upload").requiredOption("--agent <agent>", "Target agent ID or name").requiredOption("--session <session_key>", "Session key").requiredOption("--path <file_path>", "Relative file path in session workspace").option("--json", "Output raw JSON").action(async (opts) => {
-    try {
-      const { id } = await resolveTargetAgent(opts.agent);
-      const client = createClient();
-      const data = await client.post(`/api/agents/${id}/files/upload`, {
-        session_key: opts.session,
-        path: opts.path
-      });
-      if (opts.json) {
-        console.log(JSON.stringify(data));
-        return;
-      }
-      if (!data.file?.url) {
-        throw new Error("No file URL returned");
-      }
-      log.success(`Uploaded ${opts.path}`);
-      console.log(`  ${GRAY}URL${RESET}  ${data.file.url}`);
-    } catch (err) {
-      handleError7(err);
-    }
-  });
-  files.command("upload-all").requiredOption("--agent <agent>", "Target agent ID or name").requiredOption("--session <session_key>", "Session key").option("--json", "Output raw JSON").action(async (opts) => {
-    try {
-      const { id } = await resolveTargetAgent(opts.agent);
-      const client = createClient();
-      const data = await client.post(`/api/agents/${id}/files/upload-all`, {
-        session_key: opts.session
-      });
-      if (opts.json) {
-        console.log(JSON.stringify(data));
-        return;
-      }
-      if (!data.file?.url) {
-        throw new Error("No ZIP URL returned");
-      }
-      log.success("Uploaded session ZIP");
-      console.log(`  ${GRAY}URL${RESET}  ${data.file.url}`);
-    } catch (err) {
-      handleError7(err);
-    }
-  });
-  files.command("download").requiredOption("--agent <agent>", "Target agent ID or name").requiredOption("--session <session_key>", "Session key").requiredOption("--path <file_path>", "Relative file path in session workspace").option("--output <path>", "Local output path").option("--json", "Output raw JSON").action(async (opts) => {
-    try {
-      const { id } = await resolveTargetAgent(opts.agent);
-      const client = createClient();
-      const data = await client.post(`/api/agents/${id}/files/upload`, {
-        session_key: opts.session,
-        path: opts.path
-      });
-      const url = data.file?.url;
-      if (!url) throw new Error("No file URL returned");
-      const output = opts.output || defaultOutputPath(opts.path);
-      await downloadToFile(url, output);
-      if (opts.json) {
-        console.log(JSON.stringify({ success: true, output, url }));
-        return;
-      }
-      log.success(`Downloaded ${opts.path}`);
-      console.log(`  ${GRAY}Saved${RESET}  ${output}`);
-    } catch (err) {
-      handleError7(err);
-    }
-  });
-  files.command("download-all").requiredOption("--agent <agent>", "Target agent ID or name").requiredOption("--session <session_key>", "Session key").option("--output <path>", "Local output path").option("--json", "Output raw JSON").action(async (opts) => {
-    try {
-      const { id } = await resolveTargetAgent(opts.agent);
-      const client = createClient();
-      const data = await client.post(`/api/agents/${id}/files/upload-all`, {
-        session_key: opts.session
-      });
-      const url = data.file?.url;
-      if (!url) throw new Error("No ZIP URL returned");
-      const output = opts.output || defaultZipOutputPath(opts.session);
-      await downloadToFile(url, output);
-      if (opts.json) {
-        console.log(JSON.stringify({ success: true, output, url }));
-        return;
-      }
-      log.success("Downloaded session ZIP");
-      console.log(`  ${GRAY}Saved${RESET}  ${output}`);
+      console.log(`  ${GRAY}Use --with-files in call/chat to receive files via WebRTC P2P${RESET}`);
     } catch (err) {
       handleError7(err);
     }
@@ -5372,12 +5354,9 @@ function registerFilesCommand(program2) {
       command: "agent-mesh files",
       docs: "https://agents.hot/docs/cli/files",
       commands: [
-        { name: "list", required: ["--agent", "--session"], optional: ["--json"] },
-        { name: "upload", required: ["--agent", "--session", "--path"], optional: ["--json"] },
-        { name: "upload-all", required: ["--agent", "--session"], optional: ["--json"] },
-        { name: "download", required: ["--agent", "--session", "--path"], optional: ["--output", "--json"] },
-        { name: "download-all", required: ["--agent", "--session"], optional: ["--output", "--json"] }
-      ]
+        { name: "list", required: ["--agent", "--session"], optional: ["--json"] }
+      ],
+      notes: "File transfer now uses WebRTC P2P. Use --with-files flag in call/chat commands."
     };
     if (opts.json) {
       console.log(JSON.stringify(reference));
@@ -5388,6 +5367,8 @@ function registerFilesCommand(program2) {
     for (const item of reference.commands) {
       console.log(`  ${item.name}`);
     }
+    console.log("");
+    console.log(`  ${GRAY}${reference.notes}${RESET}`);
   });
 }
 
@@ -5506,7 +5487,7 @@ function maybeAutoUpgradeOnStartup(opts) {
 }
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var { version } = require2("../package.json");
 var autoUpgrade = maybeAutoUpgradeOnStartup({ currentVersion: version });
 if (autoUpgrade.relaunched) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-mesh",
-  "version": "0.16.13",
+  "version": "0.17.2",
   "description": "CLI bridge connecting local AI agents to the Agents.Hot platform",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "dependencies": {
     "@annals/bridge-protocol": "^0.2.0",
     "commander": "^13.0.0",
+    "node-datachannel": "^0.32.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
@@ -18,7 +19,8 @@
     "typescript": "^5.7.0"
   },
   "files": [
-    "dist"
+    "dist",
+    "prebuilds"
   ],
   "license": "MIT",
   "repository": {