@annals/agent-mesh 0.16.13 → 0.17.0

package/dist/index.js

@@ -269,6 +269,106 @@ var BridgeWSClient = class extends EventEmitter {
 // src/bridge/manager.ts
 import { BridgeErrorCode } from "@annals/bridge-protocol";
 
+// src/utils/webrtc-transfer.ts
+import { createHash } from "crypto";
+var ICE_SERVERS = ["stun:stun.l.google.com:19302"];
+var CHUNK_SIZE = 64 * 1024;
+var ndcModule;
+async function loadNdc() {
+  if (ndcModule !== void 0) return ndcModule;
+  try {
+    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();
@@ -688,6 +788,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 +817,7 @@ var BridgeManager = class {
     this.wiredSessions.clear();
     this.sessionLastSeenAt.clear();
     this.cleanupRequestDispatches("shutdown");
+    this.cleanupPendingTransfers();
     log.info("Bridge manager stopped");
   }
   /**
@@ -746,6 +849,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 +917,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 +936,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 +998,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 +1196,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);
   }
@@ -1423,7 +1576,7 @@ function createClientWorkspace(projectPath, clientId) {
 }
 
 // src/adapters/claude.ts
-import { readFile as readFile2, writeFile, mkdir, stat as stat2 } from "fs/promises";
+import { writeFile, mkdir, stat as stat2 } from "fs/promises";
 import { join as join5, relative as relative3, basename } from "path";
 
 // src/utils/auto-upload.ts
@@ -1440,23 +1593,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) => {
@@ -1641,7 +1777,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 +1810,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);
@@ -1786,145 +1915,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 +2119,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;
           }
@@ -3399,8 +3441,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,11 +3647,11 @@ 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 { readFile as readFile3, 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";
 
 // src/utils/skill-parser.ts
-import { readFile as readFile3, writeFile as writeFile2, stat as stat3 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, stat as stat3 } from "fs/promises";
 import { join as join8 } from "path";
 function parseSkillMd(raw) {
   const trimmed = raw.trimStart();
@@ -3694,7 +3736,7 @@ function parseSkillMd(raw) {
 async function loadSkillManifest(dir) {
   const skillMdPath = join8(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 +3769,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");
@@ -3860,7 +3902,7 @@ async function packSkill(dir, manifest) {
   for (const relPath of fileList) {
     const absPath = join9(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}`);
@@ -3945,7 +3987,7 @@ function registerSkillsCommand(program2) {
       await mkdir2(dir, { recursive: true });
       const skillMdPath = join9(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}`);
@@ -4018,7 +4060,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(join9(dir, manifest.main || "SKILL.md"), "utf-8");
         packResult = await packSkill(dir, manifest);
         slog.info(`Packed ${packResult.files.length} files (${packResult.size} bytes)`);
       }
@@ -4159,7 +4201,7 @@ function registerSkillsCommand(program2) {
       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);
@@ -4221,7 +4263,7 @@ function registerSkillsCommand(program2) {
         const skillMdPath = join9(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";
         }
@@ -4250,7 +4292,7 @@ function registerSkillsCommand(program2) {
             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;
@@ -4319,7 +4361,7 @@ function registerSkillsCommand(program2) {
         const slug = entry.name;
         const skillMdPath = join9(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 +4512,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 +4575,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 +4585,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 +4631,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 +4717,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 +4775,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 +4804,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 +5272,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 +5289,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 +5313,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 +5323,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 +5336,8 @@ function registerFilesCommand(program2) {
     for (const item of reference.commands) {
       console.log(`  ${item.name}`);
     }
+    console.log("");
+    console.log(`  ${GRAY}${reference.notes}${RESET}`);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-mesh",
-  "version": "0.16.13",
+  "version": "0.17.0",
   "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": {