@pmate/cli 0.24.14 → 0.24.15

package/dist/index.js

@@ -9016,10 +9016,33 @@ function unwrapAgentResult(agentId, value) {
   }
   return value;
 }
-var DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_FROM, DEFAULT_AGENT_PROMPT_TIMEOUT_MS, AgentLlmClient;
+function resolveMimeType(filePath) {
+  const ext = import_node_path11.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".wav":
+      return "audio/wav";
+    case ".mp3":
+      return "audio/mpeg";
+    case ".m4a":
+      return "audio/mp4";
+    case ".mp4":
+      return "audio/mp4";
+    case ".ogg":
+      return "audio/ogg";
+    case ".webm":
+      return "audio/webm";
+    case ".flac":
+      return "audio/flac";
+    default:
+      return "application/octet-stream";
+  }
+}
+var import_node_fs7, import_node_path11, DEFAULT_AGENT_API_BASE_URL, DEFAULT_AGENT_HUB_BASE_URL, DEFAULT_NAMESPACE, DEFAULT_FROM, DEFAULT_AGENT_PROMPT_TIMEOUT_MS, AgentLlmClient;
 var init_AgentLlmClient = __esm({
   "src/llm/AgentLlmClient.ts"() {
     "use strict";
+    import_node_fs7 = require("fs");
+    import_node_path11 = __toESM(require("path"));
     init_dist2();
     init_sessionStore();
     DEFAULT_AGENT_API_BASE_URL = "https://agent-api.pmate.chat";
@@ -9061,6 +9084,33 @@ var init_AgentLlmClient = __esm({
           client.close();
         }
       }
+      async callFile(agentId, filePath, params, options) {
+        const client = new AgentClient({
+          baseUrl: options?.hubBaseUrl ?? this.hubBaseUrl,
+          agentService: this.agentService,
+          timeoutMs: DEFAULT_AGENT_PROMPT_TIMEOUT_MS,
+          streamTimeoutMs: DEFAULT_AGENT_PROMPT_TIMEOUT_MS,
+          minChunkSizeBytes: 0
+        });
+        try {
+          await client.login(options?.from ?? this.from, {
+            token: this.token
+          });
+          const input = new AsyncStream();
+          const stream = client.stream({
+            agentId,
+            stream: input,
+            params,
+            minChunkSizeBytes: 0
+          });
+          const file = (0, import_node_fs7.readFileSync)(filePath);
+          input.push(new Blob([file], { type: resolveMimeType(filePath) }));
+          input.end();
+          return await stream.finish();
+        } finally {
+          client.close();
+        }
+      }
     };
   }
 });
@@ -9071,8 +9121,8 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs22 = require("fs");
-var import_node_path26 = __toESM(require("path"));
+var import_node_fs23 = require("fs");
+var import_node_path27 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/cli.ts
@@ -12326,7 +12376,7 @@ var CommitCommandHandler = class {
 
 // src/commands/SummaryCommandHandler.ts
 var import_node_child_process7 = require("child_process");
-var import_node_path11 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var SummaryCommandHandler = class {
   async handle(args) {
     const cwd = this.resolveCwd(args.cwd);
@@ -12511,7 +12561,7 @@ var SummaryCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path11.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
   }
 };
 function truncate2(value, limit) {
@@ -12524,9 +12574,9 @@ function truncate2(value, limit) {
 
 // src/commands/LinearCommandHandler.ts
 var import_node_child_process8 = require("child_process");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_os4 = __toESM(require("os"));
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var import_promises3 = require("readline/promises");
 var import_openai = __toESM(require("openai"));
 var import_sdk = require("@linear/sdk");
@@ -13410,15 +13460,15 @@ var LinearCommandHandler = class {
     }
   }
   getLinearSelectionPath() {
-    return import_node_path12.default.join(import_node_os4.default.homedir(), ".pmate", "linear-selection.json");
+    return import_node_path13.default.join(import_node_os4.default.homedir(), ".pmate", "linear-selection.json");
   }
   readCachedLinearSelection(cwd) {
     const selectionPath = this.getLinearSelectionPath();
-    if (!(0, import_node_fs7.existsSync)(selectionPath)) {
+    if (!(0, import_node_fs8.existsSync)(selectionPath)) {
       return void 0;
     }
     try {
-      const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
+      const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
       if (!raw) return void 0;
       const parsed = JSON.parse(raw);
       const value = parsed[cwd];
@@ -13429,12 +13479,12 @@ var LinearCommandHandler = class {
   }
   writeCachedLinearSelection(cwd, title) {
     const selectionPath = this.getLinearSelectionPath();
-    const dir = import_node_path12.default.dirname(selectionPath);
-    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+    const dir = import_node_path13.default.dirname(selectionPath);
+    (0, import_node_fs8.mkdirSync)(dir, { recursive: true });
     let data = {};
-    if ((0, import_node_fs7.existsSync)(selectionPath)) {
+    if ((0, import_node_fs8.existsSync)(selectionPath)) {
       try {
-        const raw = (0, import_node_fs7.readFileSync)(selectionPath, "utf8").trim();
+        const raw = (0, import_node_fs8.readFileSync)(selectionPath, "utf8").trim();
         if (raw) {
           data = JSON.parse(raw);
         }
@@ -13443,7 +13493,7 @@ var LinearCommandHandler = class {
       }
     }
     data[cwd] = title;
-    (0, import_node_fs7.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
+    (0, import_node_fs8.writeFileSync)(selectionPath, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   }
   async lookupIssue(client, issueRef) {
@@ -13620,14 +13670,14 @@ var LinearCommandHandler = class {
     if (process.platform !== "darwin") {
       throw new Error("Screenshot capture only supports macOS.");
     }
-    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os4.default.tmpdir(), "pmate-screenshot-"));
-    const filePath = import_node_path12.default.join(dir, `screenshot-${index}.png`);
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os4.default.tmpdir(), "pmate-screenshot-"));
+    const filePath = import_node_path13.default.join(dir, `screenshot-${index}.png`);
     try {
       const code = await this.run("screencapture", ["-i", "-x", filePath], true);
       if (code !== 0) {
         throw new Error("Screenshot capture canceled or failed.");
       }
-      const buffer = await import_node_fs7.promises.readFile(filePath);
+      const buffer = await import_node_fs8.promises.readFile(filePath);
       if (buffer.length === 0) {
         throw new Error("Screenshot capture produced an empty file.");
       }
@@ -13639,7 +13689,7 @@ var LinearCommandHandler = class {
       return { buffer, mime, filename: `screenshot-${index}.${extension}` };
     } finally {
       try {
-        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -13783,17 +13833,17 @@ var LinearCommandHandler = class {
     return compact.length > limit ? `${compact.slice(0, limit)}...` : compact;
   }
   async convertToPng(buffer, ext) {
-    const dir = await import_node_fs7.promises.mkdtemp(import_node_path12.default.join(import_node_os4.default.tmpdir(), "pmate-"));
-    const inputPath = import_node_path12.default.join(dir, `clipboard.${ext}`);
-    const outputPath = import_node_path12.default.join(dir, "clipboard.png");
+    const dir = await import_node_fs8.promises.mkdtemp(import_node_path13.default.join(import_node_os4.default.tmpdir(), "pmate-"));
+    const inputPath = import_node_path13.default.join(dir, `clipboard.${ext}`);
+    const outputPath = import_node_path13.default.join(dir, "clipboard.png");
     try {
-      await import_node_fs7.promises.writeFile(inputPath, buffer);
+      await import_node_fs8.promises.writeFile(inputPath, buffer);
       const stderr = await this.runCapture(
         "sips",
         ["-s", "format", "png", inputPath, "--out", outputPath],
         true
       );
-      const out = await import_node_fs7.promises.readFile(outputPath);
+      const out = await import_node_fs8.promises.readFile(outputPath);
       if (this.detectImageMime(out) !== "image/png") {
         throw new Error(
           stderr?.trim() ? `Failed to convert clipboard ${ext} to PNG: ${stderr.trim()}` : `Failed to convert clipboard ${ext} to PNG.`
@@ -13802,7 +13852,7 @@ var LinearCommandHandler = class {
       return out;
     } finally {
       try {
-        await import_node_fs7.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs8.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -14096,7 +14146,7 @@ var LinearCommandHandler = class {
     return this.runCapture("gh", args, allowFailure, await this.getGhEnv(cwd), cwd);
   }
   resolveCwd(value) {
-    return value ? import_node_path12.default.resolve(process.cwd(), value) : process.cwd();
+    return value ? import_node_path13.default.resolve(process.cwd(), value) : process.cwd();
   }
   createOpenAiClient() {
     const config = loadPmateConfig();
@@ -14148,8 +14198,8 @@ function sleep2(ms) {
 }
 
 // src/commands/NotionCommandHandler.ts
-var import_node_fs8 = require("fs");
-var import_node_path13 = __toESM(require("path"));
+var import_node_fs9 = require("fs");
+var import_node_path14 = __toESM(require("path"));
 
 // src/services/NotionService.ts
 var NotionService = class {
@@ -14388,9 +14438,9 @@ ${indent}\`\`\``;
   static richTextToPlain(richText) {
     return richText.map((item) => item.plain_text ?? item.text?.content ?? "").join("").trim();
   }
-  static async requestJson(path27, init) {
+  static async requestJson(path28, init) {
     const token = this.getToken();
-    const response = await fetch(`${this.baseUrl}${path27}`, {
+    const response = await fetch(`${this.baseUrl}${path28}`, {
       method: init.method,
       headers: {
         Authorization: `Bearer ${token}`,
@@ -14488,16 +14538,16 @@ var NotionCommandHandler = class {
     if (!args.filePath) {
       return "";
     }
-    const resolved = import_node_path13.default.resolve(process.cwd(), args.filePath);
-    return (0, import_node_fs8.readFileSync)(resolved, "utf8");
+    const resolved = import_node_path14.default.resolve(process.cwd(), args.filePath);
+    return (0, import_node_fs9.readFileSync)(resolved, "utf8");
   }
 };
 
 // src/commands/QrcodeCommandHandler.ts
 var import_node_child_process9 = require("child_process");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_os5 = __toESM(require("os"));
-var import_node_path14 = __toESM(require("path"));
+var import_node_path15 = __toESM(require("path"));
 var import_promises4 = require("readline/promises");
 var import_jsqr = __toESM(require("jsqr"));
 var import_pngjs = require("pngjs");
@@ -14523,7 +14573,7 @@ var QrcodeCommandHandler = class {
       ui.success("QR code value:", value);
     } finally {
       try {
-        await import_node_fs9.promises.rm(dir, { recursive: true, force: true });
+        await import_node_fs10.promises.rm(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -14539,13 +14589,13 @@ var QrcodeCommandHandler = class {
     } finally {
       rl.close();
     }
-    const dir = await import_node_fs9.promises.mkdtemp(import_node_path14.default.join(import_node_os5.default.tmpdir(), "pmate-qrcode-"));
-    const filePath = import_node_path14.default.join(dir, "qrcode.png");
+    const dir = await import_node_fs10.promises.mkdtemp(import_node_path15.default.join(import_node_os5.default.tmpdir(), "pmate-qrcode-"));
+    const filePath = import_node_path15.default.join(dir, "qrcode.png");
     const code = await this.run("screencapture", ["-i", "-x", filePath], true);
     if (code !== 0) {
       throw new Error("Screenshot capture canceled or failed.");
     }
-    const buffer = await import_node_fs9.promises.readFile(filePath);
+    const buffer = await import_node_fs10.promises.readFile(filePath);
     if (buffer.length === 0) {
       throw new Error("Screenshot capture produced an empty file.");
     }
@@ -14561,7 +14611,7 @@ var QrcodeCommandHandler = class {
   async decodeQr(filePath) {
     let buffer;
     try {
-      buffer = await import_node_fs9.promises.readFile(filePath);
+      buffer = await import_node_fs10.promises.readFile(filePath);
     } catch {
       return null;
     }
@@ -14819,8 +14869,8 @@ function clampNumber(value, min, max, fallback) {
 }
 
 // src/commands/QuizCommandHandler.ts
-var import_node_fs10 = require("fs");
-var import_node_path15 = __toESM(require("path"));
+var import_node_fs11 = require("fs");
+var import_node_path16 = __toESM(require("path"));
 init_sessionStore();
 
 // src/services/QuizService.ts
@@ -15336,8 +15386,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-meta") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const metadata = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path16.default.resolve(process.cwd(), args.filePath);
+      const metadata = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       const result = await updateQuizPaperMetadata({
         apiBaseUrl,
         linkBaseUrl,
@@ -15349,8 +15399,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "append-step") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path16.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       const result = await appendQuizPaperStep({
         apiBaseUrl,
         linkBaseUrl,
@@ -15363,8 +15413,8 @@ var QuizCommandHandler = class {
       return;
     }
     if (args.action === "update-step") {
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const step = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path16.default.resolve(process.cwd(), args.filePath);
+      const step = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       step.stepId = args.stepId;
       const result = await updateQuizPaperStep({
         apiBaseUrl,
@@ -15415,8 +15465,8 @@ var QuizCommandHandler = class {
       if (targetIndex < 0) {
         throw new Error(`\u672A\u627E\u5230 stepId=${args.stepId}\uFF0C\u65E0\u6CD5\u66F4\u65B0\u8BE5\u9898\u76EE\u3002`);
       }
-      const resolvedFilePath = import_node_path15.default.resolve(process.cwd(), args.filePath);
-      const nextStep = JSON.parse((0, import_node_fs10.readFileSync)(resolvedFilePath, "utf8"));
+      const resolvedFilePath = import_node_path16.default.resolve(process.cwd(), args.filePath);
+      const nextStep = JSON.parse((0, import_node_fs11.readFileSync)(resolvedFilePath, "utf8"));
       nextStep.stepId = args.stepId;
       const nextSteps = [...basePaper.steps];
       nextSteps[targetIndex] = nextStep;
@@ -15470,13 +15520,13 @@ var import_playwright = require("playwright");
 
 // src/collectStore.ts
 var import_node_crypto3 = require("crypto");
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_os6 = __toESM(require("os"));
-var import_node_path16 = __toESM(require("path"));
+var import_node_path17 = __toESM(require("path"));
 function resolveCollectTarget(input) {
   const endpoint = input.endpoint ?? (input.source === "cc" ? "http://localhost:9223" : "http://localhost:9222");
   const sourceKey = input.source ?? `endpoint-${(0, import_node_crypto3.createHash)("sha1").update(endpoint).digest("hex").slice(0, 8)}`;
-  const rootDir = import_node_path16.default.join(import_node_os6.default.homedir(), ".pmate", "collect", sourceKey);
+  const rootDir = import_node_path17.default.join(import_node_os6.default.homedir(), ".pmate", "collect", sourceKey);
   return { sourceKey, endpoint, rootDir };
 }
 function toThreadKey(name) {
@@ -15488,7 +15538,7 @@ function toThreadKey(name) {
 async function readStoredThread(rootDir, threadKey) {
   const filePath = getThreadMetaFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if ("messages" in parsed && Array.isArray(parsed.messages)) {
       return parsed;
@@ -15506,15 +15556,15 @@ async function writeStoredThread(rootDir, thread) {
   const metaPath = getThreadMetaFilePath(rootDir, thread.threadKey);
   const messagePath = getThreadMessagesFilePath(rootDir, thread.threadKey);
   const { messages: messages2, ...meta } = thread;
-  await import_node_fs11.promises.mkdir(import_node_path16.default.dirname(metaPath), { recursive: true });
-  await import_node_fs11.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
+  await import_node_fs12.promises.mkdir(import_node_path17.default.dirname(metaPath), { recursive: true });
+  await import_node_fs12.promises.writeFile(metaPath, JSON.stringify(meta, null, 2) + "\n", "utf8");
   const body = messages2.map((message) => JSON.stringify(message)).join("\n");
-  await import_node_fs11.promises.writeFile(messagePath, `${body}${body ? "\n" : ""}`, "utf8");
+  await import_node_fs12.promises.writeFile(messagePath, `${body}${body ? "\n" : ""}`, "utf8");
 }
 async function writeStoredIndex(rootDir, index) {
-  await import_node_fs11.promises.mkdir(rootDir, { recursive: true });
-  const filePath = import_node_path16.default.join(rootDir, "index.json");
-  await import_node_fs11.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
+  await import_node_fs12.promises.mkdir(rootDir, { recursive: true });
+  const filePath = import_node_path17.default.join(rootDir, "index.json");
+  await import_node_fs12.promises.writeFile(filePath, JSON.stringify(index, null, 2) + "\n", "utf8");
 }
 function mergeMessages(existing, incoming) {
   const seenMessageIds = new Set(
@@ -15567,7 +15617,7 @@ function joinNormalized(values) {
 async function readStoredMessages(rootDir, threadKey) {
   const filePath = getThreadMessagesFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     return raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => normalizeStoredMessage(JSON.parse(line)));
   } catch {
     return [];
@@ -15576,20 +15626,20 @@ async function readStoredMessages(rootDir, threadKey) {
 async function readLegacyStoredThread(rootDir, threadKey) {
   const filePath = getLegacyThreadFilePath(rootDir, threadKey);
   try {
-    const raw = await import_node_fs11.promises.readFile(filePath, "utf8");
+    const raw = await import_node_fs12.promises.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function getThreadMetaFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
+  return import_node_path17.default.join(rootDir, "threads", `${threadKey}.json`);
 }
 function getThreadMessagesFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.jsonl`);
+  return import_node_path17.default.join(rootDir, "threads", `${threadKey}.jsonl`);
 }
 function getLegacyThreadFilePath(rootDir, threadKey) {
-  return import_node_path16.default.join(rootDir, "threads", `${threadKey}.json`);
+  return import_node_path17.default.join(rootDir, "threads", `${threadKey}.json`);
 }
 function normalizeStoredMessage(message) {
   return {
@@ -16053,7 +16103,7 @@ function pad2(value) {
 }
 
 // src/commands/ChatRoomCommandHandler.ts
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var ChatRoomCommandHandler = class {
   async handle(args) {
     const sdk = await loadChatSdk();
@@ -16103,8 +16153,8 @@ var ChatRoomCommandHandler = class {
     const a = await this.connect(sdk, args.botA, args.app, args.hubUrl, args.authBaseUrl);
     const b = await this.connect(sdk, args.botB, args.app, args.hubUrl, args.authBaseUrl);
     try {
-      const botA = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(args.botA, "utf8"));
-      const botB = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(args.botB, "utf8"));
+      const botA = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(args.botA, "utf8"));
+      const botB = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(args.botB, "utf8"));
       await a.requestFriend({ to: botB.name, message: "smoke friend request" });
       await b.acceptFriend({ to: botA.name, message: "smoke friend accept" });
       await a.sendDm({ to: botB.name, text: "smoke dm from a" });
@@ -16123,7 +16173,7 @@ var ChatRoomCommandHandler = class {
     if (!botPath) {
       throw new Error("Missing required option: --bot");
     }
-    const botKey = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(botPath, "utf8"));
+    const botKey = sdk.parsePmateBotKeyJson((0, import_node_fs13.readFileSync)(botPath, "utf8"));
     const client = sdk.createChatClient({ appId, botKey, hubUrl, authBaseUrl });
     await client.connect();
     return client;
@@ -16135,8 +16185,8 @@ async function loadChatSdk() {
 }
 
 // src/commands/AgentCommandHandler.ts
-var import_node_fs13 = require("fs");
-var import_node_path17 = __toESM(require("path"));
+var import_node_fs14 = require("fs");
+var import_node_path18 = __toESM(require("path"));
 init_AgentLlmClient();
 init_sessionStore();
 
@@ -16169,8 +16219,8 @@ function descriptorPathSegments(descriptor) {
   return ["chains", normalized.chain, "namespaces", normalized.ns, normalized.kind, normalized.name];
 }
 function buildPathUrl(baseUrl, pathSegments, query) {
-  const path27 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
-  const url = new URL(path27, baseUrl);
+  const path28 = `/${pathSegments.map((segment) => encodeURIComponent(segment)).join("/")}`;
+  const url = new URL(path28, baseUrl);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       url.searchParams.set(key, String(value));
@@ -16507,16 +16557,44 @@ var AgentCommandHandler = class {
         return;
       }
       case "call": {
-        const payload = args.filePath ? this.readJsonObjectFile(args.filePath) : args.payload;
         const client = this.createRuntimeClient({
           token,
           agentApiBaseUrl: baseUrl,
           hubBaseUrl: args.hubBaseUrl,
           from: args.from
         });
+        if (args.filePath) {
+          const filePayload = this.tryReadJsonObjectFile(args.filePath);
+          if (filePayload) {
+            if (args.payload) {
+              throw new Error("Agent call accepts --payload with --file only when --file is a binary stream input.");
+            }
+            const result3 = await client.call(
+              formatNamespacedDisplayId(args.namespace, args.name),
+              filePayload,
+              {
+                hubBaseUrl: args.hubBaseUrl,
+                from: args.from
+              }
+            );
+            this.renderCallResult(result3, args.json);
+            return;
+          }
+          const result2 = await client.callFile(
+            formatNamespacedDisplayId(args.namespace, args.name),
+            this.resolveExistingFile(args.filePath),
+            args.payload,
+            {
+              hubBaseUrl: args.hubBaseUrl,
+              from: args.from
+            }
+          );
+          this.renderCallResult(result2, args.json);
+          return;
+        }
         const result = await client.call(
           formatNamespacedDisplayId(args.namespace, args.name),
-          payload,
+          args.payload,
           {
             hubBaseUrl: args.hubBaseUrl,
             from: args.from
@@ -16602,11 +16680,11 @@ var AgentCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16617,11 +16695,31 @@ var AgentCommandHandler = class {
   readJsonObjectFile(filePath) {
     const parsed = this.readJsonFile(filePath);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
+      const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
       throw new Error(`Invalid JSON in ${absolutePath}: expected an object`);
     }
     return parsed;
   }
+  tryReadJsonObjectFile(filePath) {
+    const absolutePath = this.resolveExistingFile(filePath);
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    try {
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("expected an object");
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  resolveExistingFile(filePath) {
+    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    return absolutePath;
+  }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
       method,
@@ -16701,8 +16799,8 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/RunnerCommandHandler.ts
-var import_node_fs14 = require("fs");
-var import_node_path18 = __toESM(require("path"));
+var import_node_fs15 = require("fs");
+var import_node_path19 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
 var RunnerCommandHandler = class {
@@ -16797,11 +16895,11 @@ var RunnerCommandHandler = class {
     }).token;
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16920,8 +17018,8 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs15 = require("fs");
-var import_node_path19 = __toESM(require("path"));
+var import_node_fs16 = require("fs");
+var import_node_path20 = __toESM(require("path"));
 var StoreCommandHandler = class {
   async handle(args) {
     if (args.scope === "namespace") {
@@ -17063,11 +17161,11 @@ var StoreCommandHandler = class {
     return payload.data ?? [];
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path20.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17119,14 +17217,14 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs17 = require("fs");
-var import_node_path21 = __toESM(require("path"));
+var import_node_fs18 = require("fs");
+var import_node_path22 = __toESM(require("path"));
 init_sessionStore();
 
 // src/appIcon.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_os7 = __toESM(require("os"));
-var import_node_path20 = __toESM(require("path"));
+var import_node_path21 = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
 init_namespacedRef();
 var ANDROID_ICON_SPECS = [
@@ -17231,13 +17329,13 @@ function createAppIconExportPlans(input) {
     if (!input.outDir) {
       throw new Error("App icon preset export requires --out-dir.");
     }
-    const outDir = import_node_path20.default.resolve(input.cwd, input.outDir);
-    (0, import_node_fs16.mkdirSync)(outDir, { recursive: true });
+    const outDir = import_node_path21.default.resolve(input.cwd, input.outDir);
+    (0, import_node_fs17.mkdirSync)(outDir, { recursive: true });
     return specs.map((spec) => ({
       width: spec.width,
       height: spec.height,
       format: "png",
-      outputPath: import_node_path20.default.join(
+      outputPath: import_node_path21.default.join(
         outDir,
         `${namespace}-${objectId}-${spec.name}-${spec.width}x${spec.height}.png`
       )
@@ -17250,8 +17348,8 @@ function createAppIconExportPlans(input) {
   if (!input.output) {
     throw new Error("Single-size app icon export requires --output.");
   }
-  const resolvedOutput = import_node_path20.default.resolve(input.cwd, input.output);
-  (0, import_node_fs16.mkdirSync)(import_node_path20.default.dirname(resolvedOutput), { recursive: true });
+  const resolvedOutput = import_node_path21.default.resolve(input.cwd, input.output);
+  (0, import_node_fs17.mkdirSync)(import_node_path21.default.dirname(resolvedOutput), { recursive: true });
   return [
     {
       width: input.width,
@@ -17265,7 +17363,7 @@ async function exportAppIcon(icon, plans) {
   const svg = await resolveAppIconSvg(icon);
   for (const plan of plans) {
     const bytes = await renderAppIcon(svg, plan.width, plan.height, plan.format);
-    (0, import_node_fs16.writeFileSync)(plan.outputPath, bytes);
+    (0, import_node_fs17.writeFileSync)(plan.outputPath, bytes);
   }
 }
 async function renderAppIconVariant(input) {
@@ -17273,9 +17371,9 @@ async function renderAppIconVariant(input) {
   const bytes = await renderAppIcon(svg, input.width, input.height, input.format);
   let outputPath;
   if (input.output) {
-    outputPath = import_node_path20.default.resolve(input.cwd, input.output);
-    (0, import_node_fs16.mkdirSync)(import_node_path20.default.dirname(outputPath), { recursive: true });
-    (0, import_node_fs16.writeFileSync)(outputPath, bytes);
+    outputPath = import_node_path21.default.resolve(input.cwd, input.output);
+    (0, import_node_fs17.mkdirSync)(import_node_path21.default.dirname(outputPath), { recursive: true });
+    (0, import_node_fs17.writeFileSync)(outputPath, bytes);
   }
   if (input.name) {
     return {
@@ -17296,7 +17394,7 @@ async function renderAppIconVariant(input) {
   };
 }
 async function loadAppIconVariantFile(input) {
-  const absolutePath = import_node_path20.default.resolve(input.cwd, input.filePath);
+  const absolutePath = import_node_path21.default.resolve(input.cwd, input.filePath);
   const format = inferVariantFormatFromPath(absolutePath);
   return {
     value: input.name ? await uploadAppIconVariantAsset({
@@ -17305,7 +17403,7 @@ async function loadAppIconVariantFile(input) {
       name: input.name,
       format,
       sourcePath: absolutePath
-    }) : createImageDataUrl((0, import_node_fs16.readFileSync)(absolutePath), format),
+    }) : createImageDataUrl((0, import_node_fs17.readFileSync)(absolutePath), format),
     format,
     absolutePath
   };
@@ -17364,7 +17462,7 @@ function shouldAutoGenerateDefaultVariant(icon) {
   return looksLikeSvgMarkup(icon) || looksLikeSvgUrl(icon);
 }
 function inferVariantFormatFromPath(filePath) {
-  const ext = import_node_path20.default.extname(filePath).toLowerCase();
+  const ext = import_node_path21.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".png":
       return "png";
@@ -17435,13 +17533,13 @@ async function uploadAppIconVariantAsset(input) {
     await AliyunService.uploadFile(sourcePath, DEFAULT_APP_ICON_VARIANT_BUCKET, objectKey);
   } finally {
     if (shouldCleanup) {
-      (0, import_node_fs16.rmSync)(import_node_path20.default.dirname(sourcePath), { recursive: true, force: true });
+      (0, import_node_fs17.rmSync)(import_node_path21.default.dirname(sourcePath), { recursive: true, force: true });
     }
   }
   return `${DEFAULT_APP_ICON_VARIANT_PUBLIC_BASE_URL}/${objectKey}`;
 }
 function buildAppIconVariantObjectKey(input) {
-  return import_node_path20.default.posix.join(
+  return import_node_path21.default.posix.join(
     "apps",
     `${resolveAppIconAssetStem(input.icon, input.appRef)}-${input.name}.${extensionForIconFormat(input.format)}`
   );
@@ -17450,8 +17548,8 @@ function resolveAppIconAssetStem(icon, appRef) {
   if (icon) {
     try {
       const url = new URL(icon);
-      const ext = import_node_path20.default.posix.extname(url.pathname);
-      const basename = import_node_path20.default.posix.basename(url.pathname, ext);
+      const ext = import_node_path21.default.posix.extname(url.pathname);
+      const basename = import_node_path21.default.posix.basename(url.pathname, ext);
       const normalized = sanitizeAppIconAssetStem(basename);
       if (normalized) {
         return normalized;
@@ -17480,9 +17578,9 @@ function writeTempAppIconVariantFile(objectKey, format, bytes) {
   if (!bytes) {
     throw new Error("App icon variant upload requires bytes or a source file.");
   }
-  const tempDir = (0, import_node_fs16.mkdtempSync)(import_node_path20.default.join(import_node_os7.default.tmpdir(), "pmate-app-icon-"));
-  const tempPath = import_node_path20.default.join(tempDir, import_node_path20.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
-  (0, import_node_fs16.writeFileSync)(tempPath, bytes);
+  const tempDir = (0, import_node_fs17.mkdtempSync)(import_node_path21.default.join(import_node_os7.default.tmpdir(), "pmate-app-icon-"));
+  const tempPath = import_node_path21.default.join(tempDir, import_node_path21.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
+  (0, import_node_fs17.writeFileSync)(tempPath, bytes);
   return tempPath;
 }
 
@@ -17691,10 +17789,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17704,10 +17802,10 @@ var AppCommandHandler = class {
   }
   async preparePayload(filePath, appRef) {
     const absolutePath = this.resolveFilePath(filePath);
-    return prepareAppPayload(this.readJsonFile(filePath), import_node_path21.default.dirname(absolutePath), { appRef });
+    return prepareAppPayload(this.readJsonFile(filePath), import_node_path22.default.dirname(absolutePath), { appRef });
   }
   resolveFilePath(filePath) {
-    return import_node_path21.default.resolve(process.cwd(), filePath);
+    return import_node_path22.default.resolve(process.cwd(), filePath);
   }
   async request(baseUrl, token, method, pathname, body) {
     const response = await fetch(`${baseUrl}${pathname}`, {
@@ -17824,15 +17922,15 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_promises5 = require("fs/promises");
-var import_node_path23 = __toESM(require("path"));
+var import_node_path24 = __toESM(require("path"));
 var import_promises6 = require("readline/promises");
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_os8 = __toESM(require("os"));
-var import_node_path22 = __toESM(require("path"));
+var import_node_path23 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
 var import_node_readline = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
@@ -18226,18 +18324,18 @@ var ServiceRuntimeRunner = class {
   }
   resolveRepoRoot(service, cwd) {
     if (cwd) {
-      return import_node_path22.default.resolve(process.cwd(), cwd);
+      return import_node_path23.default.resolve(process.cwd(), cwd);
     }
     const repository = this.getType(service) === "vite" || this.getType(service) === "static" ? this.getSite(service).repository?.trim() : this.getType(service) === "fc" ? this.getFc(service).repository?.trim() : this.getType(service) === "ios" || this.getType(service) === "android" ? void 0 : this.getNetwork(service).repository?.trim();
     if (repository) {
       const repoName = repository.replace(/\/+$/, "").split("/").pop()?.replace(/\.git$/i, "");
       if (repoName) {
         const candidates = [
-          import_node_path22.default.join(import_node_os8.default.homedir(), "dev", "pmate", repoName),
-          import_node_path22.default.join(import_node_os8.default.homedir(), "dev", "pmate-envs", repoName)
+          import_node_path23.default.join(import_node_os8.default.homedir(), "dev", "pmate", repoName),
+          import_node_path23.default.join(import_node_os8.default.homedir(), "dev", "pmate-envs", repoName)
         ];
         for (const candidate of candidates) {
-          if ((0, import_node_fs18.existsSync)(candidate)) {
+          if ((0, import_node_fs19.existsSync)(candidate)) {
             return candidate;
           }
         }
@@ -18251,12 +18349,12 @@ var ServiceRuntimeRunner = class {
     if (!dir) {
       throw new Error(`Missing service dir for ${service.id}`);
     }
-    return import_node_path22.default.resolve(repoRoot, dir);
+    return import_node_path23.default.resolve(repoRoot, dir);
   }
   async deployVite(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+    if (!(0, import_node_fs19.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -18265,8 +18363,8 @@ var ServiceRuntimeRunner = class {
       throw new Error(`Missing package name in ${packageJsonPath}`);
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], this.resolveRepoRoot(service, options.cwd));
-    const distDir = import_node_path22.default.join(appDir, "dist");
-    if (!(0, import_node_fs18.existsSync)(distDir)) {
+    const distDir = import_node_path23.default.join(appDir, "dist");
+    if (!(0, import_node_fs19.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const site = this.getSite(service);
@@ -18278,8 +18376,8 @@ var ServiceRuntimeRunner = class {
   }
   async deployStatic(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
-    const srcDir = import_node_path22.default.join(appDir, "src");
-    if (!(0, import_node_fs18.existsSync)(srcDir)) {
+    const srcDir = import_node_path23.default.join(appDir, "src");
+    if (!(0, import_node_fs19.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const site = this.getSite(service);
@@ -18294,8 +18392,8 @@ var ServiceRuntimeRunner = class {
     this.validateFcConfig(service, fc);
     const repoRoot = this.resolveRepoRoot(service);
     const appDir = this.resolveLocalDir(service);
-    const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+    if (!(0, import_node_fs19.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -18348,15 +18446,15 @@ var ServiceRuntimeRunner = class {
     const repoRoot = this.resolveRepoRoot(service, options.cwd);
     const appDir = this.resolveLocalDir(service, options.cwd);
     await this.ensurePnpmWorkspaceRoot(repoRoot);
-    const configPath = import_node_path22.default.join(appDir, fc.configFile ?? "s.yaml");
-    if (!(0, import_node_fs18.existsSync)(configPath)) {
+    const configPath = import_node_path23.default.join(appDir, fc.configFile ?? "s.yaml");
+    if (!(0, import_node_fs19.existsSync)(configPath)) {
       throw new Error(`Missing FC config file at ${configPath}`);
     }
-    const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
+    const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+    if (!(0, import_node_fs19.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
-    const rawConfig = (0, import_node_fs18.readFileSync)(configPath, "utf8");
+    const rawConfig = (0, import_node_fs19.readFileSync)(configPath, "utf8");
     if (!rawConfig.includes(fc.functionName)) {
       throw new Error(`FC config ${configPath} does not mention functionName ${fc.functionName}`);
     }
@@ -18570,7 +18668,7 @@ var ServiceRuntimeRunner = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = exposeType === "websocket" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs18.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs19.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.${("domain" in network ? network.domain?.trim() : void 0) || "pmate.chat"}`;
       const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
       const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
@@ -18602,11 +18700,11 @@ var ServiceRuntimeRunner = class {
     }
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
-      const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-      if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
+      const packageJsonPath = import_node_path23.default.join(appDir, "package.json");
+      if (!(0, import_node_fs19.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs18.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs19.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -19030,9 +19128,9 @@ var ServiceRuntimeRunner = class {
     return tokens;
   }
   readPathValue(source, pathExpr) {
-    const path27 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
+    const path28 = pathExpr.split(".").map((segment) => segment.trim()).filter(Boolean);
     let cursor = source;
-    for (const segment of path27) {
+    for (const segment of path28) {
       if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
         return void 0;
       }
@@ -19075,12 +19173,12 @@ var ServiceRuntimeRunner = class {
   }
   resolveTemplatePath(templateName) {
     const candidates = [
-      import_node_path22.default.join(__dirname, "..", "templates", templateName),
-      import_node_path22.default.join(__dirname, "..", "src", "templates", templateName),
-      import_node_path22.default.join(__dirname, "templates", templateName)
+      import_node_path23.default.join(__dirname, "..", "templates", templateName),
+      import_node_path23.default.join(__dirname, "..", "src", "templates", templateName),
+      import_node_path23.default.join(__dirname, "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs18.existsSync)(candidate)) {
+      if ((0, import_node_fs19.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -19112,7 +19210,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs18.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs19.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -19121,7 +19219,7 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs18.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs19.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   validateFcConfig(service, fc) {
@@ -19148,8 +19246,8 @@ var ServiceRuntimeRunner = class {
     }
   }
   async ensurePnpmWorkspaceRoot(repoRoot) {
-    const workspacePath = import_node_path22.default.join(repoRoot, "pnpm-workspace.yaml");
-    if (!(0, import_node_fs18.existsSync)(workspacePath)) {
+    const workspacePath = import_node_path23.default.join(repoRoot, "pnpm-workspace.yaml");
+    if (!(0, import_node_fs19.existsSync)(workspacePath)) {
       throw new Error(`Missing pnpm-workspace.yaml at ${workspacePath}`);
     }
   }
@@ -19218,16 +19316,16 @@ var ServiceRuntimeRunner = class {
     if (!privateKeyPath) {
       throw new Error("Missing ssl.prv in ~/.pmate/config.yaml.");
     }
-    if (!(0, import_node_fs18.existsSync)(certificatePath)) {
+    if (!(0, import_node_fs19.existsSync)(certificatePath)) {
       throw new Error(`SSL certificate file not found: ${certificatePath}`);
     }
-    if (!(0, import_node_fs18.existsSync)(privateKeyPath)) {
+    if (!(0, import_node_fs19.existsSync)(privateKeyPath)) {
       throw new Error(`SSL private key file not found: ${privateKeyPath}`);
     }
     return {
       certName: host,
-      certificate: (0, import_node_fs18.readFileSync)(certificatePath, "utf8"),
-      privateKey: (0, import_node_fs18.readFileSync)(privateKeyPath, "utf8")
+      certificate: (0, import_node_fs19.readFileSync)(certificatePath, "utf8"),
+      privateKey: (0, import_node_fs19.readFileSync)(privateKeyPath, "utf8")
     };
   }
   resolveFcProtocol(fc, certConfig) {
@@ -19555,7 +19653,7 @@ var ServiceCommandHandler = class {
             format: "dotenv"
           }
         );
-        const outputPath = import_node_path23.default.resolve(process.cwd(), args.output);
+        const outputPath = import_node_path24.default.resolve(process.cwd(), args.output);
         await (0, import_promises5.writeFile)(outputPath, payload.content, "utf8");
         ui.success(`Wrote env file for ${args.appId} to ${outputPath}`);
         this.renderJson({ ...payload, output: outputPath }, args.json);
@@ -19584,11 +19682,11 @@ var ServiceCommandHandler = class {
     return (baseUrl || process.env.PMATE_APPS_API_BASE_URL || "https://apps-api.pmate.chat").replace(/\/+$/, "");
   }
   readJsonFile(filePath) {
-    const absolutePath = import_node_path23.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path24.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19970,9 +20068,9 @@ var RoleCommandHandler = class {
 };
 
 // src/commands/AccountCommandHandler.ts
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_node_crypto4 = require("crypto");
-var import_node_path24 = __toESM(require("path"));
+var import_node_path25 = __toESM(require("path"));
 init_sessionStore();
 var AccountCommandHandler = class {
   async handle(args) {
@@ -19980,9 +20078,9 @@ var AccountCommandHandler = class {
       case "bot-keygen": {
         const keyFile = this.generateBotKeyFile(args.app, args.name);
         const outPath = args.out ? this.resolveFilePath(args.out) : this.resolveDefaultBotKeyPath(args.app, args.name);
-        (0, import_node_fs20.mkdirSync)(import_node_path24.default.dirname(outPath), { recursive: true });
-        (0, import_node_fs20.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-        (0, import_node_fs20.chmodSync)(outPath, 384);
+        (0, import_node_fs21.mkdirSync)(import_node_path25.default.dirname(outPath), { recursive: true });
+        (0, import_node_fs21.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
+        (0, import_node_fs21.chmodSync)(outPath, 384);
         if (!args.json) {
           ui.success(`Bot key saved to ${outPath}`);
         }
@@ -20426,10 +20524,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing visible apps input");
     }
     const absolutePath = this.resolveFilePath(args.filePath);
-    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20443,10 +20541,10 @@ var AccountCommandHandler = class {
     return parsed;
   }
   resolveFilePath(filePath) {
-    return import_node_path24.default.resolve(process.cwd(), filePath);
+    return import_node_path25.default.resolve(process.cwd(), filePath);
   }
   resolveDefaultBotKeyPath(app, name) {
-    return import_node_path24.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
+    return import_node_path25.default.join(this.homeDir(), ".pmate", "bots", app, `${name}.bot-key.json`);
   }
   homeDir() {
     return process.env.HOME || process.env.USERPROFILE || process.cwd();
@@ -20469,10 +20567,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing bot key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
       throw new Error(`Bot key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs21.readFileSync)(absolutePath, "utf8"));
     if (parsed.type !== "pmate-bot-key" || parsed.version !== 1 || parsed.algorithm !== "ed25519" || !parsed.publicKey || !parsed.privateKey) {
       throw new Error(`Invalid PMate bot key file: ${absolutePath}`);
     }
@@ -20524,8 +20622,8 @@ function encodePathSegment(value) {
 }
 
 // src/commands/OrgCommandHandler.ts
-var import_node_fs21 = require("fs");
-var import_node_path25 = __toESM(require("path"));
+var import_node_fs22 = require("fs");
+var import_node_path26 = __toESM(require("path"));
 init_sessionStore();
 var OrgCommandHandler = class {
   async handle(args) {
@@ -20696,11 +20794,11 @@ var OrgCommandHandler = class {
     if (!filePath) {
       throw new Error(`Missing ${itemLabel} input`);
     }
-    const absolutePath = import_node_path25.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
+    const absolutePath = import_node_path26.default.resolve(process.cwd(), filePath);
+    if (!(0, import_node_fs22.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs22.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20958,15 +21056,9 @@ function parseAgentArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--payload":
-          if (filePath) {
-            throw new Error("Agent call accepts either --payload or --file, not both.");
-          }
           payload = parseJsonObject(requireValue(rest, token), token);
           break;
         case "--file":
-          if (payload) {
-            throw new Error("Agent call accepts either --payload or --file, not both.");
-          }
           filePath = requireValue(rest, token);
           break;
         case "--base-url":
@@ -23614,7 +23706,7 @@ function requireValue12(tokens, option) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs22.readFileSync)(import_node_path26.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs23.readFileSync)(import_node_path27.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -23709,6 +23801,7 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  rename --from <id> --to <id> --ns <namespace> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  move --from <id> --ns <namespace> --to-ns <namespace> [--to <id>] [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  call <ns:objectId> [--payload <json>] [--file <path>] [--base-url <url>] [--hub-base-url <url>] [--from <id>] [--json]")}`,
+  `  ${import_chalk4.default.gray("                    --file reads JSON payload files, or streams binary files such as .wav to ASR agents; --payload becomes stream params for binary files")}`,
   `  ${import_chalk4.default.gray("                  delete <ns:objectId> [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  list defaults to all namespaces; create defaults to namespace: pmate; default base URL: https://agent-api.pmate.chat; call uses pmate:factory session and default hub: https://hub.pmate.chat")}`,
   `  ${import_chalk4.default.cyan("runner")}           Manage runner registry entries via agent-api`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/cli",
-  "version": "0.24.14",
+  "version": "0.24.15",
   "description": "CLI utilities for the pMate project",
   "license": "MIT",
   "bin": {