1import path from "node:path";
2import { spawn } from "node:child_process";
3import { fileURLToPath } from "node:url";
4import { tmpdir } from "node:os";
5import { mkdir, readFile, rm, writeFile, access } from "node:fs/promises";
6import { randomBytes } from "node:crypto";
7import type { CliArgs } from "../types";
8 
9const PROVIDER_FILE = fileURLToPath(import.meta.url);
10const SCRIPTS_DIR = path.resolve(path.dirname(PROVIDER_FILE), "..");
11const BUNDLED_WRAPPER = path.join(SCRIPTS_DIR, "codex-imagegen", "main.ts");
12 
13type WrapperOkResult = {
14  status: "ok";
15  path: string;
16  bytes: number;
17  elapsed_seconds: number;
18  thread_id: string | null;
19  attempts: number;
20  cached: boolean;
21};
22 
23type WrapperErrorResult = {
24  status: "error";
25  path: string;
26  bytes: number;
27  error: string;
28  error_kind: string;
29};
30 
31type WrapperResult = WrapperOkResult | WrapperErrorResult;
32 
33export function getDefaultModel(): string {
34  return "codex-image-gen";
35}
36 
37export function getDefaultOutputExtension(): string {
38  return ".png";
39}
40 
41export function validateArgs(_model: string, args: CliArgs): void {
42  if (args.n > 1) {
43    throw new Error(
44      "codex-cli provider supports only n=1 (Codex image_gen returns a single image per call).",
45    );
46  }
47  if (args.imageApiDialect && args.imageApiDialect !== "openai-native") {
48    throw new Error(
49      `Invalid imageApiDialect for codex-cli: ${args.imageApiDialect}. codex-cli does not use OpenAI Images API dialects.`,
50    );
51  }
52}
53 
54async function exists(filePath: string): Promise<boolean> {
55  try {
56    await access(filePath);
57    return true;
58  } catch {
59    return false;
60  }
61}
62 
63async function resolveWrapperPath(): Promise<string> {
64  const override = process.env.BAOYU_CODEX_IMAGEGEN_BIN;
65  if (override) {
66    if (!(await exists(override))) {
67      throw new Error(
68        `Invalid BAOYU_CODEX_IMAGEGEN_BIN: ${override} does not exist.`,
69      );
70    }
71    return override;
72  }
73  if (await exists(BUNDLED_WRAPPER)) return BUNDLED_WRAPPER;
74  throw new Error(
75    `codex-cli wrapper not found at ${BUNDLED_WRAPPER}. ` +
76      `Reinstall baoyu-image-gen, or set BAOYU_CODEX_IMAGEGEN_BIN to a codex-imagegen main.ts (or .sh) path.`,
77  );
78}
79 
80type SpawnResult = {
81  stdout: string;
82  stderr: string;
83  code: number;
84};
85 
86async function spawnWrapper(wrapperPath: string, cliArgs: string[]): Promise<SpawnResult> {
87  return new Promise((resolve, reject) => {
88    const isTs = wrapperPath.endsWith(".ts");
89    const command = isTs ? "bun" : wrapperPath;
90    const args = isTs ? [wrapperPath, ...cliArgs] : cliArgs;
91    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
92    let stdout = "";
93    let stderr = "";
94    child.stdout.on("data", (chunk: Buffer) => {
95      stdout += chunk.toString("utf8");
96    });
97    child.stderr.on("data", (chunk: Buffer) => {
98      const text = chunk.toString("utf8");
99      stderr += text;
100      process.stderr.write(text);
101    });
102    child.on("error", (err) => reject(err));
103    child.on("close", (code) => resolve({ stdout, stderr, code: code ?? 1 }));
104  });
105}
106 
107function parseWrapperJson(stdout: string): WrapperResult {
108  const trimmed = stdout.trim();
109  if (!trimmed) {
110    throw new Error("Invalid codex-cli response: empty stdout from wrapper.");
111  }
112  const lastLine = trimmed.split(/\r?\n/).pop() ?? trimmed;
113  try {
114    return JSON.parse(lastLine) as WrapperResult;
115  } catch (parseErr) {
116    throw new Error(
117      `Invalid codex-cli response: could not parse JSON from wrapper stdout (${(parseErr as Error).message}).`,
118    );
119  }
120}
121 
122function parsePositiveInt(value: string | undefined): number | null {
123  if (!value) return null;
124  const parsed = parseInt(value, 10);
125  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
126}
127 
128function getEnvOverride(name: string): string | null {
129  const value = process.env[name];
130  return value && value.length > 0 ? value : null;
131}
132 
133export async function generateImage(
134  prompt: string,
135  _model: string,
136  args: CliArgs,
137): Promise<Uint8Array> {
138  const wrapperPath = await resolveWrapperPath();
139 
140  const sessionDir = path.join(tmpdir(), "baoyu-image-gen-codex-cli");
141  await mkdir(sessionDir, { recursive: true });
142  const token = randomBytes(8).toString("hex");
143  const tmpOutput = path.join(sessionDir, `out-${token}.png`);
144  const tmpPrompt = path.join(sessionDir, `prompt-${token}.md`);
145  await writeFile(tmpPrompt, prompt, "utf8");
146 
147  const aspect = args.aspectRatio ?? "1:1";
148  const cliArgs: string[] = [
149    "--image",
150    tmpOutput,
151    "--prompt-file",
152    tmpPrompt,
153    "--aspect",
154    aspect,
155  ];
156 
157  for (const ref of args.referenceImages) {
158    cliArgs.push("--ref", path.resolve(ref));
159  }
160 
161  const cacheDir = getEnvOverride("BAOYU_CODEX_IMAGEGEN_CACHE_DIR");
162  if (cacheDir) cliArgs.push("--cache-dir", cacheDir);
163 
164  const timeoutMs = parsePositiveInt(process.env.BAOYU_CODEX_IMAGEGEN_TIMEOUT_MS);
165  if (timeoutMs) cliArgs.push("--timeout", String(timeoutMs));
166 
167  const retries = parsePositiveInt(process.env.BAOYU_CODEX_IMAGEGEN_RETRIES);
168  if (retries !== null) cliArgs.push("--retries", String(retries));
169 
170  const logFile = getEnvOverride("BAOYU_CODEX_IMAGEGEN_LOG_FILE");
171  if (logFile) cliArgs.push("--log-file", logFile);
172 
173  try {
174    const spawnResult = await spawnWrapper(wrapperPath, cliArgs);
175    const parsed = parseWrapperJson(spawnResult.stdout);
176 
177    if (parsed.status === "error") {
178      throw new Error(
179        `Invalid codex-cli result (${parsed.error_kind}): ${parsed.error}`,
180      );
181    }
182 
183    if (spawnResult.code !== 0) {
184      throw new Error(
185        `Invalid codex-cli result: wrapper exited with code ${spawnResult.code} despite reporting status=ok.`,
186      );
187    }
188 
189    const bytes = await readFile(parsed.path ?? tmpOutput);
190    return new Uint8Array(bytes);
191  } finally {
192    await Promise.allSettled([
193      rm(tmpOutput, { force: true }),
194      rm(tmpPrompt, { force: true }),
195    ]);
196  }
197}
198