@mrgoonie/multix 0.0.8 → 0.1.1

package/dist/cli.js

@@ -414,9 +414,9 @@ var BytePlusClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path41, opts = {}) {
+  async request(path45, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const url = new URL(base + path41);
+    const url = new URL(base + path45);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -434,14 +434,14 @@ var BytePlusClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path41, query, logger) {
-    return this.request(path41, { method: "GET", query, logger });
+  get(path45, query, logger) {
+    return this.request(path45, { method: "GET", query, logger });
   }
-  post(path41, body, logger) {
-    return this.request(path41, { method: "POST", body, logger });
+  post(path45, body, logger) {
+    return this.request(path45, { method: "POST", body, logger });
   }
-  delete(path41, logger) {
-    return this.request(path41, { method: "DELETE", logger });
+  delete(path45, logger) {
+    return this.request(path45, { method: "DELETE", logger });
   }
 };
 function createBytePlusClient() {
@@ -990,10 +990,10 @@ function toRef(kind, resolved, role) {
   return { kind, url: resolved.dataUrl, mime: resolved.mime, role };
 }
 async function resolveRefSpec(kind, spec, logger) {
-  const { path: path41, role } = parseRefSpec(spec);
-  if (kind === "image") return toRef(kind, await resolveImageInput(path41, logger), role);
-  if (kind === "video") return toRef(kind, await resolveVideoInput(path41, logger), role);
-  return toRef(kind, await resolveAudioInput(path41, logger), role);
+  const { path: path45, role } = parseRefSpec(spec);
+  if (kind === "image") return toRef(kind, await resolveImageInput(path45, logger), role);
+  if (kind === "video") return toRef(kind, await resolveVideoInput(path45, logger), role);
+  return toRef(kind, await resolveAudioInput(path45, logger), role);
 }
 async function resolveRefSpecs(specs, logger) {
   const out = [];
@@ -1325,8 +1325,8 @@ function requireElevenLabsKey() {
 function authHeaders(apiKey, extra) {
   return { "xi-api-key": apiKey, ...extra ?? {} };
 }
-function apiGet(endpoint, apiKey, query) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+function apiGet(endpoint2, apiKey, query) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (query) {
     for (const [k, v] of Object.entries(query)) {
       if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
@@ -1334,8 +1334,8 @@ function apiGet(endpoint, apiKey, query) {
   }
   return httpJson({ url: url.toString(), headers: authHeaders(apiKey) });
 }
-function apiPostJson(endpoint, payload, apiKey, opts = {}) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+function apiPostJson(endpoint2, payload, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (opts.query) {
     for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
   }
@@ -1347,8 +1347,8 @@ function apiPostJson(endpoint, payload, apiKey, opts = {}) {
     timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2
   });
 }
-async function apiDelete(endpoint, apiKey) {
-  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+async function apiDelete(endpoint2, apiKey) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
   const res = await globalThis.fetch(url, {
     method: "DELETE",
     headers: authHeaders(apiKey),
@@ -1359,8 +1359,8 @@ async function apiDelete(endpoint, apiKey) {
     throw new HttpError(res.status, text.slice(0, 500), url);
   }
 }
-async function apiPostBinary(endpoint, body, apiKey, opts = {}) {
-  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`);
+async function apiPostBinary(endpoint2, body, apiKey, opts = {}) {
+  const url = new URL(`${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`);
   if (opts.query) {
     for (const [k, v] of Object.entries(opts.query)) url.searchParams.set(k, v);
   }
@@ -1394,8 +1394,8 @@ async function apiPostBinary(endpoint, body, apiKey, opts = {}) {
   }
   return Buffer.from(await res.arrayBuffer());
 }
-async function apiPostMultipart(endpoint, form, apiKey, opts = {}) {
-  const url = `${ELEVENLABS_BASE_URL}/${endpoint.replace(/^\//, "")}`;
+async function apiPostMultipart(endpoint2, form, apiKey, opts = {}) {
+  const url = `${ELEVENLABS_BASE_URL}/${endpoint2.replace(/^\//, "")}`;
   let res;
   try {
     res = await globalThis.fetch(url, {
@@ -3126,11 +3126,11 @@ var LeonardoClient = class {
   }
   apiKey;
   baseUrl;
-  async request(path41, opts = {}) {
+  async request(path45, opts = {}) {
     const base = this.baseUrl.replace(/\/$/, "");
-    const v2Override = path41.startsWith("v2:");
+    const v2Override = path45.startsWith("v2:");
     const finalBase = v2Override ? base.replace(/\/v1$/, "/v2") : base;
-    const finalPath = v2Override ? path41.slice(3) : path41;
+    const finalPath = v2Override ? path45.slice(3) : path45;
     const url = new URL(finalBase + finalPath);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
@@ -3149,14 +3149,14 @@ var LeonardoClient = class {
       timeoutMs: opts.timeoutMs ?? 12e4
     });
   }
-  get(path41, query, logger) {
-    return this.request(path41, { method: "GET", query, logger });
+  get(path45, query, logger) {
+    return this.request(path45, { method: "GET", query, logger });
   }
-  post(path41, body, logger) {
-    return this.request(path41, { method: "POST", body, logger });
+  post(path45, body, logger) {
+    return this.request(path45, { method: "POST", body, logger });
   }
-  delete(path41, logger) {
-    return this.request(path41, { method: "DELETE", logger });
+  delete(path45, logger) {
+    return this.request(path45, { method: "DELETE", logger });
   }
 };
 function createLeonardoClient() {
@@ -3756,8 +3756,8 @@ function authHeaders3(apiKey) {
     "Content-Type": "application/json"
   };
 }
-async function apiPost(endpoint, payload, apiKey, opts = {}) {
-  const url = `${MINIMAX_BASE_URL}/${endpoint}`;
+async function apiPost(endpoint2, payload, apiKey, opts = {}) {
+  const url = `${MINIMAX_BASE_URL}/${endpoint2}`;
   opts.logger?.debug(`POST ${url}`);
   const data = await httpJson({
     url,
@@ -3775,8 +3775,8 @@ async function apiPost(endpoint, payload, apiKey, opts = {}) {
   }
   return data;
 }
-async function apiGet2(endpoint, params, apiKey) {
-  const url = new URL(`${MINIMAX_BASE_URL}/${endpoint}`);
+async function apiGet2(endpoint2, params, apiKey) {
+  const url = new URL(`${MINIMAX_BASE_URL}/${endpoint2}`);
   for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
   return httpJson({ url: url.toString(), headers: authHeaders3(apiKey) });
 }
@@ -4356,11 +4356,638 @@ function registerMinimaxCommands(program2) {
   registerMinimaxGenerateMusicCommand(minimax);
 }
 
-// src/providers/openrouter/client.ts
+// src/providers/openai/commands/generate-speech.ts
+init_errors();
+
+// src/providers/openai/models.ts
+init_errors();
+var OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_OPENAI_IMAGE_MODEL = "gpt-image-2";
+var DEFAULT_OPENAI_TTS_MODEL = "gpt-4o-mini-tts";
+var DEFAULT_OPENAI_STT_MODEL = "gpt-4o-transcribe";
+var OPENAI_IMAGE_OUTPUT_FORMATS = ["png", "jpeg", "webp"];
+var OPENAI_IMAGE_QUALITIES = ["low", "medium", "high"];
+var OPENAI_IMAGE_SIZES = ["1024x1024", "1024x1536", "1536x1024", "auto"];
+var OPENAI_TTS_OUTPUT_FORMATS = ["mp3", "opus", "aac", "flac", "wav", "pcm"];
+var OPENAI_TTS_VOICES = [
+  "alloy",
+  "ash",
+  "ballad",
+  "cedar",
+  "coral",
+  "echo",
+  "fable",
+  "marin",
+  "nova",
+  "onyx",
+  "sage",
+  "shimmer",
+  "verse"
+];
+var OPENAI_TRANSCRIPT_FORMATS = ["json", "text", "diarized_json"];
+function isOneOf(value, values) {
+  return values.includes(value);
+}
+function extFromImageFormat(format) {
+  if (format === "jpeg") return "jpg";
+  return format;
+}
+function extFromAudioFormat(format) {
+  return format;
+}
+function parseImageFormat(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_OUTPUT_FORMATS)) {
+    throw new ValidationError(`--format must be one of: ${OPENAI_IMAGE_OUTPUT_FORMATS.join(", ")}`);
+  }
+  return value;
+}
+function parseImageQuality(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_QUALITIES)) {
+    throw new ValidationError(`--quality must be one of: ${OPENAI_IMAGE_QUALITIES.join(", ")}`);
+  }
+  return value;
+}
+function parseImageSize(value) {
+  if (!isOneOf(value, OPENAI_IMAGE_SIZES)) {
+    throw new ValidationError(`--size must be one of: ${OPENAI_IMAGE_SIZES.join(", ")}`);
+  }
+  return value;
+}
+function parseDriver(value) {
+  if (!isOneOf(value, ["api", "codex", "auto"])) {
+    throw new ValidationError("--driver must be one of: api, codex, auto");
+  }
+  return value;
+}
+function parseNumImages(value) {
+  if (!/^\d+$/.test(value)) {
+    throw new ValidationError("--num-images must be an integer from 1 to 10");
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (parsed < 1 || parsed > 10) {
+    throw new ValidationError("--num-images must be an integer from 1 to 10");
+  }
+  return parsed;
+}
+function parseTtsFormat(value) {
+  if (!isOneOf(value, OPENAI_TTS_OUTPUT_FORMATS)) {
+    throw new ValidationError(
+      `--output-format must be one of: ${OPENAI_TTS_OUTPUT_FORMATS.join(", ")}`
+    );
+  }
+  return value;
+}
+function validateTtsVoice(value) {
+  if (!isOneOf(value, OPENAI_TTS_VOICES)) {
+    throw new ValidationError(`--voice must be one of: ${OPENAI_TTS_VOICES.join(", ")}`);
+  }
+}
+function parseTranscriptFormat(value) {
+  if (!isOneOf(value, OPENAI_TRANSCRIPT_FORMATS)) {
+    throw new ValidationError(`--format must be one of: ${OPENAI_TRANSCRIPT_FORMATS.join(", ")}`);
+  }
+  return value;
+}
+function resolveTranscriptionRequestFormat(cliFormat, model) {
+  if (cliFormat === "diarized_json") {
+    if (model !== "gpt-4o-transcribe-diarize") {
+      throw new ValidationError("--format diarized_json requires gpt-4o-transcribe-diarize");
+    }
+    return "diarized_json";
+  }
+  return "json";
+}
+function validateKnownSpeakerPairing(names = [], refs = []) {
+  if (names.length !== refs.length) {
+    throw new ValidationError(
+      "--known-speaker-name and --known-speaker-reference must have equal counts"
+    );
+  }
+  if (names.length > 4) {
+    throw new ValidationError("OpenAI diarization supports up to 4 known speakers");
+  }
+}
+
+// src/providers/openai/openai-audio.ts
+init_http_client();
+import fs30 from "fs";
+import path35 from "path";
+
+// src/providers/openai/client.ts
 import fs29 from "fs";
 import path34 from "path";
 init_errors();
 init_http_client();
+var DEFAULT_TIMEOUT_MS3 = 24e4;
+function requireOpenAIKey() {
+  const key = resolveKey("OPENAI_API_KEY");
+  if (!key) {
+    throw new ConfigError(
+      "OPENAI_API_KEY is not set. Get one at https://platform.openai.com/api-keys"
+    );
+  }
+  return key;
+}
+function endpoint(pathname) {
+  return `${OPENAI_BASE_URL}/${pathname.replace(/^\//, "")}`;
+}
+function authHeaders4(apiKey, extra) {
+  return { Authorization: `Bearer ${apiKey}`, ...extra ?? {} };
+}
+function postOpenAIJson(pathname, body, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  return httpJson({
+    url: endpoint(pathname),
+    method: "POST",
+    headers: authHeaders4(apiKey, { "Content-Type": "application/json" }),
+    body,
+    timeoutMs
+  });
+}
+async function postOpenAIForm(pathname, form, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  const url = endpoint(pathname);
+  let res;
+  try {
+    res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: authHeaders4(apiKey),
+      body: form,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+  return res.json();
+}
+async function postOpenAIBinary(pathname, body, apiKey, timeoutMs = DEFAULT_TIMEOUT_MS3) {
+  const url = endpoint(pathname);
+  let res;
+  try {
+    res = await globalThis.fetch(url, {
+      method: "POST",
+      headers: authHeaders4(apiKey, { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (cause) {
+    throw new HttpError(0, cause instanceof Error ? cause.message : String(cause), url);
+  }
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new HttpError(res.status, text.slice(0, 500), url);
+  }
+  return Buffer.from(await res.arrayBuffer());
+}
+function fileFromPath(filePath) {
+  const abs = path34.resolve(filePath);
+  if (!fs29.existsSync(abs)) throw new ValidationError(`File not found: ${abs}`);
+  const bytes = fs29.readFileSync(abs);
+  return new File([new Uint8Array(bytes)], path34.basename(abs));
+}
+
+// src/providers/openai/openai-audio.ts
+function buildSpeechBody(opts) {
+  const body = {
+    model: opts.model ?? DEFAULT_OPENAI_TTS_MODEL,
+    input: opts.text,
+    voice: opts.voice,
+    response_format: opts.outputFormat
+  };
+  if (opts.instructions) body.instructions = opts.instructions;
+  return body;
+}
+async function buildTranscriptionForm(opts) {
+  const model = opts.model ?? DEFAULT_OPENAI_STT_MODEL;
+  const form = new FormData();
+  form.append("file", opts.input);
+  form.append("model", model);
+  form.append("response_format", resolveTranscriptionRequestFormat(opts.cliFormat, model));
+  if (opts.language) form.append("language", opts.language);
+  if (opts.chunkingStrategy) form.append("chunking_strategy", opts.chunkingStrategy);
+  const names = opts.knownSpeakerNames ?? [];
+  const refs = opts.knownSpeakerReferences ?? [];
+  validateKnownSpeakerPairing(names, refs);
+  for (const name of names) form.append("known_speaker_names[]", name);
+  for (const ref of refs) {
+    form.append("known_speaker_references[]", await resolveAudioReferenceDataUrl(ref));
+  }
+  return form;
+}
+async function resolveAudioReferenceDataUrl(ref) {
+  const resolved = await resolveAudioInput(ref);
+  if (resolved.kind === "data") return resolved.dataUrl;
+  const bytes = await fetchBytes(resolved.url);
+  return `data:${audioMimeFromReference(resolved.url)};base64,${bytes.toString("base64")}`;
+}
+function audioMimeFromReference(ref) {
+  const pathname = new URL(ref).pathname;
+  const ext = path35.extname(pathname).toLowerCase();
+  switch (ext) {
+    case ".mp3":
+      return "audio/mpeg";
+    case ".wav":
+      return "audio/wav";
+    case ".m4a":
+      return "audio/mp4";
+    case ".flac":
+      return "audio/flac";
+    case ".ogg":
+      return "audio/ogg";
+    default:
+      return "application/octet-stream";
+  }
+}
+async function generateOpenAISpeech(opts) {
+  const bytes = await postOpenAIBinary("/audio/speech", buildSpeechBody(opts), requireOpenAIKey());
+  const ext = extFromAudioFormat(opts.outputFormat);
+  const dest = path35.join(getOutputDir(), `openai-speech-${Date.now()}.${ext}`);
+  fs30.writeFileSync(dest, bytes);
+  opts.logger?.success(`Saved: ${dest} (${(bytes.length / 1024).toFixed(1)} KB)`);
+  if (opts.output) {
+    fs30.mkdirSync(path35.dirname(path35.resolve(opts.output)), { recursive: true });
+    fs30.copyFileSync(dest, opts.output);
+  }
+  return dest;
+}
+async function transcribeOpenAIAudio(opts) {
+  const form = await buildTranscriptionForm({
+    input: fileFromPath(opts.inputPath),
+    model: opts.model,
+    cliFormat: opts.format,
+    language: opts.language,
+    chunkingStrategy: opts.chunkingStrategy ?? (opts.model === "gpt-4o-transcribe-diarize" || opts.format === "diarized_json" ? "auto" : void 0),
+    knownSpeakerNames: opts.knownSpeakerNames,
+    knownSpeakerReferences: opts.knownSpeakerReferences
+  });
+  const data = await postOpenAIForm(
+    "/audio/transcriptions",
+    form,
+    requireOpenAIKey(),
+    6e5
+  );
+  const text = typeof data.text === "string" ? data.text : void 0;
+  const ext = opts.format === "text" ? "txt" : "json";
+  const dest = opts.output ? path35.resolve(opts.output) : path35.join(getOutputDir(), `openai-transcribe-${Date.now()}.${ext}`);
+  fs30.mkdirSync(path35.dirname(dest), { recursive: true });
+  fs30.writeFileSync(dest, opts.format === "text" ? text ?? "" : JSON.stringify(data, null, 2));
+  opts.logger?.success(`Saved transcript: ${dest}`);
+  return { path: dest, text };
+}
+
+// src/providers/openai/commands/generate-speech.ts
+function registerOpenAIGenerateSpeechCommand(parent) {
+  parent.command("generate-speech").description("Generate speech with OpenAI TTS").option("--text <str>", "Text to speak").option("--prompt <str>", "Alias for --text").option("--model <id>", "TTS model", process.env.OPENAI_TTS_MODEL ?? DEFAULT_OPENAI_TTS_MODEL).option("--voice <name>", "OpenAI voice", "marin").option("--instructions <text>", "Voice/style instructions").option("--output-format <fmt>", "mp3|opus|aac|flac|wav|pcm", "mp3").option("--output <path>", "Copy generated audio to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const text = opts.text ?? opts.prompt;
+    if (!text) throw new ValidationError("Either --text or --prompt is required");
+    validateTtsVoice(opts.voice);
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const dest = await generateOpenAISpeech({
+      text,
+      model: opts.model,
+      voice: opts.voice,
+      outputFormat: parseTtsFormat(opts.outputFormat),
+      instructions: opts.instructions,
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated audio: ${dest}`);
+  });
+}
+
+// src/providers/openai/codex-image-driver.ts
+import fs31 from "fs";
+import os2 from "os";
+import path36 from "path";
+import { execa } from "execa";
+init_errors();
+var defaultRunner = async (cmd, args, opts) => {
+  const res = await execa(cmd, args, {
+    cwd: opts?.cwd,
+    env: opts?.env,
+    reject: false,
+    timeout: opts?.timeoutMs
+  });
+  return { stdout: res.stdout, stderr: res.stderr, exitCode: res.exitCode ?? 0 };
+};
+async function checkCodexAuthenticated(runner = defaultRunner) {
+  try {
+    const res = await runner("codex", ["login", "status"], { timeoutMs: 15e3 });
+    return res.exitCode === 0 && /Logged in using ChatGPT/i.test(`${res.stdout}
+${res.stderr}`);
+  } catch {
+    return false;
+  }
+}
+async function resolveImageDriver(opts) {
+  const hasApiKey = opts.hasApiKey ?? Boolean(resolveKey("OPENAI_API_KEY"));
+  const codexAuthCheck = opts.codexAuthCheck ?? (() => checkCodexAuthenticated());
+  if (opts.requested === "api") {
+    if (!hasApiKey) throw new ConfigError("OPENAI_API_KEY is required for --driver api");
+    return "api";
+  }
+  if (opts.requested === "codex") {
+    if (!await codexAuthCheck()) throw new ConfigError("Codex driver requires `codex login`");
+    return "codex";
+  }
+  if (hasApiKey) return "api";
+  if (await codexAuthCheck()) return "codex";
+  throw new ConfigError(
+    "Set OPENAI_API_KEY or run `codex login` for the experimental image driver"
+  );
+}
+function sanitizeCodexEnv() {
+  const keep = ["PATH", "HOME", "CODEX_HOME", "TMPDIR", "TEMP", "LANG", "LC_ALL"];
+  const env = {};
+  for (const key of keep) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  return env;
+}
+async function runCodexImageGeneration(opts) {
+  const runner = opts.runner ?? defaultRunner;
+  const ext = extFromImageFormat(opts.outputFormat);
+  const dest = opts.output ? path36.resolve(opts.output) : path36.join(getOutputDir(), `codex-image-${Date.now()}.${ext}`);
+  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
+  const tmp = fs31.mkdtempSync(path36.join(os2.tmpdir(), "multix-codex-image-"));
+  const schema = path36.join(tmp, "schema.json");
+  const result = path36.join(tmp, "result.json");
+  fs31.writeFileSync(
+    schema,
+    JSON.stringify({
+      type: "object",
+      properties: { status: { type: "string" }, path: { type: "string" } },
+      required: ["status", "path"],
+      additionalProperties: false
+    })
+  );
+  const args = [
+    "exec",
+    "--ephemeral",
+    "--skip-git-repo-check",
+    "--cd",
+    tmp,
+    "--output-schema",
+    schema,
+    "--output-last-message",
+    result
+  ];
+  for (const ref of opts.refs ?? []) args.push("--image", ref);
+  args.push(buildCodexPrompt(opts.prompt, dest));
+  const res = await runner("codex", args, {
+    cwd: tmp,
+    env: sanitizeCodexEnv(),
+    timeoutMs: 6e5
+  });
+  if (res.exitCode !== 0) {
+    throw new ProviderError(`Codex image driver failed: ${res.stderr || res.stdout}`, "openai");
+  }
+  if (!fs31.existsSync(dest) || fs31.statSync(dest).size === 0) {
+    throw new ProviderError(`Codex did not create a non-empty image at ${dest}`, "openai");
+  }
+  return { path: dest };
+}
+function buildCodexPrompt(userPrompt, outputPath) {
+  return [
+    `Create exactly one image at ${outputPath}.`,
+    "Do not modify any repository files.",
+    "Use the attached reference images if present.",
+    `Image request: ${userPrompt}`,
+    `Reply with JSON only: {"status":"ok","path":"${outputPath}"}.`
+  ].join(" ");
+}
+
+// src/providers/openai/openai-image.ts
+init_errors();
+init_http_client();
+import fs32 from "fs";
+import path37 from "path";
+function buildImageGenerationBody(opts) {
+  return {
+    model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
+    prompt: opts.prompt,
+    size: opts.size ?? "1024x1024",
+    quality: opts.quality ?? "medium",
+    output_format: opts.outputFormat,
+    n: opts.numImages ?? 1
+  };
+}
+async function buildImageEditForm(opts) {
+  const form = new FormData();
+  form.append("model", opts.model);
+  form.append("prompt", opts.prompt);
+  form.append("size", opts.size);
+  form.append("quality", opts.quality);
+  form.append("output_format", opts.outputFormat);
+  for (const ref of opts.refs) {
+    form.append("image[]", new File([new Uint8Array(ref.bytes)], ref.filename, { type: ref.mime }));
+  }
+  return form;
+}
+function saveOpenAIImages(opts) {
+  const items = opts.data ?? [];
+  if (items.length === 0) throw new ProviderError("No images in OpenAI response", "openai");
+  const outDir = getOutputDir();
+  const ext = extFromImageFormat(opts.format);
+  const ts = Date.now();
+  const saved = [];
+  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 = path37.join(outDir, `openai-${opts.task}-${ts}-${i + 1}.${ext}`);
+    fs32.writeFileSync(dest, Buffer.from(b64, "base64"));
+    saved.push(dest);
+    opts.logger?.success(`Saved: ${dest}`);
+  }
+  if (opts.output && saved[0]) {
+    fs32.mkdirSync(path37.dirname(path37.resolve(opts.output)), { recursive: true });
+    fs32.copyFileSync(saved[0], opts.output);
+    opts.logger?.success(`Copied to: ${opts.output}`);
+  }
+  return saved;
+}
+async function resolveImageRefBytes(ref) {
+  if (isHttpUrl(ref)) {
+    const bytes2 = await fetchBytes(ref);
+    const pathname = new URL(ref).pathname;
+    const filename = path37.basename(pathname) || "reference.png";
+    return { filename, bytes: bytes2, mime: sniffImageMime2(bytes2, filename) };
+  }
+  const file = fileFromPath(ref);
+  const bytes = Buffer.from(await file.arrayBuffer());
+  return { filename: file.name, bytes, mime: file.type || sniffImageMime2(bytes, file.name) };
+}
+async function generateOpenAIImage(opts) {
+  const data = await postOpenAIJson(
+    "/images/generations",
+    buildImageGenerationBody(opts),
+    requireOpenAIKey()
+  );
+  return saveOpenAIImages({
+    data: data.data,
+    task: "image",
+    format: opts.outputFormat,
+    output: opts.output,
+    logger: opts.logger
+  });
+}
+async function editOpenAIImage(opts) {
+  const refs = await Promise.all(opts.refs.map((ref) => resolveImageRefBytes(ref)));
+  const form = await buildImageEditForm({
+    prompt: opts.prompt,
+    refs,
+    model: opts.model ?? DEFAULT_OPENAI_IMAGE_MODEL,
+    size: opts.size ?? "1024x1024",
+    quality: opts.quality ?? "medium",
+    outputFormat: opts.outputFormat
+  });
+  const data = await postOpenAIForm("/images/edits", form, requireOpenAIKey());
+  return saveOpenAIImages({
+    data: data.data,
+    task: "image-edit",
+    format: opts.outputFormat,
+    output: opts.output,
+    logger: opts.logger
+  });
+}
+function sniffImageMime2(buf, name) {
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
+  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 = path37.extname(name).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  return "image/png";
+}
+
+// src/providers/openai/commands/generate.ts
+function registerOpenAIGenerateCommand(parent) {
+  parent.command("generate").description("Generate images with OpenAI Image API or experimental Codex driver").requiredOption("--prompt <text>", "Text prompt").option("--driver <driver>", "api|codex|auto", "auto").option(
+    "-m, --model <id>",
+    "Image model",
+    resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("-n, --num-images <n>", "Number of images for API driver", "1").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const outputFormat = parseImageFormat(opts.format);
+    const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
+    const saved = driver === "codex" ? [
+      (await runCodexImageGeneration({
+        prompt: opts.prompt,
+        outputFormat,
+        output: opts.output
+      })).path
+    ] : await generateOpenAIImage({
+      prompt: opts.prompt,
+      model: opts.model,
+      size: parseImageSize(opts.size),
+      quality: parseImageQuality(opts.quality),
+      outputFormat,
+      numImages: parseNumImages(opts.numImages),
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated ${saved.length} image(s):`);
+    for (const file of saved) console.log(`  ${file}`);
+  });
+}
+
+// src/providers/openai/commands/image-to-image.ts
+init_errors();
+function registerOpenAIImageToImageCommand(parent) {
+  parent.command("image-to-image").alias("i2i").description("Edit images with OpenAI Image API or experimental Codex driver").requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
+    "--ref <path>",
+    "Reference image path or URL; repeatable",
+    collect5,
+    []
+  ).option("--driver <driver>", "api|codex|auto", "auto").option(
+    "-m, --model <id>",
+    "Image model",
+    resolveKey("OPENAI_IMAGE_MODEL") ?? DEFAULT_OPENAI_IMAGE_MODEL
+  ).option("--size <size>", "1024x1024|1024x1536|1536x1024|auto", "1024x1024").option("--quality <q>", "low|medium|high", "medium").option("--format <fmt>", "png|jpeg|webp", "png").option("--output <path>", "Save first image to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    if (!opts.ref || opts.ref.length === 0) {
+      throw new ValidationError("At least one --ref is required for image-to-image.");
+    }
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const outputFormat = parseImageFormat(opts.format);
+    const driver = await resolveImageDriver({ requested: parseDriver(opts.driver) });
+    const saved = driver === "codex" ? [
+      (await runCodexImageGeneration({
+        prompt: opts.prompt,
+        refs: opts.ref,
+        outputFormat,
+        output: opts.output
+      })).path
+    ] : await editOpenAIImage({
+      prompt: opts.prompt,
+      refs: opts.ref,
+      model: opts.model,
+      size: parseImageSize(opts.size),
+      quality: parseImageQuality(opts.quality),
+      outputFormat,
+      output: opts.output,
+      logger
+    });
+    console.log(`
+Generated ${saved.length} image(s):`);
+    for (const file of saved) console.log(`  ${file}`);
+  });
+}
+function collect5(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/openai/commands/transcribe.ts
+function registerOpenAITranscribeCommand(parent) {
+  parent.command("transcribe").description("Transcribe audio/video with OpenAI STT").requiredOption("--input <path>", "Audio or video file").option("--model <id>", "STT model", process.env.OPENAI_STT_MODEL ?? DEFAULT_OPENAI_STT_MODEL).option("--format <fmt>", "json|text|diarized_json", "text").option("--language <code>", "ISO language code").option("--chunking-strategy <strategy>", "e.g. auto").option(
+    "--known-speaker-name <name>",
+    "Known speaker name; repeatable",
+    collect6,
+    []
+  ).option(
+    "--known-speaker-reference <path>",
+    "2-10s reference audio; repeatable",
+    collect6,
+    []
+  ).option("--output <path>", "Save transcript to this path").option("-v, --verbose", "Verbose logging").action(async (opts) => {
+    const logger = createLogger({ verbose: opts.verbose ?? false });
+    const result = await transcribeOpenAIAudio({
+      inputPath: opts.input,
+      model: opts.model,
+      format: parseTranscriptFormat(opts.format),
+      language: opts.language,
+      chunkingStrategy: opts.chunkingStrategy,
+      knownSpeakerNames: opts.knownSpeakerName,
+      knownSpeakerReferences: opts.knownSpeakerReference,
+      output: opts.output,
+      logger
+    });
+    if (opts.format === "text" && result.text) console.log(`
+${result.text.trim()}`);
+  });
+}
+function collect6(value, prev) {
+  return [...prev, value];
+}
+
+// src/providers/openai/commands/index.ts
+function registerOpenAICommands(program2) {
+  const openai = program2.command("openai").description("OpenAI image generation/editing, TTS, STT, and experimental Codex image driver");
+  registerOpenAIGenerateCommand(openai);
+  registerOpenAIImageToImageCommand(openai);
+  registerOpenAIGenerateSpeechCommand(openai);
+  registerOpenAITranscribeCommand(openai);
+}
+
+// src/providers/openrouter/client.ts
+import fs33 from "fs";
+import path38 from "path";
+init_errors();
+init_http_client();
 
 // src/providers/openrouter/payload.ts
 var IMAGE_ONLY_MODEL_PREFIXES = [
@@ -4523,8 +5150,8 @@ async function generateOpenRouterImage(opts) {
     if (!url) continue;
     try {
       const bytes = await fetchBytes(url);
-      const dest = path34.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
-      fs29.writeFileSync(dest, bytes);
+      const dest = path38.join(outDir, `openrouter_image_${Date.now()}_${i}.png`);
+      fs33.writeFileSync(dest, bytes);
       savedFiles.push(dest);
       logger?.success(`Saved: ${dest}`);
     } catch (e) {
@@ -4535,8 +5162,8 @@ async function generateOpenRouterImage(opts) {
     }
   }
   if (output && savedFiles[0]) {
-    fs29.mkdirSync(path34.dirname(path34.resolve(output)), { recursive: true });
-    fs29.writeFileSync(output, fs29.readFileSync(savedFiles[0]));
+    fs33.mkdirSync(path38.dirname(path38.resolve(output)), { recursive: true });
+    fs33.writeFileSync(output, fs33.readFileSync(savedFiles[0]));
   }
   return { status: "success", generatedImages: savedFiles, model: usedModel };
 }
@@ -4571,8 +5198,8 @@ Generated ${result.generatedImages?.length ?? 0} image(s):`);
 }
 
 // src/providers/openrouter/commands/image-to-image.ts
-import fs30 from "fs";
-import path35 from "path";
+import fs34 from "fs";
+import path39 from "path";
 init_errors();
 init_http_client();
 var DEFAULT_MODEL = "google/gemini-2.5-flash-image";
@@ -4582,7 +5209,7 @@ function registerOpenRouterImageToImageCommand(parent) {
   parent.command("image-to-image").alias("i2i").description("Edit/transform images via OpenRouter (default: google/gemini-2.5-flash-image)").requiredOption("--prompt <text>", "Text prompt describing the edit").requiredOption(
     "--ref <path>",
     "Reference image (URL or local path); repeatable (most models accept 1)",
-    collect5,
+    collect7,
     []
   ).option("-m, --model <id>", `OpenRouter model id (default ${DEFAULT_MODEL})`).option("--strength <n>", "Recraft init-image strength 0..1 (Recraft models only)").option("--output <path>", "Save first generated image to this path").option("-v, --verbose", "Verbose logging").action(
     async (opts) => {
@@ -4623,7 +5250,7 @@ Generated ${saved.length} image(s):`);
     }
   );
 }
-function collect5(value, prev) {
+function collect7(value, prev) {
   return [...prev, value];
 }
 function parseStrength(raw) {
@@ -4662,14 +5289,14 @@ async function runImageToImage(opts) {
     const url = parsed.urls[i];
     if (!url) continue;
     const bytes = await fetchBytes(url);
-    const dest = path35.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
-    fs30.writeFileSync(dest, bytes);
+    const dest = path39.join(outDir, `openrouter-i2i-${ts}-${i + 1}.png`);
+    fs34.writeFileSync(dest, bytes);
     saved.push(dest);
     opts.logger.success(`Saved: ${dest}`);
   }
   if (opts.output && saved[0]) {
-    fs30.mkdirSync(path35.dirname(path35.resolve(opts.output)), { recursive: true });
-    fs30.copyFileSync(saved[0], opts.output);
+    fs34.mkdirSync(path39.dirname(path39.resolve(opts.output)), { recursive: true });
+    fs34.copyFileSync(saved[0], opts.output);
     opts.logger.success(`Copied to: ${opts.output}`);
   }
   return saved;
@@ -4678,7 +5305,7 @@ async function runImageToImage(opts) {
 // src/providers/openrouter/video-client.ts
 init_http_client();
 var OPENROUTER_VIDEOS_URL = "https://openrouter.ai/api/v1/videos";
-function authHeaders4(apiKey) {
+function authHeaders5(apiKey) {
   const headers = {
     Authorization: `Bearer ${apiKey}`,
     "Content-Type": "application/json"
@@ -4693,7 +5320,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: OPENROUTER_VIDEOS_URL,
     method: "POST",
-    headers: authHeaders4(apiKey),
+    headers: authHeaders5(apiKey),
     body,
     timeoutMs: 12e4
   });
@@ -4701,7 +5328,7 @@ async function submitVideoJob(body, apiKey = requireOpenRouterKey()) {
 async function pollVideoJob(jobId, apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/${jobId}`,
-    headers: authHeaders4(apiKey)
+    headers: authHeaders5(apiKey)
   });
 }
 function videoContentUrl(jobId) {
@@ -4710,18 +5337,18 @@ function videoContentUrl(jobId) {
 async function listVideoModels(apiKey = requireOpenRouterKey()) {
   return httpJson({
     url: `${OPENROUTER_VIDEOS_URL}/models`,
-    headers: authHeaders4(apiKey)
+    headers: authHeaders5(apiKey)
   });
 }
 
 // src/providers/openrouter/commands/video-status.ts
-import fs31 from "fs";
-import path36 from "path";
+import fs35 from "fs";
+import path40 from "path";
 async function downloadOpenRouterVideo(opts) {
   const { jobId, logger, source } = opts;
   const apiKey = requireOpenRouterKey();
   const url = videoContentUrl(jobId);
-  const dest = path36.join(getOutputDir(), `openrouter_video_${jobId}.mp4`);
+  const dest = path40.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}`);
@@ -4731,14 +5358,14 @@ async function downloadOpenRouterVideo(opts) {
     logger.error("Empty response body");
     process.exit(1);
   }
-  fs31.mkdirSync(path36.dirname(dest), { recursive: true });
-  const ws = fs31.createWriteStream(dest);
+  fs35.mkdirSync(path40.dirname(dest), { recursive: true });
+  const ws = fs35.createWriteStream(dest);
   const { pipeline: pipeline2 } = await import("stream/promises");
   await pipeline2(r.body, ws);
   logger.success(`Saved ${dest}`);
   if (opts.output) {
-    fs31.mkdirSync(path36.dirname(path36.resolve(opts.output)), { recursive: true });
-    fs31.copyFileSync(dest, opts.output);
+    fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
+    fs35.copyFileSync(dest, opts.output);
     logger.success(`Copied to ${opts.output}`);
   }
   await maybeDownloadThumb(source, dest, {
@@ -4898,10 +5525,10 @@ function registerOpenRouterCommands(program2) {
 }
 
 // src/commands/check-helpers/binary-check.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 async function checkBinary(binary) {
   try {
-    const result = await execa(binary, ["--version"], { reject: true, all: true });
+    const result = await execa2(binary, ["--version"], { reject: true, all: true });
     const version = (result.stdout || result.stderr || "").split("\n")[0]?.trim();
     return { available: true, version, binary };
   } catch (e) {
@@ -4982,6 +5609,12 @@ var PROVIDERS = [
     optional: true,
     link: "https://openrouter.ai/settings/keys"
   },
+  {
+    name: "OpenAI",
+    envPrimary: "OPENAI_API_KEY",
+    optional: true,
+    link: "https://platform.openai.com/api-keys"
+  },
   {
     name: "MiniMax",
     envPrimary: "MINIMAX_API_KEY",
@@ -5017,6 +5650,10 @@ function resolveProviderKey(p) {
   }
   return {};
 }
+async function checkCodexImageReadiness(hasAnyProviderKey, verbose = false, checker = checkCodexAuthenticated) {
+  if (hasAnyProviderKey && !verbose) return false;
+  return checker();
+}
 function registerCheckCommand(program2) {
   program2.command("check").description("Validate multix setup: tooling, API keys, and live Gemini connectivity").option("-v, --verbose", "Verbose output").action(async (opts) => {
     const logger = createLogger({ verbose: opts.verbose ?? false });
@@ -5053,10 +5690,25 @@ function registerCheckCommand(program2) {
         logger.warn(`${p.envPrimary} not set (${p.name} features unavailable)`);
       }
     }
+    const shouldCheckCodex = !anyKey || opts.verbose;
+    let codexReady = false;
+    if (shouldCheckCodex) {
+      logger.header("Codex Image Driver");
+      logger.info("Checking Codex login status...");
+      codexReady = await checkCodexImageReadiness(anyKey, opts.verbose ?? false);
+      if (codexReady) {
+        logger.success("Codex authenticated \u2014 experimental OpenAI image driver available");
+      } else {
+        logger.info("Codex image driver unavailable (run `codex login` to enable it)");
+      }
+    }
     if (!anyKey) {
-      logger.header("No Provider Keys Configured");
-      console.log(SETUP_HINTS);
-      process.exit(1);
+      if (!codexReady) {
+        logger.header("No Provider Keys Configured");
+        console.log(SETUP_HINTS);
+        process.exit(1);
+      }
+      anyKey = true;
     }
     const geminiKey = resolved.get("Gemini")?.key;
     if (geminiKey) {
@@ -5079,9 +5731,11 @@ function registerCheckCommand(program2) {
         console.log(
           "  Full Gemini multimodal setup (analyze, transcribe, generate, doc convert)"
         );
+      } else if (resolved.get("OpenAI")?.key) {
+        console.log("  OpenAI API setup available (images, TTS, STT)");
       } else {
-        console.log("  Image generation via OpenRouter/MiniMax/Leonardo/BytePlus available");
-        console.log("  Add GEMINI_API_KEY for analysis, transcription, and doc conversion");
+        console.log("  Image generation via configured providers or experimental Codex driver");
+        console.log("  Add API keys for full provider features");
       }
     } else {
       logger.error("One or more checks failed \u2014 see above");
@@ -5092,8 +5746,8 @@ function registerCheckCommand(program2) {
 
 // src/commands/doc/convert.ts
 init_errors();
-import fs32 from "fs";
-import path37 from "path";
+import fs36 from "fs";
+import path41 from "path";
 
 // src/commands/doc/default-prompt.ts
 var DEFAULT_CONVERT_PROMPT = `Convert this document to clean, well-formatted Markdown.
@@ -5114,18 +5768,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 (!fs32.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
+    if (!fs36.existsSync(f)) throw new ValidationError(`Input file not found: ${f}`);
   }
   let outputPath;
   if (output) {
-    outputPath = path37.resolve(output);
+    outputPath = path41.resolve(output);
   } else if (autoName && inputs.length === 1 && inputs[0]) {
-    const base = path37.basename(inputs[0], path37.extname(inputs[0]));
-    outputPath = path37.join(getOutputDir(), `${base}-extraction.md`);
+    const base = path41.basename(inputs[0], path41.extname(inputs[0]));
+    outputPath = path41.join(getOutputDir(), `${base}-extraction.md`);
   } else {
-    outputPath = path37.join(getOutputDir(), "document-extraction.md");
+    outputPath = path41.join(getOutputDir(), "document-extraction.md");
   }
-  fs32.mkdirSync(path37.dirname(outputPath), { recursive: true });
+  fs36.mkdirSync(path41.dirname(outputPath), { recursive: true });
   const results = [];
   for (let i = 0; i < inputs.length; i++) {
     const filePath = inputs[i];
@@ -5176,7 +5830,7 @@ async function convertDocuments(opts) {
 `);
   for (const r of results) {
     lines.push(`
-## ${path37.basename(r.file)}
+## ${path41.basename(r.file)}
 `);
     if (r.status === "success" && r.markdown) {
       lines.push(`${r.markdown}
@@ -5189,7 +5843,7 @@ async function convertDocuments(opts) {
     }
     lines.push("\n---\n");
   }
-  fs32.writeFileSync(outputPath, lines.join("\n"), "utf8");
+  fs36.writeFileSync(outputPath, lines.join("\n"), "utf8");
   const succeeded = results.filter((r) => r.status === "success").length;
   console.log(`
 ${"=".repeat(50)}`);
@@ -5235,12 +5889,12 @@ function registerDocCommands(program2) {
 
 // src/commands/media/index.ts
 init_errors();
-import fs35 from "fs";
-import path40 from "path";
+import fs39 from "fs";
+import path44 from "path";
 
 // src/commands/media/batch.ts
-import fs33 from "fs";
-import path38 from "path";
+import fs37 from "fs";
+import path42 from "path";
 
 // src/commands/media/detect-type.ts
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".mpg", ".mpeg"]);
@@ -5259,10 +5913,10 @@ init_errors();
 
 // src/commands/media/ffmpeg-runner.ts
 init_errors();
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 async function assertFfmpeg() {
   try {
-    await execa2("ffmpeg", ["-version"], { reject: true });
+    await execa3("ffmpeg", ["-version"], { reject: true });
   } catch (e) {
     if (e.code === "ENOENT") {
       throw new ValidationError(
@@ -5275,7 +5929,7 @@ async function runFfmpeg(args, opts = {}) {
   const { verbose, logger } = opts;
   logger?.debug(`ffmpeg ${args.join(" ")}`);
   try {
-    const result = await execa2("ffmpeg", args, { reject: true, all: true });
+    const result = await execa3("ffmpeg", args, { reject: true, all: true });
     if (verbose && result.stderr) logger?.debug(result.stderr);
   } catch (e) {
     const err2 = e;
@@ -5285,7 +5939,7 @@ async function runFfmpeg(args, opts = {}) {
 }
 async function getMediaInfo(filePath) {
   try {
-    const result = await execa2(
+    const result = await execa3(
       "ffprobe",
       ["-v", "quiet", "-print_format", "json", "-show_format", "-show_streams", filePath],
       { reject: true }
@@ -5348,10 +6002,10 @@ async function optimizeAudio(opts) {
 
 // src/commands/media/magick-runner.ts
 init_errors();
-import { execa as execa3 } from "execa";
+import { execa as execa4 } from "execa";
 async function assertMagick() {
   try {
-    await execa3("magick", ["-version"], { reject: true });
+    await execa4("magick", ["-version"], { reject: true });
   } catch (e) {
     if (e.code === "ENOENT") {
       throw new ValidationError(
@@ -5364,7 +6018,7 @@ async function runMagick(args, opts = {}) {
   const { verbose, logger } = opts;
   logger?.debug(`magick ${args.join(" ")}`);
   try {
-    const result = await execa3("magick", args, { reject: true, all: true });
+    const result = await execa4("magick", args, { reject: true, all: true });
     if (verbose && result.stderr) logger?.debug(result.stderr);
   } catch (e) {
     const err2 = e;
@@ -5436,10 +6090,10 @@ async function batchOptimize(opts) {
     verbose,
     logger
   } = opts;
-  fs33.mkdirSync(outputDir, { recursive: true });
-  const entries = fs33.readdirSync(inputDir);
+  fs37.mkdirSync(outputDir, { recursive: true });
+  const entries = fs37.readdirSync(inputDir);
   const mediaFiles = entries.filter((f) => {
-    const ext = path38.extname(f).toLowerCase();
+    const ext = path42.extname(f).toLowerCase();
     return ALL_EXTS.has(ext);
   });
   if (mediaFiles.length === 0) {
@@ -5450,9 +6104,9 @@ async function batchOptimize(opts) {
   let succeeded = 0;
   const errors = [];
   for (const file of mediaFiles) {
-    const inputPath = path38.join(inputDir, file);
-    const outputPath = path38.join(outputDir, file);
-    const ext = path38.extname(file).toLowerCase();
+    const inputPath = path42.join(inputDir, file);
+    const outputPath = path42.join(outputDir, file);
+    const ext = path42.extname(file).toLowerCase();
     const kind = extToKind(ext);
     logger?.debug(`Processing: ${file}`);
     try {
@@ -5489,8 +6143,8 @@ async function batchOptimize(opts) {
 
 // src/commands/media/split-video.ts
 init_errors();
-import fs34 from "fs";
-import path39 from "path";
+import fs38 from "fs";
+import path43 from "path";
 async function splitVideo(opts) {
   await assertFfmpeg();
   const { input, outputDir, chunkDuration = 3600, verbose, logger } = opts;
@@ -5501,10 +6155,10 @@ async function splitVideo(opts) {
     logger?.info("Video is short enough \u2014 no splitting needed");
     return [input];
   }
-  fs34.mkdirSync(outputDir, { recursive: true });
-  const ext = path39.extname(input) || ".mp4";
-  const baseName = path39.basename(input, ext);
-  const outputPattern = path39.join(outputDir, `${baseName}_chunk_%03d${ext}`);
+  fs38.mkdirSync(outputDir, { recursive: true });
+  const ext = path43.extname(input) || ".mp4";
+  const baseName = path43.basename(input, ext);
+  const outputPattern = path43.join(outputDir, `${baseName}_chunk_%03d${ext}`);
   logger?.debug(`Splitting into ~${numChunks} chunks of ${chunkDuration}s each`);
   const args = [
     "-i",
@@ -5523,8 +6177,8 @@ async function splitVideo(opts) {
   await runFfmpeg(args, { verbose, logger });
   const files = [];
   for (let i = 0; i < numChunks + 1; i++) {
-    const fname = path39.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
-    if (fs34.existsSync(fname)) files.push(fname);
+    const fname = path43.join(outputDir, `${baseName}_chunk_${String(i).padStart(3, "0")}${ext}`);
+    if (fs38.existsSync(fname)) files.push(fname);
   }
   logger?.success(`Created ${files.length} chunks in ${outputDir}`);
   return files;
@@ -5538,9 +6192,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 (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
-      fs35.mkdirSync(path40.dirname(path40.resolve(opts.output)), { recursive: true });
-      const ext = path40.extname(opts.input).toLowerCase();
+      if (!fs39.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      fs39.mkdirSync(path44.dirname(path44.resolve(opts.output)), { recursive: true });
+      const ext = path44.extname(opts.input).toLowerCase();
       const kind = extToKind(ext);
       if (!kind) throw new ValidationError(`Unsupported file type: ${ext}`);
       const quality = Number.parseInt(opts.quality, 10);
@@ -5580,7 +6234,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 (!fs35.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
+      if (!fs39.existsSync(opts.input)) throw new ValidationError(`Input not found: ${opts.input}`);
       const chunks = await splitVideo({
         input: opts.input,
         outputDir: opts.outputDir,
@@ -5596,7 +6250,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 (!fs35.existsSync(opts.inputDir))
+      if (!fs39.existsSync(opts.inputDir))
         throw new ValidationError(`Input dir not found: ${opts.inputDir}`);
       const result = await batchOptimize({
         inputDir: opts.inputDir,
@@ -5622,6 +6276,7 @@ function registerCommands(program2) {
   registerCheckCommand(program2);
   registerGeminiCommands(program2);
   registerMinimaxCommands(program2);
+  registerOpenAICommands(program2);
   registerOpenRouterCommands(program2);
   registerLeonardoCommands(program2);
   registerBytePlusCommands(program2);