@mrgoonie/multix 0.15.3 → 1.0.1

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.1](https://github.com/mrgoonie/multix-cli/compare/v1.0.0...v1.0.1) (2026-10-11)
+
+
+### Changed
+
+* **gemini:** move file-system work out of the Gemini client ([#109](https://github.com/mrgoonie/multix-cli/issues/109)) ([7df49b2](https://github.com/mrgoonie/multix-cli/commit/7df49b24994bf169cb5709adbada61663a66c786))
+
+## [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)
 
 

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];
 }
@@ -1158,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();
@@ -2346,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";
@@ -2369,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"
@@ -2378,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()) {
@@ -3159,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";
@@ -3183,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
   };
 }
 
@@ -4307,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",
@@ -4326,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()) {
@@ -4947,118 +5150,9 @@ async function resolveFileInputs(files, opts = {}) {
 }
 
 // src/providers/gemini/client.ts
-import fs21 from "fs";
-import path25 from "path";
-init_errors();
-
-// src/providers/gemini/key-pool.ts
 init_errors();
-var PRIMARY_KEY_ENV = "GEMINI_API_KEY";
-var DEFAULT_COOLDOWN_MS = 6e4;
-var cooldownUntil = /* @__PURE__ */ new Map();
-function listGeminiKeys(env = process.env) {
-  const numbered = Object.keys(env).map((name) => ({ name, match: /^GEMINI_API_KEY_(\d+)$/.exec(name) })).filter((e) => e.match !== null).sort((a, b) => Number(a.match[1]) - Number(b.match[1])).map((e) => e.name);
-  const seen = /* @__PURE__ */ new Set();
-  const keys = [];
-  for (const name of [PRIMARY_KEY_ENV, ...numbered]) {
-    const value = env[name]?.trim();
-    if (!value || seen.has(value)) continue;
-    seen.add(value);
-    keys.push({ name, value });
-  }
-  return keys;
-}
-function isGeminiRateLimitError(error) {
-  if (!(error instanceof HttpError)) return false;
-  if (error.status === 429) return true;
-  return (error.status === 400 || error.status === 403) && error.snippet.includes("RESOURCE_EXHAUSTED");
-}
-function cooldownMs(error) {
-  if (!(error instanceof HttpError)) return DEFAULT_COOLDOWN_MS;
-  if (error.retryAfterMs !== void 0 && error.retryAfterMs > 0) return error.retryAfterMs;
-  const delay = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/.exec(error.snippet);
-  if (delay?.[1]) return Math.ceil(Number(delay[1]) * 1e3);
-  return DEFAULT_COOLDOWN_MS;
-}
-function keysToTry(keys, now) {
-  const until = (k) => cooldownUntil.get(k.value) ?? 0;
-  const ready = keys.filter((k) => until(k) <= now);
-  if (ready.length > 0) return ready;
-  const soonest = [...keys].sort((a, b) => until(a) - until(b))[0];
-  return soonest ? [soonest] : [];
-}
-async function withGeminiKey(fn, opts = {}) {
-  const now = opts.now ?? Date.now;
-  const keys = listGeminiKeys(opts.env);
-  if (keys.length === 0) {
-    throw new ConfigError(
-      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
-    );
-  }
-  const ordered = keysToTry(keys, now());
-  let lastError;
-  for (const [i, key] of ordered.entries()) {
-    try {
-      return await fn(key.value, key.name);
-    } catch (error) {
-      if (!isGeminiRateLimitError(error)) throw error;
-      lastError = error;
-      cooldownUntil.set(key.value, now() + cooldownMs(error));
-      const next = ordered[i + 1];
-      if (next) opts.logger?.warn(`${key.name} is rate-limited; retrying with ${next.name}`);
-    }
-  }
-  if (keys.length > 1) {
-    opts.logger?.warn(`All ${keys.length} Gemini keys are rate-limited; try again later`);
-  }
-  throw lastError;
-}
 
-// src/providers/gemini/task-resolver.ts
-import path24 from "path";
-var MIME_MAP = {
-  // Audio
-  ".mp3": "audio/mp3",
-  ".wav": "audio/wav",
-  ".aac": "audio/aac",
-  ".flac": "audio/flac",
-  ".ogg": "audio/ogg",
-  ".aiff": "audio/aiff",
-  ".m4a": "audio/mp4",
-  // Image
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".webp": "image/webp",
-  ".heic": "image/heic",
-  ".heif": "image/heif",
-  ".gif": "image/gif",
-  ".bmp": "image/bmp",
-  // Video
-  ".mp4": "video/mp4",
-  ".mpeg": "video/mpeg",
-  ".mov": "video/quicktime",
-  ".avi": "video/x-msvideo",
-  ".flv": "video/x-flv",
-  ".mpg": "video/mpeg",
-  ".webm": "video/webm",
-  ".wmv": "video/x-ms-wmv",
-  ".3gpp": "video/3gpp",
-  // Document
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".html": "text/html",
-  ".htm": "text/html",
-  ".md": "text/markdown",
-  ".csv": "text/csv",
-  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-};
-function getMimeType(filePath) {
-  const ext = path24.extname(filePath).toLowerCase();
-  return MIME_MAP[ext] ?? "application/octet-stream";
-}
+// src/providers/gemini/media-types.ts
 function requiresProcessingWait(mimeType) {
   return mimeType.startsWith("audio/") || mimeType.startsWith("video/");
 }
@@ -5067,39 +5161,24 @@ function requiresProcessingWait(mimeType) {
 var BASE = "https://generativelanguage.googleapis.com";
 var FILES_BASE = `${BASE}/upload/v1beta/files`;
 var GENERATE_BASE = `${BASE}/v1beta/models`;
-function withKey(opts, fn) {
-  return opts.apiKey ? fn(opts.apiKey) : withGeminiKey(fn, { logger: opts.logger });
-}
 function authHeaders2(apiKey) {
   return { "x-goog-api-key": apiKey };
 }
 var DEFAULT_TIMEOUT_MS3 = 3e5;
-var UPLOAD_MIN_KBPS_ENV = "MULTIX_UPLOAD_MIN_KBPS";
 var DEFAULT_MIN_UPLOAD_BYTES_PER_SEC = 1e6;
 var UPLOAD_TIMEOUT_SLACK_MS = 6e4;
-function minUploadBytesPerSec() {
-  const raw = resolveKey(UPLOAD_MIN_KBPS_ENV)?.trim();
-  if (!raw) return DEFAULT_MIN_UPLOAD_BYTES_PER_SEC;
-  const kbps = Number(raw);
-  if (!Number.isFinite(kbps) || kbps < 1) {
-    throw new ConfigError(
-      `${UPLOAD_MIN_KBPS_ENV} must be a number of kilobytes per second, at least 1, got "${raw}"`
-    );
-  }
-  return kbps * 1e3;
-}
 function uploadTimeoutMs(size, timeoutMs = DEFAULT_TIMEOUT_MS3, bytesPerSec = DEFAULT_MIN_UPLOAD_BYTES_PER_SEC) {
   return Math.max(timeoutMs, UPLOAD_TIMEOUT_SLACK_MS + Math.ceil(size / bytesPerSec * 1e3));
 }
-async function uploadFile(filePath, opts = {}) {
-  const size = fs21.statSync(filePath).size;
+async function uploadFile(source, opts) {
+  const size = source.blob.size;
   if (size > FILES_API_MAX_BYTES) {
     throw new ValidationError(
-      `File too large for the Gemini Files API: ${path25.basename(filePath)} is ${formatMb3(size)} MB (limit 2 GB = ${FILES_API_MAX_BYTES} bytes)`
+      `File too large for the Gemini Files API: ${source.displayName} is ${formatMb3(size)} MB (limit 2 GB = ${FILES_API_MAX_BYTES} bytes)`
     );
   }
-  const bytesPerSec = minUploadBytesPerSec();
-  return withKey(opts, (apiKey) => uploadFileWithKey(filePath, apiKey, { ...opts, bytesPerSec }));
+  const { apiKey, minUploadBytesPerSec: minUploadBytesPerSec2 = DEFAULT_MIN_UPLOAD_BYTES_PER_SEC } = opts;
+  return uploadFileWithKey(source, apiKey, { ...opts, bytesPerSec: minUploadBytesPerSec2 });
 }
 function formatMb3(bytes) {
   return (bytes / 1024 / 1024).toFixed(2);
@@ -5148,11 +5227,10 @@ async function readFinalizedFile(resp) {
   }
   return file;
 }
-async function uploadFileWithKey(filePath, apiKey, opts) {
+async function uploadFileWithKey(source, apiKey, opts) {
   const { timeoutMs = DEFAULT_TIMEOUT_MS3, logger, bytesPerSec } = opts;
-  const mimeType = getMimeType(filePath);
-  const displayName = path25.basename(filePath);
-  const file = await fs21.openAsBlob(filePath);
+  const { mimeType, displayName, label = source.displayName } = source;
+  const file = source.blob.type ? source.blob.slice(0, source.blob.size, "") : source.blob;
   logger?.debug(`Uploading ${displayName} (${formatMb3(file.size)} MB)`);
   const start = await uploadFetch(
     FILES_BASE,
@@ -5194,44 +5272,38 @@ async function uploadFileWithKey(filePath, apiKey, opts) {
     const deadline = Date.now() + timeoutMs;
     while (fileRef.state === "PROCESSING" && Date.now() < deadline) {
       await sleep2(2e3);
-      fileRef = await httpJson({
+      fileRef = await fetchJson({
         url: `${BASE}/v1beta/${fileRef.name}`,
         headers: authHeaders2(apiKey)
       }).then((r) => r.file);
       logger?.debug(`Processing... state=${fileRef.state}`);
     }
     if (fileRef.state === "FAILED")
-      throw new ProviderError(`File processing failed: ${filePath}`, "gemini");
+      throw new ProviderError(`File processing failed: ${label}`, "gemini");
     if (fileRef.state === "PROCESSING")
-      throw new ProviderError(`Processing timeout: ${filePath}`, "gemini");
+      throw new ProviderError(`Processing timeout: ${label}`, "gemini");
   }
   logger?.debug(`Uploaded: ${fileRef.name} (${fileRef.uri})`);
   return fileRef;
 }
-async function generateContent(req, opts = {}) {
-  return withKey(
-    opts,
-    (apiKey) => httpJson({
-      url: `${GENERATE_BASE}/${req.model}:generateContent`,
-      method: "POST",
-      headers: authHeaders2(apiKey),
-      body: {
-        contents: req.contents,
-        ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
-      }
-    })
-  );
+async function generateContent(req, opts) {
+  return fetchJson({
+    url: `${GENERATE_BASE}/${req.model}:generateContent`,
+    method: "POST",
+    headers: authHeaders2(opts.apiKey),
+    body: {
+      contents: req.contents,
+      ...req.generationConfig ? { generationConfig: req.generationConfig } : {}
+    }
+  });
 }
-async function createInteraction(body, opts = {}) {
-  return withKey(
-    opts,
-    (apiKey) => httpJson({
-      url: `${BASE}/v1beta/interactions`,
-      method: "POST",
-      headers: authHeaders2(apiKey),
-      body
-    })
-  );
+async function createInteraction(body, opts) {
+  return fetchJson({
+    url: `${BASE}/v1beta/interactions`,
+    method: "POST",
+    headers: authHeaders2(opts.apiKey),
+    body
+  });
 }
 function extractInteractionAudio(resp) {
   let found = null;
@@ -5270,6 +5342,150 @@ function extractImages(resp) {
     (p) => p.inlineData !== void 0
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/providers/gemini/key-pool.ts
+init_errors();
+var PRIMARY_KEY_ENV = "GEMINI_API_KEY";
+var DEFAULT_COOLDOWN_MS = 6e4;
+var cooldownUntil = /* @__PURE__ */ new Map();
+function listGeminiKeys(env = process.env) {
+  const numbered = Object.keys(env).map((name) => ({ name, match: /^GEMINI_API_KEY_(\d+)$/.exec(name) })).filter((e) => e.match !== null).sort((a, b) => Number(a.match[1]) - Number(b.match[1])).map((e) => e.name);
+  const seen = /* @__PURE__ */ new Set();
+  const keys = [];
+  for (const name of [PRIMARY_KEY_ENV, ...numbered]) {
+    const value = env[name]?.trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    keys.push({ name, value });
+  }
+  return keys;
+}
+function isGeminiRateLimitError(error) {
+  if (!(error instanceof HttpError)) return false;
+  if (error.status === 429) return true;
+  return (error.status === 400 || error.status === 403) && error.snippet.includes("RESOURCE_EXHAUSTED");
+}
+function cooldownMs(error) {
+  if (!(error instanceof HttpError)) return DEFAULT_COOLDOWN_MS;
+  if (error.retryAfterMs !== void 0 && error.retryAfterMs > 0) return error.retryAfterMs;
+  const delay = /"retryDelay"\s*:\s*"(\d+(?:\.\d+)?)s"/.exec(error.snippet);
+  if (delay?.[1]) return Math.ceil(Number(delay[1]) * 1e3);
+  return DEFAULT_COOLDOWN_MS;
+}
+function keysToTry(keys, now) {
+  const until = (k) => cooldownUntil.get(k.value) ?? 0;
+  const ready = keys.filter((k) => until(k) <= now);
+  if (ready.length > 0) return ready;
+  const soonest = [...keys].sort((a, b) => until(a) - until(b))[0];
+  return soonest ? [soonest] : [];
+}
+async function withGeminiKey(fn, opts = {}) {
+  const now = opts.now ?? Date.now;
+  const keys = listGeminiKeys(opts.env);
+  if (keys.length === 0) {
+    throw new ConfigError(
+      "GEMINI_API_KEY is not set. Get one at https://aistudio.google.com/apikey"
+    );
+  }
+  const ordered = keysToTry(keys, now());
+  let lastError;
+  for (const [i, key] of ordered.entries()) {
+    try {
+      return await fn(key.value, key.name);
+    } catch (error) {
+      if (!isGeminiRateLimitError(error)) throw error;
+      lastError = error;
+      cooldownUntil.set(key.value, now() + cooldownMs(error));
+      const next = ordered[i + 1];
+      if (next) opts.logger?.warn(`${key.name} is rate-limited; retrying with ${next.name}`);
+    }
+  }
+  if (keys.length > 1) {
+    opts.logger?.warn(`All ${keys.length} Gemini keys are rate-limited; try again later`);
+  }
+  throw lastError;
+}
+
+// src/providers/gemini/local-files.ts
+import fs21 from "fs";
+import path25 from "path";
+init_errors();
+
+// src/providers/gemini/task-resolver.ts
+import path24 from "path";
+var MIME_MAP = {
+  // Audio
+  ".mp3": "audio/mp3",
+  ".wav": "audio/wav",
+  ".aac": "audio/aac",
+  ".flac": "audio/flac",
+  ".ogg": "audio/ogg",
+  ".aiff": "audio/aiff",
+  ".m4a": "audio/mp4",
+  // Image
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  // Video
+  ".mp4": "video/mp4",
+  ".mpeg": "video/mpeg",
+  ".mov": "video/quicktime",
+  ".avi": "video/x-msvideo",
+  ".flv": "video/x-flv",
+  ".mpg": "video/mpeg",
+  ".webm": "video/webm",
+  ".wmv": "video/x-ms-wmv",
+  ".3gpp": "video/3gpp",
+  // Document
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+function getMimeType(filePath) {
+  const ext = path24.extname(filePath).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+
+// src/providers/gemini/local-files.ts
+var INLINE_MAX_BYTES = 20 * 1024 * 1024;
+var UPLOAD_MIN_KBPS_ENV = "MULTIX_UPLOAD_MIN_KBPS";
+function minUploadBytesPerSec() {
+  const raw = resolveKey(UPLOAD_MIN_KBPS_ENV)?.trim();
+  if (!raw) return DEFAULT_MIN_UPLOAD_BYTES_PER_SEC;
+  const kbps = Number(raw);
+  if (!Number.isFinite(kbps) || kbps < 1) {
+    throw new ConfigError(
+      `${UPLOAD_MIN_KBPS_ENV} must be a number of kilobytes per second, at least 1, got "${raw}"`
+    );
+  }
+  return kbps * 1e3;
+}
+async function uploadLocalFile(filePath, opts = {}) {
+  const bytesPerSec = minUploadBytesPerSec();
+  const blob = await fs21.openAsBlob(filePath);
+  const source = {
+    blob,
+    displayName: path25.basename(filePath),
+    mimeType: getMimeType(filePath),
+    label: filePath
+  };
+  const upload = (apiKey) => uploadFile(source, { ...opts, apiKey, minUploadBytesPerSec: bytesPerSec });
+  return opts.apiKey ? upload(opts.apiKey) : withGeminiKey(upload, { logger: opts.logger });
+}
 function inlinePart(filePath) {
   const data = fs21.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
@@ -5277,10 +5493,7 @@ function inlinePart(filePath) {
 }
 function shouldUseFileApi(filePath) {
   const stat = fs21.statSync(filePath);
-  return stat.size > 20 * 1024 * 1024;
-}
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return stat.size > INLINE_MAX_BYTES;
 }
 
 // src/providers/gemini/models.ts
@@ -5416,7 +5629,7 @@ function registerAnalyzeCommand(parent) {
               let contentParts;
               if (useApi) {
                 logger.debug("File >20MB \u2014 using Files API");
-                const ref = await uploadFile(filePath, { logger, apiKey });
+                const ref = await uploadLocalFile(filePath, { logger, apiKey });
                 contentParts = [
                   { text: opts.prompt },
                   { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
@@ -5479,7 +5692,7 @@ function registerExtractCommand(parent) {
               const useApi = shouldUseFileApi(filePath);
               let contentParts;
               if (useApi) {
-                const ref = await uploadFile(filePath, { logger, apiKey });
+                const ref = await uploadLocalFile(filePath, { logger, apiKey });
                 contentParts = [
                   { text: opts.prompt },
                   { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
@@ -5605,12 +5818,15 @@ async function generateGeminiSpeech(opts) {
   logger?.debug(`Gemini TTS model=${model} mode=${speakers?.length ? "multi" : "single"}`);
   let resp;
   try {
-    resp = await generateContent(
-      {
-        model,
-        contents: [{ parts: [{ text }] }],
-        generationConfig
-      },
+    resp = await withGeminiKey(
+      (apiKey) => generateContent(
+        {
+          model,
+          contents: [{ parts: [{ text }] }],
+          generationConfig
+        },
+        { apiKey, logger }
+      ),
       { logger }
     );
   } catch (e) {
@@ -5648,7 +5864,10 @@ async function generateInteractionsSpeech(opts) {
   }
   let resp;
   try {
-    resp = await createInteraction(buildInteractionsSpeechBody(opts), { logger });
+    resp = await withGeminiKey(
+      (apiKey) => createInteraction(buildInteractionsSpeechBody(opts), { apiKey, logger }),
+      { logger }
+    );
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
@@ -6006,12 +6225,15 @@ function registerGenerateCommand(parent) {
       const savedFiles = [];
       for (let i = 0; i < numImages; i++) {
         try {
-          const resp = await generateContent(
-            {
-              model,
-              contents: [{ parts: [{ text: opts.prompt }] }],
-              generationConfig
-            },
+          const resp = await withGeminiKey(
+            (apiKey) => generateContent(
+              {
+                model,
+                contents: [{ parts: [{ text: opts.prompt }] }],
+                generationConfig
+              },
+              { apiKey, logger }
+            ),
             { logger }
           );
           const images = extractImages(resp);
@@ -6101,7 +6323,9 @@ function registerGeminiImageToImageCommand(parent) {
         contents: [{ parts }],
         generationConfig: { responseModalities: ["IMAGE"] }
       };
-      const resp = await generateContent(req, { logger });
+      const resp = await withGeminiKey((apiKey) => generateContent(req, { apiKey, logger }), {
+        logger
+      });
       const images = extractImages(resp);
       if (images.length === 0) {
         logger.error(
@@ -6234,7 +6458,7 @@ function registerTranscribeCommand2(parent) {
               let contentParts;
               if (useApi) {
                 logger.debug("File >20MB \u2014 using Files API");
-                const ref = await uploadFile(filePath, { logger, apiKey });
+                const ref = await uploadLocalFile(filePath, { logger, apiKey });
                 contentParts = [
                   { text: opts.prompt },
                   { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }
@@ -6291,6 +6515,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"];
@@ -7312,7 +7541,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).`
@@ -7322,13 +7551,10 @@ 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) {
+async function uploadLocalFile2(client, filePath, logger) {
   const abs = path32.resolve(filePath);
   let stat;
   try {
@@ -7364,7 +7590,7 @@ async function resolveMediaInput(client, value, logger) {
   const ref = classifyMediaRef(value);
   if (ref.kind === "url") return { type: "url", url: ref.url };
   if (ref.kind === "asset") return { type: "asset_id", asset_id: ref.assetId };
-  return uploadLocalFile(client, ref.path, logger);
+  return uploadLocalFile2(client, ref.path, logger);
 }
 async function resolveMediaInputs(client, values, logger) {
   const out = [];
@@ -8186,6 +8412,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,
@@ -8234,7 +8465,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"
@@ -8243,7 +8474,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()) {
@@ -10686,6 +10917,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 = [
@@ -11009,10 +11245,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() {
@@ -11025,7 +11260,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;
@@ -11364,7 +11599,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) => {
@@ -11376,8 +11611,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}`
           );
@@ -11807,6 +12042,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",
@@ -11834,14 +12073,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"
   },
@@ -11853,26 +12091,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"
   }
@@ -11887,14 +12124,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;
@@ -11958,18 +12245,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;
@@ -12096,7 +12396,7 @@ async function convertResolved(inputs, ctx) {
             let contentParts;
             if (useApi) {
               logger?.debug("File >20MB \u2014 using Files API");
-              const ref = await uploadFile(filePath, { logger, apiKey });
+              const ref = await uploadLocalFile(filePath, { logger, apiKey });
               contentParts = [
                 { text: prompt },
                 { fileData: { mimeType: ref.mimeType, fileUri: ref.uri } }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrgoonie/multix",
-  "version": "0.15.3",
+  "version": "1.0.1",
   "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.3 # x-release-please-version
+version: 1.0.1 # 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