@mrgoonie/multix 0.11.0 → 0.12.0

package/dist/cli.js

@@ -417,6 +417,13 @@ function getLoadedEnvFiles() {
 function resolveKey(name) {
   return process.env[name] || void 0;
 }
+function resolveFirstKey(...names) {
+  for (const name of names) {
+    const value = resolveKey(name)?.trim();
+    if (value) return { value, envUsed: name };
+  }
+  return void 0;
+}
 
 // src/providers/atlascloud/commands/env.ts
 init_errors();
@@ -855,13 +862,13 @@ var AtlasCloudClient = class {
   }
   /** Submit a generation job. `body` holds `model` plus the model's own fields, flattened. */
   async submit(kind, body) {
-    const path52 = SUBMIT_PATHS[kind];
-    if (!path52) throw new ValidationError(`Unknown Atlas Cloud media type: ${String(kind)}`);
+    const path54 = SUBMIT_PATHS[kind];
+    if (!path54) throw new ValidationError(`Unknown Atlas Cloud media type: ${String(kind)}`);
     if (typeof body.model !== "string" || !body.model.trim()) {
       throw new ValidationError("Atlas Cloud request body needs a non-empty `model`");
     }
     const env = await fetchJson({
-      url: `${this.baseUrl}${path52}`,
+      url: `${this.baseUrl}${path54}`,
       method: "POST",
       headers: this.authHeaders(),
       body,
@@ -2175,9 +2182,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path52, opts = {}) {
+  async request(path54, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path52);
+    const url = new URL(base + path54);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -2195,14 +2202,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path52, query, logger) {
-    return this.request(path52, { method: "GET", query, logger });
+  get(path54, query, logger) {
+    return this.request(path54, { method: "GET", query, logger });
   }
-  post(path52, body, logger) {
-    return this.request(path52, { method: "POST", body, logger });
+  post(path54, body, logger) {
+    return this.request(path54, { method: "POST", body, logger });
   }
-  delete(path52, logger) {
-    return this.request(path52, { method: "DELETE", logger });
+  delete(path54, logger) {
+    return this.request(path54, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -2671,10 +2678,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path52, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path52, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path52, logger), role);
-  return toRef(kind, await resolveAudioInput(path52, logger), role);
+  const { path: path54, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path54, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path54, logger), role);
+  return toRef(kind, await resolveAudioInput(path54, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -4101,9 +4108,9 @@ var FalClient = class {
   apiKey;
   baseUrl;
   /** `path` is appended verbatim to the base queue URL, e.g. "/fal-ai/flux/schnell". */
-  async request(path52, opts = {}) {
+  async request(path54, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const suffix = path52.startsWith("/") ? path52 : `/${path52}`;
+    const suffix = path54.startsWith("/") ? path54 : `/${path54}`;
     return this.requestAbsolute(base + suffix, opts);
   }
   /** Same auth/headers as `request`, but `url` is used verbatim (e.g. a status_url/response_url returned by submit). */
@@ -4120,11 +4127,11 @@ var FalClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path52, logger) {
-    return this.request(path52, { method: "GET", logger });
+  get(path54, logger) {
+    return this.request(path54, { method: "GET", logger });
   }
-  post(path52, body, logger) {
-    return this.request(path52, { method: "POST", body, logger });
+  post(path54, body, logger) {
+    return this.request(path54, { method: "POST", body, logger });
   }
   getAbsolute(url, logger) {
     return this.requestAbsolute(url, { method: "GET", logger });
@@ -6032,11 +6039,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path52, opts = {}) {
+  async request(path54, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path52.startsWith("v2:");
+    const v2Override = path54.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path52.slice(3) : path52;
+    const finalPath = v2Override ? path54.slice(3) : path54;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -6055,14 +6062,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path52, query, logger) {
-    return this.request(path52, { method: "GET", query, logger });
+  get(path54, query, logger) {
+    return this.request(path54, { method: "GET", query, logger });
   }
-  post(path52, body, logger) {
-    return this.request(path52, { method: "POST", body, logger });
+  post(path54, body, logger) {
+    return this.request(path54, { method: "POST", body, logger });
   }
-  delete(path52, logger) {
-    return this.request(path52, { method: "DELETE", logger });
+  delete(path54, logger) {
+    return this.request(path54, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -8289,8 +8296,8 @@ async function downloadOpenRouterVideo(opts) {
   }
   fs42.mkdirSync(path47.dirname(dest), { recursive: true });
   const ws = fs42.createWriteStream(dest);
-  const { pipeline: pipeline2 } = await import("stream/promises");
-  await pipeline2(r.body, ws);
+  const { pipeline: pipeline3 } = await import("stream/promises");
+  await pipeline3(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
     fs42.mkdirSync(path47.dirname(path47.resolve(opts.output)), { recursive: true });
@@ -8459,8 +8466,916 @@ function registerOpenRouterCommands(program2) {
   registerOpenRouterVideoModelsCommand(openrouter);
 }
 
-// src/commands/check.ts
+// src/providers/replicate/models.ts
+init_errors();
+var DEFAULT_REPLICATE_BASE_URL = "https://api.replicate.com/v1";
+var DEFAULT_REPLICATE_IMAGE_MODEL = "black-forest-labs/flux-schnell";
+var DEFAULT_REPLICATE_VIDEO_MODEL = "prunaai/p-video";
+var TERMINAL_STATUSES = [
+  "succeeded",
+  "failed",
+  "canceled",
+  "aborted"
+];
+function isTerminalStatus2(status) {
+  return TERMINAL_STATUSES.includes(status);
+}
+var NAME_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+var VERSION_RE = /^[a-z0-9]+$/i;
+var BARE_VERSION_RE = /^[a-f0-9]{64}$/i;
+function parseModelRef(ref, explicitVersion) {
+  const trimmed = ref.trim();
+  if (explicitVersion !== void 0 && !VERSION_RE.test(explicitVersion)) {
+    throw new ValidationError(`Invalid Replicate version id "${explicitVersion}"`);
+  }
+  if (BARE_VERSION_RE.test(trimmed)) {
+    if (explicitVersion && explicitVersion !== trimmed) {
+      throw new ValidationError("Conflicting version ids: model argument and --version differ");
+    }
+    return { kind: "version", version: trimmed };
+  }
+  const [path54, inlineVersion, ...rest] = trimmed.split(":");
+  const [owner, name, ...extra] = (path54 ?? "").split("/");
+  if (rest.length > 0 || extra.length > 0 || !owner || !name) {
+    throw new ValidationError(
+      `Invalid Replicate model "${ref}" \u2014 expected owner/name, owner/name:version, or a 64-char version id`
+    );
+  }
+  if (!NAME_RE.test(owner) || !NAME_RE.test(name)) {
+    throw new ValidationError(`Invalid Replicate model "${ref}" \u2014 owner and name must be slugs`);
+  }
+  if (inlineVersion !== void 0) {
+    if (!VERSION_RE.test(inlineVersion)) {
+      throw new ValidationError(`Invalid Replicate version id in "${ref}"`);
+    }
+    if (explicitVersion && explicitVersion !== inlineVersion) {
+      throw new ValidationError("Conflicting version ids: model argument and --version differ");
+    }
+    return { kind: "version", version: inlineVersion, owner, name };
+  }
+  if (explicitVersion) return { kind: "version", version: explicitVersion, owner, name };
+  return { kind: "official", owner, name };
+}
+function describeModelRef(ref) {
+  if (ref.kind === "official") return `${ref.owner}/${ref.name}`;
+  const short = ref.version.slice(0, 12);
+  return ref.owner && ref.name ? `${ref.owner}/${ref.name}:${short}` : `version ${short}`;
+}
+var PREDICTION_ID_RE2 = /^[a-z0-9]+$/i;
+function isValidPredictionId(id) {
+  return typeof id === "string" && PREDICTION_ID_RE2.test(id);
+}
+function assertPredictionId(id) {
+  const trimmed = id.trim();
+  if (!PREDICTION_ID_RE2.test(trimmed)) {
+    throw new ValidationError(`Invalid Replicate prediction id "${id}"`);
+  }
+  return trimmed;
+}
+
+// src/providers/replicate/node-client.ts
+init_errors();
+
+// src/providers/replicate/client.ts
+init_errors();
+var PROVIDER = "replicate";
+var DETAIL_MAX = 300;
+var CREATE_MAX_RETRIES = 2;
+var CREATE_RETRY_CAP_MS = 3e4;
+var REQUEST_TIMEOUT_MS = 6e4;
+var UPLOAD_TIMEOUT_MS = 3e5;
+var ReplicateApiError = class extends ProviderError {
+  constructor(message, status, retryAfterMs) {
+    super(message, PROVIDER);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "ReplicateApiError";
+  }
+  status;
+  retryAfterMs;
+};
+var ReplicatePredictionError = class extends ProviderError {
+  constructor(prediction2) {
+    const detail = formatPredictionError(prediction2.error);
+    super(
+      `Replicate prediction ${prediction2.id} ${prediction2.status}${detail ? `: ${detail}` : ""}`,
+      PROVIDER
+    );
+    this.prediction = prediction2;
+    this.name = "ReplicatePredictionError";
+  }
+  prediction;
+};
+function formatPredictionError(error) {
+  if (error === null || error === void 0 || error === "") return "";
+  const text = typeof error === "string" ? error : JSON.stringify(error);
+  return text.slice(0, DETAIL_MAX);
+}
+function errorDetail(snippet) {
+  try {
+    const body = JSON.parse(snippet);
+    const detail = body.detail ?? body.title ?? body.error;
+    if (typeof detail === "string" && detail) return detail.slice(0, DETAIL_MAX);
+  } catch {
+  }
+  return snippet.trim().slice(0, DETAIL_MAX);
+}
+function mapReplicateError(error, subject) {
+  if (!(error instanceof HttpError)) return error;
+  const detail = errorDetail(error.snippet);
+  const suffix = detail ? `: ${detail}` : "";
+  const { status, retryAfterMs } = error;
+  let message;
+  if (status === 0) {
+    message = `Network error contacting Replicate${suffix}`;
+  } else if (status === 401) {
+    message = "Replicate rejected the API token (401). Check REPLICATE_API_TOKEN (or REPLICATE_API_KEY); create one at https://replicate.com/account/api-tokens";
+  } else if (status === 402) {
+    message = `Replicate requires billing for this request (402)${suffix}. See https://replicate.com/account/billing`;
+  } else if (status === 403) {
+    message = `Replicate denied access to ${subject} (403)${suffix}`;
+  } else if (status === 404) {
+    message = subject.startsWith("prediction") ? `Replicate could not find ${subject} (404); it may belong to another account or have expired` : `Replicate could not find ${subject} (404). Check owner/name; community models need an explicit version (owner/name:version or --version)`;
+  } else if (status === 422) {
+    message = `Replicate rejected the input for ${subject} (422)${suffix}. Check the model's input schema on replicate.com`;
+  } else if (status === 429) {
+    const wait = retryAfterMs !== void 0 ? `; retry after ${Math.ceil(retryAfterMs / 1e3)}s` : "";
+    message = `Replicate rate limit reached (429)${wait}`;
+  } else if (status >= 500) {
+    message = `Replicate server error (${status})${suffix}. Try again later`;
+  } else {
+    message = `Replicate request for ${subject} failed (${status})${suffix}`;
+  }
+  return new ReplicateApiError(message, status, retryAfterMs);
+}
+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);
+  }
+  if (!isValidPredictionId(value.id)) {
+    throw new ProviderError("Malformed Replicate response: invalid prediction id", PROVIDER);
+  }
+  return value;
+}
+function assertSucceeded(prediction2) {
+  if (prediction2.status === "succeeded") return prediction2;
+  if (isTerminalStatus2(prediction2.status)) throw new ReplicatePredictionError(prediction2);
+  throw new ProviderError(
+    `Replicate prediction ${prediction2.id} is not finished (status: ${prediction2.status})`,
+    PROVIDER
+  );
+}
+var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var ReplicateClient = class {
+  apiKey;
+  baseUrl;
+  doFetch;
+  sleep;
+  constructor(opts) {
+    if (!opts.apiKey) throw new ProviderError("Replicate API token is required", PROVIDER);
+    this.apiKey = opts.apiKey;
+    this.baseUrl = (opts.baseUrl || DEFAULT_REPLICATE_BASE_URL).replace(/\/+$/, "");
+    this.doFetch = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.sleep = opts.sleep ?? defaultSleep2;
+  }
+  headers(extra = {}) {
+    return { accept: "application/json", authorization: `Bearer ${this.apiKey}`, ...extra };
+  }
+  /** Raw request: throws HttpError so polling can classify transient failures. */
+  raw(path54, method, body, headers2, timeoutMs = REQUEST_TIMEOUT_MS) {
+    return fetchJson({
+      url: `${this.baseUrl}${path54}`,
+      method,
+      headers: this.headers(headers2),
+      body,
+      timeoutMs,
+      fetch: this.doFetch
+    });
+  }
+  /** Create a prediction on the official-model or versioned endpoint. */
+  async createPrediction(opts) {
+    const { model, input } = opts;
+    const isOfficial = model.kind === "official";
+    const path54 = isOfficial ? `/models/${model.owner}/${model.name}/predictions` : "/predictions";
+    const body = isOfficial ? { input } : { version: model.version, input };
+    const subject = isOfficial ? `model ${model.owner}/${model.name}` : `model version ${model.version}`;
+    const headers2 = {};
+    let timeoutMs = REQUEST_TIMEOUT_MS;
+    if (opts.preferWaitSeconds !== void 0) {
+      const seconds = Math.min(60, Math.max(1, Math.round(opts.preferWaitSeconds)));
+      headers2.prefer = `wait=${seconds}`;
+      timeoutMs += seconds * 1e3;
+    }
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const res = await this.raw(path54, "POST", body, headers2, timeoutMs);
+        return validatePrediction(res);
+      } catch (error) {
+        if (error instanceof HttpError && error.status === 429 && attempt < CREATE_MAX_RETRIES) {
+          const delay = Math.min(error.retryAfterMs ?? 2e3 * (attempt + 1), CREATE_RETRY_CAP_MS);
+          await this.sleep(delay);
+          continue;
+        }
+        throw mapReplicateError(error, subject);
+      }
+    }
+  }
+  async getPrediction(id) {
+    const safeId = assertPredictionId(id);
+    try {
+      return validatePrediction(await this.raw(`/predictions/${safeId}`, "GET"));
+    } catch (error) {
+      throw mapReplicateError(error, `prediction ${safeId}`);
+    }
+  }
+  /** Cancel a running prediction (POST /predictions/{id}/cancel). */
+  async cancelPrediction(id) {
+    const safeId = assertPredictionId(id);
+    try {
+      return validatePrediction(await this.raw(`/predictions/${safeId}/cancel`, "POST"));
+    } catch (error) {
+      throw mapReplicateError(error, `prediction ${safeId}`);
+    }
+  }
+  /**
+   * Poll until the prediction reaches a terminal status (succeeded, failed,
+   * 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);
+    try {
+      return await pollUntil({
+        fetchStatus: async ({ remainingMs }) => validatePrediction(
+          await this.raw(
+            `/predictions/${safeId}`,
+            "GET",
+            void 0,
+            void 0,
+            // AbortSignal.timeout needs a positive integer; clocks may be fractional.
+            Math.max(1, Math.ceil(Math.min(REQUEST_TIMEOUT_MS, remainingMs)))
+          )
+        ),
+        isTerminal: (p) => isTerminalStatus2(p.status),
+        isTransientError: isTransientHttpError,
+        timeoutMs: opts.timeoutMs,
+        intervalMs: opts.intervalMs ?? 2e3,
+        maxIntervalMs: opts.maxIntervalMs ?? 1e4,
+        resumeHint: opts.resumeHint,
+        onPoll: opts.onPoll,
+        sleep: opts.sleep ?? this.sleep,
+        now: opts.now
+      });
+    } catch (error) {
+      if (error instanceof PollTimeoutError) throw error;
+      throw mapReplicateError(error, `prediction ${safeId}`);
+    }
+  }
+  /**
+   * Upload a file via the Files API (multipart, < 100 MB) and return the file
+   * resource; pass `urls.get` as a model input value.
+   */
+  async uploadFile(opts) {
+    const form = new FormData();
+    const blob = opts.data.type ? opts.data : new Blob([opts.data], { type: opts.contentType });
+    form.append("content", blob, opts.filename);
+    form.append("filename", opts.filename);
+    form.append("type", opts.contentType);
+    const url = `${this.baseUrl}/files`;
+    const subject = `file upload ${opts.filename}`;
+    let response;
+    try {
+      response = await this.doFetch(url, {
+        method: "POST",
+        headers: this.headers(),
+        body: form,
+        signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS)
+      });
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      throw mapReplicateError(new HttpError(0, msg, url), subject);
+    }
+    if (!response.ok) {
+      if (response.status === 413) {
+        throw new ReplicateApiError(
+          "Replicate rejected the upload: files must be less than 100MB",
+          413
+        );
+      }
+      throw mapReplicateError(await httpErrorFromResponse(response, url), subject);
+    }
+    const file = await response.json();
+    if (typeof file?.urls?.get !== "string") {
+      throw new ProviderError("Malformed Replicate file response: missing urls.get", PROVIDER);
+    }
+    return file;
+  }
+};
+
+// src/providers/replicate/node-client.ts
+var REPLICATE_TOKEN_ENV = "REPLICATE_API_TOKEN";
+var REPLICATE_TOKEN_FALLBACK_ENV = "REPLICATE_API_KEY";
+function resolveReplicateToken() {
+  const found = resolveFirstKey(REPLICATE_TOKEN_ENV, REPLICATE_TOKEN_FALLBACK_ENV);
+  return found ? { token: found.value, envUsed: found.envUsed } : void 0;
+}
+function requireReplicateToken() {
+  const resolved = resolveReplicateToken();
+  if (!resolved) {
+    throw new ConfigError(
+      `${REPLICATE_TOKEN_ENV} is not set (${REPLICATE_TOKEN_FALLBACK_ENV} is also accepted). Get one at https://replicate.com/account/api-tokens`
+    );
+  }
+  return resolved.token;
+}
+function replicateBaseUrl() {
+  return resolveKey("REPLICATE_BASE_URL")?.trim() || DEFAULT_REPLICATE_BASE_URL;
+}
+function replicateImageModel() {
+  return resolveKey("REPLICATE_IMAGE_MODEL")?.trim() || DEFAULT_REPLICATE_IMAGE_MODEL;
+}
+function replicateVideoModel() {
+  return resolveKey("REPLICATE_VIDEO_MODEL")?.trim() || DEFAULT_REPLICATE_VIDEO_MODEL;
+}
+function createReplicateClient() {
+  return new ReplicateClient({ apiKey: requireReplicateToken(), baseUrl: replicateBaseUrl() });
+}
+
+// src/providers/replicate/commands/cancel.ts
+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})`);
+    } else {
+      logger.info(`Cancel requested for ${prediction2.id} (status: ${prediction2.status})`);
+    }
+  });
+}
+
+// src/providers/replicate/commands/image.ts
+init_errors();
+
+// src/providers/replicate/commands/prediction-flow.ts
+init_errors();
+
+// src/providers/replicate/node-outputs.ts
+init_errors();
+init_redact();
+import { once as once2 } from "events";
 import fs43 from "fs";
+import path48 from "path";
+import { Readable } from "stream";
+import { pipeline as pipeline2 } from "stream/promises";
+
+// src/providers/replicate/output.ts
+init_redact();
+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));
+}
+function extractOutput(output) {
+  const result = { media: [], texts: [] };
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value, path54) => {
+    if (value === null || value === void 0) return;
+    if (typeof value === "string") {
+      if (isMediaRef(value)) result.media.push({ url: value, path: path54 || "output" });
+      else if (value.length > 0) result.texts.push(path54 ? `${path54}: ${value}` : value);
+      return;
+    }
+    if (typeof value !== "object") {
+      result.texts.push(path54 ? `${path54}: ${String(value)}` : String(value));
+      return;
+    }
+    if (seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      if (value.length > 0 && value.every((v) => typeof v === "string" && !isMediaRef(v))) {
+        const joined = value.join("");
+        if (joined.length > 0) result.texts.push(path54 ? `${path54}: ${joined}` : joined);
+        return;
+      }
+      value.forEach((item, i) => visit(item, `${path54}[${i}]`));
+      return;
+    }
+    for (const [key, val] of Object.entries(value)) {
+      visit(val, path54 ? `${path54}.${key}` : key);
+    }
+  };
+  visit(output, "");
+  return result;
+}
+var MIME_TO_EXT = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/jpg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "image/svg+xml": ".svg",
+  "image/bmp": ".bmp",
+  "image/tiff": ".tiff",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "video/webm": ".webm",
+  "audio/mpeg": ".mp3",
+  "audio/mp3": ".mp3",
+  "audio/wav": ".wav",
+  "audio/x-wav": ".wav",
+  "audio/ogg": ".ogg",
+  "audio/flac": ".flac",
+  "audio/mp4": ".m4a",
+  "audio/aac": ".aac",
+  "model/gltf-binary": ".glb",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "application/zip": ".zip",
+  "text/plain": ".txt"
+};
+var EXT_TO_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".tif": "image/tiff",
+  ".tiff": "image/tiff",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".flac": "audio/flac",
+  ".m4a": "audio/mp4",
+  ".aac": "audio/aac",
+  ".glb": "model/gltf-binary",
+  ".pdf": "application/pdf",
+  ".json": "application/json",
+  ".zip": "application/zip",
+  ".txt": "text/plain"
+};
+function extFromContentType(contentType) {
+  if (!contentType) return void 0;
+  const mime = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  return MIME_TO_EXT[mime];
+}
+function mimeFromFilename(filename) {
+  const dot = filename.lastIndexOf(".");
+  const ext = dot === -1 ? "" : filename.slice(dot).toLowerCase();
+  return EXT_TO_MIME[ext] ?? "application/octet-stream";
+}
+function extFromUrl4(url) {
+  if (DATA_URI_RE.test(url)) {
+    const mime = url.slice(5, url.indexOf(",")).split(";")[0];
+    return extFromContentType(mime);
+  }
+  try {
+    const pathname = new URL(url).pathname;
+    const last = pathname.split("/").pop() ?? "";
+    const dot = last.lastIndexOf(".");
+    if (dot <= 0) return void 0;
+    const ext = last.slice(dot).toLowerCase();
+    return /^\.[a-z0-9]{1,5}$/.test(ext) ? ext : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function summarizePrediction(p) {
+  const summary = { id: p.id, status: p.status };
+  if (p.model) summary.model = p.model;
+  if (p.version) summary.version = p.version;
+  if (p.error !== void 0 && p.error !== null) summary.error = p.error;
+  if (p.output !== void 0 && p.output !== null) summary.output = redactOutputUrls(p.output);
+  if (p.metrics) summary.metrics = p.metrics;
+  if (p.created_at) summary.created_at = p.created_at;
+  if (p.completed_at) summary.completed_at = p.completed_at;
+  if (p.urls?.web) summary.web_url = p.urls.web;
+  return summary;
+}
+function redactOutputUrls(value) {
+  if (typeof value === "string") {
+    if (DATA_URI_RE.test(value)) return `${value.slice(0, value.indexOf(",") + 1)}[redacted]`;
+    return HTTP_RE.test(value) ? redactUrl(value) : value;
+  }
+  if (Array.isArray(value)) return value.map(redactOutputUrls);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, redactOutputUrls(v)])
+    );
+  }
+  return value;
+}
+function outputFilename(predictionId, index, ext) {
+  const prefix = predictionId.replace(/[^a-z0-9]/gi, "").slice(0, 8) || "output";
+  return `replicate-${prefix}-${String(index + 1).padStart(2, "0")}${ext}`;
+}
+
+// src/providers/replicate/node-outputs.ts
+var DOWNLOAD_TIMEOUT_MS = 3e5;
+function isDirTarget(output) {
+  if (/[\\/]$/.test(output)) return true;
+  try {
+    return fs43.statSync(output).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveDestination(predictionId, index, count, ext, opts) {
+  if (!opts.output) return path48.join(opts.outDir, outputFilename(predictionId, index, ext));
+  const output = path48.resolve(opts.output);
+  if (isDirTarget(opts.output)) return path48.join(output, outputFilename(predictionId, index, ext));
+  const givenExt = path48.extname(output);
+  if (count === 1) return givenExt ? output : `${output}${ext}`;
+  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 = fs43.createWriteStream(dest);
+  try {
+    await pipeline2(
+      Readable.fromWeb(response.body),
+      fileStream
+    );
+  } catch (err2) {
+    if (!fileStream.closed) await once2(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(
+      predictionId,
+      index,
+      count,
+      extFromUrl4(item.url) ?? ".bin",
+      opts
+    );
+    fs43.mkdirSync(path48.dirname(dest2), { recursive: true });
+    fs43.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);
+  }
+  const ext = extFromUrl4(item.url) ?? extFromContentType(response.headers.get("content-type")) ?? ".bin";
+  const dest = resolveDestination(predictionId, index, count, ext, opts);
+  fs43.mkdirSync(path48.dirname(dest), { recursive: true });
+  try {
+    await writeResponse(response, dest);
+  } catch (err2) {
+    fs43.rmSync(dest, { force: true });
+    throw err2;
+  }
+  return dest;
+}
+async function saveMediaOutputs(predictionId, media, opts) {
+  const saved = [];
+  const failed = [];
+  for (let i = 0; i < media.length; i++) {
+    const item = media[i];
+    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);
+      saved.push(dest);
+      opts.logger.success(`Saved ${dest}`);
+    } catch (e) {
+      failed.push(item.path);
+      opts.logger.warn(`Download failed for ${item.path}: ${e instanceof Error ? e.message : e}`);
+    }
+  }
+  if (failed.length > 0) {
+    const what = saved.length === 0 ? `none of ${media.length} output file(s) could be downloaded` : `${failed.length} of ${media.length} output file(s) failed to download (${failed.join(", ")})`;
+    const hint = opts.retryHint ? `. ${opts.retryHint}` : "";
+    throw new ProviderError(`Prediction ${predictionId}: ${what}${hint}`, "replicate");
+  }
+  return saved;
+}
+
+// src/providers/replicate/commands/prediction-flow.ts
+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"
+  ).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 parsePositiveInt(raw, flag, max) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0 || max !== void 0 && n > max) {
+    throw new ValidationError(
+      `${flag} must be a positive integer${max !== void 0 ? ` up to ${max}` : ""}`
+    );
+  }
+  return n;
+}
+function parsePreferWait(value) {
+  if (value === void 0 || value === false) return void 0;
+  if (value === true) return 60;
+  return parsePositiveInt(value, "--prefer-wait", 60);
+}
+function resumeCommand2(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: ${resumeCommand2(prediction2.id)}`);
+  console.log(`  Cancel: multix replicate cancel ${prediction2.id}`);
+}
+async function reportOutputs(prediction2, opts) {
+  const { media, texts } = extractOutput(prediction2.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));
+    return [];
+  }
+  if (!opts.download) {
+    for (const m of media) console.log(m.url);
+    return [];
+  }
+  const saved = await saveMediaOutputs(prediction2.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`
+  });
+  const finals = opts.finalize ? opts.finalize(saved) : saved;
+  console.log(`
+Saved ${finals.length} file(s) from prediction ${prediction2.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)) {
+    opts.logger.info(`Waiting for prediction ${id}...`);
+  }
+  const final = await client.waitForPrediction(prediction2, {
+    timeoutMs: opts.waitTimeoutMs,
+    resumeHint: `Resume with: ${resumeCommand2(id)}`,
+    onPoll: (p, attempt) => {
+      if (p.status !== lastStatus) opts.logger.debug(`attempt ${attempt}: ${p.status}`);
+      lastStatus = p.status;
+    }
+  });
+  assertSucceeded(final);
+  opts.logger.success(`Prediction ${final.id} succeeded`);
+  return reportOutputs(final, opts);
+}
+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) {
+    throw new ValidationError("--async and --prefer-wait are mutually exclusive");
+  }
+  const waitTimeoutMs = parsePositiveInt(opts.waitTimeout, "--wait-timeout");
+  const preferWaitSeconds = parsePreferWait(opts.preferWait);
+  logger.info(`Submitting to Replicate ${describeModelRef(model)}...`);
+  const prediction2 = await client.createPrediction({ model, input, preferWaitSeconds });
+  if (opts.async) {
+    printAsyncHandle(prediction2);
+    return;
+  }
+  logger.info(`Prediction ${prediction2.id} (status: ${prediction2.status})`);
+  await completePrediction(client, prediction2, {
+    waitTimeoutMs,
+    logger,
+    download: opts.download !== false,
+    output: opts.output,
+    finalize: params.finalize
+  });
+}
+
+// src/providers/replicate/commands/image.ts
+var ASPECT_RE = /^\d{1,2}:\d{1,2}$/;
+var OUTPUT_FORMATS = ["webp", "jpg", "png"];
+function buildImageInput(prompt, opts) {
+  if (!prompt.trim()) throw new ValidationError("Prompt must not be empty");
+  if (opts.aspectRatio && !ASPECT_RE.test(opts.aspectRatio)) {
+    throw new ValidationError("--aspect-ratio must look like 16:9");
+  }
+  if (opts.outputFormat && !OUTPUT_FORMATS.includes(opts.outputFormat)) {
+    throw new ValidationError(`--output-format must be one of: ${OUTPUT_FORMATS.join(", ")}`);
+  }
+  const extra = opts.input ? parseJsonInput(opts.input) : {};
+  return {
+    ...extra,
+    prompt,
+    ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
+    ...opts.numOutputs ? { num_outputs: parsePositiveInt(opts.numOutputs, "--num-outputs", 10) } : {},
+    ...opts.seed !== void 0 ? { seed: parseSeed(opts.seed) } : {},
+    ...opts.outputFormat ? { output_format: opts.outputFormat } : {}
+  };
+}
+function parseSeed(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0)
+    throw new ValidationError("--seed must be a non-negative integer");
+  return n;
+}
+function registerReplicateImageCommand(parent) {
+  const cmd = parent.command("image <prompt>").description(`Generate images via Replicate (default: ${replicateImageModel()})`).option("-m, --model <ref>", "Model: owner/name or owner/name:version").option("--aspect-ratio <ratio>", "Aspect ratio, e.g. 1:1, 16:9, 9:16").option("-n, --num-outputs <n>", "Number of images (model limits apply)").option("--seed <n>", "Seed for reproducible output").option("--output-format <fmt>", "Provider output format: webp | jpg | png").option("--input <json>", "Extra model-specific input fields as JSON or @file.json").addOption(imageFormatOption()).addOption(noWebpOption());
+  addFlowOptions(cmd, 3e5).action(async (prompt, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const model = parseModelRef(opts.model ?? replicateImageModel());
+    const input = buildImageInput(prompt, opts);
+    const client = createReplicateClient();
+    await executePrediction2({
+      client,
+      model,
+      input,
+      opts,
+      logger,
+      finalize: (files) => finalizeGeneratedImages(files, {
+        imageFormat: opts.imageFormat,
+        webp: opts.webp,
+        output: opts.output,
+        logger,
+        explicitProviderFormat: Boolean(opts.outputFormat)
+      })
+    });
+  });
+}
+
+// src/providers/replicate/node-input-files.ts
+init_errors();
+import fs44 from "fs";
+import path49 from "path";
+var DATA_URI_MAX_BYTES = 256 * 1024;
+var UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+function formatMb2(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function resolveFileInput(value, client, logger) {
+  if (isMediaRef(value)) return value;
+  const filePath = path49.resolve(value);
+  let stat;
+  try {
+    stat = fs44.statSync(filePath);
+  } catch {
+    throw new ValidationError(`Input file not found: ${value} (pass a local path or an https URL)`);
+  }
+  if (!stat.isFile()) throw new ValidationError(`Input path is not a file: ${value}`);
+  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.`
+    );
+  }
+  const filename = path49.basename(filePath);
+  const contentType = mimeFromFilename(filename);
+  const bytes = fs44.readFileSync(filePath);
+  if (stat.size <= DATA_URI_MAX_BYTES) {
+    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...`);
+  const file = await client.uploadFile({
+    data: new Blob([bytes], { type: contentType }),
+    filename,
+    contentType
+  });
+  logger.debug(`Uploaded ${filename} as file ${file.id}`);
+  return file.urls.get;
+}
+function parseFileAssignments(values) {
+  return (values ?? []).map((raw) => {
+    const eq = raw.indexOf("=");
+    const key = eq > 0 ? raw.slice(0, eq).trim() : "";
+    const value = eq > 0 ? raw.slice(eq + 1).trim() : "";
+    if (!key || !value || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new ValidationError(`Invalid --file "${raw}" \u2014 expected key=path (e.g. image=./a.png)`);
+    }
+    return [key, value];
+  });
+}
+
+// src/providers/replicate/commands/run.ts
+var collect8 = (value, previous = []) => [...previous, value];
+function registerReplicateRunCommand(parent) {
+  const cmd = parent.command("run <model>").description(
+    "Run any Replicate model: owner/name (official), owner/name:version, or a version id"
+  ).requiredOption("--input <json>", "Model input as JSON, or @path/to/input.json").option("--version <id>", "Explicit model version id (uses the versioned endpoint)").option(
+    "--file <key=path>",
+    "Set input <key> to a local file or URL (uploaded if needed); repeatable",
+    collect8
+  );
+  addFlowOptions(cmd, 6e5).action(
+    async (model, opts) => {
+      const logger = createLogger({ verbose: opts.verbose ?? false });
+      const ref = parseModelRef(model, opts.version);
+      const input = parseJsonInput(opts.input);
+      const files = parseFileAssignments(opts.file);
+      const client = createReplicateClient();
+      for (const [key, value] of files) {
+        input[key] = await resolveFileInput(value, client, logger);
+      }
+      await executePrediction2({ client, model: ref, input, opts, logger });
+    }
+  );
+}
+
+// src/providers/replicate/commands/status.ts
+function registerReplicateStatusCommand(parent) {
+  parent.command("status <predictionId>").description("Get a Replicate prediction's status; --wait/--download to resume it").option("--wait", "Poll until the prediction reaches a terminal status").option("--download", "Download media outputs once succeeded").option("--output <path>", "Output file path, or a directory for multiple outputs").option("--wait-timeout <ms>", "Polling timeout in milliseconds", "900000").option("-v, --verbose", "Verbose logging").action(async (predictionId, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const client = createReplicateClient();
+    if (opts.wait) {
+      await completePrediction(client, predictionId, {
+        waitTimeoutMs: parsePositiveInt(opts.waitTimeout, "--wait-timeout"),
+        logger,
+        download: Boolean(opts.download),
+        output: opts.output
+      });
+      return;
+    }
+    const prediction2 = await client.getPrediction(predictionId);
+    if (prediction2.status === "succeeded" && opts.download) {
+      await reportOutputs(prediction2, { 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: ${resumeCommand2(prediction2.id)}`);
+    } else if (prediction2.status !== "succeeded") {
+      throw new ReplicatePredictionError(prediction2);
+    }
+  });
+}
+
+// src/providers/replicate/commands/video.ts
+init_errors();
+var ASPECT_RE2 = /^\d{1,2}:\d{1,2}$/;
+var RESOLUTION_RE = /^\d{3,4}p$/;
+function buildVideoInput(prompt, opts) {
+  if (!prompt.trim()) throw new ValidationError("Prompt must not be empty");
+  if (opts.aspectRatio && !ASPECT_RE2.test(opts.aspectRatio)) {
+    throw new ValidationError("--aspect-ratio must look like 16:9");
+  }
+  if (opts.resolution && !RESOLUTION_RE.test(opts.resolution)) {
+    throw new ValidationError("--resolution must look like 720p");
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(opts.imageKey)) {
+    throw new ValidationError("--image-key must be an input field name such as image");
+  }
+  const extra = opts.input ? parseJsonInput(opts.input) : {};
+  return {
+    ...extra,
+    prompt,
+    ...opts.duration ? { duration: parsePositiveInt(opts.duration, "--duration", 60) } : {},
+    ...opts.aspectRatio ? { aspect_ratio: opts.aspectRatio } : {},
+    ...opts.resolution ? { resolution: opts.resolution } : {},
+    ...opts.seed !== void 0 ? { seed: parseSeed(opts.seed) } : {}
+  };
+}
+function registerReplicateVideoCommand(parent) {
+  const cmd = parent.command("video <prompt>").description(`Generate video via Replicate (default: ${replicateVideoModel()})`).option("-m, --model <ref>", "Model: owner/name or owner/name:version").option("--image <path|url>", "First-frame image (local files are inlined or uploaded)").option("--image-key <name>", "Input field that receives --image", "image").option("--duration <seconds>", "Duration in seconds (model limits apply)").option("--aspect-ratio <ratio>", "Aspect ratio, e.g. 16:9, 9:16").option("--resolution <res>", "Resolution, e.g. 720p, 1080p").option("--seed <n>", "Seed for reproducible output").option("--input <json>", "Extra model-specific input fields as JSON or @file.json");
+  addFlowOptions(cmd, 9e5).action(async (prompt, opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const model = parseModelRef(opts.model ?? replicateVideoModel());
+    const input = buildVideoInput(prompt, opts);
+    const client = createReplicateClient();
+    if (opts.image) input[opts.imageKey] = await resolveFileInput(opts.image, client, logger);
+    await executePrediction2({ client, model, input, opts, logger });
+  });
+}
+
+// src/providers/replicate/commands/index.ts
+function registerReplicateCommands(program2) {
+  const replicate = program2.command("replicate").description("Replicate: generic model runner, image, video, prediction status and cancel");
+  registerReplicateRunCommand(replicate);
+  registerReplicateImageCommand(replicate);
+  registerReplicateVideoCommand(replicate);
+  registerReplicateStatusCommand(replicate);
+  registerReplicateCancelCommand(replicate);
+}
+
+// src/commands/check.ts
+import fs45 from "fs";
 import os4 from "os";
 
 // src/commands/check-helpers/binary-check.ts
@@ -8518,6 +9433,7 @@ To configure multix, set at least one provider API key:
     BytePlus           : https://console.byteplus.com/auth/api-keys
     fal.ai             : https://fal.ai/dashboard/keys
     Atlas Cloud        : https://www.atlascloud.ai/console/api-keys
+    Replicate          : https://replicate.com/account/api-tokens
 
   Option A \u2014 user global config (recommended):
     echo 'GEMINI_API_KEY=your-key' >> ~/.multix/.env
@@ -8592,6 +9508,13 @@ var PROVIDERS = [
     envPrimary: "ATLASCLOUD_API_KEY",
     optional: true,
     link: "https://www.atlascloud.ai/console/api-keys"
+  },
+  {
+    name: "Replicate",
+    envPrimary: "REPLICATE_API_TOKEN",
+    envFallback: "REPLICATE_API_KEY",
+    optional: true,
+    link: "https://replicate.com/account/api-tokens"
   }
 ];
 function resolveProviderKey(p) {
@@ -8599,13 +9522,9 @@ function resolveProviderKey(p) {
     const first = listGeminiKeys()[0];
     return first ? { key: first.value, envUsed: first.name } : {};
   }
-  const primary = resolveKey(p.envPrimary);
-  if (primary) return { key: primary, envUsed: p.envPrimary };
-  if (p.envFallback) {
-    const fb = resolveKey(p.envFallback);
-    if (fb) return { key: fb, envUsed: p.envFallback };
-  }
-  return {};
+  const names = p.envFallback ? [p.envPrimary, p.envFallback] : [p.envPrimary];
+  const found = resolveFirstKey(...names);
+  return found ? { key: found.value, envUsed: found.envUsed } : {};
 }
 function cloudflareReadiness() {
   const accountId = resolveKey("CLOUDFLARE_ACCOUNT_ID")?.trim();
@@ -8647,7 +9566,7 @@ function registerCheckCommand(program2) {
     }
     if (!legacyClaudeEnvEnabled()) {
       const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os4.homedir();
-      const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs43.existsSync(f));
+      const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs45.existsSync(f));
       if (legacy.length > 0) {
         logger.info(
           `Found ${legacy.length} legacy .claude env file(s); set MULTIX_LEGACY_CLAUDE_ENV=1 to load them`
@@ -8752,8 +9671,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs44 from "fs";
-import path48 from "path";
+import fs46 from "fs";
+import path50 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -8774,18 +9693,18 @@ async function convertDocuments(opts) {
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
   for (const f of inputs) {
-    if (!fs44.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs46.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path48.resolve(output);
+    outputPath = path50.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path48.basename(inputs[0], path48.extname(inputs[0]));
-    outputPath = path48.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path50.basename(inputs[0], path50.extname(inputs[0]));
+    outputPath = path50.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path48.join(getOutputDir(), "document-extraction.md");
+    outputPath = path50.join(getOutputDir(), "document-extraction.md");
   }
-  fs44.mkdirSync(path48.dirname(outputPath), { recursive: true });
+  fs46.mkdirSync(path50.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -8845,7 +9764,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path48.basename(r.file)}
+## ${path50.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -8858,7 +9777,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs44.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs46.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -8906,12 +9825,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs47 from "fs";
-import path51 from "path";
+import fs49 from "fs";
+import path53 from "path";
 
 // src/commands/media/batch.ts
-import fs45 from "fs";
-import path49 from "path";
+import fs47 from "fs";
+import path51 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -9107,10 +10026,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs45.mkdirSync(outputDir, { recursive: true });
-  const entries = fs45.readdirSync(inputDir);
+  fs47.mkdirSync(outputDir, { recursive: true });
+  const entries = fs47.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path49.extname(f).toLowerCase();
+    const ext = path51.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -9121,9 +10040,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path49.join(inputDir, file);
-    const outputPath = path49.join(outputDir, file);
-    const ext = path49.extname(file).toLowerCase();
+    const inputPath = path51.join(inputDir, file);
+    const outputPath = path51.join(outputDir, file);
+    const ext = path51.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -9160,8 +10079,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs46 from "fs";
-import path50 from "path";
+import fs48 from "fs";
+import path52 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -9172,10 +10091,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs46.mkdirSync(outputDir, { recursive: true });
-  const ext = path50.extname(input) || ".mp4";
-  const baseName = path50.basename(input, ext);
-  const outputPattern = path50.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs48.mkdirSync(outputDir, { recursive: true });
+  const ext = path52.extname(input) || ".mp4";
+  const baseName = path52.basename(input, ext);
+  const outputPattern = path52.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -9194,8 +10113,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path50.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs46.existsSync(fname)) files.push(fname);
+    const fname = path52.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs48.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -9209,9 +10128,9 @@ function registerMediaCommands(program2) {
   media.command("optimize").description("Optimize a single media file (video, audio, or image)").requiredOption("--input <file>", "Input media file").requiredOption("--output <file>", "Output file path").option("--target-size <MB>", "Target file size in MB").option("--quality <n>", "Quality: video CRF (0-51) or image (1-100)", "85").option("--max-width <px>", "Max image/video width in pixels", "1920").option("--bitrate <rate>", "Audio bitrate (e.g. 64k)", "64k").option("--resolution <WxH>", "Force video resolution (e.g. 1920x1080)").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs47.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs47.mkdirSync(path51.dirname(path51.resolve(opts.output)), { recursive: true });
-      const ext = path51.extname(opts.input).toLowerCase();
+      if (!fs49.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs49.mkdirSync(path53.dirname(path53.resolve(opts.output)), { recursive: true });
+      const ext = path53.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -9251,7 +10170,7 @@ function registerMediaCommands(program2) {
   media.command("split").description("Split a long video into fixed-duration chunks").requiredOption("--input <file>", "Input video file").option("--output-dir <dir>", "Output directory for chunks", "./chunks").option("--chunk-duration <sec>", "Chunk duration in seconds", "3600").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs47.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs49.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -9267,7 +10186,7 @@ Created ${chunks.length} chunk(s) in ${opts.outputDir}`);
   media.command("batch").description("Batch optimize all media files in a directory").requiredOption("--input-dir <dir>", "Input directory").requiredOption("--output-dir <dir>", "Output directory").option("--quality <n>", "Quality setting", "85").option("--max-width <px>", "Max image/video width", "1920").option("--bitrate <rate>", "Audio bitrate", "64k").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs47.existsSync(opts.inputDir))
+      if (!fs49.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -9448,6 +10367,7 @@ function registerCommands(program2) {
   registerElevenLabsCommands(program2);
   registerFalCommands(program2);
   registerAtlasCloudCommands(program2);
+  registerReplicateCommands(program2);
   registerMediaCommands(program2);
   registerDocCommands(program2);
 }
@@ -9461,8 +10381,8 @@ loadEnv();
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
 var program = new Command().name("multix").description(
-  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, ffmpeg, and ImageMagick"
-).version(pkg.version);
+  "AI multimodal CLI \u2014 image/video/audio/3D generation, editing, transcription, and media processing via OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, Replicate, ffmpeg, and ImageMagick"
+).version(pkg.version).enablePositionalOptions();
 registerCommands(program);
 program.parseAsync(process.argv).catch((err2) => {
   const msg = err2 instanceof Error ? err2.message : String(err2);