@mrgoonie/multix 0.8.0 → 0.10.0

package/dist/cli.js

@@ -280,22 +280,78 @@ init_redact();
 import fs3 from "fs";
 import os from "os";
 import path3 from "path";
-import { config as dotenvConfig } from "dotenv";
+import { config as dotenvConfig, parse as dotenvParse } from "dotenv";
 var loaded = false;
+var loadedFiles = [];
+var LEGACY_SKILL_DIRS = ["ai-multimodal", "ak-ai-multimodal"];
+function legacyFilesUnder(root) {
+  const claude = path3.join(root, ".claude");
+  return [
+    ...LEGACY_SKILL_DIRS.map((dir) => path3.join(claude, "skills", dir, ".env")),
+    path3.join(claude, "skills", ".env"),
+    path3.join(claude, ".env")
+  ];
+}
+function samePath(a, b) {
+  const norm = (p) => {
+    const r = path3.resolve(p);
+    return process.platform === "win32" ? r.toLowerCase() : r;
+  };
+  return norm(a) === norm(b);
+}
+function legacyClaudeEnvFiles(cwd, home) {
+  const files = legacyFilesUnder(cwd);
+  if (home && !samePath(home, cwd)) files.push(...legacyFilesUnder(home));
+  return files;
+}
+function legacyClaudeEnvEnabled(env = process.env) {
+  const value = env.MULTIX_LEGACY_CLAUDE_ENV;
+  return value !== void 0 && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+var LEGACY_ALLOWED_NAME = /^[A-Z][A-Z0-9_]*_(API_KEY(_\d+)?|API_TOKEN|ACCOUNT_ID|GATEWAY_ID)$|^(FAL_KEY|ARK_API_KEY)$/;
+function isLegacyAllowedName(name) {
+  return LEGACY_ALLOWED_NAME.test(name);
+}
+function isReadableFile(file) {
+  try {
+    return fs3.statSync(file).isFile();
+  } catch {
+    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;
+  try {
+    parsed = dotenvParse(fs3.readFileSync(file));
+  } catch {
+    return;
+  }
+  for (const [name, value] of Object.entries(parsed)) {
+    if (isLegacyAllowedName(name) && process.env[name] === void 0) process.env[name] = value;
+  }
+  loadedFiles.push(file);
+}
 function loadEnv() {
   if (loaded) return;
   loaded = true;
-  const cwdEnv = path3.resolve(process.cwd(), ".env");
-  if (fs3.existsSync(cwdEnv)) {
-    dotenvConfig({ path: cwdEnv, override: false });
-  }
-  if (!process.env.MULTIX_DISABLE_HOME_ENV) {
-    const homeEnv = path3.join(os.homedir(), ".multix", ".env");
-    if (fs3.existsSync(homeEnv)) {
-      dotenvConfig({ path: homeEnv, override: false });
-    }
+  loadedFiles = [];
+  const cwd = process.cwd();
+  const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os.homedir();
+  loadFile(path3.resolve(cwd, ".env"));
+  if (home) loadFile(path3.join(home, ".multix", ".env"));
+  if (legacyClaudeEnvEnabled()) {
+    for (const file of legacyClaudeEnvFiles(cwd, home)) loadLegacyFile(file);
   }
 }
+function getLoadedEnvFiles() {
+  return [...loadedFiles];
+}
 function resolveKey(name) {
   return process.env[name] || void 0;
 }
@@ -475,9 +531,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path49, opts = {}) {
+  async request(path50, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path49);
+    const url = new URL(base + path50);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -495,14 +551,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, query, logger) {
-    return this.request(path49, { method: "GET", query, logger });
+  get(path50, query, logger) {
+    return this.request(path50, { method: "GET", query, logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path50, body, logger) {
+    return this.request(path50, { method: "POST", body, logger });
   }
-  delete(path49, logger) {
-    return this.request(path49, { method: "DELETE", logger });
+  delete(path50, logger) {
+    return this.request(path50, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -1242,10 +1298,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path49, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path49, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path49, logger), role);
-  return toRef(kind, await resolveAudioInput(path49, logger), role);
+  const { path: path50, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path50, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path50, logger), role);
+  return toRef(kind, await resolveAudioInput(path50, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -2701,9 +2757,9 @@ var FalClient = class {
   apiKey;
   baseUrl;
   /** `path` is appended verbatim to the base queue URL, e.g. "/fal-ai/flux/schnell". */
-  async request(path49, opts = {}) {
+  async request(path50, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const suffix = path49.startsWith("/") ? path49 : `/${path49}`;
+    const suffix = path50.startsWith("/") ? path50 : `/${path50}`;
     return this.requestAbsolute(base + suffix, opts);
   }
   /** Same auth/headers as `request`, but `url` is used verbatim (e.g. a status_url/response_url returned by submit). */
@@ -2720,11 +2776,11 @@ var FalClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, logger) {
-    return this.request(path49, { method: "GET", logger });
+  get(path50, logger) {
+    return this.request(path50, { method: "GET", logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path50, body, logger) {
+    return this.request(path50, { method: "POST", body, logger });
   }
   getAbsolute(url, logger) {
     return this.requestAbsolute(url, { method: "GET", logger });
@@ -3085,14 +3141,214 @@ function registerFalCommands(program2) {
   registerFalResultCommand(fal);
 }
 
-// src/providers/gemini/commands/analyze.ts
+// src/core/stdin-file.ts
 init_errors();
-import fs20 from "fs";
+import fs18 from "fs";
+import os2 from "os";
+import path21 from "path";
+var STDIN_ARG = "-";
+var STDIN_LABEL = "<stdin>";
+var HEAD_BYTES = 4096;
+var MAX_STDIN_BYTES = 2 * 1024 ** 3;
+var WAIT_HINT_MS = 2e3;
+var ascii = (buf, start, end) => buf.toString("latin1", start, end);
+var HEIF_BRANDS = /* @__PURE__ */ new Set([
+  "heic",
+  "heix",
+  "hevc",
+  "hevx",
+  "heim",
+  "heis",
+  "hevm",
+  "hevs",
+  "mif1",
+  "msf1"
+]);
+var AVIF_BRANDS = /* @__PURE__ */ new Set(["avif", "avis"]);
+function isMpegAudioFrame(head) {
+  if (head.length < 4 || head[0] !== 255) return false;
+  const b1 = head[1] ?? 0;
+  const b2 = head[2] ?? 0;
+  if ((b1 & 224) !== 224) return false;
+  const version = b1 >> 3 & 3;
+  const layer = b1 >> 1 & 3;
+  const bitrate = b2 >> 4;
+  const sampleRate = b2 >> 2 & 3;
+  return version !== 1 && layer !== 0 && bitrate !== 15 && bitrate !== 0 && sampleRate !== 3;
+}
+function detectExtension(head) {
+  if (head.length >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191) return ".txt";
+  if (head.length >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) {
+    return void 0;
+  }
+  if (head.length >= 8 && head.readUInt32BE(0) === 2303741511) return ".png";
+  if (head.length >= 3 && head[0] === 255 && head[1] === 216 && head[2] === 255) return ".jpg";
+  if (ascii(head, 0, 4) === "GIF8") return ".gif";
+  if (ascii(head, 0, 5) === "%PDF-") return ".pdf";
+  if (ascii(head, 0, 2) === "BM" && head.length >= 26 && head.readUInt32LE(14) >= 12) return ".bmp";
+  if (ascii(head, 0, 4) === "RIFF") {
+    const kind = ascii(head, 8, 12);
+    if (kind === "WEBP") return ".webp";
+    if (kind === "WAVE") return ".wav";
+    if (kind === "AVI ") return ".avi";
+  }
+  if (ascii(head, 0, 4) === "OggS") return ".ogg";
+  if (ascii(head, 0, 4) === "fLaC") return ".flac";
+  if (ascii(head, 0, 4) === "FORM" && ascii(head, 8, 12) === "AIFF") return ".aiff";
+  if (ascii(head, 0, 3) === "ID3" && (head[3] ?? 0) >= 2 && (head[3] ?? 0) <= 4 && head[4] !== 255) {
+    return ".mp3";
+  }
+  if (ascii(head, 4, 8) === "ftyp") {
+    const brand = ascii(head, 8, 12);
+    if (HEIF_BRANDS.has(brand)) return ".heic";
+    if (AVIF_BRANDS.has(brand)) return void 0;
+    if (brand.startsWith("M4A") || brand.startsWith("M4B")) return ".m4a";
+    if (brand === "qt  ") return ".mov";
+    if (brand.startsWith("3g")) return ".3gpp";
+    return ".mp4";
+  }
+  if (head.length >= 4 && head.readUInt32BE(0) === 440786851) {
+    return head.includes("webm", 0, "latin1") ? ".webm" : void 0;
+  }
+  if (head.length >= 2 && head[0] === 255 && ((head[1] ?? 0) & 246) === 240) return ".aac";
+  if (isMpegAudioFrame(head)) return ".mp3";
+  if (looksLikeText(head)) return ".txt";
+  return void 0;
+}
+function looksLikeText(head) {
+  if (head.length === 0) return false;
+  for (const byte of head) {
+    if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 12 && byte !== 13 && byte !== 27) {
+      return false;
+    }
+  }
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(head, { stream: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeExt(ext) {
+  const clean = ext.trim().toLowerCase();
+  if (!/^\.?[a-z0-9]{1,10}$/.test(clean)) {
+    throw new ValidationError(`Invalid --stdin-ext: ${ext} (expected e.g. .mp3 or txt)`);
+  }
+  return clean.startsWith(".") ? clean : `.${clean}`;
+}
+var SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function trackTempDir(dir) {
+  let done = false;
+  const remove = () => {
+    try {
+      fs18.rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+    } catch {
+    }
+  };
+  const onSignal = (signal) => {
+    dispose();
+    process.kill(process.pid, signal);
+  };
+  const dispose = () => {
+    if (done) return;
+    done = true;
+    process.removeListener("exit", dispose);
+    for (const s of SIGNALS) process.removeListener(s, onSignal);
+    remove();
+  };
+  process.once("exit", dispose);
+  for (const s of SIGNALS) process.once(s, onSignal);
+  return dispose;
+}
+async function stdinToTempFile(opts = {}) {
+  const input = opts.input ?? process.stdin;
+  if (input.isTTY) {
+    throw new ValidationError(
+      "`--files -` reads piped input, but stdin is a terminal. Example: cat clip.mp3 | multix gemini transcribe --files -"
+    );
+  }
+  const forcedExt = opts.ext ? normalizeExt(opts.ext) : void 0;
+  const maxBytes = opts.maxBytes ?? MAX_STDIN_BYTES;
+  const dir = fs18.mkdtempSync(path21.join(os2.tmpdir(), "multix-stdin-"));
+  const cleanup = trackTempDir(dir);
+  const rawPath = path21.join(dir, "input");
+  const hint = setTimeout(() => {
+    process.stderr.write("Waiting for data on stdin (`--files -`)... press Ctrl+C to cancel\n");
+  }, WAIT_HINT_MS);
+  hint.unref?.();
+  let head = Buffer.alloc(0);
+  let size = 0;
+  try {
+    const fd = fs18.openSync(rawPath, "w", 384);
+    try {
+      for await (const chunk of input) {
+        clearTimeout(hint);
+        const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+        if (size + buf.length > maxBytes) {
+          throw new ValidationError(
+            `Piped stdin exceeds ${Math.floor(maxBytes / 1024 ** 2)} MB; save it to a file instead`
+          );
+        }
+        if (head.length < HEAD_BYTES) {
+          head = Buffer.concat([head, buf.subarray(0, HEAD_BYTES - head.length)]);
+        }
+        let offset = 0;
+        while (offset < buf.length) offset += fs18.writeSync(fd, buf, offset);
+        size += buf.length;
+      }
+    } finally {
+      clearTimeout(hint);
+      fs18.closeSync(fd);
+    }
+    if (size === 0) throw new ValidationError("`--files -` was given but stdin was empty");
+    const detectedExt = forcedExt ?? detectExtension(head);
+    const finalPath = path21.join(dir, `stdin${detectedExt ?? ".bin"}`);
+    fs18.renameSync(rawPath, finalPath);
+    return { path: finalPath, size, detected: detectedExt !== void 0, cleanup };
+  } catch (error) {
+    cleanup();
+    throw error;
+  }
+}
+function labelError(message, input) {
+  return input.path === input.label ? message : message.split(input.path).join(input.label);
+}
+async function resolveFileInputs(files, opts = {}) {
+  const stdinCount = files.filter((f) => f === STDIN_ARG).length;
+  if (stdinCount > 1) throw new ValidationError("`-` (stdin) can only be passed once to --files");
+  if (opts.stdinExt && stdinCount === 0) {
+    throw new ValidationError("--stdin-ext only applies when --files includes `-`");
+  }
+  for (const f of files) {
+    if (f !== STDIN_ARG && !fs18.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
+  }
+  if (stdinCount === 0) {
+    return { inputs: files.map((f) => ({ path: f, label: f })), cleanup: () => {
+    } };
+  }
+  const stdin = await stdinToTempFile({
+    input: opts.input,
+    ext: opts.stdinExt,
+    maxBytes: opts.maxBytes
+  });
+  if (!stdin.detected) {
+    stdin.cleanup();
+    throw new ValidationError(
+      "Could not detect the type of piped stdin; pass --stdin-ext (e.g. --stdin-ext mp3)"
+    );
+  }
+  return {
+    inputs: files.map(
+      (f) => f === STDIN_ARG ? { path: stdin.path, label: STDIN_LABEL } : { path: f, label: f }
+    ),
+    cleanup: stdin.cleanup
+  };
+}
 
 // src/providers/gemini/client.ts
 init_errors();
-import fs18 from "fs";
-import path22 from "path";
+import fs19 from "fs";
+import path23 from "path";
 
 // src/providers/gemini/key-pool.ts
 init_errors();
@@ -3158,7 +3414,7 @@ async function withGeminiKey(fn, opts = {}) {
 }
 
 // src/providers/gemini/task-resolver.ts
-import path21 from "path";
+import path22 from "path";
 var MIME_MAP = {
   // Audio
   ".mp3": "audio/mp3",
@@ -3199,7 +3455,7 @@ var MIME_MAP = {
   ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
 };
 function getMimeType(filePath) {
-  const ext = path21.extname(filePath).toLowerCase();
+  const ext = path22.extname(filePath).toLowerCase();
   return MIME_MAP[ext] ?? "application/octet-stream";
 }
 function requiresProcessingWait(mimeType) {
@@ -3222,8 +3478,8 @@ async function uploadFile(filePath, opts = {}) {
 async function uploadFileWithKey(filePath, apiKey, opts) {
   const { timeoutMs = 3e5, logger } = opts;
   const mimeType = getMimeType(filePath);
-  const fileBytes = fs18.readFileSync(filePath);
-  const displayName = path22.basename(filePath);
+  const fileBytes = fs19.readFileSync(filePath);
+  const displayName = path23.basename(filePath);
   const boundary = `multix_${Date.now()}`;
   const metaJson = JSON.stringify({ file: { displayName, mimeType } });
   const body = Buffer.concat([
@@ -3340,12 +3596,12 @@ function extractImages(resp) {
   ).map((p) => ({ mimeType: p.inlineData.mimeType, data: p.inlineData.data }));
 }
 function inlinePart(filePath) {
-  const data = fs18.readFileSync(filePath).toString("base64");
+  const data = fs19.readFileSync(filePath).toString("base64");
   const mimeType = getMimeType(filePath);
   return { inlineData: { mimeType, data } };
 }
 function shouldUseFileApi(filePath) {
-  const stat = fs18.statSync(filePath);
+  const stat = fs19.statSync(filePath);
   return stat.size > 20 * 1024 * 1024;
 }
 function sleep2(ms) {
@@ -3399,13 +3655,13 @@ function getDefaultModel(task) {
 }
 
 // src/providers/gemini/result-formatter.ts
-import fs19 from "fs";
-import path23 from "path";
+import fs20 from "fs";
+import path24 from "path";
 function formatResults(results, format, outputPath) {
   const content = renderFormat(results, format);
   if (outputPath) {
-    fs19.mkdirSync(path23.dirname(path23.resolve(outputPath)), { recursive: true });
-    fs19.writeFileSync(outputPath, content, "utf8");
+    fs20.mkdirSync(path24.dirname(path24.resolve(outputPath)), { recursive: true });
+    fs20.writeFileSync(outputPath, content, "utf8");
   } else {
     process.stdout.write(content);
   }
@@ -3467,17 +3723,17 @@ ${r.response}
 
 // src/providers/gemini/commands/analyze.ts
 function registerAnalyzeCommand(parent) {
-  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
+  parent.command("analyze").description("Analyze files with Gemini (images, video, audio, documents)").requiredOption("--files <paths...>", "Input file paths to analyze (use - to read piped stdin)").option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").option("--prompt <text>", "Analysis prompt", "Analyze this content").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file instead of stdout").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("analyze");
-      for (const f of opts.files) {
-        if (!fs20.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Processing: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Processing: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -3504,17 +3760,21 @@ function registerAnalyzeCommand(parent) {
             { logger }
           );
           results.push({
-            file: filePath,
+            file: label,
             status: "success",
             response: extractText(resp)
           });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       logger.debug(
         `Done: ${results.filter((r) => r.status === "success").length}/${results.length} succeeded`
       );
@@ -3525,21 +3785,19 @@ function registerAnalyzeCommand(parent) {
 }
 
 // src/providers/gemini/commands/extract.ts
-init_errors();
-import fs21 from "fs";
 function registerExtractCommand(parent) {
-  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
+  parent.command("extract").description("Extract structured information from files with Gemini").requiredOption("--files <paths...>", "Input file paths (use - to read piped stdin)").option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").requiredOption("--prompt <text>", "Extraction prompt (required)").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("extract");
-      for (const f of opts.files) {
-        if (!fs21.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const generationConfig = opts.format === "json" ? { responseMimeType: "application/json" } : void 0;
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Extracting: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Extracting: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -3565,14 +3823,18 @@ function registerExtractCommand(parent) {
             },
             { logger }
           );
-          results.push({ file: filePath, status: "success", response: extractText(resp) });
+          results.push({ file: label, status: "success", response: extractText(resp) });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       const failed = results.filter((r) => r.status === "error").length;
       if (failed > 0) process.exit(1);
     }
@@ -3583,8 +3845,8 @@ function registerExtractCommand(parent) {
 init_errors();
 
 // src/providers/gemini/generators/speech.ts
-import fs22 from "fs";
-import path24 from "path";
+import fs21 from "fs";
+import path25 from "path";
 
 // src/providers/gemini/voices.ts
 var GEMINI_TTS_VOICES = [
@@ -3750,12 +4012,12 @@ function extractWavData(wav) {
 }
 function saveSpeech(outBytes, outputFormat, output, logger) {
   const outDir = getOutputDir();
-  const dest = path24.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
-  fs22.writeFileSync(dest, outBytes);
+  const dest = path25.join(outDir, `gemini_speech_${Date.now()}.${outputFormat}`);
+  fs21.writeFileSync(dest, outBytes);
   logger?.success(`Saved: ${dest} (${(outBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs22.mkdirSync(path24.dirname(path24.resolve(output)), { recursive: true });
-    fs22.copyFileSync(dest, output);
+    fs21.mkdirSync(path25.dirname(path25.resolve(output)), { recursive: true });
+    fs21.copyFileSync(dest, output);
     logger?.success(`Copied to: ${output}`);
   }
   return dest;
@@ -3868,11 +4130,11 @@ function collectSpeakers(value, prev) {
 
 // src/providers/gemini/commands/generate-video.ts
 init_errors();
-import fs24 from "fs";
-import path25 from "path";
+import fs23 from "fs";
+import path26 from "path";
 
 // src/providers/gemini/veo.ts
-import fs23 from "fs";
+import fs22 from "fs";
 
 // src/core/async-poll.ts
 init_errors();
@@ -3939,13 +4201,13 @@ var BASE2 = `https://${API_HOST}/v1beta`;
 var VEO_IMAGE_TYPES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/webp"]);
 var VEO_TIMEOUT_MS = 10 * 60 * 1e3;
 function veoImageFromFile(imgPath) {
-  if (!fs23.existsSync(imgPath)) throw new ValidationError(`Image not found: ${imgPath}`);
+  if (!fs22.existsSync(imgPath)) throw new ValidationError(`Image not found: ${imgPath}`);
   const detected = getMimeType(imgPath);
   const mimeType = detected === "application/octet-stream" ? "image/jpeg" : detected;
   if (!VEO_IMAGE_TYPES.has(mimeType)) {
     throw new ValidationError(`Veo accepts JPEG, PNG or WebP images: ${imgPath} (${mimeType})`);
   }
-  return { bytesBase64Encoded: fs23.readFileSync(imgPath).toString("base64"), mimeType };
+  return { bytesBase64Encoded: fs22.readFileSync(imgPath).toString("base64"), mimeType };
 }
 function veoFramesFromPaths(paths = []) {
   if (paths.length > 2) {
@@ -4070,7 +4332,7 @@ function registerGenerateVideoCommand(parent) {
       logger.debug(`Submitting video generation with ${model}...`);
       logger.info("This may take 30s\u20136 minutes. Veo requires billing.");
       const frames = veoFramesFromPaths(opts.referenceImages);
-      const dest = path25.join(getOutputDir(), `veo_generated_${Date.now()}.mp4`);
+      const dest = path26.join(getOutputDir(), `veo_generated_${Date.now()}.mp4`);
       const finalOp = await runVeo(
         model,
         {
@@ -4084,8 +4346,8 @@ function registerGenerateVideoCommand(parent) {
       );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs24.mkdirSync(path25.dirname(path25.resolve(opts.output)), { recursive: true });
-        fs24.copyFileSync(dest, opts.output);
+        fs23.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
+        fs23.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -4101,8 +4363,8 @@ Generated video: ${dest}`);
 
 // src/providers/gemini/commands/generate.ts
 init_errors();
-import fs25 from "fs";
-import path26 from "path";
+import fs24 from "fs";
+import path27 from "path";
 function registerGenerateCommand(parent) {
   parent.command("generate").description("Generate images with Gemini (Nano Banana / Imagen 4)").requiredOption("--prompt <text>", "Image generation prompt").option("--model <id>", "Gemini image model to use").option("--aspect-ratio <ratio>", `Aspect ratio (${ASPECT_RATIOS.join("|")})`, "1:1").option("--num-images <n>", "Number of images to generate (1-4)", "1").option("--size <sz>", `Image size (${IMAGE_SIZES.join("|")})`).option("--output <path>", "Copy first generated image to this path").addOption(imageFormatOption()).addOption(noWebpOption()).option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -4147,8 +4409,8 @@ function registerGenerateCommand(parent) {
             const outDir = getOutputDir();
             const ext = img.mimeType.includes("png") ? "png" : "jpg";
             const fname = `gemini_generated_${Date.now()}_${i}.${ext}`;
-            const dest = path26.join(outDir, fname);
-            fs25.writeFileSync(dest, Buffer.from(img.data, "base64"));
+            const dest = path27.join(outDir, fname);
+            fs24.writeFileSync(dest, Buffer.from(img.data, "base64"));
             savedFiles.push(dest);
             logger.success(`Saved: ${dest}`);
           }
@@ -4163,8 +4425,8 @@ function registerGenerateCommand(parent) {
         process.exit(1);
       }
       if (opts.output && savedFiles[0]) {
-        fs25.mkdirSync(path26.dirname(path26.resolve(opts.output)), { recursive: true });
-        fs25.copyFileSync(savedFiles[0], opts.output);
+        fs24.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
+        fs24.copyFileSync(savedFiles[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(savedFiles, { ...opts, logger });
@@ -4176,8 +4438,8 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/gemini/commands/image-to-image.ts
-import fs26 from "fs";
-import path27 from "path";
+import fs25 from "fs";
+import path28 from "path";
 var SOFT_LIMIT_BYTES = 5 * 1024 * 1024;
 var HARD_LIMIT_BYTES = 7 * 1024 * 1024;
 function registerGeminiImageToImageCommand(parent) {
@@ -4238,14 +4500,14 @@ function registerGeminiImageToImageCommand(parent) {
         const img = images[i];
         if (!img) continue;
         const ext = img.mimeType.includes("png") ? "png" : "jpg";
-        const dest = path27.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
-        fs26.writeFileSync(dest, Buffer.from(img.data, "base64"));
+        const dest = path28.join(outDir, `gemini-i2i-${ts}-${i + 1}.${ext}`);
+        fs25.writeFileSync(dest, Buffer.from(img.data, "base64"));
         saved.push(dest);
         logger.success(`Saved: ${dest}`);
       }
       if (opts.output && saved[0]) {
-        fs26.mkdirSync(path27.dirname(path27.resolve(opts.output)), { recursive: true });
-        fs26.copyFileSync(saved[0], opts.output);
+        fs25.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
+        fs25.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4273,7 +4535,7 @@ function sniffImageMime(buf, url) {
     if (buf.length >= 12 && buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
       return "image/webp";
   }
-  const ext = path27.extname(new URL(url).pathname).toLowerCase();
+  const ext = path28.extname(new URL(url).pathname).toLowerCase();
   if (ext === ".png") return "image/png";
   if (ext === ".webp") return "image/webp";
   if (ext === ".gif") return "image/gif";
@@ -4282,8 +4544,8 @@ function sniffImageMime(buf, url) {
 
 // src/providers/gemini/commands/image-to-video.ts
 init_errors();
-import fs27 from "fs";
-import path28 from "path";
+import fs26 from "fs";
+import path29 from "path";
 function registerGeminiImageToVideoCommand(parent) {
   parent.command("image-to-video <imagePath>").alias("i2v").description("Generate video from a starting image with Veo (image-to-video) [EXPERIMENTAL]").requiredOption("--prompt <text>", "Motion/scene prompt").option("--last-frame <path>", "Optional closing frame image (Veo 3.1)").option("--model <id>", "Veo model id").option("--resolution <res>", "720p|1080p", "1080p").option("--aspect-ratio <ratio>", "Aspect ratio", "16:9").option("--output <path>", "Copy generated video to this path").option("--no-thumb", "Skip downloading the thumbnail if the API returns one").option("-v, --verbose", "Verbose logging").action(
     async (imagePath, opts) => {
@@ -4303,7 +4565,7 @@ function registerGeminiImageToVideoCommand(parent) {
       logger.info(
         "Submitting image-to-video. This may take 30s\u20136 minutes. Veo requires billing."
       );
-      const dest = path28.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
+      const dest = path29.join(getOutputDir(), `veo_i2v_${Date.now()}.mp4`);
       const finalOp = await runVeo(
         model,
         {
@@ -4318,8 +4580,8 @@ function registerGeminiImageToVideoCommand(parent) {
       );
       logger.success(`Saved video: ${dest}`);
       if (opts.output) {
-        fs27.mkdirSync(path28.dirname(path28.resolve(opts.output)), { recursive: true });
-        fs27.copyFileSync(dest, opts.output);
+        fs26.mkdirSync(path29.dirname(path29.resolve(opts.output)), { recursive: true });
+        fs26.copyFileSync(dest, opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       await maybeDownloadThumb(finalOp.response, dest, {
@@ -4334,20 +4596,21 @@ Generated video: ${dest}`);
 }
 
 // src/providers/gemini/commands/transcribe.ts
-init_errors();
-import fs28 from "fs";
 function registerTranscribeCommand2(parent) {
-  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption("--files <paths...>", "Audio/video file paths to transcribe").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
+  parent.command("transcribe").description("Transcribe audio or video files with Gemini").requiredOption(
+    "--files <paths...>",
+    "Audio/video file paths to transcribe (use - to read piped stdin)"
+  ).option("--stdin-ext <ext>", "Extension for piped stdin when auto-detection fails (e.g. mp3)").option("--prompt <text>", "Transcription prompt", "Generate a transcript with timestamps").option("--model <id>", "Gemini model to use").option("--format <fmt>", "Output format: text|json|csv|markdown", "text").option("--output <path>", "Write results to file").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
       const model = opts.model ?? getDefaultModel("transcribe");
-      for (const f of opts.files) {
-        if (!fs28.existsSync(f)) throw new ValidationError(`File not found: ${f}`);
-      }
+      const { inputs, cleanup } = await resolveFileInputs(opts.files, {
+        stdinExt: opts.stdinExt
+      });
       const results = [];
-      for (let i = 0; i < opts.files.length; i++) {
-        const filePath = opts.files[i];
-        logger.debug(`[${i + 1}/${opts.files.length}] Transcribing: ${filePath}`);
+      for (let i = 0; i < inputs.length; i++) {
+        const { path: filePath, label } = inputs[i];
+        logger.debug(`[${i + 1}/${inputs.length}] Transcribing: ${label}`);
         try {
           const resp = await withGeminiKey(
             async (apiKey) => {
@@ -4374,17 +4637,21 @@ function registerTranscribeCommand2(parent) {
             { logger }
           );
           results.push({
-            file: filePath,
+            file: label,
             status: "success",
             response: extractText(resp)
           });
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
-          logger.error(`Failed: ${filePath} \u2014 ${msg}`);
-          results.push({ file: filePath, status: "error", error: msg });
+          const msg = labelError(
+            e instanceof Error ? e.message : String(e),
+            inputs[i]
+          );
+          logger.error(`Failed: ${label} \u2014 ${msg}`);
+          results.push({ file: label, status: "error", error: msg });
         }
       }
       formatResults(results, opts.format, opts.output);
+      cleanup();
       const failed = results.filter((r) => r.status === "error").length;
       if (failed > 0) process.exit(1);
     }
@@ -4407,8 +4674,8 @@ function registerGeminiCommands(program2) {
 }
 
 // src/providers/leonardo/commands/generate.ts
-import fs29 from "fs";
-import path29 from "path";
+import fs27 from "fs";
+import path30 from "path";
 
 // src/providers/leonardo/client.ts
 init_errors();
@@ -4481,11 +4748,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path49, opts = {}) {
+  async request(path50, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path49.startsWith("v2:");
+    const v2Override = path50.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path49.slice(3) : path49;
+    const finalPath = v2Override ? path50.slice(3) : path50;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -4504,14 +4771,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path49, query, logger) {
-    return this.request(path49, { method: "GET", query, logger });
+  get(path50, query, logger) {
+    return this.request(path50, { method: "GET", query, logger });
   }
-  post(path49, body, logger) {
-    return this.request(path49, { method: "POST", body, logger });
+  post(path50, body, logger) {
+    return this.request(path50, { method: "POST", body, logger });
   }
-  delete(path49, logger) {
-    return this.request(path49, { method: "DELETE", logger });
+  delete(path50, logger) {
+    return this.request(path50, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -4522,7 +4789,7 @@ function createLeonardoClient() {
 function extFromUrl2(url, fallback = ".png") {
   try {
     const u = new URL(url);
-    const e = path29.extname(u.pathname);
+    const e = path30.extname(u.pathname);
     return e.length > 0 ? e : fallback;
   } catch {
     return fallback;
@@ -4607,7 +4874,7 @@ function registerLeonardoGenerateCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl2(img.url);
         const filename = autoFilename(generationId, i + 1, ext);
-        const filepath = path29.join(outDir, filename);
+        const filepath = path30.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -4617,9 +4884,9 @@ function registerLeonardoGenerateCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path29.resolve(opts.output);
-        fs29.mkdirSync(path29.dirname(dest), { recursive: true });
-        fs29.copyFileSync(saved[0], dest);
+        const dest = path30.resolve(opts.output);
+        fs27.mkdirSync(path30.dirname(dest), { recursive: true });
+        fs27.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4631,11 +4898,11 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/image-to-image.ts
-import fs30 from "fs";
-import path30 from "path";
+import fs28 from "fs";
+import path31 from "path";
 function extFromUrl3(url, fallback = ".png") {
   try {
-    return path30.extname(new URL(url).pathname) || fallback;
+    return path31.extname(new URL(url).pathname) || fallback;
   } catch {
     return fallback;
   }
@@ -4697,7 +4964,7 @@ function registerLeonardoImageToImageCommand(parent) {
         if (!img) continue;
         const ext = extFromUrl3(img.url);
         const filename = `leonardo-i2i-${generationId.slice(0, 8)}-${String(i + 1).padStart(2, "0")}${ext}`;
-        const filepath = path30.join(outDir, filename);
+        const filepath = path31.join(outDir, filename);
         try {
           await downloadFile(img.url, filepath);
           saved.push(filepath);
@@ -4707,9 +4974,9 @@ function registerLeonardoImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        const dest = path30.resolve(opts.output);
-        fs30.mkdirSync(path30.dirname(dest), { recursive: true });
-        fs30.copyFileSync(saved[0], dest);
+        const dest = path31.resolve(opts.output);
+        fs28.mkdirSync(path31.dirname(dest), { recursive: true });
+        fs28.copyFileSync(saved[0], dest);
         logger.success(`Copied to ${dest}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -4721,7 +4988,7 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/leonardo/commands/video.ts
-import path31 from "path";
+import path32 from "path";
 function v2DimsFor(resolution) {
   if (resolution === "RESOLUTION_1080") return { width: 1920, height: 1080 };
   if (resolution === "RESOLUTION_480") return { width: 854, height: 480 };
@@ -4832,7 +5099,7 @@ async function pollAndDownload(client, jobId, opts) {
     logger.error(`No video URL in completed generation: ${JSON.stringify(gen)}`);
     process.exit(1);
   }
-  const outPath = opts.output ?? path31.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
+  const outPath = opts.output ?? path32.join(getOutputDir(), `${opts.basename}-${jobId.slice(0, 8)}.mp4`);
   await downloadFile(videoUrl2, outPath);
   logger.success(`Saved ${outPath}`);
   await maybeDownloadThumb(gen, outPath, {
@@ -4938,7 +5205,7 @@ function registerLeonardoModelsCommand(parent) {
 }
 
 // src/providers/leonardo/commands/status.ts
-import path32 from "path";
+import path33 from "path";
 var VIDEO_KEYS = ["motionMP4URL", "url"];
 var IMAGE_EXT_RE2 = /\.(jpe?g|png|webp|gif)(\?|$)/i;
 var VIDEO_EXT_RE = /\.(mp4|webm|mov|m4v)(\?|$)/i;
@@ -5003,7 +5270,7 @@ function registerLeonardoStatusCommand(parent) {
       const outDir = getOutputDir();
       let idx = 0;
       for (const url of videos) {
-        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
+        const dest = opts.output && videos.length === 1 && images.length === 0 ? opts.output : path33.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.mp4`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         await maybeDownloadThumb(gen, dest, {
@@ -5016,7 +5283,7 @@ function registerLeonardoStatusCommand(parent) {
       for (const url of images) {
         const m = url.match(IMAGE_EXT_RE2);
         const ext = m?.[1] ? m[1].toLowerCase().replace("jpeg", "jpg") : "png";
-        const dest = path32.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
+        const dest = path33.join(outDir, `leonardo-${generationId.slice(0, 8)}-${idx}.${ext}`);
         await downloadFile(url, dest);
         logger.success(`Saved ${dest}`);
         idx++;
@@ -5173,8 +5440,8 @@ function sleep3(ms) {
 }
 
 // src/providers/minimax/generators/music.ts
-import fs31 from "fs";
-import path33 from "path";
+import fs29 from "fs";
+import path34 from "path";
 async function generateMinimaxMusic(opts) {
   const {
     apiKey,
@@ -5219,14 +5486,14 @@ async function generateMinimaxMusic(opts) {
   }
   const durationMs = resp.extra_info?.music_duration ?? 0;
   const outDir = getOutputDir();
-  const dest = path33.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
+  const dest = path34.join(outDir, `minimax_music_${Date.now()}.${outputFormat}`);
   try {
     if (audioData.startsWith("http")) {
       const bytes = await fetchBytes(audioData);
-      fs31.writeFileSync(dest, bytes);
+      fs29.writeFileSync(dest, bytes);
     } else {
       const audioBytes = Buffer.from(audioData, "hex");
-      fs31.writeFileSync(dest, audioBytes);
+      fs29.writeFileSync(dest, audioBytes);
     }
   } catch (e) {
     return {
@@ -5237,8 +5504,8 @@ async function generateMinimaxMusic(opts) {
   const durSec = durationMs / 1e3;
   logger?.success(`Saved: ${dest} (${durSec.toFixed(1)}s)`);
   if (output) {
-    fs31.mkdirSync(path33.dirname(path33.resolve(output)), { recursive: true });
-    fs31.copyFileSync(dest, output);
+    fs29.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
+    fs29.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, durationMs, model };
 }
@@ -5312,8 +5579,8 @@ Generated music: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/speech.ts
-import fs32 from "fs";
-import path34 from "path";
+import fs30 from "fs";
+import path35 from "path";
 async function generateMinimaxSpeech(opts) {
   const {
     apiKey,
@@ -5360,12 +5627,12 @@ async function generateMinimaxSpeech(opts) {
   const audioBytes = Buffer.from(audioHex, "hex");
   const ext = ["mp3", "wav", "flac"].includes(outputFormat) ? outputFormat : "mp3";
   const outDir = getOutputDir();
-  const dest = path34.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
-  fs32.writeFileSync(dest, audioBytes);
+  const dest = path35.join(outDir, `minimax_speech_${Date.now()}.${ext}`);
+  fs30.writeFileSync(dest, audioBytes);
   logger?.success(`Saved: ${dest} (${(audioBytes.length / 1024).toFixed(1)} KB)`);
   if (output) {
-    fs32.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
-    fs32.copyFileSync(dest, output);
+    fs30.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
+    fs30.copyFileSync(dest, output);
   }
   return { status: "success", generatedAudio: dest, model };
 }
@@ -5412,8 +5679,8 @@ Generated audio: ${result.generatedAudio}`);
 init_errors();
 
 // src/providers/minimax/generators/video.ts
-import fs33 from "fs";
-import path35 from "path";
+import fs31 from "fs";
+import path36 from "path";
 async function generateMinimaxVideo(opts) {
   const {
     apiKey,
@@ -5459,18 +5726,18 @@ async function generateMinimaxVideo(opts) {
     return { status: "error", error: `No file_id in poll result: ${JSON.stringify(pollResult)}` };
   }
   const outDir = getOutputDir();
-  const dest = path35.join(outDir, `minimax_video_${Date.now()}.mp4`);
+  const dest = path36.join(outDir, `minimax_video_${Date.now()}.mp4`);
   try {
     await downloadMinimaxFile(fileId, apiKey, dest, logger);
   } catch (e) {
     return { status: "error", error: e instanceof Error ? e.message : String(e) };
   }
   const elapsed = (Date.now() - start) / 1e3;
-  const stat = fs33.statSync(dest);
+  const stat = fs31.statSync(dest);
   const fileSizeMb = stat.size / (1024 * 1024);
   if (output) {
-    fs33.mkdirSync(path35.dirname(path35.resolve(output)), { recursive: true });
-    fs33.copyFileSync(dest, output);
+    fs31.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
+    fs31.copyFileSync(dest, output);
   }
   await maybeDownloadThumb(pollResult, dest, {
     skip: thumb === false,
@@ -5532,8 +5799,8 @@ Generated video: ${result.generatedVideo}`);
 
 // src/providers/minimax/generators/image.ts
 init_errors();
-import fs34 from "fs";
-import path36 from "path";
+import fs32 from "fs";
+import path37 from "path";
 async function generateMinimaxImage(opts) {
   const {
     apiKey,
@@ -5571,8 +5838,8 @@ async function generateMinimaxImage(opts) {
     try {
       const bytes = await fetchBytes(url);
       const fname = `minimax_image_${Date.now()}_${i}.png`;
-      const dest = path36.join(outDir, fname);
-      fs34.writeFileSync(dest, bytes);
+      const dest = path37.join(outDir, fname);
+      fs32.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -5583,8 +5850,8 @@ async function generateMinimaxImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs34.mkdirSync(path36.dirname(path36.resolve(output)), { recursive: true });
-    fs34.copyFileSync(savedFiles[0], output);
+    fs32.mkdirSync(path37.dirname(path37.resolve(output)), { recursive: true });
+    fs32.copyFileSync(savedFiles[0], output);
   }
   return { status: "success", generatedImages: savedFiles, model };
 }
@@ -5623,8 +5890,8 @@ Generated ${finalImages.length} image(s):`);
 
 // src/providers/minimax/commands/image-to-image.ts
 init_errors();
-import fs35 from "fs";
-import path37 from "path";
+import fs33 from "fs";
+import path38 from "path";
 function registerMinimaxImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description(
     "MiniMax character/subject preservation. CAVEAT: NOT free-form image editing \u2014 the --ref image is used only as a character/face reference for a NEW scene described by --prompt."
@@ -5679,8 +5946,8 @@ function registerMinimaxImageToImageCommand(parent) {
         if (!url) continue;
         try {
           const bytes = await fetchBytes(url);
-          const dest = path37.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
-          fs35.writeFileSync(dest, bytes);
+          const dest = path38.join(outDir, `minimax-i2i-${ts}-${i + 1}.png`);
+          fs33.writeFileSync(dest, bytes);
           saved.push(dest);
           logger.success(`Saved: ${dest}`);
         } catch (e) {
@@ -5691,8 +5958,8 @@ function registerMinimaxImageToImageCommand(parent) {
         }
       }
       if (opts.output && saved[0]) {
-        fs35.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
-        fs35.copyFileSync(saved[0], opts.output);
+        fs33.mkdirSync(path38.dirname(path38.resolve(opts.output)), { recursive: true });
+        fs33.copyFileSync(saved[0], opts.output);
         logger.success(`Copied to: ${opts.output}`);
       }
       const finalImages = finalizeGeneratedImages(saved, { ...opts, logger });
@@ -5826,12 +6093,12 @@ function validateKnownSpeakerPairing(names = [], refs = []) {
 }
 
 // src/providers/openai/openai-audio.ts
-import fs37 from "fs";
-import path39 from "path";
+import fs35 from "fs";
+import path40 from "path";
 
 // src/providers/openai/client.ts
-import fs36 from "fs";
-import path38 from "path";
+import fs34 from "fs";
+import path39 from "path";
 init_errors();
 var DEFAULT_TIMEOUT_MS3 = 24e4;
 function requireOpenAIKey() {
@@ -5897,10 +6164,10 @@ async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIME
   return Buffer.from(await res.arrayBuffer());
 }
 function fileFromPath(filePath) {
-  const abs = path38.resolve(filePath);
-  if (!fs36.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
-  const bytes = fs36.readFileSync(abs);
-  return new File([new Uint8Array(bytes)], path38.basename(abs));
+  const abs = path39.resolve(filePath);
+  if (!fs34.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs34.readFileSync(abs);
+  return new File([new Uint8Array(bytes)], path39.basename(abs));
 }
 
 // src/providers/openai/openai-audio.ts
@@ -5939,7 +6206,7 @@ async function resolveAudioReferenceDataUrl(ref) {
 }
 function audioMimeFromReference(ref) {
   const pathname = new URL(ref).pathname;
-  const ext = path39.extname(pathname).toLowerCase();
+  const ext = path40.extname(pathname).toLowerCase();
   switch (ext) {
     case ".mp3":
       return "audio/mpeg";
@@ -5958,12 +6225,12 @@ function audioMimeFromReference(ref) {
 async function generateOpenAISpeech(opts) {
   const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
   const ext = extFromAudioFormat(opts.outputFormat);
-  const dest = path39.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
-  fs37.writeFileSync(dest, bytes);
+  const dest = path40.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs35.writeFileSync(dest, bytes);
   opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
   if (opts.output) {
-    fs37.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
-    fs37.copyFileSync(dest, opts.output);
+    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
+    fs35.copyFileSync(dest, opts.output);
   }
   return dest;
 }
@@ -5985,9 +6252,9 @@ async function transcribeOpenAIAudio(opts) {
   );
   const text = typeof data.text === "string" ? data.text : void 0;
   const ext = opts.format === "text" ? "txt" : "json";
-  const dest = opts.output ? path39.resolve(opts.output) : path39.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
-  fs37.mkdirSync(path39.dirname(dest), { recursive: true });
-  fs37.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  const dest = opts.output ? path40.resolve(opts.output) : path40.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs35.mkdirSync(path40.dirname(dest), { recursive: true });
+  fs35.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
   opts.logger?.success(`Saved transcript: ${dest}`);
   return { path: dest, text };
 }
@@ -6014,9 +6281,9 @@ Generated audio: ${dest}`);
 }
 
 // src/providers/openai/codex-image-driver.ts
-import fs38 from "fs";
-import os2 from "os";
-import path40 from "path";
+import fs36 from "fs";
+import os3 from "os";
+import path41 from "path";
 import { execa } from "execa";
 init_errors();
 var defaultRunner = async (cmd, args, opts) => {
@@ -6065,12 +6332,12 @@ function sanitizeCodexEnv() {
 async function runCodexImageGeneration(opts) {
   const runner = opts.runner ?? defaultRunner;
   const ext = extFromImageFormat(opts.outputFormat);
-  const dest = opts.output ? path40.resolve(opts.output) : path40.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
-  fs38.mkdirSync(path40.dirname(dest), { recursive: true });
-  const tmp = fs38.mkdtempSync(path40.join(os2.tmpdir(), "multix-codex-image-"));
-  const schema = path40.join(tmp, "schema.json");
-  const result = path40.join(tmp, "result.json");
-  fs38.writeFileSync(
+  const dest = opts.output ? path41.resolve(opts.output) : path41.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs36.mkdirSync(path41.dirname(dest), { recursive: true });
+  const tmp = fs36.mkdtempSync(path41.join(os3.tmpdir(), "multix-codex-image-"));
+  const schema = path41.join(tmp, "schema.json");
+  const result = path41.join(tmp, "result.json");
+  fs36.writeFileSync(
     schema,
     JSON.stringify({
       type: "object",
@@ -6100,7 +6367,7 @@ async function runCodexImageGeneration(opts) {
   if (res.exitCode !== 0) {
     throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
   }
-  if (!fs38.existsSync(dest) || fs38.statSync(dest).size === 0) {
+  if (!fs36.existsSync(dest) || fs36.statSync(dest).size === 0) {
     throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
   }
   return { path: dest };
@@ -6117,8 +6384,8 @@ function buildCodexPrompt(userPrompt, outputPath) {
 
 // src/providers/openai/openai-image.ts
 init_errors();
-import fs39 from "fs";
-import path41 from "path";
+import fs37 from "fs";
+import path42 from "path";
 function buildImageGenerationBody(opts) {
   return {
     model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
@@ -6151,14 +6418,14 @@ function saveOpenAIImages(opts) {
   for (let i = 0; i < items.length; i++) {
     const b64 = items[i]?.b64_json;
     if (!b64) throw new ProviderError("No b64_json in OpenAI image response", "openai");
-    const dest = path41.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
-    fs39.writeFileSync(dest, Buffer.from(b64, "base64"));
+    const dest = path42.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs37.writeFileSync(dest, Buffer.from(b64, "base64"));
     saved.push(dest);
     opts.logger?.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs39.mkdirSync(path41.dirname(path41.resolve(opts.output)), { recursive: true });
-    fs39.copyFileSync(saved[0], opts.output);
+    fs37.mkdirSync(path42.dirname(path42.resolve(opts.output)), { recursive: true });
+    fs37.copyFileSync(saved[0], opts.output);
     opts.logger?.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -6167,7 +6434,7 @@ async function resolveImageRefBytes(ref) {
   if (isHttpUrl(ref)) {
     const bytes2 = await fetchBytes(ref);
     const pathname = new URL(ref).pathname;
-    const filename = path41.basename(pathname) || "reference.png";
+    const filename = path42.basename(pathname) || "reference.png";
     return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
   }
   const file = fileFromPath(ref);
@@ -6212,7 +6479,7 @@ function sniffImageMime2(buf, name) {
   if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return "image/png";
   if (buf.slice(0, 4).toString() === "RIFF" && buf.slice(8, 12).toString() === "WEBP")
     return "image/webp";
-  const ext = path41.extname(name).toLowerCase();
+  const ext = path42.extname(name).toLowerCase();
   if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
   if (ext === ".webp") return "image/webp";
   return "image/png";
@@ -6356,8 +6623,8 @@ function registerOpenAICommands(program2) {
 }
 
 // src/providers/openrouter/client.ts
-import fs40 from "fs";
-import path42 from "path";
+import fs38 from "fs";
+import path43 from "path";
 init_errors();
 
 // src/providers/openrouter/payload.ts
@@ -6521,8 +6788,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path42.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs40.writeFileSync(dest, bytes);
+      const dest = path43.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs38.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -6533,8 +6800,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs40.mkdirSync(path42.dirname(path42.resolve(output)), { recursive: true });
-    fs40.writeFileSync(output, fs40.readFileSync(savedFiles[0]));
+    fs38.mkdirSync(path43.dirname(path43.resolve(output)), { recursive: true });
+    fs38.writeFileSync(output, fs38.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -6575,8 +6842,8 @@ Generated ${finalImages.length} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs41 from "fs";
-import path43 from "path";
+import fs39 from "fs";
+import path44 from "path";
 init_errors();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
 var SOFT_LIMIT_BYTES2 = 5 * 1024 * 1024;
@@ -6668,14 +6935,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path43.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs41.writeFileSync(dest, bytes);
+    const dest = path44.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs39.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs41.mkdirSync(path43.dirname(path43.resolve(opts.output)), { recursive: true });
-    fs41.copyFileSync(saved[0], opts.output);
+    fs39.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
+    fs39.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -6720,13 +6987,13 @@ async function listVideoModels(apiKey = requireOpenRouterKey()) {
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs42 from "fs";
-import path44 from "path";
+import fs40 from "fs";
+import path45 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path44.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path45.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
   const r = await globalThis.fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
   if (!r.ok) {
     logger.error(`Download HTTP ${r.status}`);
@@ -6736,14 +7003,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs42.mkdirSync(path44.dirname(dest), { recursive: true });
-  const ws = fs42.createWriteStream(dest);
+  fs40.mkdirSync(path45.dirname(dest), { recursive: true });
+  const ws = fs40.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs42.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
-    fs42.copyFileSync(dest, opts.output);
+    fs40.mkdirSync(path45.dirname(path45.resolve(opts.output)), { recursive: true });
+    fs40.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -6908,6 +7175,10 @@ function registerOpenRouterCommands(program2) {
   registerOpenRouterVideoModelsCommand(openrouter);
 }
 
+// src/commands/check.ts
+import fs41 from "fs";
+import os4 from "os";
+
 // src/commands/check-helpers/binary-check.ts
 import { execa as execa2 } from "execa";
 async function checkBinary(binary, versionFlag = "--version") {
@@ -7079,6 +7350,19 @@ function registerCheckCommand(program2) {
       if (opts.verbose) console.log(`  ${MAGICK_HINT}`);
     }
     logger.header("API Keys");
+    if (opts.verbose) {
+      const files = getLoadedEnvFiles();
+      logger.info(`Env files loaded: ${files.length > 0 ? files.join(", ") : "none"}`);
+    }
+    if (!legacyClaudeEnvEnabled()) {
+      const home = process.env.MULTIX_DISABLE_HOME_ENV ? void 0 : os4.homedir();
+      const legacy = legacyClaudeEnvFiles(process.cwd(), home).filter((f) => fs41.existsSync(f));
+      if (legacy.length > 0) {
+        logger.info(
+          `Found ${legacy.length} legacy .claude env file(s); set MULTIX_LEGACY_CLAUDE_ENV=1 to load them`
+        );
+      }
+    }
     let anyKey = false;
     const resolved = /* @__PURE__ */ new Map();
     for (const p of PROVIDERS) {
@@ -7177,8 +7461,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs43 from "fs";
-import path45 from "path";
+import fs42 from "fs";
+import path46 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -7199,18 +7483,18 @@ async function convertDocuments(opts) {
   const model = opts.model ?? DOC_MODEL_DEFAULT;
   const prompt = opts.prompt ?? DEFAULT_CONVERT_PROMPT;
   for (const f of inputs) {
-    if (!fs43.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs42.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path45.resolve(output);
+    outputPath = path46.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path45.basename(inputs[0], path45.extname(inputs[0]));
-    outputPath = path45.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path46.basename(inputs[0], path46.extname(inputs[0]));
+    outputPath = path46.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path45.join(getOutputDir(), "document-extraction.md");
+    outputPath = path46.join(getOutputDir(), "document-extraction.md");
   }
-  fs43.mkdirSync(path45.dirname(outputPath), { recursive: true });
+  fs42.mkdirSync(path46.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -7270,7 +7554,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path45.basename(r.file)}
+## ${path46.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -7283,7 +7567,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs43.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs42.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -7331,12 +7615,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs46 from "fs";
-import path48 from "path";
+import fs45 from "fs";
+import path49 from "path";
 
 // src/commands/media/batch.ts
-import fs44 from "fs";
-import path46 from "path";
+import fs43 from "fs";
+import path47 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -7532,10 +7816,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs44.mkdirSync(outputDir, { recursive: true });
-  const entries = fs44.readdirSync(inputDir);
+  fs43.mkdirSync(outputDir, { recursive: true });
+  const entries = fs43.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path46.extname(f).toLowerCase();
+    const ext = path47.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -7546,9 +7830,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path46.join(inputDir, file);
-    const outputPath = path46.join(outputDir, file);
-    const ext = path46.extname(file).toLowerCase();
+    const inputPath = path47.join(inputDir, file);
+    const outputPath = path47.join(outputDir, file);
+    const ext = path47.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -7585,8 +7869,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs45 from "fs";
-import path47 from "path";
+import fs44 from "fs";
+import path48 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -7597,10 +7881,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs45.mkdirSync(outputDir, { recursive: true });
-  const ext = path47.extname(input) || ".mp4";
-  const baseName = path47.basename(input, ext);
-  const outputPattern = path47.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs44.mkdirSync(outputDir, { recursive: true });
+  const ext = path48.extname(input) || ".mp4";
+  const baseName = path48.basename(input, ext);
+  const outputPattern = path48.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -7619,8 +7903,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path47.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs45.existsSync(fname)) files.push(fname);
+    const fname = path48.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs44.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -7634,9 +7918,9 @@ function registerMediaCommands(program2) {
   media.command("optimize").description("Optimize a single media file (video, audio, or image)").requiredOption("--input <file>", "Input media file").requiredOption("--output <file>", "Output file path").option("--target-size <MB>", "Target file size in MB").option("--quality <n>", "Quality: video CRF (0-51) or image (1-100)", "85").option("--max-width <px>", "Max image/video width in pixels", "1920").option("--bitrate <rate>", "Audio bitrate (e.g. 64k)", "64k").option("--resolution <WxH>", "Force video resolution (e.g. 1920x1080)").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs46.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs46.mkdirSync(path48.dirname(path48.resolve(opts.output)), { recursive: true });
-      const ext = path48.extname(opts.input).toLowerCase();
+      if (!fs45.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs45.mkdirSync(path49.dirname(path49.resolve(opts.output)), { recursive: true });
+      const ext = path49.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -7676,7 +7960,7 @@ function registerMediaCommands(program2) {
   media.command("split").description("Split a long video into fixed-duration chunks").requiredOption("--input <file>", "Input video file").option("--output-dir <dir>", "Output directory for chunks", "./chunks").option("--chunk-duration <sec>", "Chunk duration in seconds", "3600").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs46.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs45.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -7692,7 +7976,7 @@ Created ${chunks.length} chunk(s) in ${opts.outputDir}`);
   media.command("batch").description("Batch optimize all media files in a directory").requiredOption("--input-dir <dir>", "Input directory").requiredOption("--output-dir <dir>", "Output directory").option("--quality <n>", "Quality setting", "85").option("--max-width <px>", "Max image/video width", "1920").option("--bitrate <rate>", "Audio bitrate", "64k").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
       const logger = createLogger({ verbose: opts.verbose ?? false });
-      if (!fs46.existsSync(opts.inputDir))
+      if (!fs45.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,