@annals/agent-mesh 0.17.9 → 0.18.1

package/dist/{chunk-KEUGYA3L.js → chunk-5CMYB6XV.js}

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/commands/list.ts
 import { spawn as spawn2 } from "child_process";
@@ -951,6 +957,7 @@ function registerListCommand(program) {
 }
 
 export {
+  __require,
   DEFAULT_RUNTIME_CONFIG,
   loadConfig,
   updateConfig,

package/dist/index.js

@@ -6,6 +6,7 @@ import {
   GREEN,
   RESET,
   YELLOW,
+  __require,
   addAgent,
   findAgentByAgentId,
   getAgent,
@@ -30,7 +31,7 @@ import {
   updateConfig,
   updateRuntimeConfig,
   writePid
-} from "./chunk-KEUGYA3L.js";
+} from "./chunk-5CMYB6XV.js";
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
@@ -531,6 +532,225 @@ var FileReceiver = class {
     this.dc = null;
   }
 };
+var FileUploadReceiver = class {
+  peer = null;
+  expectedSize;
+  expectedSha256;
+  chunks = [];
+  receivedBytes = 0;
+  resolveComplete = null;
+  rejectComplete = null;
+  signalCallback = null;
+  pendingCandidates = [];
+  closed = false;
+  constructor(expectedSize, expectedSha256) {
+    this.expectedSize = expectedSize;
+    this.expectedSha256 = expectedSha256;
+  }
+  onSignal(cb) {
+    this.signalCallback = cb;
+  }
+  async handleSignal(signal) {
+    const ndc = await loadNdc();
+    if (!ndc || this.closed) return;
+    if (!this.peer) {
+      this.peer = new ndc.PeerConnection(`upload-receiver-${Date.now()}`, {
+        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.onMessage((msg) => {
+          if (typeof msg === "string") {
+            try {
+              const ctrl = JSON.parse(msg);
+              if (ctrl.type === "complete") {
+                this.finalizeReceive();
+              }
+            } catch {
+            }
+            return;
+          }
+          const buf = Buffer.isBuffer(msg) ? msg : Buffer.from(msg);
+          this.chunks.push(buf);
+          this.receivedBytes += buf.length;
+        });
+      });
+    }
+    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 });
+      }
+    }
+  }
+  waitForCompletion(timeoutMs = 3e4) {
+    return new Promise((resolve2, reject) => {
+      this.resolveComplete = resolve2;
+      this.rejectComplete = reject;
+      setTimeout(() => {
+        if (!this.closed) {
+          reject(new Error(`Upload receive timed out after ${timeoutMs}ms`));
+          this.close();
+        }
+      }, timeoutMs);
+    });
+  }
+  finalizeReceive() {
+    const zipBuffer = Buffer.concat(this.chunks);
+    const actualSha256 = createHash("sha256").update(zipBuffer).digest("hex");
+    if (zipBuffer.length !== this.expectedSize) {
+      this.rejectComplete?.(
+        new Error(`Size mismatch: expected ${this.expectedSize}, got ${zipBuffer.length}`)
+      );
+      this.close();
+      return;
+    }
+    if (actualSha256 !== this.expectedSha256) {
+      this.rejectComplete?.(
+        new Error(`SHA-256 mismatch: expected ${this.expectedSha256}, got ${actualSha256}`)
+      );
+      this.close();
+      return;
+    }
+    log.info(`[WebRTC] Upload received ${zipBuffer.length} bytes, SHA-256 verified`);
+    this.resolveComplete?.(zipBuffer);
+    this.close();
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.peer?.close();
+    } catch {
+    }
+    this.peer = null;
+  }
+};
+var FileUploadSender = class {
+  peer = null;
+  dc = null;
+  transferId;
+  zipBuffer;
+  signalCallback = null;
+  pendingCandidates = [];
+  resolveComplete = null;
+  rejectComplete = null;
+  closed = false;
+  constructor(transferId, zipBuffer) {
+    this.transferId = transferId;
+    this.zipBuffer = zipBuffer;
+  }
+  onSignal(cb) {
+    this.signalCallback = cb;
+  }
+  async createOffer() {
+    const ndc = await loadNdc();
+    if (!ndc) return null;
+    this.peer = new ndc.PeerConnection("upload-sender", {
+      iceServers: ICE_SERVERS
+    });
+    return new Promise((resolve2) => {
+      this.peer.onLocalDescription((sdp, type) => {
+        if (type === "offer") {
+          resolve2(sdp);
+        }
+        this.signalCallback?.({ signal_type: type, payload: sdp });
+      });
+      this.peer.onLocalCandidate((candidate, mid) => {
+        this.signalCallback?.({
+          signal_type: "candidate",
+          payload: JSON.stringify({ candidate, mid })
+        });
+      });
+      this.dc = this.peer.createDataChannel("file-transfer");
+      this.dc.onOpen(() => {
+        void this.sendZip();
+      });
+    });
+  }
+  async handleSignal(signal) {
+    if (!this.peer || this.closed) return;
+    if (signal.signal_type === "answer" || signal.signal_type === "offer") {
+      this.peer.setRemoteDescription(signal.payload, signal.signal_type);
+      for (const c of this.pendingCandidates) {
+        this.peer.addRemoteCandidate(c.candidate, c.mid);
+      }
+      this.pendingCandidates = [];
+    } else if (signal.signal_type === "candidate") {
+      const { candidate, mid } = JSON.parse(signal.payload);
+      if (this.peer.remoteDescription()) {
+        this.peer.addRemoteCandidate(candidate, mid);
+      } else {
+        this.pendingCandidates.push({ candidate, mid });
+      }
+    }
+  }
+  waitForCompletion(timeoutMs = 3e4) {
+    return new Promise((resolve2, reject) => {
+      this.resolveComplete = resolve2;
+      this.rejectComplete = reject;
+      setTimeout(() => {
+        if (!this.closed) {
+          reject(new Error(`Upload send timed out after ${timeoutMs}ms`));
+          this.close();
+        }
+      }, timeoutMs);
+    });
+  }
+  async sendZip() {
+    if (!this.dc) return;
+    try {
+      this.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);
+        this.dc.sendMessageBinary(chunk);
+        offset = end;
+      }
+      this.dc.sendMessage(JSON.stringify({ type: "complete" }));
+      log.info(`[WebRTC] Upload sent ${this.zipBuffer.length} bytes in ${Math.ceil(this.zipBuffer.length / CHUNK_SIZE)} chunks`);
+      this.resolveComplete?.();
+      this.close();
+    } catch (err) {
+      log.error(`[WebRTC] Upload send failed: ${err}`);
+      this.rejectComplete?.(err instanceof Error ? err : new Error(String(err)));
+      this.close();
+    }
+  }
+  close() {
+    this.closed = true;
+    try {
+      this.dc?.close();
+    } catch {
+    }
+    try {
+      this.peer?.close();
+    } catch {
+    }
+    this.peer = null;
+    this.dc = null;
+  }
+};
 function sha256Hex(data) {
   return createHash("sha256").update(data).digest("hex");
 }
@@ -954,8 +1174,10 @@ var BridgeManager = class {
   requestDispatches = /* @__PURE__ */ new Map();
   cleanupTimer = null;
   runtimeQueue;
-  /** Pending WebRTC file transfers: transfer_id → FileSender + cleanup timer */
+  /** Pending WebRTC file transfers (download): transfer_id → FileSender + cleanup timer */
   pendingTransfers = /* @__PURE__ */ new Map();
+  /** Pending WebRTC file uploads (caller→agent): transfer_id → FileUploadReceiver + cleanup timer */
+  pendingUploads = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.wsClient = opts.wsClient;
     this.adapter = opts.adapter;
@@ -984,6 +1206,7 @@ var BridgeManager = class {
     this.sessionLastSeenAt.clear();
     this.cleanupRequestDispatches("shutdown");
     this.cleanupPendingTransfers();
+    this.cleanupPendingUploads();
     log.info("Bridge manager stopped");
   }
   /**
@@ -1083,7 +1306,10 @@ var BridgeManager = class {
   }
   async dispatchWithLocalQueue(opts) {
     const { msg, handle, requestKey } = opts;
-    const { session_id, request_id, content, attachments, client_id, with_files } = msg;
+    const { session_id, request_id, content, attachments, client_id, with_files, file_upload_offer } = msg;
+    if (file_upload_offer) {
+      this.registerPendingUpload(file_upload_offer, session_id, request_id);
+    }
     const state = this.requestDispatches.get(requestKey);
     if (!state) return;
     try {
@@ -1389,19 +1615,92 @@ var BridgeManager = class {
     log.info(`WebRTC transfer registered: transfer=${offer.transfer_id.slice(0, 8)}... (${(zipBuffer.length / 1024).toFixed(1)} KB in memory)`);
   }
   handleRtcSignalRelay(msg) {
-    const entry = this.pendingTransfers.get(msg.transfer_id);
-    if (!entry) {
-      log.debug(`No pending transfer for ${msg.transfer_id.slice(0, 8)}...`);
+    const downloadEntry = this.pendingTransfers.get(msg.transfer_id);
+    if (downloadEntry) {
+      downloadEntry.targetAgentId = msg.from_agent_id;
+      void downloadEntry.sender.handleSignal({
+        signal_type: msg.signal_type,
+        payload: msg.payload
+      });
+      return;
+    }
+    const uploadEntry = this.pendingUploads.get(msg.transfer_id);
+    if (uploadEntry) {
+      void uploadEntry.receiver.handleSignal({
+        signal_type: msg.signal_type,
+        payload: msg.payload
+      });
       return;
     }
-    entry.targetAgentId = msg.from_agent_id;
-    void entry.sender.handleSignal({
-      signal_type: msg.signal_type,
-      payload: msg.payload
+    log.debug(`No pending transfer for ${msg.transfer_id.slice(0, 8)}...`);
+  }
+  // ========================================================
+  // Upload (Caller → Agent) WebRTC signaling
+  // ========================================================
+  registerPendingUpload(offer, _sessionId, _requestId) {
+    const receiver = new FileUploadReceiver(offer.zip_size, offer.zip_sha256);
+    receiver.onSignal((signal) => {
+      const rtcSignal = {
+        type: "rtc_signal",
+        transfer_id: offer.transfer_id,
+        target_agent_id: "http-caller",
+        signal_type: signal.signal_type,
+        payload: signal.payload
+      };
+      this.wsClient.send(rtcSignal);
     });
+    const timer = setTimeout(() => {
+      receiver.close();
+      this.pendingUploads.delete(offer.transfer_id);
+      log.debug(`Upload transfer ${offer.transfer_id.slice(0, 8)}... expired`);
+    }, 5 * 6e4);
+    timer.unref?.();
+    this.pendingUploads.set(offer.transfer_id, { receiver, timer });
+    void receiver.waitForCompletion(5 * 6e4).then((zipBuffer) => {
+      clearTimeout(timer);
+      this.pendingUploads.delete(offer.transfer_id);
+      const workspaceDir = this.resolveUploadWorkspace(_sessionId);
+      try {
+        const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync4 } = __require("fs");
+        const { join: join13 } = __require("path");
+        const { execSync: execSync6 } = __require("child_process");
+        mkdirSync7(workspaceDir, { recursive: true });
+        const zipPath = join13(workspaceDir, ".upload.zip");
+        writeFileSync4(zipPath, zipBuffer);
+        try {
+          execSync6(`unzip -o -q "${zipPath}" -d "${workspaceDir}"`);
+          try {
+            execSync6(`rm "${zipPath}"`);
+          } catch {
+          }
+          log.info(`[WebRTC] Upload: ${offer.file_count} file(s) extracted to ${workspaceDir}`);
+        } catch {
+          log.warn(`[WebRTC] Upload: Failed to extract ZIP. Saved to: ${zipPath}`);
+        }
+      } catch (err) {
+        log.error(`[WebRTC] Upload extraction failed: ${err}`);
+      }
+    }).catch((err) => {
+      log.warn(`[WebRTC] Upload receive failed: ${err.message}`);
+      this.pendingUploads.delete(offer.transfer_id);
+    });
+    log.info(`[WebRTC] Upload registered: transfer=${offer.transfer_id.slice(0, 8)}... (${offer.file_count} files, ${(offer.zip_size / 1024).toFixed(1)} KB)`);
+  }
+  resolveUploadWorkspace(sessionId) {
+    const { join: join13 } = __require("path");
+    const { homedir: homedir6 } = __require("os");
+    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9_:-]/g, "_").slice(0, 64);
+    return join13(homedir6(), ".agent-mesh", "uploads", safeSessionId);
+  }
+  cleanupPendingUploads() {
+    for (const [, entry] of this.pendingUploads) {
+      clearTimeout(entry.timer);
+      entry.receiver.close();
+    }
+    this.pendingUploads.clear();
   }
   cleanupPendingTransfers() {
-    for (const [id, entry] of this.pendingTransfers) {
+    for (const [, entry] of this.pendingTransfers) {
       clearTimeout(entry.timer);
       entry.sender.close();
     }
@@ -2477,7 +2776,7 @@ function registerConnectCommand(program2) {
             log.error(`Failed to start. Check logs: ${getLogPath(slug)}`);
             process.exit(1);
           }
-          const { ListTUI } = await import("./list-ROLJARYB.js");
+          const { ListTUI } = await import("./list-RV7HOA77.js");
           const tui = new ListTUI();
           await tui.run();
           return;
@@ -3555,6 +3854,11 @@ function registerAgentsCommand(program2) {
 
 // src/commands/chat.ts
 import { createInterface as createInterface4 } from "readline";
+import { existsSync as existsSync7, readFileSync as readFileSync2, mkdirSync as mkdirSync5, copyFileSync as copyFileSync2 } from "fs";
+import { basename as basename2, join as join9 } from "path";
+import { execSync as execSync4 } from "child_process";
+import { createHash as createHash2, randomUUID } from "crypto";
+import { tmpdir } from "os";
 
 // src/utils/sse-parser.ts
 function parseSseChunk(raw, carry) {
@@ -3577,9 +3881,97 @@ function parseSseChunk(raw, carry) {
 
 // src/commands/chat.ts
 var DEFAULT_BASE_URL3 = "https://agents.hot";
+function prepareUploadFile(filePath) {
+  const fileName = basename2(filePath);
+  const tempDir = join9(tmpdir(), `chat-upload-${Date.now()}`);
+  mkdirSync5(tempDir, { recursive: true });
+  const tempFile = join9(tempDir, fileName);
+  copyFileSync2(filePath, tempFile);
+  const zipPath = join9(tempDir, "upload.zip");
+  execSync4(`cd "${tempDir}" && zip -q "${zipPath}" "${fileName}"`);
+  const zipBuffer = readFileSync2(zipPath);
+  try {
+    execSync4(`rm -rf "${tempDir}"`);
+  } catch {
+  }
+  const zipSha256 = createHash2("sha256").update(zipBuffer).digest("hex");
+  const transferId = randomUUID();
+  return {
+    offer: {
+      transfer_id: transferId,
+      zip_size: zipBuffer.length,
+      zip_sha256: zipSha256,
+      file_count: 1
+    },
+    zipBuffer: Buffer.from(zipBuffer)
+  };
+}
 function sleep5(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+async function chatWebrtcUpload(agentId, offer, zipBuffer, token, baseUrl) {
+  log.info(`[WebRTC] Uploading file (${(offer.zip_size / 1024).toFixed(1)} KB)...`);
+  const sender = new FileUploadSender(offer.transfer_id, zipBuffer);
+  const exchangeSignals = async (signal) => {
+    try {
+      const res = await fetch(`${baseUrl}/api/agents/${agentId}/rtc-signal`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          transfer_id: offer.transfer_id,
+          signal_type: signal.signal_type,
+          payload: signal.payload
+        })
+      });
+      if (res.ok) {
+        const { signals } = await res.json();
+        for (const s of signals) {
+          await sender.handleSignal(s);
+        }
+      }
+    } catch {
+    }
+  };
+  sender.onSignal(exchangeSignals);
+  await sender.createOffer();
+  const poll = async () => {
+    for (let i = 0; i < 20; i++) {
+      await sleep5(500);
+      try {
+        const res = await fetch(`${baseUrl}/api/agents/${agentId}/rtc-signal`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            transfer_id: offer.transfer_id,
+            signal_type: "poll",
+            payload: ""
+          })
+        });
+        if (res.ok) {
+          const { signals } = await res.json();
+          for (const s of signals) {
+            await sender.handleSignal(s);
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  try {
+    await Promise.all([sender.waitForCompletion(3e4), poll()]);
+    log.success(`[WebRTC] File uploaded successfully`);
+  } catch (err) {
+    log.warn(`[WebRTC] Upload failed: ${err.message}`);
+  } finally {
+    sender.close();
+  }
+}
 async function asyncChat(opts) {
   const res = await fetch(`${opts.baseUrl}/api/agents/${opts.agentId}/chat`, {
     method: "POST",
@@ -3587,7 +3979,11 @@ async function asyncChat(opts) {
       Authorization: `Bearer ${opts.token}`,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify({ message: opts.message, mode: "async" }),
+    body: JSON.stringify({
+      message: opts.message,
+      mode: "async",
+      ...opts.fileUploadOffer ? { file_upload_offer: opts.fileUploadOffer } : {}
+    }),
     signal: opts.signal
   });
   if (!res.ok) {
@@ -3655,7 +4051,10 @@ async function streamChat(opts) {
       Authorization: `Bearer ${opts.token}`,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify({ message: opts.message }),
+    body: JSON.stringify({
+      message: opts.message,
+      ...opts.fileUploadOffer ? { file_upload_offer: opts.fileUploadOffer } : {}
+    }),
     signal: opts.signal
   });
   if (!res.ok) {
@@ -3789,8 +4188,10 @@ function registerChatCommand(program2) {
       process.exit(1);
     }
     log.banner(`Chat with ${agentName}`);
-    console.log(`${GRAY}Type your message and press Enter. Use /quit or Ctrl+C to exit.${RESET}
+    console.log(`${GRAY}Type your message and press Enter. /upload <path> to send a file. /quit to exit.${RESET}
 `);
+    let pendingUploadOffer;
+    let pendingUploadZipBuffer;
     const rl = createInterface4({
       input: process.stdin,
       output: process.stdout,
@@ -3813,7 +4214,34 @@ function registerChatCommand(program2) {
         rl.close();
         return;
       }
+      if (trimmed.startsWith("/upload ")) {
+        const filePath = trimmed.slice(8).trim();
+        if (!filePath) {
+          log.error("Usage: /upload <path>");
+          rl.prompt();
+          return;
+        }
+        if (!existsSync7(filePath)) {
+          log.error(`File not found: ${filePath}`);
+          rl.prompt();
+          return;
+        }
+        try {
+          const prepared = prepareUploadFile(filePath);
+          pendingUploadOffer = prepared.offer;
+          pendingUploadZipBuffer = prepared.zipBuffer;
+          log.info(`File staged: ${basename2(filePath)} (${(prepared.offer.zip_size / 1024).toFixed(1)} KB). Type a message to send with the file.`);
+        } catch (err) {
+          log.error(`Failed to prepare file: ${err.message}`);
+        }
+        rl.prompt();
+        return;
+      }
       console.log("");
+      const uploadOffer = pendingUploadOffer;
+      const uploadZipBuffer = pendingUploadZipBuffer;
+      pendingUploadOffer = void 0;
+      pendingUploadZipBuffer = void 0;
       try {
         await streamChat({
           agentId,
@@ -3821,8 +4249,12 @@ function registerChatCommand(program2) {
           token,
           baseUrl: opts.baseUrl,
           showThinking: opts.thinking,
-          mode
+          mode,
+          fileUploadOffer: uploadOffer
         });
+        if (uploadOffer && uploadZipBuffer) {
+          await chatWebrtcUpload(agentId, uploadOffer, uploadZipBuffer, token, opts.baseUrl);
+        }
       } catch (err) {
         if (abortController.signal.aborted) return;
         log.error(err.message);
@@ -3835,11 +4267,11 @@ function registerChatCommand(program2) {
 
 // src/commands/skills.ts
 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";
+import { join as join11, resolve, relative as relative4 } from "path";
 
 // src/utils/skill-parser.ts
 import { readFile as readFile2, writeFile as writeFile2, stat as stat3 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 function parseSkillMd(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -3921,7 +4353,7 @@ function parseSkillMd(raw) {
   return { frontmatter, content };
 }
 async function loadSkillManifest(dir) {
-  const skillMdPath = join9(dir, "SKILL.md");
+  const skillMdPath = join10(dir, "SKILL.md");
   try {
     const raw = await readFile2(skillMdPath, "utf-8");
     const { frontmatter } = parseSkillMd(raw);
@@ -4026,13 +4458,13 @@ function skillApiPath(authorLogin, slug) {
 }
 async function resolveSkillsRootAsync(pathArg) {
   const projectRoot = pathArg ? resolve(pathArg) : process.cwd();
-  const skillsDir = join10(projectRoot, ".agents", "skills");
-  const claudeSkillsDir = join10(projectRoot, ".claude", "skills");
+  const skillsDir = join11(projectRoot, ".agents", "skills");
+  const claudeSkillsDir = join11(projectRoot, ".claude", "skills");
   return { projectRoot, skillsDir, claudeSkillsDir };
 }
 async function ensureClaudeSymlink(claudeSkillsDir, slug) {
   await mkdir2(claudeSkillsDir, { recursive: true });
-  const linkPath = join10(claudeSkillsDir, slug);
+  const linkPath = join11(claudeSkillsDir, slug);
   try {
     await unlink(linkPath);
   } catch {
@@ -4052,7 +4484,7 @@ async function collectPackFiles(dir, manifest) {
   }
   const mainFile = manifest.main || "SKILL.md";
   if (!results.includes(mainFile)) {
-    const mainPath = join10(dir, mainFile);
+    const mainPath = join11(dir, mainFile);
     if (await pathExists(mainPath)) {
       results.unshift(mainFile);
     }
@@ -4069,7 +4501,7 @@ async function walkDir(dir) {
   }
   for (const entry of entries) {
     if (entry.isSymbolicLink()) continue;
-    const fullPath = join10(dir, entry.name);
+    const fullPath = join11(dir, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
       const sub = await walkDir(fullPath);
@@ -4087,7 +4519,7 @@ async function packSkill(dir, manifest) {
   }
   const entries = [];
   for (const relPath of fileList) {
-    const absPath = join10(dir, relPath);
+    const absPath = join11(dir, relPath);
     try {
       const data = await readFile3(absPath);
       entries.push({ path: relPath.replace(/\\/g, "/"), data });
@@ -4121,7 +4553,7 @@ function bumpVersion(current, bump) {
 }
 async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
   const meta = await client.get(skillApiPath(authorLogin, slug));
-  const targetDir = join10(skillsDir, slug);
+  const targetDir = join11(skillsDir, slug);
   await mkdir2(targetDir, { recursive: true });
   if (meta.has_files) {
     const res = await client.getRaw(`${skillApiPath(authorLogin, slug)}/download`);
@@ -4129,8 +4561,8 @@ async function downloadAndInstallSkill(client, authorLogin, slug, skillsDir) {
     const buf = Buffer.from(arrayBuf);
     const entries = extractZipBuffer(buf);
     for (const entry of entries) {
-      const filePath = join10(targetDir, entry.path);
-      const dir = join10(filePath, "..");
+      const filePath = join11(targetDir, entry.path);
+      const dir = join11(filePath, "..");
       await mkdir2(dir, { recursive: true });
       await writeFile3(filePath, entry.data);
     }
@@ -4143,7 +4575,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(join10(targetDir, "SKILL.md"), content);
+    await writeFile3(join11(targetDir, "SKILL.md"), content);
     return {
       slug,
       name: meta.name,
@@ -4172,7 +4604,7 @@ function registerSkillsCommand(program2) {
     try {
       const dir = resolveSkillDir(pathArg);
       await mkdir2(dir, { recursive: true });
-      const skillMdPath = join10(dir, "SKILL.md");
+      const skillMdPath = join11(dir, "SKILL.md");
       if (await pathExists(skillMdPath)) {
         const raw = await readFile3(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
@@ -4201,7 +4633,7 @@ function registerSkillsCommand(program2) {
       const dir = resolveSkillDir(pathArg);
       const manifest = await loadSkillManifest(dir);
       const result = await packSkill(dir, manifest);
-      const outPath = join10(dir, result.filename);
+      const outPath = join11(dir, result.filename);
       await writeFile3(outPath, result.buffer);
       slog.info(`Packed ${result.files.length} files \u2192 ${result.filename} (${result.size} bytes)`);
       outputJson({
@@ -4247,7 +4679,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 readFile3(join10(dir, manifest.main || "SKILL.md"), "utf-8");
+        content = await readFile3(join11(dir, manifest.main || "SKILL.md"), "utf-8");
         packResult = await packSkill(dir, manifest);
         slog.info(`Packed ${packResult.files.length} files (${packResult.size} bytes)`);
       }
@@ -4384,7 +4816,7 @@ 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 = join10(dir, "SKILL.md");
+      const skillMdPath = join11(dir, "SKILL.md");
       if (!await pathExists(skillMdPath)) {
         outputError("not_found", "No SKILL.md found. Run `agent-mesh skills init` first.");
       }
@@ -4404,7 +4836,7 @@ function registerSkillsCommand(program2) {
     try {
       const { authorLogin, slug } = parseSkillRef(ref);
       const { skillsDir, claudeSkillsDir } = await resolveSkillsRootAsync(pathArg);
-      const targetDir = join10(skillsDir, slug);
+      const targetDir = join11(skillsDir, slug);
       if (await pathExists(targetDir)) {
         if (!opts.force) {
           outputError("already_installed", `Skill "${slug}" is already installed at ${targetDir}. Use --force to overwrite.`);
@@ -4443,11 +4875,11 @@ function registerSkillsCommand(program2) {
       const failed = [];
       if (ref) {
         const { authorLogin, slug } = parseSkillRef(ref);
-        const targetDir = join10(skillsDir, slug);
+        const targetDir = join11(skillsDir, slug);
         if (!await pathExists(targetDir)) {
           outputError("not_installed", `Skill "${slug}" is not installed. Use "skills install ${ref}" first.`);
         }
-        const skillMdPath = join10(targetDir, "SKILL.md");
+        const skillMdPath = join11(targetDir, "SKILL.md");
         let localVersion = "0.0.0";
         if (await pathExists(skillMdPath)) {
           const raw = await readFile3(skillMdPath, "utf-8");
@@ -4474,7 +4906,7 @@ function registerSkillsCommand(program2) {
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           const slug = entry.name;
-          const skillMdPath = join10(skillsDir, slug, "SKILL.md");
+          const skillMdPath = join11(skillsDir, slug, "SKILL.md");
           if (!await pathExists(skillMdPath)) {
             skipped.push({ slug, reason: "no_skill_md" });
             continue;
@@ -4494,7 +4926,7 @@ function registerSkillsCommand(program2) {
               skipped.push({ slug, reason: "up_to_date" });
             } else {
               slog.info(`Updating ${slug}: v${localVersion} \u2192 v${remoteVersion}...`);
-              await rm(join10(skillsDir, slug), { recursive: true, force: true });
+              await rm(join11(skillsDir, slug), { recursive: true, force: true });
               await downloadAndInstallSkill(client, authorLogin, slug, skillsDir);
               updated.push({ slug, name: remote.name, old_version: localVersion, new_version: remoteVersion });
             }
@@ -4515,13 +4947,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 = join10(skillsDir, slug);
+      const targetDir = join11(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(join10(claudeSkillsDir, slug));
+        await unlink(join11(claudeSkillsDir, slug));
       } catch {
       }
       slog.success(`Removed skill: ${slug}`);
@@ -4546,7 +4978,7 @@ function registerSkillsCommand(program2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const slug = entry.name;
-        const skillMdPath = join10(skillsDir, slug, "SKILL.md");
+        const skillMdPath = join11(skillsDir, slug, "SKILL.md");
         if (!await pathExists(skillMdPath)) continue;
         const raw = await readFile3(skillMdPath, "utf-8");
         const { frontmatter } = parseSkillMd(raw);
@@ -4658,9 +5090,11 @@ function registerDiscoverCommand(program2) {
 }
 
 // src/commands/call.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync5 } from "fs";
-import { execSync as execSync4 } from "child_process";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync6, copyFileSync as copyFileSync3 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
+import { join as join12, basename as basename3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
 var DEFAULT_BASE_URL4 = "https://agents.hot";
 async function submitRating(baseUrl, token, agentId, callId, rating) {
   const res = await fetch(`${baseUrl}/api/agents/${agentId}/rate`, {
@@ -4753,13 +5187,13 @@ async function webrtcDownload(agentId, offer, token, outputDir, json) {
       receiver.waitForCompletion(3e4),
       poll()
     ]);
-    mkdirSync5(outputDir, { recursive: true });
-    const zipPath = join11(outputDir, ".transfer.zip");
+    mkdirSync6(outputDir, { recursive: true });
+    const zipPath = join12(outputDir, ".transfer.zip");
     writeFileSync3(zipPath, zipBuffer);
     try {
-      execSync4(`unzip -o -q "${zipPath}" -d "${outputDir}"`);
+      execSync5(`unzip -o -q "${zipPath}" -d "${outputDir}"`);
       try {
-        execSync4(`rm "${zipPath}"`);
+        execSync5(`rm "${zipPath}"`);
       } catch {
       }
     } catch {
@@ -4788,6 +5222,113 @@ async function webrtcDownload(agentId, offer, token, outputDir, json) {
     receiver.close();
   }
 }
+function prepareFileForUpload(filePath) {
+  const fileName = basename3(filePath);
+  const tempDir = join12(tmpdir2(), `upload-${Date.now()}`);
+  mkdirSync6(tempDir, { recursive: true });
+  const tempFile = join12(tempDir, fileName);
+  copyFileSync3(filePath, tempFile);
+  const zipPath = join12(tempDir, "upload.zip");
+  execSync5(`cd "${tempDir}" && zip -q "${zipPath}" "${fileName}"`);
+  const zipBuffer = readFileSync3(zipPath);
+  try {
+    execSync5(`rm -rf "${tempDir}"`);
+  } catch {
+  }
+  const zipSha256 = createHash3("sha256").update(zipBuffer).digest("hex");
+  const transferId = randomUUID2();
+  return {
+    offer: {
+      transfer_id: transferId,
+      zip_size: zipBuffer.length,
+      zip_sha256: zipSha256,
+      file_count: 1
+    },
+    zipBuffer: Buffer.from(zipBuffer)
+  };
+}
+async function webrtcUpload(agentId, offer, zipBuffer, token, json) {
+  if (!json) {
+    log.info(`[WebRTC] Uploading file (${(offer.zip_size / 1024).toFixed(1)} KB)...`);
+  }
+  const sender = new FileUploadSender(offer.transfer_id, zipBuffer);
+  const exchangeSignals = async (signal) => {
+    try {
+      const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${agentId}/rtc-signal`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          transfer_id: offer.transfer_id,
+          signal_type: signal.signal_type,
+          payload: signal.payload
+        })
+      });
+      if (res.ok) {
+        const { signals } = await res.json();
+        for (const s of signals) {
+          await sender.handleSignal(s);
+        }
+      }
+    } catch {
+    }
+  };
+  sender.onSignal(exchangeSignals);
+  await sender.createOffer();
+  const poll = async () => {
+    for (let i = 0; i < 20; i++) {
+      await sleep6(500);
+      try {
+        const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${agentId}/rtc-signal`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            transfer_id: offer.transfer_id,
+            signal_type: "poll",
+            payload: ""
+          })
+        });
+        if (res.ok) {
+          const { signals } = await res.json();
+          for (const s of signals) {
+            await sender.handleSignal(s);
+          }
+        }
+      } catch {
+      }
+    }
+  };
+  try {
+    await Promise.all([
+      sender.waitForCompletion(3e4),
+      poll()
+    ]);
+    if (json) {
+      console.log(JSON.stringify({
+        type: "files_uploaded",
+        file_count: offer.file_count,
+        zip_size: offer.zip_size,
+        sha256: offer.zip_sha256
+      }));
+    } else {
+      log.success(`[WebRTC] File uploaded successfully`);
+    }
+  } catch (err) {
+    const msg = err.message;
+    if (json) {
+      console.log(JSON.stringify({ type: "file_upload_failed", error: msg }));
+    } else {
+      log.warn(`[WebRTC] File upload failed: ${msg}`);
+    }
+  } finally {
+    sender.close();
+  }
+}
 async function asyncCall(opts) {
   const selfAgentId = process.env.AGENT_BRIDGE_AGENT_ID;
   const res = await fetch(`${DEFAULT_BASE_URL4}/api/agents/${opts.id}/call`, {
@@ -4800,7 +5341,8 @@ async function asyncCall(opts) {
     body: JSON.stringify({
       task_description: opts.taskDescription,
       mode: "async",
-      ...opts.withFiles ? { with_files: true } : {}
+      ...opts.withFiles ? { with_files: true } : {},
+      ...opts.uploadOffer ? { file_upload_offer: opts.uploadOffer } : {}
     }),
     signal: opts.signal
   });
@@ -4880,7 +5422,7 @@ async function asyncCall(opts) {
         if (!opts.json) log.info(`Saved to ${opts.outputFile}`);
       }
       if (offer && opts.withFiles) {
-        const outputDir = opts.outputFile ? join11(opts.outputFile, "..", "files") : join11(process.cwd(), "agent-output");
+        const outputDir = opts.outputFile ? join12(opts.outputFile, "..", "files") : join12(process.cwd(), "agent-output");
         await webrtcDownload(opts.id, offer, opts.token, outputDir, opts.json);
       }
       if (!opts.json) {
@@ -4919,7 +5461,8 @@ async function streamCall(opts) {
     },
     body: JSON.stringify({
       task_description: opts.taskDescription,
-      ...opts.withFiles ? { with_files: true } : {}
+      ...opts.withFiles ? { with_files: true } : {},
+      ...opts.uploadOffer ? { file_upload_offer: opts.uploadOffer } : {}
     }),
     signal: opts.signal
   });
@@ -5054,7 +5597,7 @@ Error: ${event.message}
   }
   if (fileOffer && opts.withFiles) {
     console.log("");
-    const outputDir = opts.outputFile ? join11(opts.outputFile, "..", "files") : join11(process.cwd(), "agent-output");
+    const outputDir = opts.outputFile ? join12(opts.outputFile, "..", "files") : join12(process.cwd(), "agent-output");
     await webrtcDownload(opts.id, fileOffer, opts.token, outputDir, opts.json);
   }
   if (!opts.json) {
@@ -5070,7 +5613,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("--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) => {
+  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("--upload-file <path>", "Upload file to agent via WebRTC P2P").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) {
@@ -5081,13 +5624,25 @@ function registerCallCommand(program2) {
       const { id, name } = await resolveAgentId(agentInput, client);
       let taskDescription = opts.task;
       if (opts.inputFile) {
-        const content = readFileSync2(opts.inputFile, "utf-8");
+        const content = readFileSync3(opts.inputFile, "utf-8");
         taskDescription = `${taskDescription}
 
 ---
 
 ${content}`;
       }
+      let uploadOffer;
+      let uploadZipBuffer;
+      if (opts.uploadFile) {
+        const { existsSync: existsSync8 } = __require("fs");
+        if (!existsSync8(opts.uploadFile)) {
+          log.error(`File not found: ${opts.uploadFile}`);
+          process.exit(1);
+        }
+        const prepared = prepareFileForUpload(opts.uploadFile);
+        uploadOffer = prepared.offer;
+        uploadZipBuffer = prepared.zipBuffer;
+      }
       const timeoutMs = parseInt(opts.timeout || "300", 10) * 1e3;
       const abortController = new AbortController();
       const timer = setTimeout(() => abortController.abort(), timeoutMs);
@@ -5100,13 +5655,20 @@ ${content}`;
         json: opts.json,
         outputFile: opts.outputFile,
         signal: abortController.signal,
-        withFiles: opts.withFiles
+        withFiles: opts.withFiles,
+        uploadOffer
       };
       let result;
       if (opts.stream) {
+        if (uploadOffer && uploadZipBuffer) {
+          void webrtcUpload(id, uploadOffer, uploadZipBuffer, token, opts.json);
+        }
         result = await streamCall(callOpts);
       } else {
         result = await asyncCall(callOpts);
+        if (uploadOffer && uploadZipBuffer) {
+          await webrtcUpload(id, uploadOffer, uploadZipBuffer, token, opts.json);
+        }
       }
       clearTimeout(timer);
       if (opts.rate && result.callId) {

package/dist/{list-ROLJARYB.js → list-RV7HOA77.js}

@@ -2,7 +2,7 @@
 import {
   ListTUI,
   registerListCommand
-} from "./chunk-KEUGYA3L.js";
+} from "./chunk-5CMYB6XV.js";
 export {
   ListTUI,
   registerListCommand

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@annals/agent-mesh",
-  "version": "0.17.9",
+  "version": "0.18.1",
   "description": "CLI bridge connecting local AI agents to the Agents.Hot platform",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "commander": "^13.0.0",
     "node-datachannel": "^0.32.0",
     "ws": "^8.18.0",
-    "@annals/bridge-protocol": "^0.2.1"
+    "@annals/bridge-protocol": "^0.2.2"
   },
   "devDependencies": {
     "@types/ws": "^8.5.0",