@mrgoonie/multix 1.0.7 → 1.0.9

package/dist/index.js

@@ -0,0 +1,1189 @@
+// src/core/env-loader.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { parse as dotenvParse } from "dotenv";
+
+// src/core/redact.ts
+function redact(key) {
+  if (key.length <= 10) return "***";
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+function redactUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.origin === "null") return `${u.protocol}[redacted]`;
+    const suffix = u.search || u.hash ? "?[redacted]" : "";
+    return `${u.origin}${u.pathname}${suffix}`;
+  } catch {
+    const cut = url.search(/[?#]/);
+    return cut === -1 ? url : `${url.slice(0, cut)}?[redacted]`;
+  }
+}
+
+// src/core/errors.ts
+var MultixError = class extends Error {
+  constructor(message, code, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "MultixError";
+    Error.captureStackTrace?.(
+      this,
+      this.constructor
+    );
+  }
+  code;
+};
+var ConfigError = class extends MultixError {
+  constructor(message, options) {
+    super(message, "CONFIG_ERROR", options);
+    this.name = "ConfigError";
+  }
+};
+var ProviderError = class extends MultixError {
+  constructor(message, provider, options) {
+    super(message, "PROVIDER_ERROR", options);
+    this.provider = provider;
+    this.name = "ProviderError";
+  }
+  provider;
+};
+var ValidationError = class extends MultixError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+  }
+};
+var HttpError = class extends MultixError {
+  constructor(status, snippet, url, retryAfterMs, options) {
+    super(`HTTP ${status} from ${redactUrl(url)}: ${snippet}`, "HTTP_ERROR", options);
+    this.status = status;
+    this.snippet = snippet;
+    this.retryAfterMs = retryAfterMs;
+    this.url = redactUrl(url);
+    Object.defineProperty(this, "rawUrl", { value: url, enumerable: false });
+    this.name = "HttpError";
+  }
+  status;
+  snippet;
+  retryAfterMs;
+  /** Request URL with query string and fragment redacted — safe to log or serialize. */
+  url;
+};
+
+// src/core/env-loader.ts
+function envNameKey(name, platform = process.platform) {
+  return platform === "win32" ? name.toUpperCase() : name;
+}
+var loaded = false;
+var loadedFiles = [];
+var fileOrigins = /* @__PURE__ */ new Map();
+var userFileValues = {};
+var warned = /* @__PURE__ */ new Set();
+var LEGACY_SKILL_DIRS = ["ai-multimodal", "ak-ai-multimodal"];
+function legacyFilesUnder(root) {
+  const claude = path.join(root, ".claude");
+  return [
+    ...LEGACY_SKILL_DIRS.map((dir) => path.join(claude, "skills", dir, ".env")),
+    path.join(claude, "skills", ".env"),
+    path.join(claude, ".env")
+  ];
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    const r = path.resolve(p);
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return norm(a) === norm(b);
+}
+function legacyClaudeEnvFiles(cwd, home) {
+  const files = legacyFilesUnder(cwd);
+  if (home && !samePath(home, cwd)) files.push(...legacyFilesUnder(home));
+  return files;
+}
+function legacyClaudeEnvEnabled(env = process.env) {
+  return isTruthy(env.MULTIX_LEGACY_CLAUDE_ENV);
+}
+var LEGACY_ALLOWED_NAME = /^[A-Z][A-Z0-9_]*_(API_KEY(_\d+)?|API_TOKEN|ACCOUNT_ID|GATEWAY_ID)$|^(FAL_KEY|ARK_API_KEY)$/;
+function isLegacyAllowedName(name) {
+  return LEGACY_ALLOWED_NAME.test(name);
+}
+function isReadableFile(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function parseFile(file) {
+  if (!isReadableFile(file)) return void 0;
+  try {
+    return dotenvParse(fs.readFileSync(file));
+  } catch {
+    return void 0;
+  }
+}
+function fileMaySet(name, value) {
+  const current = process.env[name];
+  if (current === void 0) return true;
+  if (current.trim() !== "" || value.trim() === "") return false;
+  return fileOrigins.get(envNameKey(name))?.value === current;
+}
+function loadFile(file, source, accept = () => true, onRefused) {
+  const parsed = parseFile(file);
+  if (!parsed) return void 0;
+  for (const [name, value] of Object.entries(parsed)) {
+    if (!accept(name)) {
+      onRefused?.(name);
+      continue;
+    }
+    if (!fileMaySet(name, value)) continue;
+    process.env[name] = value;
+    fileOrigins.set(envNameKey(name), { source, file, value });
+  }
+  loadedFiles.push(file);
+  return parsed;
+}
+function byNameKey(values) {
+  const out = {};
+  for (const [name, value] of Object.entries(values ?? {})) {
+    const key = envNameKey(name);
+    if (!(key in out)) out[key] = value;
+  }
+  return out;
+}
+var MAX_LISTED_NAMES = 10;
+function listNames(names) {
+  const shown = names.slice(0, MAX_LISTED_NAMES).join(", ");
+  const rest = names.length - MAX_LISTED_NAMES;
+  return rest > 0 ? `${shown} and ${rest} more` : shown;
+}
+function loadEnv({ isProjectEnvName: isProjectEnvName2 }) {
+  if (loaded) return;
+  loaded = true;
+  loadedFiles = [];
+  fileOrigins = /* @__PURE__ */ new Map();
+  userFileValues = {};
+  const cwd = process.cwd();
+  const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os.homedir();
+  const projectFile = path.resolve(cwd, ".env");
+  const refused = [];
+  loadFile(projectFile, "project", isProjectEnvName2, (name) => refused.push(name));
+  if (refused.length > 0) {
+    warnOnce(
+      "project-env-refused",
+      `Ignoring ${refused.length} variable(s) in project env file ${projectFile}: ${listNames(refused)}. A project .env may only set provider keys and documented multix settings; set anything else in your shell.`
+    );
+  }
+  if (home) userFileValues = byNameKey(loadFile(path.join(home, ".multix", ".env"), "user"));
+  if (legacyClaudeEnvEnabled()) {
+    const projectLegacy = new Set(legacyFilesUnder(cwd));
+    const projectLegacyName = (name) => isLegacyAllowedName(name) && isProjectEnvName2(name);
+    for (const file of legacyClaudeEnvFiles(cwd, home)) {
+      if (projectLegacy.has(file)) loadFile(file, "project", projectLegacyName);
+      else loadFile(file, "legacy", isLegacyAllowedName);
+    }
+  }
+}
+function isTruthy(value) {
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+var ALLOW_PROJECT_BASE_URL_ENV = "MULTIX_ALLOW_PROJECT_BASE_URL";
+var OPT_IN_HINT = `To use the project value for one command, run it as \`${ALLOW_PROJECT_BASE_URL_ENV}=1 multix ...\`. Do not put ${ALLOW_PROJECT_BASE_URL_ENV} in ~/.multix/.env: that trusts the .env of every directory you run multix in.`;
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(`\u26A0 ${message}`);
+}
+function resolveKey(name) {
+  return process.env[name] || void 0;
+}
+
+// src/core/http-client.ts
+import fs2 from "fs";
+import path2 from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// src/core/fetch-error.ts
+var MAX_CAUSE_DEPTH = 4;
+var TLS_CODES = /* @__PURE__ */ new Set([
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+function kindOfCode(code) {
+  if (typeof code !== "string") return void 0;
+  if (code === "ERR_INVALID_URL") return "url";
+  if (code === "ERR_INVALID_CHAR" || code === "ERR_INVALID_HTTP_TOKEN") return "header";
+  if (TLS_CODES.has(code) || code.startsWith("CERT_") || code.startsWith("UNABLE_TO_")) {
+    return "tls";
+  }
+  if (code === "UND_ERR_INVALID_ARG" || code === "UND_ERR_NOT_SUPPORTED") return "request";
+  return void 0;
+}
+function kindOfMessage(message) {
+  if (typeof message !== "string") return void 0;
+  if (/Invalid URL|Failed to parse URL/i.test(message)) return "url";
+  if (/ByteString|is not a legal HTTP header value|invalid header value|invalid header name/i.test(
+    message
+  )) {
+    return "header";
+  }
+  if (/duplex option is required|cannot have body|unexpected redirect/i.test(message)) {
+    return "request";
+  }
+  return void 0;
+}
+function causeChain(err2) {
+  const out = [];
+  let current = err2;
+  for (let depth = 0; depth <= MAX_CAUSE_DEPTH && current && typeof current === "object"; depth++) {
+    const e = current;
+    out.push(e);
+    if (Array.isArray(e.errors)) {
+      for (const member of e.errors) if (member && typeof member === "object") out.push(member);
+    }
+    current = e.cause;
+  }
+  return out;
+}
+function deterministicKind(err2) {
+  for (const e of causeChain(err2)) {
+    const kind = kindOfCode(e.code) ?? kindOfMessage(e.message);
+    if (kind) return kind;
+  }
+  return void 0;
+}
+function scrub(message) {
+  return message.replace(/\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi, (u) => redactUrl(u)).replace(/[?#](?!\[redacted\])[^\s"'<>]*=[^\s"'<>]*/g, "?[redacted]");
+}
+function messageOf(e) {
+  return typeof e?.message === "string" ? scrub(e.message) : "";
+}
+function detailOf(err2) {
+  const chain = causeChain(err2);
+  const parts = [messageOf(chain[0]), messageOf(chain[1])].filter(Boolean);
+  return parts.length > 0 ? parts.join(": ") : scrub(String(err2));
+}
+function toFetchError(err2, url, opts = {}) {
+  const options = { cause: err2 };
+  const prefix = opts.prefix ?? "";
+  const target = opts.target ?? redactUrl(url);
+  switch (deterministicKind(err2)) {
+    case "url":
+      return new ConfigError(`${prefix}Invalid request URL: ${target}`, options);
+    case "header":
+      return new ConfigError(
+        `${prefix}Invalid HTTP header value in the request to ${target}. Check the API key and other header values for non-ASCII characters such as smart quotes, or line breaks.`,
+        options
+      );
+    case "tls":
+    case "request":
+      return new ProviderError(
+        `${prefix}Request to ${target} failed: ${detailOf(err2)}`,
+        opts.provider ?? "http",
+        options
+      );
+    default:
+      return new HttpError(0, `${prefix}${detailOf(err2)}`, url, void 0, options);
+  }
+}
+
+// src/core/redirect-fetch.ts
+var MAX_REDIRECTS = 5;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var BODY_HEADERS = ["content-type", "content-length", "content-encoding", "content-language"];
+function withoutBodyHeaders(headers) {
+  if (headers === void 0) return void 0;
+  const copy = new Headers(headers);
+  for (const name of BODY_HEADERS) copy.delete(name);
+  return copy;
+}
+async function fetchFollowingRedirects(url, init = {}, opts = {}) {
+  const doFetch = opts.fetch ?? ((input, i) => globalThis.fetch(input, i));
+  const { validateUrl } = opts;
+  const maxRedirects = opts.maxRedirects ?? MAX_REDIRECTS;
+  let current = url;
+  let hopInit = { ...init, redirect: "manual" };
+  for (let hop = 0; ; hop++) {
+    await validateUrl?.(current);
+    let response;
+    try {
+      response = await doFetch(current, hopInit);
+    } catch (cause) {
+      if (!opts.wrapNetworkErrors) throw cause;
+      throw toFetchError(cause, current);
+    }
+    if (validateUrl && response.url && response.url !== current) {
+      try {
+        await validateUrl(response.url);
+      } catch (err2) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw err2;
+      }
+    }
+    const location = response.headers.get("location");
+    if (!REDIRECT_STATUSES.has(response.status) || !location) {
+      return { response, url: current };
+    }
+    let next;
+    try {
+      next = new URL(location, current);
+    } catch {
+    }
+    const crossOrigin = next !== void 0 && next.origin !== new URL(current).origin;
+    if (crossOrigin && opts.crossOrigin === "stop") return { response, url: current };
+    await response.body?.cancel().catch(() => {
+    });
+    if (hop >= maxRedirects) {
+      throw new HttpError(response.status, `too many redirects (over ${maxRedirects})`, current);
+    }
+    if (!next) {
+      throw new HttpError(response.status, "redirect with a malformed Location header", current);
+    }
+    if (crossOrigin) {
+      if (opts.crossOrigin === "error") {
+        throw new HttpError(
+          response.status,
+          `refusing to follow a redirect to another origin (${next.origin})`,
+          current
+        );
+      }
+      hopInit = { ...hopInit, headers: void 0 };
+    }
+    const method = (hopInit.method ?? "GET").toUpperCase();
+    const toGet = response.status === 303 && method !== "GET" && method !== "HEAD" || (response.status === 301 || response.status === 302) && method === "POST";
+    if (toGet) {
+      hopInit = {
+        ...hopInit,
+        method: "GET",
+        body: void 0,
+        headers: withoutBodyHeaders(hopInit.headers)
+      };
+    }
+    current = next.toString();
+  }
+}
+async function fetchWithValidatedRedirects(url, opts = {}) {
+  const { signal, headers, validateUrl } = opts;
+  const init = { ...signal ? { signal } : {}, ...headers ? { headers } : {} };
+  if (!validateUrl && !headers) {
+    const doFetch = opts.fetch ?? ((input, i) => globalThis.fetch(input, i));
+    try {
+      return { response: await doFetch(url, init), url };
+    } catch (cause) {
+      throw toFetchError(cause, url);
+    }
+  }
+  return fetchFollowingRedirects(url, init, {
+    validateUrl,
+    maxRedirects: opts.maxRedirects,
+    fetch: opts.fetch,
+    wrapNetworkErrors: true
+  });
+}
+
+// src/core/fetch-json.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var SNIPPET_MAX = 500;
+function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.round(Number(trimmed) * 1e3);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, date - now);
+}
+async function httpErrorFromResponse(response, url) {
+  let snippet = "";
+  try {
+    const text = await response.text();
+    snippet = text.slice(0, SNIPPET_MAX);
+  } catch {
+    snippet = "(could not read body)";
+  }
+  return new HttpError(
+    response.status,
+    snippet,
+    url,
+    parseRetryAfter(response.headers.get("retry-after"))
+  );
+}
+var NON_CREDENTIAL_HEADERS = /* @__PURE__ */ new Set(["accept", "accept-language", "content-type", "user-agent"]);
+function carriesCredentialHeaders(headers) {
+  return Object.keys(headers).some((name) => !NON_CREDENTIAL_HEADERS.has(name.toLowerCase()));
+}
+async function fetchJson(opts) {
+  const { url, method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
+  const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
+  const init = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: AbortSignal.timeout(timeoutMs)
+  };
+  if (body !== void 0) {
+    init.body = JSON.stringify(body);
+  }
+  const { response } = await fetchFollowingRedirects(url, init, {
+    fetch: doFetch,
+    crossOrigin: carriesCredentialHeaders(headers) ? "error" : "drop-headers",
+    wrapNetworkErrors: true
+  });
+  if (!response.ok) {
+    throw await httpErrorFromResponse(response, url);
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    throw new HttpError(0, `Failed to read response body: ${msg}`, url);
+  }
+  if (text.trim() === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new HttpError(
+      response.status,
+      `Invalid JSON response: ${text.slice(0, SNIPPET_MAX)}`,
+      url
+    );
+  }
+}
+
+// src/core/http-client.ts
+async function httpJson(opts) {
+  return fetchJson(opts);
+}
+var MAX_DOWNLOAD_ENV = "MULTIX_MAX_DOWNLOAD_MB";
+function formatMb(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+var DownloadTooLargeError = class extends MultixError {
+  constructor(limitBytes, url) {
+    super(
+      `Download from ${redactUrl(url)} exceeds the ${formatMb(limitBytes)} limit (set ${MAX_DOWNLOAD_ENV} to change it)`,
+      "DOWNLOAD_TOO_LARGE"
+    );
+    this.limitBytes = limitBytes;
+    this.name = "DownloadTooLargeError";
+  }
+  limitBytes;
+};
+function removeQuietly(file) {
+  try {
+    fs2.rmSync(file, { force: true });
+  } catch {
+  }
+}
+function replaceFile(from, to) {
+  try {
+    fs2.renameSync(from, to);
+  } catch (err2) {
+    const code = err2.code;
+    const existing = fs2.statSync(to, { throwIfNoEntry: false });
+    if (!existing?.isFile() || code !== "EEXIST" && code !== "EPERM" && code !== "EACCES") {
+      throw err2;
+    }
+    fs2.rmSync(to, { force: true });
+    fs2.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) {
+    await response.body?.cancel().catch(() => {
+    });
+    throw new HttpError(response.status, "(download failed)", finalUrl);
+  }
+  if (!response.body) {
+    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;
+    fs2.mkdirSync(path2.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 part = `${dest}.${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.part`;
+  let fileStream;
+  try {
+    fileStream = fs2.createWriteStream(part);
+    await pipeline(
+      Readable.fromWeb(body),
+      countBytes,
+      fileStream
+    );
+    replaceFile(part, dest);
+  } catch (err2) {
+    if (fileStream && !fileStream.closed) {
+      await new Promise((resolve) => fileStream?.once("close", () => resolve()));
+    }
+    removeQuietly(part);
+    throw err2;
+  }
+  return { dest, contentType: response.headers.get("content-type") ?? void 0, bytes };
+}
+async function downloadFile(url, dest, timeoutMs = DEFAULT_TIMEOUT_MS, headers) {
+  const result = await downloadToFile(url, { dest, timeoutMs, headers });
+  return result.contentType;
+}
+async function fetchBytes(urlOrDataUri) {
+  if (urlOrDataUri.startsWith("data:")) {
+    const commaIdx = urlOrDataUri.indexOf(",");
+    if (commaIdx === -1) throw new Error("Malformed data URI: missing comma");
+    const encoded = urlOrDataUri.slice(commaIdx + 1);
+    return Buffer.from(encoded, "base64");
+  }
+  let response;
+  try {
+    response = await globalThis.fetch(urlOrDataUri, {
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
+    });
+  } catch (cause) {
+    throw toFetchError(cause, urlOrDataUri);
+  }
+  if (!response.ok) {
+    throw new HttpError(response.status, "(bytes fetch failed)", urlOrDataUri);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+// src/providers/atlascloud/commands/env.ts
+import { openAsBlob } from "fs";
+import fs3 from "fs/promises";
+import path3 from "path";
+
+// src/core/logger.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m"
+};
+function c(color, text) {
+  if (process.env.NO_COLOR || !process.stdout.isTTY) return text;
+  return `${color}${text}${ANSI.reset}`;
+}
+function createLogger(opts) {
+  const { verbose } = opts;
+  return {
+    info(msg) {
+      console.log(c(ANSI.blue, `  ${msg}`));
+    },
+    success(msg) {
+      console.log(c(ANSI.green, `\u2713 ${msg}`));
+    },
+    warn(msg) {
+      console.warn(c(ANSI.yellow, `\u26A0 ${msg}`));
+    },
+    error(msg) {
+      console.error(c(ANSI.red, `\u2717 ${msg}`));
+    },
+    debug(msg) {
+      if (verbose) console.log(c(ANSI.dim, `  [debug] ${msg}`));
+    },
+    header(msg) {
+      const line = "=".repeat(60);
+      console.log(c(ANSI.bold + ANSI.cyan, `
+${line}
+${msg}
+${line}
+`));
+    }
+  };
+}
+var defaultLogger = createLogger({ verbose: false });
+
+// src/core/async-poll.ts
+var PollTimeoutError = class extends MultixError {
+  constructor(message, lastStatus) {
+    super(message, "POLL_TIMEOUT");
+    this.lastStatus = lastStatus;
+    this.name = "PollTimeoutError";
+  }
+  lastStatus;
+};
+function isTransientHttpError(error) {
+  if (!(error instanceof HttpError)) return false;
+  const { status } = error;
+  return status === 408 || status === 429 || isRetryableServerStatus(status);
+}
+function isRetryableServerStatus(status) {
+  if (status === 501 || status === 505) return false;
+  return status === 0 || status >= 500;
+}
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function pollUntil(opts) {
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? defaultSleep;
+  const random = opts.random ?? Math.random;
+  const isTransient = opts.isTransientError ?? isTransientHttpError;
+  const maxInterval = opts.maxIntervalMs ?? 15e3;
+  const minInterval = opts.minIntervalMs ?? 500;
+  const factor = opts.backoffFactor ?? 1.5;
+  const jitter = opts.jitter ?? true;
+  const deadline = now() + opts.timeoutMs;
+  let interval = opts.intervalMs ?? 3e3;
+  let attempt = 0;
+  let last;
+  let lastError;
+  for (; ; ) {
+    attempt++;
+    let retryAfterMs;
+    try {
+      last = await opts.fetchStatus({ remainingMs: Math.max(1, deadline - now()), attempt });
+      lastError = void 0;
+      opts.onPoll?.(last, attempt);
+      if (opts.isTerminal(last)) return last;
+    } catch (error) {
+      if (!isTransient(error)) throw error;
+      lastError = error;
+      if (error instanceof HttpError) retryAfterMs = error.retryAfterMs;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) {
+      const hint = opts.resumeHint ? ` ${opts.resumeHint}` : "";
+      const cause = lastError instanceof Error ? ` Last error: ${lastError.message}.` : "";
+      throw new PollTimeoutError(
+        `Timed out after ${opts.timeoutMs}ms waiting for job.${cause}${hint}`,
+        last
+      );
+    }
+    let delay = retryAfterMs ?? interval;
+    if (jitter && retryAfterMs === void 0) delay *= 0.8 + random() * 0.4;
+    await sleep(Math.min(Math.max(delay, minInterval), remaining));
+    interval = Math.min(interval * factor, maxInterval);
+  }
+}
+
+// src/providers/atlascloud/models.ts
+var DEFAULT_ATLAS_BASE_URL = "https://api.atlascloud.ai/api/v1";
+var ATLAS_ROUTING = {
+  name: "ATLASCLOUD_BASE_URL",
+  defaultUrl: DEFAULT_ATLAS_BASE_URL,
+  keyEnvs: ["ATLASCLOUD_API_KEY"]
+};
+
+// src/providers/atlascloud/prediction-output.ts
+var EXT_CATEGORY = {
+  png: "image",
+  jpg: "image",
+  jpeg: "image",
+  webp: "image",
+  gif: "image",
+  bmp: "image",
+  avif: "image",
+  mp4: "video",
+  webm: "video",
+  mov: "video",
+  mkv: "video",
+  avi: "video",
+  mp3: "audio",
+  wav: "audio",
+  aac: "audio",
+  m4a: "audio",
+  flac: "audio",
+  ogg: "audio",
+  opus: "audio",
+  weba: "audio",
+  pcm: "audio",
+  glb: "3d",
+  gltf: "3d",
+  obj: "3d",
+  fbx: "3d",
+  stl: "3d",
+  ply: "3d",
+  usdz: "3d",
+  usdc: "3d",
+  usd: "3d",
+  zip: "3d"
+};
+var KNOWN_EXTENSIONS = /* @__PURE__ */ new Set([...Object.keys(EXT_CATEGORY), "svg"]);
+
+// src/providers/atlascloud/upload-mime.ts
+var UPLOAD_MIME_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  avif: "image/avif",
+  heic: "image/heic",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  avi: "video/x-msvideo",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  aac: "audio/aac",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  opus: "audio/opus"
+};
+var UPLOAD_EXTENSIONS = Object.keys(UPLOAD_MIME_TYPES);
+
+// src/providers/atlascloud/commands/env.ts
+var ATLAS_MODEL_ENV = {
+  image: "ATLASCLOUD_IMAGE_MODEL",
+  imageEdit: "ATLASCLOUD_IMAGE_EDIT_MODEL",
+  video: "ATLASCLOUD_VIDEO_MODEL",
+  imageToVideo: "ATLASCLOUD_IMAGE_TO_VIDEO_MODEL",
+  tts: "ATLASCLOUD_TTS_MODEL",
+  stt: "ATLASCLOUD_STT_MODEL",
+  textTo3d: "ATLASCLOUD_TEXT_TO_3D_MODEL",
+  imageTo3d: "ATLASCLOUD_IMAGE_TO_3D_MODEL"
+};
+var MAX_UPLOAD_ENV = "ATLASCLOUD_MAX_UPLOAD_MB";
+
+// src/providers/byteplus/models.ts
+var DEFAULT_BYTEPLUS_BASE_URL = "https://ark.ap-southeast.bytepluses.com/api/v3";
+var BYTEPLUS_ROUTING = {
+  name: "BYTEPLUS_BASE_URL",
+  defaultUrl: DEFAULT_BYTEPLUS_BASE_URL,
+  keyEnvs: ["BYTEPLUS_API_KEY", "ARK_API_KEY"]
+};
+
+// src/providers/cloudflare/models.ts
+var CLOUDFLARE_ACCOUNT_ID_ENV = "CLOUDFLARE_ACCOUNT_ID";
+var CLOUDFLARE_GATEWAY_ID_ENV = "CLOUDFLARE_AI_GATEWAY_ID";
+var CLOUDFLARE_TOKEN_ENV = "CLOUDFLARE_API_TOKEN";
+var GATEWAY_REPLICATE_TOKEN_ENV = "REPLICATE_API_TOKEN";
+var CLOUDFLARE_VIDEO_CREDENTIALS = [
+  CLOUDFLARE_TOKEN_ENV,
+  GATEWAY_REPLICATE_TOKEN_ENV
+];
+
+// src/providers/fal/models.ts
+var DEFAULT_FAL_BASE_URL = "https://queue.fal.run";
+var FAL_ROUTING = {
+  name: "FAL_BASE_URL",
+  defaultUrl: DEFAULT_FAL_BASE_URL,
+  keyEnvs: ["FAL_KEY"]
+};
+
+// src/providers/gemini/local-files.ts
+import fs4 from "fs";
+import path5 from "path";
+
+// src/providers/gemini/client.ts
+var BASE = "https://generativelanguage.googleapis.com";
+var FILES_BASE = `${BASE}/upload/v1beta/files`;
+var GENERATE_BASE = `${BASE}/v1beta/models`;
+
+// src/providers/gemini/task-resolver.ts
+import path4 from "path";
+
+// src/providers/gemini/local-files.ts
+var INLINE_MAX_BYTES = 20 * 1024 * 1024;
+var UPLOAD_MIN_KBPS_ENV = "MULTIX_UPLOAD_MIN_KBPS";
+
+// src/providers/heygen/models.ts
+var DEFAULT_HEYGEN_BASE_URL = "https://api.heygen.com";
+var HEYGEN_ROUTING = {
+  name: "HEYGEN_BASE_URL",
+  defaultUrl: DEFAULT_HEYGEN_BASE_URL,
+  keyEnvs: ["HEYGEN_API_KEY"]
+};
+var LIMITS = {
+  agentPromptMax: 1e4,
+  agentFilesMax: 20,
+  scriptMax: 5e3,
+  speechTextMax: 5e3,
+  /** POST /v3/assets single-request upload cap (32 MB). */
+  assetUploadMaxBytes: 32 * 1024 * 1024,
+  modelVideoPromptMax: 32e3,
+  modelVideoMinDuration: 5,
+  modelVideoMaxDuration: 15,
+  modelVideoReferenceImagesMax: 9,
+  modelVideoReferenceVideosMax: 3,
+  modelVideoReferenceAudioMax: 3,
+  /** Combined cap across reference images, videos and audio. */
+  modelVideoReferenceTotalMax: 12,
+  avatarListMax: 50,
+  voiceListMax: 100,
+  stylesListMax: 100
+};
+
+// src/providers/leonardo/models.ts
+var DEFAULT_LEONARDO_BASE_URL = "https://cloud.leonardo.ai/api/rest/v1";
+var LEONARDO_ROUTING = {
+  name: "LEONARDO_BASE_URL",
+  defaultUrl: DEFAULT_LEONARDO_BASE_URL,
+  keyEnvs: ["LEONARDO_API_KEY"]
+};
+
+// src/providers/replicate/models.ts
+var DEFAULT_REPLICATE_BASE_URL = "https://api.replicate.com/v1";
+var REPLICATE_ROUTING = {
+  name: "REPLICATE_BASE_URL",
+  defaultUrl: DEFAULT_REPLICATE_BASE_URL,
+  keyEnvs: ["REPLICATE_API_TOKEN", "REPLICATE_API_KEY"]
+};
+
+// src/providers/provider-keys.ts
+function keyNames(routing) {
+  const [envPrimary, envFallback] = routing.keyEnvs;
+  return envFallback ? { envPrimary, envFallback } : { envPrimary };
+}
+var PROVIDER_KEYS = [
+  {
+    name: "Gemini",
+    envPrimary: "GEMINI_API_KEY",
+    optional: false,
+    link: "https://aistudio.google.com/apikey"
+  },
+  {
+    name: "OpenRouter",
+    envPrimary: "OPENROUTER_API_KEY",
+    optional: true,
+    link: "https://openrouter.ai/settings/keys"
+  },
+  {
+    name: "OpenAI",
+    envPrimary: "OPENAI_API_KEY",
+    optional: true,
+    link: "https://platform.openai.com/api-keys"
+  },
+  {
+    name: "MiniMax",
+    envPrimary: "MINIMAX_API_KEY",
+    optional: true,
+    link: "https://platform.minimax.io/user-center/basic-information/interface-key"
+  },
+  {
+    name: "Leonardo.Ai",
+    ...keyNames(LEONARDO_ROUTING),
+    optional: true,
+    link: "https://app.leonardo.ai/settings/api-keys"
+  },
+  {
+    name: "BytePlus",
+    ...keyNames(BYTEPLUS_ROUTING),
+    optional: true,
+    link: "https://console.byteplus.com/auth/api-keys"
+  },
+  {
+    name: "ElevenLabs",
+    envPrimary: "ELEVENLABS_API_KEY",
+    optional: true,
+    link: "https://elevenlabs.io/app/settings/api-keys"
+  },
+  {
+    name: "fal.ai",
+    ...keyNames(FAL_ROUTING),
+    optional: true,
+    link: "https://fal.ai/dashboard/keys"
+  },
+  {
+    name: "Atlas Cloud",
+    ...keyNames(ATLAS_ROUTING),
+    optional: true,
+    link: "https://www.atlascloud.ai/console/api-keys"
+  },
+  {
+    name: "Replicate",
+    ...keyNames(REPLICATE_ROUTING),
+    optional: true,
+    link: "https://replicate.com/account/api-tokens"
+  },
+  {
+    name: "HeyGen",
+    ...keyNames(HEYGEN_ROUTING),
+    optional: true,
+    link: "https://app.heygen.com/developers/api"
+  }
+];
+
+// src/project-env-names.ts
+var PROJECT_ENV_EXCLUDED = /* @__PURE__ */ new Set([
+  ALLOW_PROJECT_BASE_URL_ENV,
+  "MULTIX_LEGACY_CLAUDE_ENV"
+]);
+var OWN_SETTINGS = [
+  "MULTIX_OUTPUT_DIR",
+  "MULTIX_IMAGE_FORMAT",
+  MAX_DOWNLOAD_ENV,
+  UPLOAD_MIN_KBPS_ENV,
+  // Read before the project file loads, so setting it there has no effect.
+  "MULTIX_DISABLE_HOME_ENV"
+];
+var INLINE_SETTINGS = [
+  "GEMINI_MODEL",
+  "MULTIMODAL_MODEL",
+  "IMAGE_GEN_MODEL",
+  "GEMINI_IMAGE_GEN_MODEL",
+  "VIDEO_GEN_MODEL",
+  "GEMINI_TTS_MODEL",
+  "TTS_MODEL",
+  "OPENAI_IMAGE_MODEL",
+  "OPENAI_TTS_MODEL",
+  "OPENAI_STT_MODEL",
+  "OPENROUTER_IMAGE_MODEL",
+  "OPENROUTER_VIDEO_MODEL",
+  "OPENROUTER_FALLBACK_MODELS",
+  "OPENROUTER_SITE_URL",
+  "OPENROUTER_APP_NAME",
+  "MINIMAX_IMAGE_MODEL",
+  "MINIMAX_VIDEO_MODEL",
+  "MINIMAX_SPEECH_MODEL",
+  "MINIMAX_MUSIC_MODEL",
+  "LEONARDO_DEFAULT_MODEL",
+  "LEONARDO_VIDEO_MODEL",
+  "BYTEPLUS_IMAGE_MODEL",
+  "BYTEPLUS_VIDEO_MODEL",
+  "BYTEPLUS_3D_MODEL",
+  "BYTEPLUS_VIDEO_PARAMS_MODE",
+  "FAL_IMAGE_MODEL",
+  "FAL_VIDEO_MODEL",
+  "FAL_VIDEO_IMAGE_MODEL",
+  "REPLICATE_IMAGE_MODEL",
+  "REPLICATE_VIDEO_MODEL",
+  "CLOUDFLARE_AI_IMAGE_MODEL",
+  "CLOUDFLARE_AI_TTS_MODEL",
+  // Read in providers/cloudflare/client.ts (collectPayloadHeader).
+  "CLOUDFLARE_AI_GATEWAY_COLLECT_LOG_PAYLOAD",
+  "NO_COLOR"
+];
+var ROUTING = [
+  ATLAS_ROUTING,
+  BYTEPLUS_ROUTING,
+  FAL_ROUTING,
+  HEYGEN_ROUTING,
+  LEONARDO_ROUTING,
+  REPLICATE_ROUTING
+];
+var PROJECT_ENV_NAMES = /* @__PURE__ */ new Set([
+  ...PROVIDER_KEYS.flatMap((p) => p.envFallback ? [p.envPrimary, p.envFallback] : [p.envPrimary]),
+  ...ROUTING.flatMap((r) => [r.name, ...r.keyEnvs]),
+  CLOUDFLARE_ACCOUNT_ID_ENV,
+  CLOUDFLARE_GATEWAY_ID_ENV,
+  ...CLOUDFLARE_VIDEO_CREDENTIALS,
+  ...Object.values(ATLAS_MODEL_ENV),
+  MAX_UPLOAD_ENV,
+  ...OWN_SETTINGS,
+  ...INLINE_SETTINGS
+]);
+var GEMINI_NUMBERED_KEY = /^GEMINI_API_KEY_\d+$/;
+function isProjectEnvName(name, platform = process.platform) {
+  const key = envNameKey(name, platform);
+  return PROJECT_ENV_NAMES.has(key) || GEMINI_NUMBERED_KEY.test(key);
+}
+
+// src/core/result.ts
+function ok(data) {
+  return { status: "success", ...data };
+}
+function err(message) {
+  return { status: "error", error: message };
+}
+function isOk(result) {
+  return result.status === "success";
+}
+function isErr(result) {
+  return result.status === "error";
+}
+
+// src/core/output-dir.ts
+import fs5 from "fs";
+import path6 from "path";
+var cachedOutputDir;
+function getOutputDir() {
+  if (cachedOutputDir) return cachedOutputDir;
+  const dir = process.env.MULTIX_OUTPUT_DIR ? path6.resolve(process.env.MULTIX_OUTPUT_DIR) : path6.resolve(process.cwd(), "multix-output");
+  fs5.mkdirSync(dir, { recursive: true });
+  cachedOutputDir = dir;
+  return dir;
+}
+
+// src/core/json-input.ts
+import fs6 from "fs";
+function parseJsonInput(raw, flag = "--input") {
+  let text;
+  if (raw.startsWith("@")) {
+    try {
+      text = fs6.readFileSync(raw.slice(1), "utf8");
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new ValidationError(`Cannot read ${flag} file: ${msg}`);
+    }
+  } else {
+    text = raw;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error("input must be a JSON object");
+    }
+    return parsed;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ValidationError(`Invalid ${flag} JSON: ${msg}`);
+  }
+}
+
+// src/core/video-thumb.ts
+import fs7 from "fs";
+import path7 from "path";
+var THUMB_KEYS = /* @__PURE__ */ new Set([
+  "cover_image_url",
+  "coverImageUrl",
+  "cover_url",
+  "coverUrl",
+  "thumbnail_url",
+  "thumbnailUrl",
+  "thumb_url",
+  "thumbUrl",
+  "preview_url",
+  "previewUrl",
+  "first_frame_url",
+  "firstFrameUrl",
+  "poster_url",
+  "posterUrl",
+  "image_url",
+  "imageUrl"
+]);
+var IMAGE_EXT_RE = /\.(jpe?g|png|webp|gif|bmp)(\?|$)/i;
+function isImageUrl(value) {
+  if (typeof value !== "string") return false;
+  if (!/^https?:\/\//i.test(value)) return false;
+  return IMAGE_EXT_RE.test(value);
+}
+function detectThumbUrl(obj) {
+  if (obj === null || obj === void 0) return null;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      const found = detectThumbUrl(item);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (typeof obj !== "object") return null;
+  const record = obj;
+  for (const [key, value] of Object.entries(record)) {
+    if (THUMB_KEYS.has(key) && isImageUrl(value)) return value;
+  }
+  for (const value of Object.values(record)) {
+    if (value && typeof value === "object") {
+      const found = detectThumbUrl(value);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function resultDest(result) {
+  const dest = result?.dest;
+  return typeof dest === "string" ? dest : void 0;
+}
+async function downloadThumbBeside(thumbUrl, videoPath, logger, download = downloadFile) {
+  const match = thumbUrl.match(IMAGE_EXT_RE);
+  const ext = match?.[1] ? match[1].toLowerCase().replace("jpeg", "jpg") : "jpg";
+  const dir = path7.dirname(videoPath);
+  const base = path7.basename(videoPath, path7.extname(videoPath));
+  const planned = path7.join(dir, `${base}_thumb.${ext}`);
+  try {
+    const dest = resultDest(await download(thumbUrl, planned)) ?? planned;
+    logger?.success(`Saved thumb ${dest}`);
+    return dest;
+  } catch (e) {
+    logger?.warn(`Thumb download failed: ${e instanceof Error ? e.message : String(e)}`);
+    return null;
+  }
+}
+async function maybeDownloadThumb(source, videoPath, opts = {}) {
+  if (opts.skip) return null;
+  const url = detectThumbUrl(source);
+  if (!url) {
+    opts.logger?.debug("No thumbnail URL detected in provider response");
+    return null;
+  }
+  const saved = await downloadThumbBeside(url, videoPath, opts.logger, opts.download);
+  if (saved && opts.copyTo) {
+    const copyExt = path7.extname(saved);
+    const copyBase = path7.basename(opts.copyTo, path7.extname(opts.copyTo));
+    const copyDir = path7.dirname(path7.resolve(opts.copyTo));
+    const copyDest = path7.join(copyDir, `${copyBase}_thumb${copyExt}`);
+    fs7.mkdirSync(copyDir, { recursive: true });
+    fs7.copyFileSync(saved, copyDest);
+    opts.logger?.success(`Copied thumb to ${copyDest}`);
+  }
+  return saved;
+}
+
+// src/index.ts
+function loadEnv2(options = { isProjectEnvName }) {
+  loadEnv(options);
+}
+export {
+  ConfigError,
+  HttpError,
+  MultixError,
+  PROJECT_ENV_EXCLUDED,
+  PROJECT_ENV_NAMES,
+  PollTimeoutError,
+  ProviderError,
+  ValidationError,
+  createLogger,
+  defaultLogger,
+  detectThumbUrl,
+  downloadFile,
+  downloadThumbBeside,
+  err,
+  fetchBytes,
+  fetchJson,
+  getOutputDir,
+  httpErrorFromResponse,
+  httpJson,
+  isErr,
+  isOk,
+  isProjectEnvName,
+  isTransientHttpError,
+  loadEnv2 as loadEnv,
+  maybeDownloadThumb,
+  ok,
+  parseJsonInput,
+  parseRetryAfter,
+  pollUntil,
+  redact,
+  redactUrl,
+  resolveKey
+};