@mrgoonie/multix 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.15.0](https://github.com/mrgoonie/multix-cli/compare/v0.14.1...v0.15.0) (2026-10-11)
+
+
+### Added
+
+* **mcp:** add Streamable HTTP MCP server for Cloudflare Workers ([#91](https://github.com/mrgoonie/multix-cli/issues/91)) ([45a662c](https://github.com/mrgoonie/multix-cli/commit/45a662c638d9211009e429bc129edc913a010729))
+
+## [0.14.1](https://github.com/mrgoonie/multix-cli/compare/v0.14.0...v0.14.1) (2026-10-11)
+
+
+### Fixed
+
+* **replicate:** harden output downloads, --prefer-wait and create errors ([#88](https://github.com/mrgoonie/multix-cli/issues/88)) ([e29e81d](https://github.com/mrgoonie/multix-cli/commit/e29e81d7b3e54e5b65f4905c1adb629f2d4df6c4))
+
 ## [0.14.0](https://github.com/mrgoonie/multix-cli/compare/v0.13.0...v0.14.0) (2026-10-11)
 
 

package/README.md

@@ -98,6 +98,7 @@ Set at least one provider key. Add to `.env` in your project root or `~/.multix/
 | `CLOUDFLARE_AI_IMAGE_MODEL` | No | Image model setting; only `@cf/black-forest-labs/flux-1-schnell` is accepted |
 | `CLOUDFLARE_AI_TTS_MODEL` | No | Speech model setting; only `@cf/myshell-ai/melotts` is accepted |
 | `MULTIX_OUTPUT_DIR` | No | Override default output dir (`./multix-output`) |
+| `MULTIX_MAX_DOWNLOAD_MB` | No | Size limit per downloaded Replicate output file (default `2048`) |
 | `MULTIX_IMAGE_FORMAT` | No | `webp` (default) or `original` to keep provider image format/quality |
 | `OPENROUTER_IMAGE_MODEL` | No | Default OpenRouter model |
 | `OPENROUTER_FALLBACK_MODELS` | No | Comma-separated fallback model ids |
@@ -556,9 +557,11 @@ multix replicate cancel <prediction-id>
 
 **Notes:**
 - Auth: `Authorization: Bearer $REPLICATE_API_TOKEN` (`REPLICATE_API_KEY` accepted as fallback).
-- Default behavior waits with bounded polling; `--async` prints the prediction id plus resume/cancel commands. `--prefer-wait` sends `Prefer: wait=N` and keeps polling if the job is still running.
+- Default behavior waits with bounded polling; `--async` prints the prediction id plus resume/cancel commands. `--prefer-wait [seconds]` (an integer from 1 to 60; the bare flag means 60) sends `Prefer: wait=N` and keeps polling if the job is still running. Put the prompt before a bare `--prefer-wait`; any other value is rejected.
 - Only `succeeded` exits 0; `failed`, `canceled`, and `aborted` exit non-zero with Replicate's error.
+- If submitting fails with a network error, timeout, 5xx, or an unreadable 2xx response, the prediction may still have been created and billed (Replicate has no idempotency key). Check https://replicate.com/predictions before retrying.
 - Every media URL in the output (string, list, or nested object) is downloaded as `replicate-<id8>-NN.<ext>` (`<id8>` = first 8 characters of the prediction id); text outputs are printed. Output URLs expire, so download promptly. If any download fails, the command exits non-zero and prints `multix replicate status <id> --download` to retry.
+- Output downloads use `https://` only and refuse `localhost` and loopback, private, link-local, or other special-purpose IP literals (hostnames are not resolved), including on redirects. Files are written to `<path>.part` and renamed when complete, so a failed download never clobbers an existing file. Hosts other than `replicate.delivery` are downloaded with a warning that names the host. Each file is capped at `MULTIX_MAX_DOWNLOAD_MB` (default 2048).
 - `replicate image` converts images to WebP by default; `--image-format original`, `--no-webp`, `MULTIX_IMAGE_FORMAT=original`, an explicit `--output-format`, or a non-`.webp` `--output` extension keeps the provider format.
 - Local files (`--image`, `--file key=path`) up to 256 KB are inlined as data URIs; larger files (< 100 MB) are uploaded via the Replicate Files API.
 
@@ -671,6 +674,37 @@ Thumbnail detection is automatic: if the provider response includes any of `cove
 
 Cloudflare video is intentionally separate: it has no thumbnail flags, and `generate-video --wait` already saves the completed MP4. See [`multix cloudflare`](#multix-cloudflare) for its exact polling and download behavior.
 
+## Remote MCP server (Cloudflare Workers)
+
+`worker/` contains an optional, stateless MCP server that exposes remote-safe
+image and video tools over Streamable HTTP at `/mcp`, for agents that cannot
+run the CLI locally. It is a separate package and is not included in the npm
+CLI.
+
+- Tools: `multix_list_providers`, `multix_generate_image` (Replicate, Atlas
+  Cloud), `multix_generate_video` (Replicate, Atlas Cloud, HeyGen, Cloudflare
+  AI Gateway; returns an ID without blocking), `multix_prediction_status`,
+  `multix_prediction_cancel` (Replicate). Results are provider URLs, not bytes.
+- Auth: `Authorization: Bearer <MCP_AUTH_TOKEN>` (at least 32 characters; the
+  server returns `503` if it is unset). `/health` is public.
+- Single-tenant: provider keys are Worker secrets, and every caller spends the
+  deployer's credits. Limit exposure with `MULTIX_MCP_ALLOWED_PROVIDERS`,
+  `MULTIX_MCP_ALLOWED_MODELS`, `MULTIX_MCP_MAX_OUTPUTS`,
+  `MULTIX_MCP_MAX_VIDEO_SECONDS` (also sent as `min(5, cap)` when a caller
+  omits `duration`), `MULTIX_MCP_ALLOWED_RESOLUTIONS` (default
+  `480p,720p,1080p`), `MULTIX_MCP_ALLOWED_ORIGINS` (browser origins, with
+  CORS), and the approximate per-IP rate limiter. JSON-RPC batches are
+  rejected.
+
+```bash
+npm ci --prefix worker
+cd worker && openssl rand -hex 32 | npx wrangler secret put MCP_AUTH_TOKEN
+npx wrangler secret put REPLICATE_API_TOKEN   # and any other provider keys
+cd .. && npm run deploy:mcp                   # or: npm run dev:mcp (local, port 8787)
+```
+
+Full guide: [Remote MCP server](https://multix.zuey.me/guides/mcp-server/).
+
 ## Troubleshooting
 
 **No API key found:** Run `multix check` — it prints setup instructions.

package/dist/cli.js

@@ -50,9 +50,10 @@ var init_errors = __esm({
         super(message);
         this.code = code;
         this.name = "MultixError";
-        if (Error.captureStackTrace) {
-          Error.captureStackTrace(this, this.constructor);
-        }
+        Error.captureStackTrace?.(
+          this,
+          this.constructor
+        );
       }
       code;
     };
@@ -640,8 +641,8 @@ function predictionErrorMessage(error) {
   }
   return "";
 }
-function collectOutputs(prediction2) {
-  const raw = prediction2.outputs ?? prediction2.output;
+function collectOutputs(prediction) {
+  const raw = prediction.outputs ?? prediction.output;
   const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
   const out = [];
   for (const item of list) {
@@ -751,16 +752,16 @@ function defaultExtensionFor(category) {
       return "bin";
   }
 }
-function classifyOutputs(prediction2) {
-  const outputs = collectOutputs(prediction2);
+function classifyOutputs(prediction) {
+  const outputs = collectOutputs(prediction);
   if (outputs.length === 0) return { mode: "empty" };
   const urls = outputs.filter(isMediaOutput);
   const texts = outputs.filter((o) => !isMediaOutput(o));
   if (urls.length === 0) return { mode: "text", texts };
   return { mode: "media", urls, texts };
 }
-function hasNsfwFlag(prediction2) {
-  return Array.isArray(prediction2.has_nsfw_contents) && prediction2.has_nsfw_contents.some(Boolean);
+function hasNsfwFlag(prediction) {
+  return Array.isArray(prediction.has_nsfw_contents) && prediction.has_nsfw_contents.some(Boolean);
 }
 function outputFileName(predictionId, index, ext) {
   const prefix = predictionId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 8) || "output";
@@ -773,10 +774,10 @@ var DEFAULT_UPLOAD_TIMEOUT_MS = 3e5;
 var CATALOG_TIMEOUT_MS = 15e3;
 var PREDICTION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var AtlasPredictionFailedError = class extends ProviderError {
-  constructor(prediction2) {
-    const reason = predictionErrorMessage(prediction2.error) || `status "${prediction2.status}"`;
-    super(`Atlas Cloud prediction ${prediction2.id} failed: ${reason}`, ATLAS_PROVIDER);
-    this.prediction = prediction2;
+  constructor(prediction) {
+    const reason = predictionErrorMessage(prediction.error) || `status "${prediction.status}"`;
+    super(`Atlas Cloud prediction ${prediction.id} failed: ${reason}`, ATLAS_PROVIDER);
+    this.prediction = prediction;
     this.name = "AtlasPredictionFailedError";
   }
   prediction;
@@ -786,11 +787,11 @@ function assertValidPredictionId(id) {
     throw new ValidationError(`Invalid Atlas Cloud prediction id: "${id}"`);
   }
 }
-function assertPredictionSucceeded(prediction2) {
-  if (isFailureStatus(prediction2.status)) throw new AtlasPredictionFailedError(prediction2);
-  if (!isSuccessStatus(prediction2.status)) {
+function assertPredictionSucceeded(prediction) {
+  if (isFailureStatus(prediction.status)) throw new AtlasPredictionFailedError(prediction);
+  if (!isSuccessStatus(prediction.status)) {
     throw new ProviderError(
-      `Atlas Cloud prediction ${prediction2.id} is not finished (status "${prediction2.status}")`,
+      `Atlas Cloud prediction ${prediction.id} is not finished (status "${prediction.status}")`,
       ATLAS_PROVIDER
     );
   }
@@ -1120,40 +1121,168 @@ import fs8 from "fs";
 import path7 from "path";
 
 // src/core/http-client.ts
-init_errors();
-import { once } from "events";
 import fs3 from "fs";
 import path3 from "path";
+import { Readable } from "stream";
 import { pipeline } from "stream/promises";
+init_errors();
+init_redact();
 async function httpJson(opts) {
   return fetchJson(opts);
 }
-async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers2) {
-  fs3.mkdirSync(path3.dirname(dest), { recursive: true });
-  let response;
-  try {
-    response = await globalThis.fetch(url, {
-      signal: AbortSignal.timeout(timeoutMs),
-      ...headers2 ? { headers: headers2 } : {}
+var MAX_DOWNLOAD_ENV = "MULTIX_MAX_DOWNLOAD_MB";
+var DEFAULT_MAX_DOWNLOAD_MB = 2048;
+var MAX_REDIRECTS = 5;
+function formatMb2(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var DownloadTooLargeError = class extends MultixError {
+  constructor(limitBytes, url) {
+    super(
+      `Download from ${redactUrl(url)} exceeds the ${formatMb2(limitBytes)} limit (set ${MAX_DOWNLOAD_ENV} to change it)`,
+      "DOWNLOAD_TOO_LARGE"
+    );
+    this.limitBytes = limitBytes;
+    this.name = "DownloadTooLargeError";
+  }
+  limitBytes;
+};
+function maxDownloadBytes() {
+  const raw = resolveKey(MAX_DOWNLOAD_ENV)?.trim();
+  if (!raw) return DEFAULT_MAX_DOWNLOAD_MB * 1024 * 1024;
+  const mb = Number(raw);
+  if (!Number.isFinite(mb) || mb <= 0) {
+    throw new ConfigError(
+      `${MAX_DOWNLOAD_ENV} must be a positive number of megabytes, got "${raw}"`
+    );
+  }
+  const bytes = Math.floor(mb * 1024 * 1024);
+  if (bytes < 1) {
+    throw new ConfigError(`${MAX_DOWNLOAD_ENV} is too small: "${raw}" MB is less than one byte`);
+  }
+  return bytes;
+}
+async function fetchWithValidatedRedirects(url, opts = {}) {
+  const doFetch = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+  const { validateUrl, signal } = opts;
+  const maxRedirects = opts.maxRedirects ?? MAX_REDIRECTS;
+  let current = url;
+  let headers2 = opts.headers;
+  for (let hop = 0; ; hop++) {
+    await validateUrl?.(current);
+    let response;
+    try {
+      response = await doFetch(current, {
+        ...signal ? { signal } : {},
+        ...headers2 ? { headers: headers2 } : {},
+        ...validateUrl ? { redirect: "manual" } : {}
+      });
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      throw new HttpError(0, msg, current);
+    }
+    const location = response.headers.get("location");
+    if (!validateUrl || !location || response.status < 300 || response.status >= 400) {
+      return { response, url: current };
+    }
+    await response.body?.cancel().catch(() => {
     });
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
+    if (hop >= maxRedirects) {
+      throw new HttpError(response.status, `too many redirects (over ${maxRedirects})`, current);
+    }
+    let next;
+    try {
+      next = new URL(location, current);
+    } catch {
+      throw new HttpError(response.status, "redirect with a malformed Location header", current);
+    }
+    if (next.origin !== new URL(current).origin) headers2 = void 0;
+    current = next.toString();
+  }
+}
+function removeQuietly(file) {
+  try {
+    fs3.rmSync(file, { force: true });
+  } catch {
   }
+}
+function replaceFile(from, to) {
+  try {
+    fs3.renameSync(from, to);
+  } catch (err2) {
+    const code = err2.code;
+    const existing = fs3.statSync(to, { throwIfNoEntry: false });
+    if (!existing?.isFile() || code !== "EEXIST" && code !== "EPERM" && code !== "EACCES") {
+      throw err2;
+    }
+    fs3.rmSync(to, { force: true });
+    fs3.renameSync(from, to);
+  }
+}
+async function downloadToFile(url, opts) {
+  const signal = AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  const { response, url: finalUrl } = await fetchWithValidatedRedirects(url, {
+    signal,
+    headers: opts.headers,
+    validateUrl: opts.validateUrl,
+    fetch: opts.fetch
+  });
   if (!response.ok) {
-    throw new HttpError(response.status, "(download failed)", url);
+    await response.body?.cancel().catch(() => {
+    });
+    throw new HttpError(response.status, "(download failed)", finalUrl);
   }
   if (!response.body) {
-    throw new HttpError(0, "Response body is null", url);
+    throw new HttpError(0, "Response body is null", finalUrl);
+  }
+  const body = response.body;
+  const { maxBytes } = opts;
+  const declared = Number(response.headers.get("content-length") ?? Number.NaN);
+  if (maxBytes !== void 0 && Number.isFinite(declared) && declared > maxBytes) {
+    await body.cancel().catch(() => {
+    });
+    throw new DownloadTooLargeError(maxBytes, finalUrl);
+  }
+  let dest;
+  try {
+    dest = typeof opts.dest === "function" ? opts.dest(response) : opts.dest;
+    fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+  } catch (err2) {
+    await body.cancel().catch(() => {
+    });
+    throw err2;
+  }
+  let bytes = 0;
+  async function* countBytes(source) {
+    for await (const chunk of source) {
+      bytes += chunk.byteLength;
+      if (maxBytes !== void 0 && bytes > maxBytes)
+        throw new DownloadTooLargeError(maxBytes, finalUrl);
+      yield chunk;
+    }
   }
-  const fileStream = fs3.createWriteStream(dest);
+  const part = `${dest}.part`;
+  let fileStream;
   try {
-    await pipeline(response.body, fileStream);
+    fileStream = fs3.createWriteStream(part);
+    await pipeline(
+      Readable.fromWeb(body),
+      countBytes,
+      fileStream
+    );
+    replaceFile(part, dest);
   } catch (err2) {
-    if (!fileStream.closed) await once(fileStream, "close");
+    if (fileStream && !fileStream.closed) {
+      await new Promise((resolve) => fileStream?.once("close", () => resolve()));
+    }
+    removeQuietly(part);
     throw err2;
   }
-  return response.headers.get("content-type") ?? void 0;
+  return { dest, contentType: response.headers.get("content-type") ?? void 0, bytes };
+}
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers2) {
+  const result = await downloadToFile(url, { dest, timeoutMs, headers: headers2 });
+  return result.contentType;
 }
 async function fetchBytes(urlOrDataUri) {
   if (urlOrDataUri.startsWith("data:")) {
@@ -1566,22 +1695,22 @@ function planOutputPaths(urls, cfg) {
   const base = abs.slice(0, -path7.extname(abs).length);
   return exts.map((ext, i) => `${base}-${String(i + 1).padStart(2, "0")}.${ext}`);
 }
-async function deliverPrediction(prediction2, cfg) {
+async function deliverPrediction(prediction, cfg) {
   const { logger, opts } = cfg;
-  if (prediction2.price !== void 0 && prediction2.price !== "") {
-    logger.info(`Cost: $${prediction2.price}`);
+  if (prediction.price !== void 0 && prediction.price !== "") {
+    logger.info(`Cost: $${prediction.price}`);
   }
-  const classified = classifyOutputs(prediction2);
+  const classified = classifyOutputs(prediction);
   if (classified.mode === "empty") {
     throw new ProviderError(
-      hasNsfwFlag(prediction2) ? `Prediction ${prediction2.id} returned no output: blocked by content safety (has_nsfw_contents). Try a different prompt or input.` : `Prediction ${prediction2.id} completed but returned no outputs.`,
+      hasNsfwFlag(prediction) ? `Prediction ${prediction.id} returned no output: blocked by content safety (has_nsfw_contents). Try a different prompt or input.` : `Prediction ${prediction.id} completed but returned no outputs.`,
       ATLAS_PROVIDER
     );
   }
   for (const text of classified.texts) console.log(text);
   if (classified.mode === "text") {
     if (opts.output) {
-      const dest = isDirectoryOutput(opts.output) ? path7.resolve(opts.output, outputFileName(prediction2.id, 0, "txt")) : path7.resolve(opts.output);
+      const dest = isDirectoryOutput(opts.output) ? path7.resolve(opts.output, outputFileName(prediction.id, 0, "txt")) : path7.resolve(opts.output);
       fs8.mkdirSync(path7.dirname(dest), { recursive: true });
       fs8.writeFileSync(dest, `${classified.texts.join("\n\n")}
 `, "utf8");
@@ -1595,7 +1724,7 @@ async function deliverPrediction(prediction2, cfg) {
     return { files: [], texts: classified.texts };
   }
   const dests = planOutputPaths(classified.urls, {
-    predictionId: prediction2.id,
+    predictionId: prediction.id,
     outDir: getOutputDir,
     output: opts.output,
     hint: cfg.hint
@@ -1623,7 +1752,7 @@ async function deliverPrediction(prediction2, cfg) {
   }
   if (saved.length === 0) {
     throw new ProviderError(
-      `Prediction ${prediction2.id} produced ${classified.urls.length} output(s) but none downloaded. Retry with: ${resumeCommand(prediction2.id)}`,
+      `Prediction ${prediction.id} produced ${classified.urls.length} output(s) but none downloaded. Retry with: ${resumeCommand(prediction.id)}`,
       ATLAS_PROVIDER
     );
   }
@@ -1638,14 +1767,14 @@ async function deliverPrediction(prediction2, cfg) {
   const files = saved.map((f) => finalImages[images.indexOf(f)] ?? f);
   const firstVideo = files.find((f) => outputCategory(f) === "video");
   if (firstVideo) {
-    await maybeDownloadThumb(prediction2, firstVideo, { skip: opts.thumb === false, logger });
+    await maybeDownloadThumb(prediction, firstVideo, { skip: opts.thumb === false, logger });
   }
   console.log(`
-Prediction ${prediction2.id}: saved ${files.length} file(s)`);
+Prediction ${prediction.id}: saved ${files.length} file(s)`);
   for (const f of files) console.log(`  ${f}`);
   if (failed > 0) {
     throw new ProviderError(
-      `Prediction ${prediction2.id}: downloaded ${saved.length} of ${classified.urls.length} output(s); ${failed} failed. Saved: ${files.join(", ")}. Retry with: ${resumeCommand(prediction2.id)}`,
+      `Prediction ${prediction.id}: downloaded ${saved.length} of ${classified.urls.length} output(s); ${failed} failed. Saved: ${files.join(", ")}. Retry with: ${resumeCommand(prediction.id)}`,
       ATLAS_PROVIDER
     );
   }
@@ -1877,18 +2006,18 @@ function registerAtlasStatusCommand(parent) {
     const logger = createLogger({ verbose: opts.verbose ?? false });
     const client = createAtlasClientFromEnv();
     const wait = Boolean(opts.wait || opts.download);
-    const prediction2 = wait ? await client.waitForPrediction(predictionId, {
+    const prediction = wait ? await client.waitForPrediction(predictionId, {
       timeoutMs: parseTimeoutMs(opts.waitTimeout, STATUS_WAIT_MS),
       resumeHint: `Resume with: ${resumeCommand(predictionId)}`,
       onPoll: (p, n) => logger.debug(`poll ${n}: ${p.status}`)
     }) : await client.getPrediction(predictionId);
     if (!opts.download) {
-      console.log(JSON.stringify(prediction2, null, 2));
-      if (isFailureStatus(prediction2.status)) throw new AtlasPredictionFailedError(prediction2);
+      console.log(JSON.stringify(prediction, null, 2));
+      if (isFailureStatus(prediction.status)) throw new AtlasPredictionFailedError(prediction);
       return;
     }
-    assertPredictionSucceeded(prediction2);
-    await deliverPrediction(prediction2, { logger, opts: { ...opts, download: true } });
+    assertPredictionSucceeded(prediction);
+    await deliverPrediction(prediction, { logger, opts: { ...opts, download: true } });
   });
 }
 
@@ -2947,9 +3076,13 @@ init_errors();
 
 // src/providers/cloudflare/models.ts
 init_errors();
+
+// src/providers/cloudflare/model-ids.ts
 var CLOUDFLARE_IMAGE_MODEL = "@cf/black-forest-labs/flux-1-schnell";
 var CLOUDFLARE_TTS_MODEL = "@cf/myshell-ai/melotts";
 var CLOUDFLARE_VIDEO_MODEL = "prunaai/p-video";
+
+// src/providers/cloudflare/models.ts
 function required(name) {
   const value = resolveKey(name)?.trim();
   if (!value) throw new ConfigError(`${name} is required for Cloudflare media generation`);
@@ -2993,6 +3126,68 @@ function requireCloudflareVideoConfig() {
   };
 }
 
+// src/providers/cloudflare/video-client.ts
+init_errors();
+function cloudflareProviderFailure(status) {
+  return new ProviderError(`Cloudflare request failed with HTTP ${status}`, "Cloudflare");
+}
+async function readCloudflareJson(response) {
+  if (!response.ok) throw cloudflareProviderFailure(response.status);
+  try {
+    return await response.json();
+  } catch {
+    throw new ProviderError("Cloudflare returned an invalid JSON response", "Cloudflare");
+  }
+}
+function videoUrl(config, suffix = "") {
+  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(config.accountId)}/${encodeURIComponent(config.gatewayId)}/replicate/predictions${suffix}`;
+}
+function videoHeaders(config, opts) {
+  return {
+    Authorization: `Bearer ${config.replicateApiToken}`,
+    "cf-aig-authorization": `Bearer ${config.apiToken}`,
+    "cf-aig-collect-log-payload": opts.collectLogPayload ? "true" : "false",
+    "Content-Type": "application/json",
+    ...opts.wait ? { Prefer: "wait" } : {}
+  };
+}
+function send(opts, url, init) {
+  const f = opts.fetch;
+  const withTimeout = {
+    ...init,
+    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+  };
+  return f ? f(url, withTimeout) : globalThis.fetch(url, withTimeout);
+}
+function parseCloudflareVideoPrediction(value) {
+  if (!value || typeof value !== "object") {
+    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
+  }
+  const result = value;
+  if (typeof result.id !== "string" || typeof result.status !== "string") {
+    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
+  }
+  const output = result.output === null ? void 0 : result.output;
+  if (output !== void 0 && typeof output !== "string" && (!Array.isArray(output) || !output.every((item) => typeof item === "string"))) {
+    throw new ProviderError("Cloudflare returned an invalid video output", "Cloudflare");
+  }
+  return { id: result.id, status: result.status, output };
+}
+async function createCloudflareVideoPrediction(config, input, opts = {}) {
+  const response = await send(opts, videoUrl(config), {
+    method: "POST",
+    headers: videoHeaders(config, opts),
+    body: JSON.stringify({ version: CLOUDFLARE_VIDEO_MODEL, input })
+  });
+  return parseCloudflareVideoPrediction(await readCloudflareJson(response));
+}
+async function getCloudflareVideoPrediction(config, id, opts = {}) {
+  const response = await send(opts, videoUrl(config, `/${encodeURIComponent(id)}`), {
+    headers: videoHeaders(config, { ...opts, wait: false })
+  });
+  return parseCloudflareVideoPrediction(await readCloudflareJson(response));
+}
+
 // src/providers/cloudflare/client.ts
 function collectPayloadHeader() {
   const envName = ["CLOUDFLARE", "AI", "GATEWAY", "COLLECT", "LOG", "PAYLOAD"].join("_");
@@ -3006,17 +3201,6 @@ function gatewayHeaders(config) {
     "cf-aig-collect-log-payload": collectPayloadHeader()
   };
 }
-function providerFailure(status) {
-  return new ProviderError(`Cloudflare request failed with HTTP ${status}`, "Cloudflare");
-}
-async function readJson(response) {
-  if (!response.ok) throw providerFailure(response.status);
-  try {
-    return await response.json();
-  } catch {
-    throw new ProviderError("Cloudflare returned an invalid JSON response", "Cloudflare");
-  }
-}
 function nativeUrl(accountId, model) {
   return `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/ai/run/${model}`;
 }
@@ -3034,7 +3218,7 @@ async function runCloudflareJson(model, input) {
       body: JSON.stringify(useGateway ? { model, input } : input)
     }
   );
-  const payload = await readJson(response);
+  const payload = await readCloudflareJson(response);
   if (payload.success === false || payload.result === void 0) {
     throw new ProviderError("Cloudflare returned no usable result", "Cloudflare");
   }
@@ -3051,53 +3235,23 @@ async function runCloudflareBytes(model, input) {
       body: JSON.stringify(useGateway ? { model, input } : input)
     }
   );
-  if (!response.ok) throw providerFailure(response.status);
+  if (!response.ok) throw cloudflareProviderFailure(response.status);
   const contentType = response.headers.get("content-type") ?? "";
   if (!contentType.includes("audio/mpeg")) {
     throw new ProviderError("Cloudflare did not return MPEG audio", "Cloudflare");
   }
   return new Uint8Array(await response.arrayBuffer());
 }
-function videoUrl(config, suffix = "") {
-  return `https://gateway.ai.cloudflare.com/v1/${encodeURIComponent(config.accountId)}/${encodeURIComponent(config.gatewayId)}/replicate/predictions${suffix}`;
-}
-function videoHeaders(config, wait = false) {
-  return {
-    Authorization: `Bearer ${config.replicateApiToken}`,
-    "cf-aig-authorization": `Bearer ${config.apiToken}`,
-    "cf-aig-collect-log-payload": collectPayloadHeader(),
-    "Content-Type": "application/json",
-    ...wait ? { Prefer: "wait" } : {}
-  };
-}
-function prediction(value) {
-  if (!value || typeof value !== "object") {
-    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
-  }
-  const result = value;
-  if (typeof result.id !== "string" || typeof result.status !== "string") {
-    throw new ProviderError("Cloudflare returned an invalid video prediction", "Cloudflare");
-  }
-  if (result.output !== void 0 && typeof result.output !== "string" && (!Array.isArray(result.output) || !result.output.every((item) => typeof item === "string"))) {
-    throw new ProviderError("Cloudflare returned an invalid video output", "Cloudflare");
-  }
-  return { id: result.id, status: result.status, output: result.output };
-}
 async function createVideoPrediction(input, wait = false) {
-  const config = requireCloudflareVideoConfig();
-  const response = await globalThis.fetch(videoUrl(config), {
-    method: "POST",
-    headers: videoHeaders(config, wait),
-    body: JSON.stringify({ version: CLOUDFLARE_VIDEO_MODEL, input })
+  return createCloudflareVideoPrediction(requireCloudflareVideoConfig(), input, {
+    wait,
+    collectLogPayload: collectPayloadHeader() === "true"
   });
-  return prediction(await readJson(response));
 }
 async function getVideoPrediction(id) {
-  const config = requireCloudflareVideoConfig();
-  const response = await globalThis.fetch(videoUrl(config, `/${encodeURIComponent(id)}`), {
-    headers: videoHeaders(config)
+  return getCloudflareVideoPrediction(requireCloudflareVideoConfig(), id, {
+    collectLogPayload: collectPayloadHeader() === "true"
   });
-  return prediction(await readJson(response));
 }
 async function downloadVideo2(url) {
   let response;
@@ -3174,20 +3328,20 @@ function positiveInteger(value, flag) {
     throw new ValidationError(`${flag} must be a positive integer`);
   return parsed;
 }
-function outputUrl(prediction2) {
-  if (typeof prediction2.output === "string") return prediction2.output;
-  return prediction2.output?.find((value) => typeof value === "string");
+function outputUrl(prediction) {
+  if (typeof prediction.output === "string") return prediction.output;
+  return prediction.output?.find((value) => typeof value === "string");
 }
-async function saveCompletedVideo(prediction2, output) {
-  const url = outputUrl(prediction2);
+async function saveCompletedVideo(prediction, output) {
+  const url = outputUrl(prediction);
   if (!url)
     throw new ProviderError("Cloudflare completed the video without an output", "Cloudflare");
   const bytes = await downloadVideo2(url);
-  return saveBytes(bytes, `cloudflare_video_${prediction2.id}.mp4`, output);
+  return saveBytes(bytes, `cloudflare_video_${prediction.id}.mp4`, output);
 }
-async function waitForVideo(prediction2, timeoutMs, onTick) {
+async function waitForVideo(prediction, timeoutMs, onTick) {
   const deadline = Date.now() + timeoutMs;
-  let current = prediction2;
+  let current = prediction;
   while (!isTerminalVideoStatus(current.status)) {
     if (Date.now() >= deadline)
       throw new ProviderError("Cloudflare video polling timed out", "Cloudflare");
@@ -3219,15 +3373,15 @@ function registerCloudflareVideoCommand(parent) {
         fps: positiveInteger(opts.fps, "--fps")
       };
       const shouldWait = Boolean(opts.wait || opts.download);
-      const prediction2 = await createVideoPrediction(input, shouldWait);
-      logger.success(`Video job ${prediction2.id} (${prediction2.status})`);
+      const prediction = await createVideoPrediction(input, shouldWait);
+      logger.success(`Video job ${prediction.id} (${prediction.status})`);
       if (!shouldWait) {
-        console.log(prediction2.id);
-        console.error(`Poll with: multix cloudflare video-status ${prediction2.id}`);
+        console.log(prediction.id);
+        console.error(`Poll with: multix cloudflare video-status ${prediction.id}`);
         return;
       }
-      const completed = prediction2.status === "succeeded" ? prediction2 : await waitForVideo(
-        prediction2,
+      const completed = prediction.status === "succeeded" ? prediction : await waitForVideo(
+        prediction,
         positiveInteger(opts.waitTimeout, "--wait-timeout"),
         (status) => logger.debug(`Video status: ${status}`)
       );
@@ -3277,12 +3431,12 @@ function registerCloudflareVideoStatusCommand(parent) {
     async (id, opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const shouldWait = Boolean(opts.wait || opts.download);
-      const prediction2 = await getVideoPrediction(id);
-      const completed = shouldWait && prediction2.status !== "succeeded" ? await waitForVideo(
-        prediction2,
+      const prediction = await getVideoPrediction(id);
+      const completed = shouldWait && prediction.status !== "succeeded" ? await waitForVideo(
+        prediction,
         positiveInteger(opts.waitTimeout, "--wait-timeout"),
         (status) => logger.debug(`Video status: ${status}`)
-      ) : prediction2;
+      ) : prediction;
       console.log(`${completed.id}: ${completed.status}`);
       if (opts.download) {
         if (completed.status !== "succeeded") {
@@ -6080,7 +6234,7 @@ var HEYGEN_OPERATIONS = {
 };
 
 // src/providers/heygen/node-helpers.ts
-import { once as once2 } from "events";
+import { once } from "events";
 import fs29 from "fs";
 import path32 from "path";
 import { pipeline as pipeline2 } from "stream/promises";
@@ -7087,7 +7241,7 @@ function inferExtension(url, fallback) {
 function safeSlug(value) {
   return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "out";
 }
-var MAX_REDIRECTS = 5;
+var MAX_REDIRECTS2 = 5;
 var isRedirect = (status) => [301, 302, 303, 307, 308].includes(status);
 async function downloadHttpsOnly(url, dest, timeoutMs) {
   const signal = AbortSignal.timeout(timeoutMs);
@@ -7109,7 +7263,7 @@ async function downloadHttpsOnly(url, dest, timeoutMs) {
     const location = response.headers.get("location");
     if (isRedirect(response.status) && location) {
       await response.body?.cancel();
-      if (hop >= MAX_REDIRECTS) throw new HttpError(0, "too many redirects", url);
+      if (hop >= MAX_REDIRECTS2) throw new HttpError(0, "too many redirects", url);
       current = new URL(location, current).href;
       continue;
     }
@@ -7120,7 +7274,7 @@ async function downloadHttpsOnly(url, dest, timeoutMs) {
     try {
       await pipeline2(response.body, fileStream);
     } catch (err2) {
-      if (!fileStream.closed) await once2(fileStream, "close");
+      if (!fileStream.closed) await once(fileStream, "close");
       throw err2;
     }
     return;
@@ -10225,8 +10379,8 @@ async function downloadOpenRouterVideo(opts) {
   }
   fs43.mkdirSync(path50.dirname(dest), { recursive: true });
   const ws = fs43.createWriteStream(dest);
-  const { pipeline: pipeline4 } = await import("stream/promises");
-  await pipeline4(r.body, ws);
+  const { pipeline: pipeline3 } = await import("stream/promises");
+  await pipeline3(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
     fs43.mkdirSync(path50.dirname(path50.resolve(opts.output)), { recursive: true });
@@ -10484,13 +10638,13 @@ var ReplicateApiError = class extends ProviderError {
   retryAfterMs;
 };
 var ReplicatePredictionError = class extends ProviderError {
-  constructor(prediction2) {
-    const detail = formatPredictionError(prediction2.error);
+  constructor(prediction) {
+    const detail = formatPredictionError(prediction.error);
     super(
-      `Replicate prediction ${prediction2.id} ${prediction2.status}${detail ? `: ${detail}` : ""}`,
+      `Replicate prediction ${prediction.id} ${prediction.status}${detail ? `: ${detail}` : ""}`,
       PROVIDER
     );
-    this.prediction = prediction2;
+    this.prediction = prediction;
     this.name = "ReplicatePredictionError";
   }
   prediction;
@@ -10537,6 +10691,19 @@ function mapReplicateError(error, subject) {
   }
   return new ReplicateApiError(message, status, retryAfterMs);
 }
+var ORPHAN_HINT = "The prediction may have been created anyway (Replicate has no idempotency key); check https://replicate.com/predictions before retrying to avoid paying twice";
+function withOrphanHint(error) {
+  if (error instanceof ReplicateApiError) {
+    const { status } = error;
+    const mayExist = status === 0 || status >= 200 && status < 300 || status >= 500;
+    if (!mayExist) return error;
+    return new ReplicateApiError(`${error.message}. ${ORPHAN_HINT}`, status, error.retryAfterMs);
+  }
+  if (error instanceof ProviderError) {
+    return new ProviderError(`${error.message}. ${ORPHAN_HINT}`, error.provider);
+  }
+  return error;
+}
 function validatePrediction(value) {
   if (value === null || typeof value !== "object" || typeof value.id !== "string" || typeof value.status !== "string") {
     throw new ProviderError("Malformed Replicate response: missing prediction id/status", PROVIDER);
@@ -10546,11 +10713,11 @@ function validatePrediction(value) {
   }
   return value;
 }
-function assertSucceeded(prediction2) {
-  if (prediction2.status === "succeeded") return prediction2;
-  if (isTerminalStatus2(prediction2.status)) throw new ReplicatePredictionError(prediction2);
+function assertSucceeded(prediction) {
+  if (prediction.status === "succeeded") return prediction;
+  if (isTerminalStatus2(prediction.status)) throw new ReplicatePredictionError(prediction);
   throw new ProviderError(
-    `Replicate prediction ${prediction2.id} is not finished (status: ${prediction2.status})`,
+    `Replicate prediction ${prediction.id} is not finished (status: ${prediction.status})`,
     PROVIDER
   );
 }
@@ -10605,7 +10772,7 @@ var ReplicateClient = class {
           await this.sleep(delay);
           continue;
         }
-        throw mapReplicateError(error, subject);
+        throw withOrphanHint(mapReplicateError(error, subject));
       }
     }
   }
@@ -10631,9 +10798,9 @@ var ReplicateClient = class {
    * canceled, aborted) and return it — callers decide success via
    * assertSucceeded. Retries network/429/5xx; throws PollTimeoutError on deadline.
    */
-  async waitForPrediction(prediction2, opts) {
-    if (typeof prediction2 !== "string" && isTerminalStatus2(prediction2.status)) return prediction2;
-    const safeId = assertPredictionId(typeof prediction2 === "string" ? prediction2 : prediction2.id);
+  async waitForPrediction(prediction, opts) {
+    if (typeof prediction !== "string" && isTerminalStatus2(prediction.status)) return prediction;
+    const safeId = assertPredictionId(typeof prediction === "string" ? prediction : prediction.id);
     try {
       return await pollUntil({
         fetchStatus: async ({ remainingMs }) => validatePrediction(
@@ -10736,13 +10903,13 @@ function registerReplicateCancelCommand(parent) {
   parent.command("cancel <predictionId>").description("Cancel a running Replicate prediction").option("-v, --verbose", "Verbose logging").action(async (predictionId, opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
     const client = createReplicateClient();
-    const prediction2 = await client.cancelPrediction(predictionId);
-    if (prediction2.status === "canceled") {
-      logger.success(`Prediction ${prediction2.id} canceled`);
-    } else if (isTerminalStatus2(prediction2.status)) {
-      logger.warn(`Prediction ${prediction2.id} already finished (status: ${prediction2.status})`);
+    const prediction = await client.cancelPrediction(predictionId);
+    if (prediction.status === "canceled") {
+      logger.success(`Prediction ${prediction.id} canceled`);
+    } else if (isTerminalStatus2(prediction.status)) {
+      logger.warn(`Prediction ${prediction.id} already finished (status: ${prediction.status})`);
     } else {
-      logger.info(`Cancel requested for ${prediction2.id} (status: ${prediction2.status})`);
+      logger.info(`Cancel requested for ${prediction.id} (status: ${prediction.status})`);
     }
   });
 }
@@ -10752,23 +10919,137 @@ init_errors();
 
 // src/providers/replicate/commands/prediction-flow.ts
 init_errors();
+import { InvalidArgumentError, Option as Option2 } from "commander";
 
 // src/providers/replicate/node-outputs.ts
 init_errors();
-init_redact();
-import { once as once3 } from "events";
 import fs44 from "fs";
 import path51 from "path";
-import { Readable } from "stream";
-import { pipeline as pipeline3 } from "stream/promises";
+init_redact();
 
 // src/providers/replicate/output.ts
 init_redact();
+
+// src/core/url-safety.ts
+init_errors();
+function ipv4Octets(host) {
+  const parts = host.split(".");
+  if (parts.length !== 4 || !parts.every((p) => /^\d{1,3}$/.test(p))) return void 0;
+  const octets = parts.map(Number);
+  return octets.every((o) => o <= 255) ? octets : void 0;
+}
+function isNonPublicIpv4([a = 0, b = 0, c2 = 0]) {
+  return a === 0 || // "this network" / unspecified
+  a === 10 || a === 127 || // loopback
+  a === 100 && b >= 64 && b <= 127 || // carrier-grade NAT
+  a === 169 && b === 254 || // link-local (cloud metadata)
+  a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 && c2 === 0 || // IETF protocol assignments
+  a === 192 && b === 0 && c2 === 2 || // TEST-NET-1
+  a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || // benchmarking
+  a === 198 && b === 51 && c2 === 100 || // TEST-NET-2
+  a === 203 && b === 0 && c2 === 113 || // TEST-NET-3
+  a >= 224;
+}
+function ipv6Groups(host) {
+  if (!/^[0-9a-f:.]+$/i.test(host) || !host.includes(":")) return void 0;
+  let text = host;
+  const tail = /^(.*:)(\d+\.\d+\.\d+\.\d+)$/.exec(text);
+  if (tail) {
+    const octets = ipv4Octets(tail[2]);
+    if (!octets) return void 0;
+    const [a = 0, b = 0, c2 = 0, d = 0] = octets;
+    text = `${tail[1]}${(a << 8 | b).toString(16)}:${(c2 << 8 | d).toString(16)}`;
+  }
+  const halves = text.split("::");
+  if (halves.length > 2) return void 0;
+  const parse = (s) => s === "" ? [] : s.split(":");
+  const head = parse(halves[0]);
+  const rest = halves.length === 2 ? parse(halves[1]) : [];
+  const missing = 8 - head.length - rest.length;
+  if (halves.length === 2 ? missing < 1 : missing !== 0) return void 0;
+  const all = [...head, ...Array(halves.length === 2 ? missing : 0).fill("0"), ...rest];
+  if (!all.every((g) => /^[0-9a-f]{1,4}$/i.test(g))) return void 0;
+  return all.map((g) => Number.parseInt(g, 16));
+}
+function embeddedIpv4(hi, lo) {
+  return [hi >> 8, hi & 255, lo >> 8, lo & 255];
+}
+function isNonPublicIpv6(groups) {
+  const [g0 = 0, g1 = 0, g2 = 0, g3 = 0, g4 = 0, g5 = 0, g6 = 0, g7 = 0] = groups;
+  const zeroUpTo = (n) => groups.slice(0, n).every((g) => g === 0);
+  if (zeroUpTo(5) && g5 === 65535) return isNonPublicIpv4(embeddedIpv4(g6, g7));
+  if (g0 === 100 && g1 === 65435 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0) {
+    return isNonPublicIpv4(embeddedIpv4(g6, g7));
+  }
+  if (g0 === 8194) return isNonPublicIpv4(embeddedIpv4(g1, g2));
+  return g0 === 0 || // unspecified (::), loopback (::1), IPv4-compatible and other reserved
+  g0 === 256 && g1 === 0 && g2 === 0 && g3 === 0 || // discard-only 100::/64
+  (g0 & 65024) === 64512 || // unique local fc00::/7
+  (g0 & 65472) === 65152 || // link-local fe80::/10
+  (g0 & 65472) === 65216 || // deprecated site-local fec0::/10
+  (g0 & 65280) === 65280;
+}
+function bareHost(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/, "");
+  return host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+}
+function isLoopbackHost(hostname) {
+  const host = bareHost(hostname);
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  const octets = ipv4Octets(host);
+  if (octets) return octets[0] === 127;
+  const groups = ipv6Groups(host);
+  if (!groups) return false;
+  if (groups.slice(0, 5).every((g) => g === 0) && groups[5] === 65535) {
+    return groups[6] !== void 0 && groups[6] >> 8 === 127;
+  }
+  return groups.slice(0, 7).every((g) => g === 0) && groups[7] === 1;
+}
+function isNonPublicHost(hostname) {
+  const host = bareHost(hostname);
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  const octets = ipv4Octets(host);
+  if (octets) return isNonPublicIpv4(octets);
+  const groups = ipv6Groups(host);
+  return groups !== void 0 && isNonPublicIpv6(groups);
+}
+function checkUrlSafety(url, opts) {
+  const action = opts.action ?? "download from";
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ProviderError(`Refusing to ${action} a malformed URL`, opts.provider);
+  }
+  const host = parsed.hostname.toLowerCase().replace(/\.$/, "");
+  const localOk = opts.allowLocalhostHttp === true && isLoopbackHost(host);
+  const httpOk = parsed.protocol === "https:" || localOk && parsed.protocol === "http:";
+  if (!httpOk) {
+    throw new ProviderError(
+      `Refusing to ${action} ${host || "this URL"}: only https:// URLs are allowed`,
+      opts.provider
+    );
+  }
+  if (!localOk && isNonPublicHost(host)) {
+    throw new ProviderError(
+      `Refusing to ${action} ${host}: it points to a local or private address`,
+      opts.provider
+    );
+  }
+  const trusted = (opts.trustedHosts ?? []).some((t) => host === t || host.endsWith(`.${t}`));
+  return { host, trusted };
+}
+
+// src/providers/replicate/output.ts
 var HTTP_RE = /^https?:\/\//i;
 var DATA_URI_RE = /^data:[^,]*,/i;
 function isMediaRef(value) {
   return typeof value === "string" && (HTTP_RE.test(value) || DATA_URI_RE.test(value));
 }
+var REPLICATE_DELIVERY_HOST = "replicate.delivery";
+function checkOutputUrl(url) {
+  return checkUrlSafety(url, { provider: "replicate", trustedHosts: [REPLICATE_DELIVERY_HOST] });
+}
 function extractOutput(output) {
   const result = { media: [], texts: [] };
   const seen = /* @__PURE__ */ new Set();
@@ -10927,59 +11208,53 @@ function resolveDestination(predictionId, index, count, ext, opts) {
   const base = givenExt ? output.slice(0, -givenExt.length) : output;
   return `${base}-${String(index + 1).padStart(2, "0")}${ext}`;
 }
-async function writeResponse(response, dest) {
-  if (!response.body) throw new HttpError(0, "Response body is null", response.url);
-  const fileStream = fs44.createWriteStream(dest);
-  try {
-    await pipeline3(
-      Readable.fromWeb(response.body),
-      fileStream
-    );
-  } catch (err2) {
-    if (!fileStream.closed) await once3(fileStream, "close");
-    throw err2;
-  }
-}
 async function saveOne(item, predictionId, index, count, opts) {
   if (item.url.startsWith("data:")) {
     const comma = item.url.indexOf(",");
     const meta = item.url.slice(5, comma);
     const payload = item.url.slice(comma + 1);
     const bytes = meta.endsWith(";base64") ? Buffer.from(payload, "base64") : Buffer.from(decodeURIComponent(payload));
-    const dest2 = resolveDestination(
+    const dest = resolveDestination(
       predictionId,
       index,
       count,
       extFromUrl4(item.url) ?? ".bin",
       opts
     );
-    fs44.mkdirSync(path51.dirname(dest2), { recursive: true });
-    fs44.writeFileSync(dest2, bytes);
-    return dest2;
-  }
-  const doFetch = opts.fetch ?? ((url, init) => globalThis.fetch(url, init));
-  let response;
-  try {
-    response = await doFetch(item.url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
-  } catch (cause) {
-    throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), item.url);
-  }
-  if (!response.ok) {
-    const hint = response.status === 404 || response.status === 410 ? " (output may have expired)" : "";
-    throw new HttpError(response.status, `download failed${hint}`, item.url);
+    fs44.mkdirSync(path51.dirname(dest), { recursive: true });
+    fs44.writeFileSync(dest, bytes);
+    return dest;
   }
-  const ext = extFromUrl4(item.url) ?? extFromContentType(response.headers.get("content-type")) ?? ".bin";
-  const dest = resolveDestination(predictionId, index, count, ext, opts);
-  fs44.mkdirSync(path51.dirname(dest), { recursive: true });
+  const warned = opts.warnedHosts;
   try {
-    await writeResponse(response, dest);
+    const { dest } = await downloadToFile(item.url, {
+      dest: (response) => {
+        const ext = extFromUrl4(item.url) ?? extFromContentType(response.headers.get("content-type")) ?? ".bin";
+        return resolveDestination(predictionId, index, count, ext, opts);
+      },
+      timeoutMs: DOWNLOAD_TIMEOUT_MS,
+      maxBytes: opts.maxBytes,
+      fetch: opts.fetch,
+      validateUrl: (url) => {
+        const { host, trusted } = checkOutputUrl(url);
+        if (!trusted && !warned.has(host)) {
+          warned.add(host);
+          opts.logger.warn(
+            `Output ${item.path} is served from ${host}, not ${REPLICATE_DELIVERY_HOST}`
+          );
+        }
+      }
+    });
+    return dest;
   } catch (err2) {
-    fs44.rmSync(dest, { force: true });
+    if (err2 instanceof HttpError && (err2.status === 404 || err2.status === 410)) {
+      throw new HttpError(err2.status, "download failed (output may have expired)", err2.rawUrl);
+    }
     throw err2;
   }
-  return dest;
 }
 async function saveMediaOutputs(predictionId, media, opts) {
+  const withCap = { ...opts, maxBytes: maxDownloadBytes(), warnedHosts: /* @__PURE__ */ new Set() };
   const saved = [];
   const failed = [];
   for (let i = 0; i < media.length; i++) {
@@ -10987,7 +11262,7 @@ async function saveMediaOutputs(predictionId, media, opts) {
     if (!item) continue;
     opts.logger.debug(`Downloading ${item.path} from ${redactUrl(item.url).slice(0, 200)}`);
     try {
-      const dest = await saveOne(item, predictionId, i, media.length, opts);
+      const dest = await saveOne(item, predictionId, i, media.length, withCap);
       saved.push(dest);
       opts.logger.success(`Saved ${dest}`);
     } catch (e) {
@@ -11004,10 +11279,22 @@ async function saveMediaOutputs(predictionId, media, opts) {
 }
 
 // src/providers/replicate/commands/prediction-flow.ts
+var DEFAULT_PREFER_WAIT_SECONDS = 60;
+function parsePreferWaitSeconds(raw) {
+  const n = Number(raw);
+  if (!/^\d+$/.test(raw.trim()) || n < 1 || n > 60) {
+    throw new InvalidArgumentError(
+      `Expected an integer number of seconds from 1 to 60 (a bare --prefer-wait means ${DEFAULT_PREFER_WAIT_SECONDS}); put the prompt before the flag.`
+    );
+  }
+  return n;
+}
 function addFlowOptions(cmd, defaultTimeoutMs) {
-  return cmd.option("--async", "Submit and return immediately with the prediction id").option("--wait", "Wait for a terminal status (default unless --async)").option(
-    "--prefer-wait [seconds]",
-    "Ask Replicate to hold the create request open (1-60s, default 60); keeps polling if still running"
+  return cmd.option("--async", "Submit and return immediately with the prediction id").option("--wait", "Wait for a terminal status (default unless --async)").addOption(
+    new Option2(
+      "--prefer-wait [seconds]",
+      "Ask Replicate to hold the create request open for 1-60s (bare flag: 60); keeps polling if still running"
+    ).argParser(parsePreferWaitSeconds).preset(String(DEFAULT_PREFER_WAIT_SECONDS))
   ).option("--wait-timeout <ms>", "Polling timeout in milliseconds", String(defaultTimeoutMs)).option("--download", "Download media outputs (default)").option("--no-download", "Print output URLs instead of downloading").option("--output <path>", "Output file path, or a directory for multiple outputs").option("-v, --verbose", "Verbose logging");
 }
 function parsePositiveInt2(raw, flag, max) {
@@ -11019,50 +11306,45 @@ function parsePositiveInt2(raw, flag, max) {
   }
   return n;
 }
-function parsePreferWait(value) {
-  if (value === void 0 || value === false) return void 0;
-  if (value === true) return 60;
-  return parsePositiveInt2(value, "--prefer-wait", 60);
-}
 function resumeCommand3(id) {
   return `multix replicate status ${id} --wait --download`;
 }
-function printAsyncHandle(prediction2) {
-  console.log(`Prediction submitted: ${prediction2.id} (status: ${prediction2.status})`);
-  console.log(`  Check:  multix replicate status ${prediction2.id}`);
-  console.log(`  Resume: ${resumeCommand3(prediction2.id)}`);
-  console.log(`  Cancel: multix replicate cancel ${prediction2.id}`);
+function printAsyncHandle(prediction) {
+  console.log(`Prediction submitted: ${prediction.id} (status: ${prediction.status})`);
+  console.log(`  Check:  multix replicate status ${prediction.id}`);
+  console.log(`  Resume: ${resumeCommand3(prediction.id)}`);
+  console.log(`  Cancel: multix replicate cancel ${prediction.id}`);
 }
-async function reportOutputs(prediction2, opts) {
-  const { media, texts } = extractOutput(prediction2.output);
+async function reportOutputs(prediction, opts) {
+  const { media, texts } = extractOutput(prediction.output);
   for (const text of texts) console.log(text);
   if (media.length === 0) {
-    if (texts.length === 0) console.log(JSON.stringify(summarizePrediction(prediction2), null, 2));
+    if (texts.length === 0) console.log(JSON.stringify(summarizePrediction(prediction), null, 2));
     return [];
   }
   if (!opts.download) {
     for (const m of media) console.log(m.url);
     return [];
   }
-  const saved = await saveMediaOutputs(prediction2.id, media, {
+  const saved = await saveMediaOutputs(prediction.id, media, {
     outDir: opts.output ? "" : getOutputDir(),
     output: opts.output,
     logger: opts.logger,
-    retryHint: `Retry while the output URLs are live: multix replicate status ${prediction2.id} --download`
+    retryHint: `Retry while the output URLs are live: multix replicate status ${prediction.id} --download`
   });
   const finals = opts.finalize ? opts.finalize(saved) : saved;
   console.log(`
-Saved ${finals.length} file(s) from prediction ${prediction2.id}:`);
+Saved ${finals.length} file(s) from prediction ${prediction.id}:`);
   for (const f of finals) console.log(`  ${f}`);
   return finals;
 }
-async function completePrediction(client, prediction2, opts) {
-  const id = typeof prediction2 === "string" ? prediction2 : prediction2.id;
-  let lastStatus = typeof prediction2 === "string" ? "" : prediction2.status;
-  if (typeof prediction2 === "string" || !isTerminalStatus2(prediction2.status)) {
+async function completePrediction(client, prediction, opts) {
+  const id = typeof prediction === "string" ? prediction : prediction.id;
+  let lastStatus = typeof prediction === "string" ? "" : prediction.status;
+  if (typeof prediction === "string" || !isTerminalStatus2(prediction.status)) {
     opts.logger.info(`Waiting for prediction ${id}...`);
   }
-  const final = await client.waitForPrediction(prediction2, {
+  const final = await client.waitForPrediction(prediction, {
     timeoutMs: opts.waitTimeoutMs,
     resumeHint: `Resume with: ${resumeCommand3(id)}`,
     onPoll: (p, attempt) => {
@@ -11078,19 +11360,22 @@ async function executePrediction2(params) {
   const { client, model, input, opts, logger } = params;
   if (opts.async && opts.wait)
     throw new ValidationError("--async and --wait are mutually exclusive");
-  if (opts.async && opts.preferWait) {
+  if (opts.async && opts.preferWait !== void 0) {
     throw new ValidationError("--async and --prefer-wait are mutually exclusive");
   }
   const waitTimeoutMs = parsePositiveInt2(opts.waitTimeout, "--wait-timeout");
-  const preferWaitSeconds = parsePreferWait(opts.preferWait);
   logger.info(`Submitting to Replicate ${describeModelRef(model)}...`);
-  const prediction2 = await client.createPrediction({ model, input, preferWaitSeconds });
+  const prediction = await client.createPrediction({
+    model,
+    input,
+    preferWaitSeconds: opts.preferWait
+  });
   if (opts.async) {
-    printAsyncHandle(prediction2);
+    printAsyncHandle(prediction);
     return;
   }
-  logger.info(`Prediction ${prediction2.id} (status: ${prediction2.status})`);
-  await completePrediction(client, prediction2, {
+  logger.info(`Prediction ${prediction.id} (status: ${prediction.status})`);
+  await completePrediction(client, prediction, {
     waitTimeoutMs,
     logger,
     download: opts.download !== false,
@@ -11156,7 +11441,7 @@ import fs45 from "fs";
 import path52 from "path";
 var DATA_URI_MAX_BYTES = 256 * 1024;
 var UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
-function formatMb2(bytes) {
+function formatMb3(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 async function resolveFileInput(value, client, logger) {
@@ -11172,7 +11457,7 @@ async function resolveFileInput(value, client, logger) {
   if (stat.size === 0) throw new ValidationError(`Input file is empty: ${value}`);
   if (stat.size >= UPLOAD_MAX_BYTES) {
     throw new ValidationError(
-      `Input file ${value} is ${formatMb2(stat.size)}; Replicate accepts uploads under 100MB. Host it and pass an https URL instead.`
+      `Input file ${value} is ${formatMb3(stat.size)}; Replicate accepts uploads under 100MB. Host it and pass an https URL instead.`
     );
   }
   const filename = path52.basename(filePath);
@@ -11182,7 +11467,7 @@ async function resolveFileInput(value, client, logger) {
     logger.debug(`Inlining ${filename} (${stat.size} bytes) as a data URI`);
     return `data:${contentType};base64,${bytes.toString("base64")}`;
   }
-  logger.info(`Uploading ${filename} (${formatMb2(stat.size)}) to Replicate Files...`);
+  logger.info(`Uploading ${filename} (${formatMb3(stat.size)}) to Replicate Files...`);
   const file = await client.uploadFile({
     data: new Blob([bytes], { type: contentType }),
     filename,
@@ -11242,16 +11527,16 @@ function registerReplicateStatusCommand(parent) {
       });
       return;
     }
-    const prediction2 = await client.getPrediction(predictionId);
-    if (prediction2.status === "succeeded" && opts.download) {
-      await reportOutputs(prediction2, { download: true, output: opts.output, logger });
+    const prediction = await client.getPrediction(predictionId);
+    if (prediction.status === "succeeded" && opts.download) {
+      await reportOutputs(prediction, { download: true, output: opts.output, logger });
       return;
     }
-    console.log(JSON.stringify(summarizePrediction(prediction2), null, 2));
-    if (!isTerminalStatus2(prediction2.status)) {
-      logger.info(`Still running. Resume with: ${resumeCommand3(prediction2.id)}`);
-    } else if (prediction2.status !== "succeeded") {
-      throw new ReplicatePredictionError(prediction2);
+    console.log(JSON.stringify(summarizePrediction(prediction), null, 2));
+    if (!isTerminalStatus2(prediction.status)) {
+      logger.info(`Still running. Resume with: ${resumeCommand3(prediction.id)}`);
+    } else if (prediction.status !== "succeeded") {
+      throw new ReplicatePredictionError(prediction);
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrgoonie/multix",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "AI multimodal CLI — OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, Replicate, HeyGen, ffmpeg, ImageMagick, doc-to-md",
   "type": "module",
   "bin": {
@@ -35,7 +35,11 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:smoke": "vitest run tests/smoke",
-    "verify:docs": "npm run verify --prefix docs-site"
+    "verify:docs": "npm run verify --prefix docs-site",
+    "dev:mcp": "npm run dev --prefix worker",
+    "deploy:mcp": "npm run deploy --prefix worker",
+    "test:mcp": "npm test --prefix worker",
+    "check:mcp": "npm run typecheck --prefix worker && npm test --prefix worker && npm run check:bundle --prefix worker"
   },
   "keywords": [
     "cli",

package/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: multix
 description: AI multimodal CLI — generate and edit images (OpenAI, Codex driver, Gemini Nano Banana, Imagen, MiniMax, OpenRouter, Leonardo, BytePlus Seedream, Cloudflare Workers AI FLUX.1 Schnell, fal.ai FLUX, Replicate FLUX), generate video (Gemini Veo, MiniMax Hailuo, OpenRouter via Veo/Seedance/Kling, Leonardo via Motion/Veo/Kling/Hailuo/Seedance/LTX, BytePlus Seedance, Cloudflare AI Gateway via Replicate, fal.ai queue models, Replicate direct API models incl. P-Video, HeyGen Video Agent and scripted avatar videos), video translation and lipsync (HeyGen), TTS/STT/music (OpenAI, Gemini Flash TTS incl. Gemini 3.8 with delivery-style control, MiniMax, Cloudflare Workers AI MeloTTS, ElevenLabs), 3D models (BytePlus Hyper3D/Hitem3d), analyze/transcribe media, convert documents to Markdown, optimize media via ffmpeg/ImageMagick, and self-update the CLI. Use whenever the user wants to create, edit, or transform images/video/audio/3D/documents from a CLI, mentions any of: OpenAI, Codex image driver, image-to-image, i2i, image edit, watercolor/cyberpunk style transfer, reference image, OpenRouter, Nano Banana, Flux, Seedream, Veo, Hailuo, Seedance, Kling, Cloudflare Workers AI, AI Gateway, fal.ai, Atlas Cloud, Replicate, replicate.com models, Replicate predictions, HeyGen, avatar video, talking head, Video Agent, video translation, dubbing, lipsync, video generation, text-to-video, image-to-video, i2v, ElevenLabs voice cloning, updating/upgrading multix, or asks for batch media optimization.
-version: 0.14.0 # x-release-please-version
+version: 0.15.0 # x-release-please-version
 ---
 
 # multix — AI Multimodal CLI
@@ -178,7 +178,9 @@ multix replicate status <prediction-id> --wait --download
 multix replicate cancel <prediction-id>
 ```
 
-Shared flags: `--async`, `--wait`, `--prefer-wait [seconds]` (sends `Prefer: wait=N`, still polls if unfinished), `--wait-timeout <ms>`, `--no-download` (print URLs), `--output <path|dir/>`. `failed`/`canceled`/`aborted` predictions exit non-zero. Local files up to 256 KB are inlined as data URIs; larger files (< 100 MB) go through the Replicate Files API.
+Shared flags: `--async`, `--wait`, `--prefer-wait [seconds]` (integer 1-60, bare flag = 60; sends `Prefer: wait=N`, still polls if unfinished; put the prompt before a bare flag), `--wait-timeout <ms>`, `--no-download` (print URLs), `--output <path|dir/>`. `failed`/`canceled`/`aborted` predictions exit non-zero. Local files up to 256 KB are inlined as data URIs; larger files (< 100 MB) go through the Replicate Files API.
+
+Output downloads are `https://` only; `localhost` and loopback/private/link-local/special-purpose IP literals (including redirects; hostnames are not resolved) are refused, non-`replicate.delivery` hosts are downloaded with a warning, and each file is capped at `MULTIX_MAX_DOWNLOAD_MB` (default 2048). If submitting fails with a network error, timeout, 5xx, or an unreadable 2xx response, the prediction may still exist and bill: check https://replicate.com/predictions before retrying instead of resubmitting blindly.
 
 ## HeyGen
 
@@ -384,6 +386,7 @@ Requires `cwebp` (libwebp: `brew install webp`, `apt install webp`) on `PATH`.
 | Variable | Purpose |
 |---|---|
 | `MULTIX_OUTPUT_DIR` | Override default output dir |
+| `MULTIX_MAX_DOWNLOAD_MB` | Size limit per downloaded Replicate output file (default 2048) |
 | `OPENAI_IMAGE_MODEL` / `OPENAI_TTS_MODEL` / `OPENAI_STT_MODEL` | OpenAI model defaults |
 | `OPENROUTER_IMAGE_MODEL` | Default OpenRouter image model |
 | `OPENROUTER_FALLBACK_MODELS` | CSV; applies to `generate` AND `i2i` |
@@ -463,6 +466,19 @@ multix update --check
 multix update
 ```
 
+## Remote MCP server
+
+If the user cannot run the CLI locally but has deployed the optional multix
+MCP Worker (`worker/` in the repo; guide: https://multix.zuey.me/guides/mcp-server/),
+call its tools instead: `multix_list_providers` first, then
+`multix_generate_image` / `multix_generate_video`, and poll
+`multix_prediction_status` until `done` is true. It returns provider URLs (no
+local files), supports only Replicate, Atlas Cloud, HeyGen, and Cloudflare
+video, and accepts only public `https://` image URLs. Check `limits` from
+`multix_list_providers` before a video call: `duration` above
+`max_video_seconds` or a `resolution` outside `allowed_resolutions` is
+rejected, and an omitted `duration` becomes `default_video_seconds`.
+
 ## Security & scope
 
 This skill produces shell commands for the local `multix` CLI. It does NOT execute the commands itself, exfiltrate API keys, or modify provider accounts.