@mrgoonie/multix 0.15.2 → 1.0.0

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.0](https://github.com/mrgoonie/multix-cli/compare/v0.15.3...v1.0.0) (2026-10-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* **core:** a project `.env` can no longer redirect a provider base URL or Cloudflare routing ID while the API key comes from the shell or `~/.multix/.env`. Keep the key in the same project `.env`, move the override to `~/.multix/.env`, or opt in explicitly as described in the environment reference.
+
+### Fixed
+
+* **core:** only trust project .env endpoint overrides that ship their own key ([#97](https://github.com/mrgoonie/multix-cli/issues/97)) ([5c503ec](https://github.com/mrgoonie/multix-cli/commit/5c503eca08aeca6998cf5cf520180a32c0aeee0c))
+
+## [0.15.3](https://github.com/mrgoonie/multix-cli/compare/v0.15.2...v0.15.3) (2026-10-11)
+
+
+### Fixed
+
+* **core:** never forward API-key headers across origins on redirect ([#101](https://github.com/mrgoonie/multix-cli/issues/101)) ([5fd673d](https://github.com/mrgoonie/multix-cli/commit/5fd673ddac9e30b592348cafd6ab68343fa644d7))
+
 ## [0.15.2](https://github.com/mrgoonie/multix-cli/compare/v0.15.1...v0.15.2) (2026-10-11)
 
 

package/README.md

@@ -117,6 +117,8 @@ Set extra keys as `GEMINI_API_KEY_2`, `GEMINI_API_KEY_3`, … (any numeric suffi
 
 Priority: `process.env` > `cwd/.env` > `~/.multix/.env`. Set `MULTIX_LEGACY_CLAUDE_ENV=1` to also read legacy AgentKit files (`.claude/skills/{ai-multimodal,ak-ai-multimodal}/.env`, `.claude/skills/.env`, `.claude/.env`, project first, then home) with the lowest priority (credential names only, never endpoint/proxy settings); `multix check -v` lists the env files that were loaded.
 
+`*_BASE_URL`, `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_AI_GATEWAY_ID` decide where your API key is sent. Values from the shell or `~/.multix/.env` are always used. A value from the project `.env` (or a legacy `.claude` file under it) is used only when every key the provider sends with it comes from that same project file (the repository's own key). That protects your key, not your data: a project `.env` that ships its own key and base URL routes that project's requests, including your prompts and any files you upload, to that host, and its key replaces yours from `~/.multix/.env`, so review a cloned repository's `.env` before running `multix` in it. If a key comes from anywhere else, the project value is ignored: the `~/.multix/.env` value is used with a warning (variable, file and key source named, never the value), or, if there is none, the command stops with an error instead of falling back to the vendor default. `multix check` shows whether each such setting is in effect or ignored. To use a project value for one command, run `MULTIX_ALLOW_PROJECT_BASE_URL=1 multix ...`; do not put the opt-in in `~/.multix/.env`, which disables the check for every directory. Non-default base URLs must be `https://` (plain `http://` only for `localhost`, `127.0.0.1`, `[::1]`), and `multix` warns once per variable on stderr with the provider and hostname only. This covers base URLs and Cloudflare routing IDs only; other variables a project `.env` can set are tracked in [#99](https://github.com/mrgoonie/multix-cli/issues/99).
+
 ## Commands
 
 ### `multix check`

package/dist/cli.js

@@ -308,6 +308,11 @@ function validateRawInput(spec, body) {
 
 // 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"]
+};
 var SUBMIT_PATHS = {
   image: "/model/generateImage",
   video: "/model/generateVideo",
@@ -339,13 +344,20 @@ import fs2 from "fs/promises";
 import path2 from "path";
 
 // src/core/env-loader.ts
+init_errors();
 init_redact();
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { config as dotenvConfig, parse as dotenvParse } from "dotenv";
+import { parse as dotenvParse } from "dotenv";
+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");
@@ -368,8 +380,7 @@ function legacyClaudeEnvFiles(cwd, home) {
   return files;
 }
 function legacyClaudeEnvEnabled(env = process.env) {
-  const value = env.MULTIX_LEGACY_CLAUDE_ENV;
-  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+  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) {
@@ -382,36 +393,174 @@ function isReadableFile(file) {
     return false;
   }
 }
-function loadFile(file) {
-  if (!isReadableFile(file)) return;
-  const result = dotenvConfig({ path: file, override: false });
-  if (!result.error) loadedFiles.push(file);
-}
-function loadLegacyFile(file) {
-  if (!isReadableFile(file)) return;
-  let parsed;
+function parseFile(file) {
+  if (!isReadableFile(file)) return void 0;
   try {
-    parsed = dotenvParse(fs.readFileSync(file));
+    return dotenvParse(fs.readFileSync(file));
   } catch {
-    return;
+    return void 0;
   }
+}
+function loadFile(file, source, accept = () => true) {
+  const parsed = parseFile(file);
+  if (!parsed) return void 0;
   for (const [name, value] of Object.entries(parsed)) {
-    if (isLegacyAllowedName(name) && process.env[name] === void 0) process.env[name] = value;
+    if (!accept(name) || process.env[name] !== void 0) 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;
 }
 function loadEnv() {
   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();
-  loadFile(path.resolve(cwd, ".env"));
-  if (home) loadFile(path.join(home, ".multix", ".env"));
+  loadFile(path.resolve(cwd, ".env"), "project");
+  if (home) userFileValues = byNameKey(loadFile(path.join(home, ".multix", ".env"), "user"));
   if (legacyClaudeEnvEnabled()) {
-    for (const file of legacyClaudeEnvFiles(cwd, home)) loadLegacyFile(file);
+    const projectLegacy = new Set(legacyFilesUnder(cwd));
+    for (const file of legacyClaudeEnvFiles(cwd, home)) {
+      loadFile(file, projectLegacy.has(file) ? "project" : "legacy", isLegacyAllowedName);
+    }
+  }
+}
+function envFileOrigin(name) {
+  const origin = fileOrigins.get(envNameKey(name));
+  if (!origin || process.env[name] !== origin.value) return void 0;
+  return { source: origin.source, file: origin.file };
+}
+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";
+function projectBaseUrlAllowed() {
+  if (!isTruthy(process.env[ALLOW_PROJECT_BASE_URL_ENV])) return false;
+  return envFileOrigin(ALLOW_PROJECT_BASE_URL_ENV)?.source !== "project";
+}
+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 describeSource(origin) {
+  if (!origin) return "the shell";
+  if (origin.source === "user") return "~/.multix/.env";
+  if (origin.source === "legacy") return origin.file;
+  return `another project file (${origin.file})`;
+}
+function foreignCredential(credentials, file) {
+  for (const spec of credentials) {
+    const names = typeof spec === "string" ? [spec] : spec;
+    const used = names.find((n) => process.env[n]?.trim());
+    if (!used) continue;
+    const origin = envFileOrigin(used);
+    if (origin?.source === "project" && origin.file === file) continue;
+    return `${used} comes from ${describeSource(origin)}`;
+  }
+  return void 0;
+}
+function inspectTrustedSetting(name, credentials, harmless) {
+  const value = process.env[name]?.trim() || void 0;
+  const origin = envFileOrigin(name);
+  if (origin?.source !== "project") {
+    return value ? { status: "used", value, source: origin?.source ?? "shell" } : { status: "unset" };
+  }
+  const userValue = userFileValues[envNameKey(name)]?.trim() || void 0;
+  if (value === void 0) {
+    return userValue ? { status: "fallback", value: userValue, file: origin.file, reason: "it is empty" } : { status: "unset" };
+  }
+  const project = (basis) => ({
+    status: "used",
+    value,
+    source: "project",
+    basis
+  });
+  if (value === harmless) return project("default");
+  if (projectBaseUrlAllowed()) return project("opt-in");
+  const reason = foreignCredential(credentials, origin.file);
+  if (!reason) return project("same-file");
+  return userValue ? { status: "fallback", value: userValue, file: origin.file, reason } : { status: "refused", file: origin.file, reason };
+}
+function trustedSettingRefusal(name, state) {
+  return `${name} is set in project env file ${state.file}, but ${state.reason}, so the project is not trusted to choose where that key is sent. Set ${name} in your shell or ~/.multix/.env, or keep the key in the same project file. ${OPT_IN_HINT}`;
+}
+function applyTrustedSetting(name, state) {
+  if (state.status === "unset") return void 0;
+  if (state.status === "used") return state.value;
+  if (state.status === "refused") throw new ConfigError(trustedSettingRefusal(name, state));
+  const hint = state.reason === "it is empty" ? "" : ` ${OPT_IN_HINT}`;
+  warnOnce(
+    `ignored:${name}`,
+    `Ignoring ${name} from project env file ${state.file} (${state.reason}); using the value from ~/.multix/.env.${hint}`
+  );
+  return state.value;
+}
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(`\u26A0 ${message}`);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).hostname || "(no host)";
+  } catch {
+    return "(unparseable URL)";
   }
 }
+var stripSlash = (url) => url.replace(/\/+$/, "");
+var LOOPBACK_HTTP_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function baseUrlSchemeError(name, value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return `${name} must be an absolute https:// URL`;
+  }
+  if (url.protocol === "https:") return void 0;
+  if (url.protocol === "http:" && LOOPBACK_HTTP_HOSTS.has(url.hostname)) return void 0;
+  return `${name} must use https:// (host ${url.hostname || "(none)"}); plain http:// is only allowed for localhost, 127.0.0.1, or [::1]`;
+}
+function defaultHarmless(name, defaultUrl) {
+  const raw = process.env[name]?.trim();
+  return raw && stripSlash(raw) === stripSlash(defaultUrl) ? raw : void 0;
+}
+function inspectBaseUrl(name, defaultUrl, credentials) {
+  const state = inspectTrustedSetting(name, credentials, defaultHarmless(name, defaultUrl));
+  if (state.status !== "used" && state.status !== "fallback") return state;
+  if (stripSlash(state.value) === stripSlash(defaultUrl)) return state;
+  const schemeError = baseUrlSchemeError(name, state.value);
+  return schemeError ? { ...state, schemeError } : state;
+}
+function inspectProviderBaseUrl(routing) {
+  return inspectBaseUrl(routing.name, routing.defaultUrl, [routing.keyEnvs]);
+}
+function resolveBaseUrl(name, defaultUrl, credentials) {
+  const state = inspectBaseUrl(name, defaultUrl, credentials);
+  const value = applyTrustedSetting(name, state);
+  if (!value || stripSlash(value) === stripSlash(defaultUrl)) return defaultUrl;
+  if (state.schemeError) throw new ConfigError(state.schemeError);
+  const provider = name.replace(/_BASE_URL$/, "");
+  warnOnce(
+    `custom:${name}`,
+    `${name} is set: ${provider} API requests, including your API key, go to ${hostOf(value)} instead of the default host.`
+  );
+  return value;
+}
+function resolveProviderBaseUrl(routing) {
+  return resolveBaseUrl(routing.name, routing.defaultUrl, [routing.keyEnvs]);
+}
+function resolveRoutedKey(routing) {
+  return resolveFirstKey(...routing.keyEnvs)?.value;
+}
 function getLoadedEnvFiles() {
   return [...loadedFiles];
 }
@@ -541,6 +690,113 @@ init_errors();
 
 // src/core/fetch-json.ts
 init_errors();
+
+// src/core/redirect-fetch.ts
+init_errors();
+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(headers2) {
+  if (headers2 === void 0) return void 0;
+  const copy = new Headers(headers2);
+  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;
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      throw new HttpError(0, msg, 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 fetchSameOrigin(url, init = {}, fetchImpl) {
+  const { response } = await fetchFollowingRedirects(url, init, {
+    fetch: fetchImpl,
+    crossOrigin: "stop"
+  });
+  return response;
+}
+async function fetchWithValidatedRedirects(url, opts = {}) {
+  const { signal, headers: headers2, validateUrl } = opts;
+  const init = { ...signal ? { signal } : {}, ...headers2 ? { headers: headers2 } : {} };
+  if (!validateUrl && !headers2) {
+    const doFetch = opts.fetch ?? ((input, i) => globalThis.fetch(input, i));
+    try {
+      return { response: await doFetch(url, init), url };
+    } catch (cause) {
+      const msg = cause instanceof Error ? cause.message : String(cause);
+      throw new HttpError(0, msg, 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()) {
@@ -566,6 +822,10 @@ async function httpErrorFromResponse(response, url) {
     parseRetryAfter(response.headers.get("retry-after"))
   );
 }
+var NON_CREDENTIAL_HEADERS = /* @__PURE__ */ new Set(["accept", "accept-language", "content-type", "user-agent"]);
+function carriesCredentialHeaders(headers2) {
+  return Object.keys(headers2).some((name) => !NON_CREDENTIAL_HEADERS.has(name.toLowerCase()));
+}
 async function fetchJson(opts) {
   const { url, method = "GET", headers: headers2 = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = opts;
   const doFetch = opts.fetch ?? ((input, init2) => globalThis.fetch(input, init2));
@@ -580,13 +840,11 @@ async function fetchJson(opts) {
   if (body !== void 0) {
     init.body = JSON.stringify(body);
   }
-  let response;
-  try {
-    response = await doFetch(url, init);
-  } catch (cause) {
-    const msg = cause instanceof Error ? cause.message : String(cause);
-    throw new HttpError(0, msg, url);
-  }
+  const { response } = await fetchFollowingRedirects(url, init, {
+    fetch: doFetch,
+    crossOrigin: carriesCredentialHeaders(headers2) ? "error" : "drop-headers",
+    wrapNetworkErrors: true
+  });
   if (!response.ok) {
     throw await httpErrorFromResponse(response, url);
   }
@@ -934,13 +1192,18 @@ var AtlasCloudClient = class {
     const url = `${this.baseUrl}/model/uploadMedia`;
     let response;
     try {
-      response = await this.doFetch(url, {
-        method: "POST",
-        headers: this.authHeaders(),
-        body: form,
-        signal: AbortSignal.timeout(this.uploadTimeoutMs)
-      });
+      response = await fetchSameOrigin(
+        url,
+        {
+          method: "POST",
+          headers: this.authHeaders(),
+          body: form,
+          signal: AbortSignal.timeout(this.uploadTimeoutMs)
+        },
+        (input, init) => this.doFetch(input, init)
+      );
     } catch (cause) {
+      if (cause instanceof HttpError) throw cause;
       throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
     }
     if (!response.ok) throw await httpErrorFromResponse(response, url);
@@ -1044,12 +1307,17 @@ var MODEL_ENV = {
 function atlasDefaultModel(key) {
   return resolveKey(MODEL_ENV[key])?.trim() || ATLAS_DEFAULT_MODELS[key];
 }
-function createAtlasClientFromEnv() {
-  const apiKey = resolveKey("ATLASCLOUD_API_KEY")?.trim();
+function requireAtlasKey() {
+  const apiKey = resolveRoutedKey(ATLAS_ROUTING);
   if (!apiKey) {
     throw new ConfigError(`ATLASCLOUD_API_KEY is not set. Get one at ${ATLAS_KEY_URL}`);
   }
-  return new AtlasCloudClient({ apiKey, baseUrl: resolveKey("ATLASCLOUD_BASE_URL") });
+  return apiKey;
+}
+function createAtlasClientFromEnv() {
+  const apiKey = requireAtlasKey();
+  const baseUrl = resolveProviderBaseUrl(ATLAS_ROUTING);
+  return new AtlasCloudClient({ apiKey, baseUrl });
 }
 async function resolveMediaRef(client, ref, logger) {
   const trimmed = ref.trim();
@@ -1133,7 +1401,6 @@ async function httpJson(opts) {
 }
 var MAX_DOWNLOAD_ENV = "MULTIX_MAX_DOWNLOAD_MB";
 var DEFAULT_MAX_DOWNLOAD_MB = 2048;
-var MAX_REDIRECTS = 5;
 function formatMb2(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
@@ -1163,44 +1430,6 @@ function maxDownloadBytes() {
   }
   return bytes;
 }
-async function fetchWithValidatedRedirects(url, opts = {}) {
-  const doFetch = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
-  const { validateUrl, signal } = opts;
-  const maxRedirects = opts.maxRedirects ?? MAX_REDIRECTS;
-  let current = url;
-  let headers2 = opts.headers;
-  for (let hop = 0; ; hop++) {
-    await validateUrl?.(current);
-    let response;
-    try {
-      response = await doFetch(current, {
-        ...signal ? { signal } : {},
-        ...headers2 ? { headers: headers2 } : {},
-        ...validateUrl ? { redirect: "manual" } : {}
-      });
-    } catch (cause) {
-      const msg = cause instanceof Error ? cause.message : String(cause);
-      throw new HttpError(0, msg, current);
-    }
-    const location = response.headers.get("location");
-    if (!validateUrl || !location || response.status < 300 || response.status >= 400) {
-      return { response, url: current };
-    }
-    await response.body?.cancel().catch(() => {
-    });
-    if (hop >= maxRedirects) {
-      throw new HttpError(response.status, `too many redirects (over ${maxRedirects})`, current);
-    }
-    let next;
-    try {
-      next = new URL(location, current);
-    } catch {
-      throw new HttpError(response.status, "redirect with a malformed Location header", current);
-    }
-    if (next.origin !== new URL(current).origin) headers2 = void 0;
-    current = next.toString();
-  }
-}
 function removeQuietly(file) {
   try {
     fs3.rmSync(file, { force: true });
@@ -1262,7 +1491,7 @@ async function downloadToFile(url, opts) {
       yield chunk;
     }
   }
-  const part = `${dest}.part`;
+  const part = `${dest}.${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.part`;
   let fileStream;
   try {
     fileStream = fs3.createWriteStream(part);
@@ -2271,6 +2500,11 @@ init_errors();
 
 // 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"]
+};
 var DEFAULT_BYTEPLUS_IMAGE_MODEL = "seedream-4-0-250828";
 var DEFAULT_BYTEPLUS_VIDEO_MODEL = "seedance-2.0";
 var DEFAULT_BYTEPLUS_3D_MODEL = "hyper3d-gen2-260112";
@@ -2294,7 +2528,7 @@ function bytePlusVideoParamsMode() {
 
 // src/providers/byteplus/client.ts
 function requireBytePlusKey() {
-  const key = resolveKey("BYTEPLUS_API_KEY") ?? resolveKey("ARK_API_KEY");
+  const key = resolveRoutedKey(BYTEPLUS_ROUTING);
   if (!key) {
     throw new ConfigError(
       "BytePlus API key not set. Set BYTEPLUS_API_KEY or ARK_API_KEY. Get one at https://console.byteplus.com/auth/api-keys"
@@ -2303,7 +2537,7 @@ function requireBytePlusKey() {
   return key;
 }
 function bytePlusBaseUrl() {
-  return resolveKey("BYTEPLUS_BASE_URL") ?? DEFAULT_BYTEPLUS_BASE_URL;
+  return resolveProviderBaseUrl(BYTEPLUS_ROUTING);
 }
 var BytePlusClient = class {
   constructor(apiKey, baseUrl = bytePlusBaseUrl()) {
@@ -3084,11 +3318,15 @@ var CLOUDFLARE_TTS_MODEL = "@cf/myshell-ai/melotts";
 var CLOUDFLARE_VIDEO_MODEL = "prunaai/p-video";
 
 // src/providers/cloudflare/models.ts
-function required(name) {
-  const value = resolveKey(name)?.trim();
-  if (!value) throw new ConfigError(`${name} is required for Cloudflare media generation`);
-  return value;
-}
+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_NATIVE_CREDENTIALS = [CLOUDFLARE_TOKEN_ENV];
+var CLOUDFLARE_VIDEO_CREDENTIALS = [
+  CLOUDFLARE_TOKEN_ENV,
+  GATEWAY_REPLICATE_TOKEN_ENV
+];
 function getCloudflareModel(kind, requested) {
   const expected = kind === "image" ? CLOUDFLARE_IMAGE_MODEL : CLOUDFLARE_TTS_MODEL;
   const overrideName = kind === "image" ? "CLOUDFLARE_AI_IMAGE_MODEL" : "CLOUDFLARE_AI_TTS_MODEL";
@@ -3108,22 +3346,57 @@ function validateImageSteps(value) {
   }
   return steps;
 }
-function requireCloudflareConfig() {
+var requiredMessage = (name) => `${name} is required for Cloudflare media generation`;
+var token = (name) => resolveKey(name)?.trim() || void 0;
+function inspectCloudflareConfig(use = "native") {
+  const credentials = use === "video" ? CLOUDFLARE_VIDEO_CREDENTIALS : CLOUDFLARE_NATIVE_CREDENTIALS;
+  const accountId = inspectTrustedSetting(CLOUDFLARE_ACCOUNT_ID_ENV, credentials);
+  const gatewayId = inspectTrustedSetting(CLOUDFLARE_GATEWAY_ID_ENV, credentials);
+  const result = (problem, refused = false) => ({
+    problem,
+    refused,
+    accountId,
+    gatewayId
+  });
+  if (accountId.status === "refused") {
+    return result(trustedSettingRefusal(CLOUDFLARE_ACCOUNT_ID_ENV, accountId), true);
+  }
+  if (accountId.status === "unset") return result(requiredMessage(CLOUDFLARE_ACCOUNT_ID_ENV));
+  if (!token(CLOUDFLARE_TOKEN_ENV)) return result(requiredMessage(CLOUDFLARE_TOKEN_ENV));
+  if (gatewayId.status === "refused") {
+    return result(trustedSettingRefusal(CLOUDFLARE_GATEWAY_ID_ENV, gatewayId), true);
+  }
+  if (use === "video") {
+    if (gatewayId.status === "unset") {
+      return result(`${CLOUDFLARE_GATEWAY_ID_ENV} is required for Cloudflare video generation`);
+    }
+    if (!token(GATEWAY_REPLICATE_TOKEN_ENV)) {
+      return result(requiredMessage(GATEWAY_REPLICATE_TOKEN_ENV));
+    }
+  }
+  return result();
+}
+function requireConfig(use) {
+  const check = inspectCloudflareConfig(use);
+  if (check.problem) throw new ConfigError(check.problem);
   return {
-    accountId: required("CLOUDFLARE_ACCOUNT_ID"),
-    apiToken: required("CLOUDFLARE_API_TOKEN"),
-    gatewayId: resolveKey("CLOUDFLARE_AI_GATEWAY_ID")?.trim() || void 0
+    // applyTrustedSetting prints the one-time warning when a ~/.multix/.env fallback is used.
+    accountId: applyTrustedSetting(CLOUDFLARE_ACCOUNT_ID_ENV, check.accountId),
+    apiToken: token(CLOUDFLARE_TOKEN_ENV),
+    gatewayId: applyTrustedSetting(CLOUDFLARE_GATEWAY_ID_ENV, check.gatewayId),
+    ...use === "video" ? { replicateApiToken: token(GATEWAY_REPLICATE_TOKEN_ENV) } : {}
   };
 }
+function requireCloudflareConfig() {
+  return requireConfig("native");
+}
 function requireCloudflareVideoConfig() {
-  const config = requireCloudflareConfig();
-  if (!config.gatewayId) {
-    throw new ConfigError("CLOUDFLARE_AI_GATEWAY_ID is required for Cloudflare video generation");
-  }
+  const config = requireConfig("video");
   return {
-    ...config,
+    accountId: config.accountId,
+    apiToken: config.apiToken,
     gatewayId: config.gatewayId,
-    replicateApiToken: required("REPLICATE_API_TOKEN")
+    replicateApiToken: config.replicateApiToken
   };
 }
 
@@ -3132,8 +3405,13 @@ init_errors();
 function cloudflareProviderFailure(status) {
   return new ProviderError(`Cloudflare request failed with HTTP ${status}`, "Cloudflare");
 }
+async function cloudflareResponseFailure(response) {
+  await response.body?.cancel().catch(() => {
+  });
+  return cloudflareProviderFailure(response.status);
+}
 async function readCloudflareJson(response) {
-  if (!response.ok) throw cloudflareProviderFailure(response.status);
+  if (!response.ok) throw await cloudflareResponseFailure(response);
   try {
     return await response.json();
   } catch {
@@ -3153,12 +3431,11 @@ function videoHeaders(config, opts) {
   };
 }
 function send(opts, url, init) {
-  const f = opts.fetch;
   const withTimeout = {
     ...init,
     signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
   };
-  return f ? f(url, withTimeout) : globalThis.fetch(url, withTimeout);
+  return fetchSameOrigin(url, withTimeout, opts.fetch);
 }
 function parseCloudflareVideoPrediction(value) {
   if (!value || typeof value !== "object") {
@@ -3211,7 +3488,7 @@ function gatewayUrl(accountId) {
 async function runCloudflareJson(model, input) {
   const config = requireCloudflareConfig();
   const useGateway = Boolean(config.gatewayId);
-  const response = await globalThis.fetch(
+  const response = await fetchSameOrigin(
     useGateway ? gatewayUrl(config.accountId) : nativeUrl(config.accountId, model),
     {
       method: "POST",
@@ -3228,7 +3505,7 @@ async function runCloudflareJson(model, input) {
 async function runCloudflareBytes(model, input) {
   const config = requireCloudflareConfig();
   const useGateway = Boolean(config.gatewayId);
-  const response = await globalThis.fetch(
+  const response = await fetchSameOrigin(
     useGateway ? gatewayUrl(config.accountId) : nativeUrl(config.accountId, model),
     {
       method: "POST",
@@ -3236,7 +3513,7 @@ async function runCloudflareBytes(model, input) {
       body: JSON.stringify(useGateway ? { model, input } : input)
     }
   );
-  if (!response.ok) throw cloudflareProviderFailure(response.status);
+  if (!response.ok) throw await cloudflareResponseFailure(response);
   const contentType = response.headers.get("content-type") ?? "";
   if (!contentType.includes("audio/mpeg")) {
     throw new ProviderError("Cloudflare did not return MPEG audio", "Cloudflare");
@@ -3558,7 +3835,7 @@ function apiPostJson(endpoint2, payload, apiKey, opts = {}) {
 }
 async function apiDelete(endpoint2, apiKey) {
   const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
-  const res = await globalThis.fetch(url, {
+  const res = await fetchSameOrigin(url, {
     method: "DELETE",
     headers: authHeaders(apiKey),
     signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS2)
@@ -3592,8 +3869,9 @@ async function apiPostBinary(endpoint2, body, apiKey, opts = {}) {
   }
   let res;
   try {
-    res = await globalThis.fetch(url.toString(), init);
+    res = await fetchSameOrigin(url.toString(), init);
   } catch (cause) {
+    if (cause instanceof HttpError) throw cause;
     const msg = cause instanceof Error ? cause.message : String(cause);
     throw new HttpError(0, msg, url.toString());
   }
@@ -3607,13 +3885,14 @@ async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
   const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
   let res;
   try {
-    res = await globalThis.fetch(url, {
+    res = await fetchSameOrigin(url, {
       method: "POST",
       headers: authHeaders(apiKey),
       body: form,
       signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
     });
   } catch (cause) {
+    if (cause instanceof HttpError) throw cause;
     const msg = cause instanceof Error ? cause.message : String(cause);
     throw new HttpError(0, msg, url);
   }
@@ -3822,7 +4101,7 @@ Dubbed file: ${dest}`);
 }
 async function downloadDub(url, apiKey, dest) {
   fs15.mkdirSync(path18.dirname(dest), { recursive: true });
-  const res = await globalThis.fetch(url, {
+  const { response: res } = await fetchWithValidatedRedirects(url, {
     headers: { "xi-api-key": apiKey },
     signal: AbortSignal.timeout(6e5)
   });
@@ -3831,7 +4110,6 @@ async function downloadDub(url, apiKey, dest) {
   }
   const arr = new Uint8Array(await res.arrayBuffer());
   fs15.writeFileSync(dest, arr);
-  void downloadFile;
 }
 
 // src/providers/elevenlabs/commands/isolate.ts
@@ -4227,6 +4505,11 @@ import path22 from "path";
 
 // 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"]
+};
 var FAL_DEFAULTS = {
   // FLUX.1 [schnell] — fast, low-cost default text-to-image model.
   imageModel: process.env.FAL_IMAGE_MODEL ?? "fal-ai/flux/schnell",
@@ -4246,14 +4529,14 @@ init_errors();
 init_errors();
 init_redact();
 function requireFalKey() {
-  const key = resolveKey("FAL_KEY");
+  const key = resolveRoutedKey(FAL_ROUTING);
   if (!key) {
     throw new ConfigError("FAL_KEY is not set. Get one at https://fal.ai/dashboard/keys");
   }
   return key;
 }
 function falBaseUrl() {
-  return resolveKey("FAL_BASE_URL") ?? DEFAULT_FAL_BASE_URL;
+  return resolveProviderBaseUrl(FAL_ROUTING);
 }
 var FalClient = class {
   constructor(apiKey, baseUrl = falBaseUrl()) {
@@ -5814,13 +6097,14 @@ function checkVeoResult(op) {
   return op;
 }
 async function downloadVeoVideo(apiKey, uri, dest) {
-  let host = "";
+  let parsed;
   try {
-    host = new URL(uri).hostname;
+    parsed = new URL(uri);
   } catch {
     throw new ProviderError("Veo returned an invalid video URI", "gemini");
   }
-  await downloadFile(uri, dest, 3e5, host === API_HOST ? headers(apiKey) : void 0);
+  const keyed = parsed.protocol === "https:" && parsed.hostname === API_HOST;
+  await downloadFile(uri, dest, 3e5, keyed ? headers(apiKey) : void 0);
 }
 async function runVeo(model, request, dest, logger) {
   const body = buildVeoRequest(request);
@@ -6210,6 +6494,11 @@ function registerGeminiCommands(program2) {
 
 // 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 HEYGEN_API_SETTINGS_URL = "https://app.heygen.com/developers/api";
 var HEYGEN_USAGE_URL = "https://app.heygen.com/developers/usage";
 var AVATAR_VIDEO_RESOLUTIONS = ["4k", "1080p", "720p"];
@@ -6316,10 +6605,8 @@ var HEYGEN_OPERATIONS = {
 };
 
 // src/providers/heygen/node-helpers.ts
-import { once } from "events";
 import fs29 from "fs";
 import path32 from "path";
-import { pipeline as pipeline2 } from "stream/promises";
 init_errors();
 init_redact();
 
@@ -6666,13 +6953,18 @@ var HeygenClient = class {
       form.append("file", typed, input.filename);
       let response;
       try {
-        response = await doFetch(url, {
-          method: "POST",
-          headers: this.headers(key),
-          body: form,
-          signal: AbortSignal.timeout(this.timeoutMs)
-        });
+        response = await fetchSameOrigin(
+          url,
+          {
+            method: "POST",
+            headers: this.headers(key),
+            body: form,
+            signal: AbortSignal.timeout(this.timeoutMs)
+          },
+          doFetch
+        );
       } catch (cause) {
+        if (cause instanceof HttpError) throw toHeygenApiError(cause);
         const msg = cause instanceof Error ? cause.message : String(cause);
         const err3 = toHeygenApiError(new HttpError(0, msg, url));
         if (attempt >= this.maxAttempts) throw err3;
@@ -7228,7 +7520,7 @@ function qualityMode(value) {
 
 // src/providers/heygen/node-helpers.ts
 function requireHeygenKey() {
-  const key = resolveKey("HEYGEN_API_KEY")?.trim();
+  const key = resolveRoutedKey(HEYGEN_ROUTING);
   if (!key) {
     throw new ConfigError(
       `HEYGEN_API_KEY is not set. Create an API key at ${HEYGEN_API_SETTINGS_URL} (API usage is billed separately from HeyGen web plans).`
@@ -7238,11 +7530,8 @@ function requireHeygenKey() {
 }
 function createHeygenClientFromEnv() {
   const apiKey = requireHeygenKey();
-  const override = resolveKey("HEYGEN_BASE_URL")?.trim();
-  return new HeygenClient({
-    apiKey,
-    baseUrl: override ? checkBaseUrl(override, "HEYGEN_BASE_URL") : DEFAULT_HEYGEN_BASE_URL
-  });
+  const baseUrl = resolveProviderBaseUrl(HEYGEN_ROUTING);
+  return new HeygenClient({ apiKey, baseUrl: checkBaseUrl(baseUrl, "HEYGEN_BASE_URL") });
 }
 async function uploadLocalFile(client, filePath, logger) {
   const abs = path32.resolve(filePath);
@@ -7323,44 +7612,11 @@ function inferExtension(url, fallback) {
 function safeSlug(value) {
   return value.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "out";
 }
-var MAX_REDIRECTS2 = 5;
-var isRedirect = (status) => [301, 302, 303, 307, 308].includes(status);
-async function downloadHttpsOnly(url, dest, timeoutMs) {
-  const signal = AbortSignal.timeout(timeoutMs);
-  let current = url;
-  for (let hop = 0; ; hop++) {
-    if (!isHttpsUrl(current)) {
-      throw new HttpError(0, "refusing to follow a redirect to a non-https URL", current);
-    }
-    let response;
-    try {
-      response = await globalThis.fetch(current, { signal, redirect: "manual" });
-    } catch (cause) {
-      throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), current);
-    }
-    if (response.url && !isHttpsUrl(response.url)) {
-      await response.body?.cancel();
-      throw new HttpError(0, "redirected to a non-https URL", response.url);
-    }
-    const location = response.headers.get("location");
-    if (isRedirect(response.status) && location) {
-      await response.body?.cancel();
-      if (hop >= MAX_REDIRECTS2) throw new HttpError(0, "too many redirects", url);
-      current = new URL(location, current).href;
-      continue;
-    }
-    if (!response.ok) throw new HttpError(response.status, "(download failed)", current);
-    if (!response.body) throw new HttpError(0, "Response body is null", current);
-    fs29.mkdirSync(path32.dirname(dest), { recursive: true });
-    const fileStream = fs29.createWriteStream(dest);
-    try {
-      await pipeline2(response.body, fileStream);
-    } catch (err2) {
-      if (!fileStream.closed) await once(fileStream, "close");
-      throw err2;
-    }
-    return;
-  }
+function requireHttps2(url) {
+  if (!isHttpsUrl(url)) throw new HttpError(0, "redirected to a non-https URL", url);
+}
+function downloadHttps(url, dest, timeoutMs) {
+  return downloadToFile(url, { dest, timeoutMs, validateUrl: requireHttps2 });
 }
 async function downloadOutput(url, dest, resumeHint) {
   if (!url) {
@@ -7371,12 +7627,9 @@ async function downloadOutput(url, dest, resumeHint) {
       `Refusing to download HeyGen output from a non-https URL (${redactUrl(url)})`
     );
   }
-  const tmp = `${dest}.${process.pid}-${Date.now()}.part`;
   try {
-    await downloadHttpsOnly(url, tmp, 6e5);
-    fs29.renameSync(tmp, dest);
+    await downloadHttps(url, dest, 6e5);
   } catch (e) {
-    fs29.rmSync(tmp, { force: true });
     const status = e instanceof HttpError ? e.status : 0;
     const expired = status === 403 || status === 404 || status === 410;
     const reason = e instanceof Error ? e.message : String(e);
@@ -7438,7 +7691,7 @@ function captionPathFor(dest, capExt) {
   const capDest = `${stem}.${capExt}`;
   return capDest.toLowerCase() === dest.toLowerCase() ? `${stem}.captions.${capExt}` : capDest;
 }
-var downloadThumbHttpsOnly = (url, dest) => downloadHttpsOnly(url, dest, 12e4);
+var downloadThumbHttpsOnly = (url, dest) => downloadHttps(url, dest, 12e4);
 function summarizeState(state) {
   const out = {
     kind: state.kind,
@@ -8138,6 +8391,11 @@ init_errors();
 
 // 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"]
+};
 var DEFAULT_LEONARDO_MODEL_ID = "7b592283-e8a7-4c5a-9ba6-d18c31f258b9";
 var LEONARDO_DEFAULTS = {
   modelId: process.env.LEONARDO_DEFAULT_MODEL ?? DEFAULT_LEONARDO_MODEL_ID,
@@ -8186,7 +8444,7 @@ function isGptImageModel(modelId) {
 
 // src/providers/leonardo/client.ts
 function requireLeonardoKey() {
-  const key = resolveKey("LEONARDO_API_KEY");
+  const key = resolveRoutedKey(LEONARDO_ROUTING);
   if (!key) {
     throw new ConfigError(
       "LEONARDO_API_KEY is not set. Get one at https://app.leonardo.ai/settings/api-keys"
@@ -8195,7 +8453,7 @@ function requireLeonardoKey() {
   return key;
 }
 function leonardoBaseUrl() {
-  return resolveKey("LEONARDO_BASE_URL") ?? DEFAULT_LEONARDO_BASE_URL;
+  return resolveProviderBaseUrl(LEONARDO_ROUTING);
 }
 var LeonardoClient = class {
   constructor(apiKey, baseUrl = leonardoBaseUrl()) {
@@ -9585,13 +9843,14 @@ async function postOpenAIForm(pathname, form, apiKey, timeoutMs = DEFAULT_TIMEOU
   const url = endpoint(pathname);
   let res;
   try {
-    res = await globalThis.fetch(url, {
+    res = await fetchSameOrigin(url, {
       method: "POST",
       headers: authHeaders4(apiKey),
       body: form,
       signal: AbortSignal.timeout(timeoutMs)
     });
   } catch (cause) {
+    if (cause instanceof HttpError) throw cause;
     throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
   }
   if (!res.ok) {
@@ -9604,13 +9863,14 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   const url = endpoint(pathname);
   let res;
   try {
-    res = await globalThis.fetch(url, {
+    res = await fetchSameOrigin(url, {
       method: "POST",
       headers: authHeaders4(apiKey, { "Content-Type": "application/json" }),
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(timeoutMs)
     });
   } catch (cause) {
+    if (cause instanceof HttpError) throw cause;
     throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
   }
   if (!res.ok) {
@@ -10450,7 +10710,9 @@ async function downloadOpenRouterVideo(opts) {
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
   const dest = path50.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
-  const r = await globalThis.fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
+  const { response: r } = await fetchWithValidatedRedirects(url, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
   if (!r.ok) {
     logger.error(`Download HTTP ${r.status}`);
     process.exit(1);
@@ -10461,8 +10723,8 @@ async function downloadOpenRouterVideo(opts) {
   }
   fs43.mkdirSync(path50.dirname(dest), { recursive: true });
   const ws = fs43.createWriteStream(dest);
-  const { pipeline: pipeline3 } = await import("stream/promises");
-  await pipeline3(r.body, ws);
+  const { pipeline: pipeline2 } = await import("stream/promises");
+  await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
     fs43.mkdirSync(path50.dirname(path50.resolve(opts.output)), { recursive: true });
@@ -10634,6 +10896,11 @@ function registerOpenRouterCommands(program2) {
 // src/providers/replicate/models.ts
 init_errors();
 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"]
+};
 var DEFAULT_REPLICATE_IMAGE_MODEL = "black-forest-labs/flux-schnell";
 var DEFAULT_REPLICATE_VIDEO_MODEL = "prunaai/p-video";
 var TERMINAL_STATUSES = [
@@ -10924,13 +11191,18 @@ var ReplicateClient = class {
     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)
-      });
+      response = await fetchSameOrigin(
+        url,
+        {
+          method: "POST",
+          headers: this.headers(),
+          body: form,
+          signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS)
+        },
+        this.doFetch
+      );
     } catch (cause) {
+      if (cause instanceof HttpError) throw mapReplicateError(cause, subject);
       const msg = cause instanceof Error ? cause.message : String(cause);
       throw mapReplicateError(new HttpError(0, msg, url), subject);
     }
@@ -10952,10 +11224,9 @@ var ReplicateClient = class {
 };
 
 // src/providers/replicate/node-client.ts
-var REPLICATE_TOKEN_ENV = "REPLICATE_API_TOKEN";
-var REPLICATE_TOKEN_FALLBACK_ENV = "REPLICATE_API_KEY";
+var [REPLICATE_TOKEN_ENV, REPLICATE_TOKEN_FALLBACK_ENV] = REPLICATE_ROUTING.keyEnvs;
 function resolveReplicateToken() {
-  const found = resolveFirstKey(REPLICATE_TOKEN_ENV, REPLICATE_TOKEN_FALLBACK_ENV);
+  const found = resolveFirstKey(...REPLICATE_ROUTING.keyEnvs);
   return found ? { token: found.value, envUsed: found.envUsed } : void 0;
 }
 function requireReplicateToken() {
@@ -10968,7 +11239,7 @@ function requireReplicateToken() {
   return resolved.token;
 }
 function replicateBaseUrl() {
-  return resolveKey("REPLICATE_BASE_URL")?.trim() || DEFAULT_REPLICATE_BASE_URL;
+  return resolveProviderBaseUrl(REPLICATE_ROUTING);
 }
 function replicateImageModel() {
   return resolveKey("REPLICATE_IMAGE_MODEL")?.trim() || DEFAULT_REPLICATE_IMAGE_MODEL;
@@ -11307,7 +11578,7 @@ async function saveOne(item, predictionId, index, count, opts) {
     fs44.writeFileSync(dest, bytes);
     return dest;
   }
-  const warned = opts.warnedHosts;
+  const warned2 = opts.warnedHosts;
   try {
     const { dest } = await downloadToFile(item.url, {
       dest: (response) => {
@@ -11319,8 +11590,8 @@ async function saveOne(item, predictionId, index, count, opts) {
       fetch: opts.fetch,
       validateUrl: (url) => {
         const { host, trusted } = checkOutputUrl(url);
-        if (!trusted && !warned.has(host)) {
-          warned.add(host);
+        if (!trusted && !warned2.has(host)) {
+          warned2.add(host);
           opts.logger.warn(
             `Output ${item.path} is served from ${host}, not ${REPLICATE_DELIVERY_HOST}`
           );
@@ -11750,6 +12021,10 @@ var FFMPEG_HINT = "ffmpeg not found \u2014 media optimize/split/batch commands u
 var MAGICK_HINT = "ImageMagick (magick) not found \u2014 image optimization unavailable.\n  Linux: sudo apt-get install imagemagick\n  macOS: brew install imagemagick\n  Windows: https://imagemagick.org/script/download.php";
 
 // src/commands/check.ts
+function keyNames(routing) {
+  const [envPrimary, envFallback] = routing.keyEnvs;
+  return envFallback ? { envPrimary, envFallback } : { envPrimary };
+}
 var PROVIDERS = [
   {
     name: "Gemini",
@@ -11777,14 +12052,13 @@ var PROVIDERS = [
   },
   {
     name: "Leonardo.Ai",
-    envPrimary: "LEONARDO_API_KEY",
+    ...keyNames(LEONARDO_ROUTING),
     optional: true,
     link: "https://app.leonardo.ai/settings/api-keys"
   },
   {
     name: "BytePlus",
-    envPrimary: "BYTEPLUS_API_KEY",
-    envFallback: "ARK_API_KEY",
+    ...keyNames(BYTEPLUS_ROUTING),
     optional: true,
     link: "https://console.byteplus.com/auth/api-keys"
   },
@@ -11796,26 +12070,25 @@ var PROVIDERS = [
   },
   {
     name: "fal.ai",
-    envPrimary: "FAL_KEY",
+    ...keyNames(FAL_ROUTING),
     optional: true,
     link: "https://fal.ai/dashboard/keys"
   },
   {
     name: "Atlas Cloud",
-    envPrimary: "ATLASCLOUD_API_KEY",
+    ...keyNames(ATLAS_ROUTING),
     optional: true,
     link: "https://www.atlascloud.ai/console/api-keys"
   },
   {
     name: "Replicate",
-    envPrimary: "REPLICATE_API_TOKEN",
-    envFallback: "REPLICATE_API_KEY",
+    ...keyNames(REPLICATE_ROUTING),
     optional: true,
     link: "https://replicate.com/account/api-tokens"
   },
   {
     name: "HeyGen",
-    envPrimary: "HEYGEN_API_KEY",
+    ...keyNames(HEYGEN_ROUTING),
     optional: true,
     link: "https://app.heygen.com/developers/api"
   }
@@ -11830,14 +12103,64 @@ function resolveProviderKey(p) {
   return found ? { key: found.value, envUsed: found.envUsed } : {};
 }
 function cloudflareReadiness() {
-  const accountId = resolveKey("CLOUDFLARE_ACCOUNT_ID")?.trim();
-  const apiToken = resolveKey("CLOUDFLARE_API_TOKEN")?.trim();
-  const gatewayId = resolveKey("CLOUDFLARE_AI_GATEWAY_ID")?.trim();
-  const replicateToken = resolveKey("REPLICATE_API_TOKEN")?.trim();
-  return {
-    native: Boolean(accountId && apiToken),
-    video: Boolean(accountId && apiToken && gatewayId && replicateToken)
+  const nativeCheck = inspectCloudflareConfig("native");
+  const videoCheck = inspectCloudflareConfig("video");
+  return { native: !nativeCheck.problem, video: !videoCheck.problem, nativeCheck, videoCheck };
+}
+var BASE_URL_ROUTING = [
+  ATLAS_ROUTING,
+  BYTEPLUS_ROUTING,
+  FAL_ROUTING,
+  HEYGEN_ROUTING,
+  LEONARDO_ROUTING,
+  REPLICATE_ROUTING
+];
+function usedFrom(state) {
+  if (state.source === "project") {
+    if (state.basis === "default") return "project .env; same as the default endpoint";
+    if (state.basis === "opt-in") return `project .env; allowed by ${ALLOW_PROJECT_BASE_URL_ENV}`;
+    return "project .env, which also holds every key sent with it";
+  }
+  if (state.source === "user") return "~/.multix/.env";
+  if (state.source === "legacy") return "legacy .claude file";
+  return "shell";
+}
+function settingLine(label, state, commands = "commands that use it") {
+  const stops = `${commands} will stop with an error`;
+  if (state.status === "unset") return void 0;
+  if (state.status === "refused") {
+    return {
+      level: "warn",
+      message: `${label} ignored: set in project .env while ${state.reason}; ${stops}`
+    };
+  }
+  if (state.schemeError) return { level: "warn", message: `${state.schemeError}; ${stops}` };
+  if (state.status === "used") {
+    return { level: "info", message: `${label} in effect (from ${usedFrom(state)})` };
+  }
+  const why = state.reason === "it is empty" ? "set empty in project .env" : `set in project .env while ${state.reason}`;
+  return { level: "warn", message: `${label} ignored: ${why}; using ~/.multix/.env` };
+}
+var sameState = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function routingSettingReport() {
+  const lines = [];
+  const push = (line) => {
+    if (line) lines.push(line);
   };
+  for (const routing of BASE_URL_ROUTING) {
+    push(settingLine(routing.name, inspectProviderBaseUrl(routing)));
+  }
+  const { nativeCheck, videoCheck } = cloudflareReadiness();
+  for (const [name, key] of [
+    [CLOUDFLARE_ACCOUNT_ID_ENV, "accountId"],
+    [CLOUDFLARE_GATEWAY_ID_ENV, "gatewayId"]
+  ]) {
+    push(settingLine(name, nativeCheck[key]));
+    if (!sameState(nativeCheck[key], videoCheck[key])) {
+      push(settingLine(`${name} (video)`, videoCheck[key], "video commands"));
+    }
+  }
+  return lines;
 }
 async function checkCodexImageReadiness(hasAnyProviderKey, verbose = false, checker = checkCodexAuthenticated) {
   if (hasAnyProviderKey && !verbose) return false;
@@ -11901,18 +12224,31 @@ function registerCheckCommand(program2) {
       }
     }
     const cloudflare = cloudflareReadiness();
+    const blocked = (what) => logger.warn(
+      `${what} will stop: a project .env setting is not trusted (see Endpoint Overrides)`
+    );
     if (cloudflare.native) {
       anyKey = true;
       logger.success("Cloudflare Workers AI credentials configured (image and speech)");
       if (cloudflare.video) {
         logger.success("Cloudflare AI Gateway video credentials configured");
+      } else if (cloudflare.videoCheck.refused) {
+        blocked("Cloudflare video");
       } else {
-        logger.info("Cloudflare video needs CLOUDFLARE_AI_GATEWAY_ID and REPLICATE_API_TOKEN");
+        logger.info(`Cloudflare video unavailable: ${cloudflare.videoCheck.problem}`);
       }
+    } else if (cloudflare.nativeCheck.refused) {
+      blocked("Cloudflare image, speech and video");
     } else {
-      logger.info(
-        "Cloudflare media needs CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN (optional)"
-      );
+      logger.info(`Cloudflare media unavailable (optional): ${cloudflare.nativeCheck.problem}`);
+    }
+    const routing = routingSettingReport();
+    if (routing.length > 0) {
+      logger.header("Endpoint Overrides");
+      for (const line of routing) {
+        if (line.level === "warn") logger.warn(line.message);
+        else logger.info(line.message);
+      }
     }
     const shouldCheckCodex = !anyKey || opts.verbose;
     let codexReady = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrgoonie/multix",
-  "version": "0.15.2",
+  "version": "1.0.0",
   "description": "AI multimodal CLI — OpenAI, Gemini, MiniMax, OpenRouter, Leonardo, BytePlus, ElevenLabs, fal.ai, Atlas Cloud, Replicate, HeyGen, ffmpeg, ImageMagick, doc-to-md",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: multix
 description: AI multimodal CLI — generate and edit images (OpenAI, Codex driver, Gemini Nano Banana, Imagen, MiniMax, OpenRouter, Leonardo, BytePlus Seedream, Cloudflare Workers AI FLUX.1 Schnell, fal.ai FLUX, Replicate FLUX), generate video (Gemini Veo, MiniMax Hailuo, OpenRouter via Veo/Seedance/Kling, Leonardo via Motion/Veo/Kling/Hailuo/Seedance/LTX, BytePlus Seedance, Cloudflare AI Gateway via Replicate, fal.ai queue models, Replicate direct API models incl. P-Video, HeyGen Video Agent and scripted avatar videos), video translation and lipsync (HeyGen), TTS/STT/music (OpenAI, Gemini Flash TTS incl. Gemini 3.8 with delivery-style control, MiniMax, Cloudflare Workers AI MeloTTS, ElevenLabs), 3D models (BytePlus Hyper3D/Hitem3d), analyze/transcribe media, convert documents to Markdown, optimize media via ffmpeg/ImageMagick, and self-update the CLI. Use whenever the user wants to create, edit, or transform images/video/audio/3D/documents from a CLI, mentions any of: OpenAI, Codex image driver, image-to-image, i2i, image edit, watercolor/cyberpunk style transfer, reference image, OpenRouter, Nano Banana, Flux, Seedream, Veo, Hailuo, Seedance, Kling, Cloudflare Workers AI, AI Gateway, fal.ai, Atlas Cloud, Replicate, replicate.com models, Replicate predictions, HeyGen, avatar video, talking head, Video Agent, video translation, dubbing, lipsync, video generation, text-to-video, image-to-video, i2v, ElevenLabs voice cloning, updating/upgrading multix, or asks for batch media optimization.
-version: 0.15.2 # x-release-please-version
+version: 1.0.0 # x-release-please-version
 ---
 
 # multix — AI Multimodal CLI
@@ -414,6 +414,7 @@ Requires `cwebp` (libwebp: `brew install webp`, `apt install webp`) on `PATH`.
 | `CLOUDFLARE_AI_IMAGE_MODEL` / `CLOUDFLARE_AI_TTS_MODEL` | Fixed-model settings: only `@cf/black-forest-labs/flux-1-schnell` and `@cf/myshell-ai/melotts` respectively are accepted |
 | `MULTIX_DISABLE_HOME_ENV` | `1` to skip every home-directory env file (`~/.multix/.env`, `~/.claude/...`) |
 | `MULTIX_LEGACY_CLAUDE_ENV` | `1` to also read legacy `.claude` env files (credential names only) |
+| `MULTIX_ALLOW_PROJECT_BASE_URL` | Set `1` for one command (`MULTIX_ALLOW_PROJECT_BASE_URL=1 multix ...`) to honour `*_BASE_URL`, `CLOUDFLARE_ACCOUNT_ID` and `CLOUDFLARE_AI_GATEWAY_ID` from the project `.env` even when the key comes from elsewhere. Without it, a project value is used only when every key sent with it is in the same project file (a project `.env` that ships its own key and base URL then receives that project's prompts and uploaded files, and its key replaces yours, so review a cloned repo's `.env` first); otherwise the `~/.multix/.env` value is used with a warning, or the command stops with a config error. `multix check` shows the effective state. Ignored in a project `.env`; avoid `~/.multix/.env` (it trusts every directory). Non-default base URLs must be `https://` (http only for localhost/127.0.0.1/[::1]) |
 
 ## Quick examples for agents