egaki 0.5.0 → 0.7.0

package/dist/cli.js

@@ -1,968 +0,0 @@
-#!/usr/bin/env node
-// Main CLI entrypoint for egaki - AI image and video generation.
-// Uses the Vercel AI SDK for image generation across multiple providers.
-// Designed to be called by agents and humans alike.
-//
-// Two generation paths depending on model:
-//   - imagen-* models → generateImage() with google.image()
-//   - all other models → generateText() with responseModalities: ['IMAGE']
-// The CLI auto-detects which path to use based on model ID prefix.
-import { goke } from 'goke';
-import { z } from 'zod';
-import dedent from 'string-dedent';
-import { generateImage as aiGenerateImage, generateText, experimental_generateVideo as aiGenerateVideo, } from 'ai';
-import { select, isCancel, cancel } from '@clack/prompts';
-import fs from 'node:fs';
-import path from 'node:path';
-import pc from 'picocolors';
-import { createParser } from 'eventsource-parser';
-import pkg from '../package.json' with { type: 'json' };
-import { injectCredentialsToEnv, PROVIDERS, getChatGptAuth, saveChatGptAuth, getKeyStatus, } from './credentials.js';
-import { IMAGE_MODELS, VIDEO_MODELS, DEFAULT_MODEL, DEFAULT_VIDEO_MODEL, getModelConfig, createImageModel, createTextModel, createVideoModel, shouldUseResponsesApi, } from './models.js';
-import { CATALOG } from './model-catalog.js';
-import { VIDEO_CATALOG } from './video-model-catalog.js';
-import { loginInteractive, loginNonInteractive, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
-import { subscribeInteractive, subscribeNonInteractive, unsubscribe, showUsage, } from './subscription.js';
-import { getValidChatGptAuth } from './chatgpt-auth.js';
-const cli = goke('egaki');
-process.title = 'egaki';
-// Print clean error output for unhandled rejections (e.g. AI SDK APICallError).
-// The AI SDK errors include request bodies, response headers, and other noisy
-// properties that get dumped by Node's default handler. We strip those and just
-// print the message + stack trace.
-process.on('uncaughtException', (err) => {
-    console.error(pc.red(err.message));
-    if (err.stack) {
-        const lines = err.stack.split('\n');
-        const stackOnly = lines.filter((l) => l.trimStart().startsWith('at '));
-        if (stackOnly.length > 0) {
-            console.error(pc.dim(stackOnly.join('\n')));
-        }
-    }
-    process.exit(1);
-});
-// ─── login command ───────────────────────────────────────────────────────────
-cli
-    .command('login', dedent `
-      Configure API keys for image generation providers.
-      Interactive mode: shows a provider picker and secure key input.
-      Non-interactive mode: pass --provider and --key flags, or pipe key via stdin.
-      Keys are saved to ~/.config/egaki/credentials.json (mode 0600).
-    `)
-    .option('-p, --provider [name]', z
-    .string()
-    .describe(`Provider name for non-interactive login (${Object.keys(PROVIDERS).join(', ')})`))
-    .option('-k, --key [key]', z.string().describe('API key value for non-interactive login'))
-    .option('--show', 'Show which providers are configured and their status')
-    .option('--remove [provider]', z.string().describe('Remove the stored key for a provider'))
-    .example('# Interactive login (pick provider, paste key)')
-    .example('egaki login')
-    .example('# Non-interactive login with flags')
-    .example('egaki login --provider google --key AIza...')
-    .example('egaki login --provider vertex --key AIza...')
-    .example('# Pipe key from stdin (useful in CI/scripts)')
-    .example('echo "AIza..." | egaki login --provider google')
-    .example('# Show configured providers')
-    .example('egaki login --show')
-    .example('# Remove a stored key')
-    .example('egaki login --remove google')
-    .action(async (options) => {
-    if (options.show) {
-        showLoginStatus();
-        return;
-    }
-    if (options.remove) {
-        removeLogin(options.remove);
-        return;
-    }
-    // Non-interactive: --provider + --key or stdin
-    if (options.provider) {
-        // ChatGPT uses browser OAuth — skip key reading
-        if (options.provider === 'chatgpt') {
-            await loginNonInteractive({ provider: options.provider, key: '' });
-            return;
-        }
-        const key = options.key || (await readKeyFromStdin());
-        await loginNonInteractive({ provider: options.provider, key });
-        return;
-    }
-    // Interactive mode
-    await loginInteractive();
-});
-// ─── subscribe command ───────────────────────────────────────────────────────
-cli
-    .command('subscribe', dedent `
-      Subscribe to Egaki for access to all image models with a single API key.
-      You can also use your own provider keys (Google/OpenAI/Replicate/Fal)
-      via 'egaki login --provider <name> --key <key>' if you prefer BYOK.
-      Egaki subscription avoids managing one key per provider.
-      Three plans: Starter ($9/mo, 100 credits), Pro ($29/mo, 500 credits),
-      Unlimited ($99/mo, 2000 credits). One credit ≈ one standard image.
-      Interactive mode: pick a plan and get a checkout URL (email prefill optional).
-      Non-interactive: --email is optional and only pre-fills checkout.
-    `)
-    .option('-e, --email [email]', z.string().describe('Optional email prefill for checkout (skips interactive prompt)'))
-    .option('--plan [plan]', z.string().describe('Plan ID: starter, pro, or unlimited (default: pro)'))
-    .example('# Interactive subscribe')
-    .example('egaki subscribe')
-    .example('# Non-interactive (for agents)')
-    .example('egaki subscribe --email user@example.com --plan pro')
-    .example('# Non-interactive without email prefill')
-    .example('egaki subscribe --plan pro')
-    .action(async (options) => {
-    const isTTY = process.stdout.isTTY && process.stdin.isTTY;
-    if (!isTTY || options.email || options.plan) {
-        subscribeNonInteractive(options.email, options.plan);
-        return;
-    }
-    await subscribeInteractive();
-});
-// ─── unsubscribe command ─────────────────────────────────────────────────────
-cli
-    .command('unsubscribe', dedent `
-      Cancel your Egaki subscription. Uses the stored API key to identify
-      the subscription. You can resubscribe anytime with 'egaki subscribe'.
-    `)
-    .example('egaki unsubscribe')
-    .action(async () => {
-    await unsubscribe();
-});
-// ─── usage command ───────────────────────────────────────────────────────────
-cli
-    .command('usage', dedent `
-      Show your current Egaki credit usage for this billing period.
-      Displays plan, credits used, credits remaining, and period info.
-    `)
-    .example('egaki usage')
-    .action(async () => {
-    await showUsage();
-});
-// ─── image command ───────────────────────────────────────────────────────────
-cli
-    .command('image <prompt>', dedent `
-      Generate images from a text prompt using AI models.
-      Supports Imagen models (dedicated image generation) and Gemini
-      multimodal models (text+image output). The model type is auto-detected
-      from the model ID: imagen-* uses the image API, everything else uses
-      the text API with image output enabled.
-    `)
-    .option('-m, --model [model]', z.enum(IMAGE_MODELS).describe('Model ID for generation. If omitted, shows an interactive picker (or uses default in non-TTY mode)'))
-    .option('-o, --output [path]', z
-    .string()
-    .default('egaki-output.png')
-    .describe('Output file path (index suffix added when generating multiple)'))
-    .option('-n, --count [n]', z.number().default(1).describe('Number of images to generate'))
-    .option('--aspect-ratio [ratio]', z
-    .string()
-    .describe('Aspect ratio for the generated image. Imagen supports: 1:1, 3:4, 4:3, 9:16, 16:9. Gemini supports additional ratios: 2:3, 3:2, 4:5, 5:4, 21:9'))
-    .option('--seed [seed]', z.number().describe('Seed for reproducible generation. Same seed + same prompt = same image'))
-    .option('--image-size [size]', z
-    .enum(['1K', '2K', '4K'])
-    .describe('Output resolution for Gemini text-model image generation. Only applies to gemini-*-image* models'))
-    .option('-i, --input [file]', z
-    .array(z.string())
-    .describe('Reference image for editing or variations (repeatable). Accepts local file paths or URLs (http/https). Pass one or more images along with a text prompt to edit them'))
-    .option('--mask [file]', z
-    .string()
-    .describe('Mask image for inpainting. Accepts a local file path or URL (http/https). White areas in the mask are replaced with generated content. Used together with --input'))
-    .option('--allow-people', 'Allow generating images of people (Imagen blocks people by default)')
-    .option('--json', 'Output result metadata as JSON to stdout (model, usage, warnings, file paths)')
-    .option('--stdout', 'Write raw image bytes to stdout instead of saving to a file. Useful for piping to other tools')
-    .example('# Generate a simple image')
-    .example('egaki image "a sunset over mars"')
-    .example('# Use a specific model with aspect ratio')
-    .example('egaki image "cyberpunk city at night" -m imagen-4.0-ultra-generate-001 --aspect-ratio 16:9')
-    .example('# Edit an existing image')
-    .example('egaki image "add a wizard hat to the cat" --input cat.jpg -o cat-wizard.png')
-    .example('# Edit an image from a URL')
-    .example('egaki image "make it pop art" --input https://example.com/photo.jpg')
-    .example('# Inpainting with a mask')
-    .example('egaki image "fill with flowers" --input photo.jpg --mask mask.png')
-    .example('# Generate with Gemini multimodal at 4K')
-    .example('egaki image "dreamy landscape" -m gemini-2.5-flash-image --image-size 4K')
-    .example('# Route through Vertex AI (Google Cloud billing)')
-    .example('egaki image "product photo on marble" -m vertex/imagen-4.0-generate-001')
-    .example('# Generate multiple images')
-    .example('egaki image "abstract art" -n 4 -o art.png')
-    .example('# Pipe to another tool')
-    .example('egaki image "logo design" --stdout | convert - -resize 512x512 logo.png')
-    .action(async (prompt, options) => {
-    // Inject stored API keys as env vars before calling the AI SDK.
-    injectCredentialsToEnv();
-    const model = options.model ?? await resolveImageModel();
-    const outputPath = options.output ?? 'egaki-output.png';
-    const count = options.count ?? 1;
-    const config = getModelConfig(model);
-    const parsedAspectRatio = parseAspectRatioOption(options.aspectRatio);
-    if (!options.stdout) {
-        console.error(pc.dim(`Model: ${model}`));
-        console.error(pc.dim(`Prompt: ${prompt}`));
-    }
-    const inputImages = await readInputImages(options.input);
-    const maskImage = options.mask
-        ? await readInputSource(options.mask)
-        : undefined;
-    // When using ChatGPT OAuth with OpenAI image models, route through the
-    // Responses API + imageGeneration tool instead of the Image API.
-    // The Codex OAuth client lacks the `api.model.images.request` scope.
-    const useResponsesApi = config.strategy === 'image' && shouldUseResponsesApi(model);
-    if (useResponsesApi) {
-        if (!options.stdout) {
-            console.error(pc.dim('Mode: Responses API (ChatGPT OAuth)'));
-        }
-        await generateWithResponsesApi({
-            prompt,
-            model,
-            outputPath,
-            count,
-            aspectRatio: parsedAspectRatio,
-            seed: options.seed,
-            inputImages,
-            maskImage,
-            json: options.json || false,
-            stdout: options.stdout || false,
-        });
-    }
-    else if (config.strategy === 'image') {
-        await generateWithImageModel({
-            prompt,
-            model,
-            outputPath,
-            count,
-            aspectRatio: parsedAspectRatio,
-            seed: options.seed,
-            inputImages,
-            maskImage,
-            allowPeople: options.allowPeople || false,
-            json: options.json || false,
-            stdout: options.stdout || false,
-        });
-    }
-    else {
-        await generateWithTextModel({
-            prompt,
-            model,
-            outputPath,
-            inputImages,
-            imageSize: options.imageSize,
-            aspectRatio: options.aspectRatio,
-            json: options.json || false,
-            stdout: options.stdout || false,
-        });
-    }
-});
-// ─── video command ───────────────────────────────────────────────────────────
-cli
-    .command('video <prompt>', dedent `
-      Generate videos from a text prompt (or image+text prompt for models that
-      support image-to-video). Uses AI SDK experimental_generateVideo under the hood.
-
-      Agent note: video generation can be slow. When invoking this command from
-      automation, use a command timeout of at least 5 minutes.
-    `)
-    .option('-m, --model [model]', z.enum(VIDEO_MODELS).describe('Video model ID for generation. If omitted, shows an interactive picker (or uses default in non-TTY mode)'))
-    .option('-o, --output [path]', z
-    .string()
-    .default('egaki-output.mp4')
-    .describe('Output file path (index suffix added when generating multiple)'))
-    .option('-n, --count [n]', z.number().default(1).describe('Number of videos to generate'))
-    .option('--aspect-ratio [ratio]', z.string().describe('Video aspect ratio in WIDTH:HEIGHT format (e.g. 16:9, 9:16)'))
-    .option('--resolution [resolution]', z
-    .string()
-    .describe('Video resolution in WIDTHxHEIGHT or provider format (e.g. 1280x720, 720p)'))
-    .option('--duration [seconds]', z.number().describe('Video duration in seconds (provider/model-specific limits apply)'))
-    .option('--fps [fps]', z.number().describe('Frames per second for video models that support fps override'))
-    .option('--seed [seed]', z.number().describe('Seed for reproducible video generation (model support varies)'))
-    .option('-i, --input [file]', z
-    .string()
-    .describe('Optional reference image for image-to-video. Accepts local file path or URL (http/https)'))
-    .option('--json', 'Output result metadata as JSON to stdout (model, usage, warnings, file paths)')
-    .option('--stdout', 'Write raw video bytes to stdout instead of saving to a file. Useful for piping to other tools')
-    .example('# Generate a video')
-    .example('egaki video "A paper airplane gliding through clouds" -o airplane.mp4')
-    .example('# Generate with Veo model + duration')
-    .example('egaki video "cinematic rainy street at night" -m veo-3.1-fast-generate-001 --duration 6')
-    .example('# Route through Vertex AI (Google Cloud billing)')
-    .example('egaki video "storm over mountains" -m vertex/veo-3.1-fast-generate-001 --duration 6')
-    .example('# Image-to-video (model support required)')
-    .example('egaki video "animate subtle camera pan" --model luma-ray-2 --input frame.png -o animated.mp4')
-    .example('# Generate multiple videos')
-    .example('egaki video "waves crashing on cliffs" -n 2 -o waves.mp4')
-    .action(async (prompt, options) => {
-    injectCredentialsToEnv();
-    const model = options.model ?? await resolveVideoModel();
-    const outputPath = options.output ?? 'egaki-output.mp4';
-    const count = options.count ?? 1;
-    const config = getModelConfig(model);
-    if (config.strategy !== 'video') {
-        console.error(pc.red(`Model ${model} is not a video model`));
-        process.exit(1);
-    }
-    if (!options.stdout) {
-        console.error(pc.dim(`Model: ${model}`));
-        console.error(pc.dim(`Prompt: ${prompt}`));
-        console.error(pc.dim('Mode: Video API (experimental_generateVideo)'));
-    }
-    const inputImage = options.input
-        ? await readInputSource(options.input)
-        : undefined;
-    await generateWithVideoModel({
-        prompt,
-        model,
-        outputPath,
-        count,
-        aspectRatio: options.aspectRatio,
-        resolution: options.resolution,
-        duration: options.duration,
-        fps: options.fps,
-        seed: options.seed,
-        inputImage,
-        json: options.json || false,
-        stdout: options.stdout || false,
-    });
-});
-// ─── models command ──────────────────────────────────────────────────────────
-cli
-    .command('models', dedent `
-      List all supported image generation models with pricing, features,
-      and provider info. Output is YAML for easy reading and piping.
-    `)
-    .option('-p, --provider [provider]', z.string().describe('Filter models by provider name (e.g. google, openai, replicate, fal)'))
-    .option('--type [type]', z
-    .enum(['all', 'image', 'video'])
-    .default('all')
-    .describe('Filter by model type: image (image+text-image), video, or all'))
-    .option('--json', 'Output as JSON instead of YAML')
-    .action(async (options) => {
-    const yaml = await import('js-yaml');
-    const providerStatuses = Object.fromEntries(Object.keys(PROVIDERS).map((provider) => [provider, getKeyStatus(provider)]));
-    let models = options.type === 'video'
-        ? VIDEO_CATALOG
-        : options.type === 'image'
-            ? CATALOG
-            : [...CATALOG, ...VIDEO_CATALOG];
-    if (options.provider) {
-        models = models.filter((m) => m.provider === options.provider);
-        if (models.length === 0) {
-            console.error(pc.red(`No models found for provider: ${options.provider}`));
-            process.exit(1);
-        }
-    }
-    const output = models.map((m) => ({
-        id: m.id,
-        name: m.name,
-        ...(m.description ? { description: m.description } : {}),
-        provider: m.provider,
-        auth: providerStatuses[m.provider] ?? { available: false, source: 'none' },
-        strategy: m.strategy,
-        released: m.released,
-        cost: formatCatalogCost(m.cost),
-        features: m.strategy === 'video'
-            ? {
-                textToVideo: m.features.textToVideo,
-                imageToVideo: m.features.imageToVideo,
-                capabilities: m.features.capabilities.join(', ') || 'none',
-                seed: m.features.seed,
-                multipleVideos: m.features.multipleVideos,
-                aspectRatios: m.features.aspectRatios?.join(', ') || 'none',
-                resolutions: m.features.resolutions?.join(', ') || 'unknown',
-                durationRangeSec: m.features.durationRangeSec
-                    ? `${m.features.durationRangeSec.min}-${m.features.durationRangeSec.max}`
-                    : 'unknown',
-            }
-            : {
-                editing: m.features.editing,
-                inpainting: m.features.inpainting,
-                seed: m.features.seed,
-                multipleImages: m.features.multipleImages,
-                aspectRatios: m.features.aspectRatios.join(', ') || 'none',
-                ...(m.features.sizes ? { sizes: m.features.sizes.join(', ') } : {}),
-            },
-    }));
-    if (options.json) {
-        console.log(JSON.stringify(output, null, 2));
-    }
-    else {
-        console.log(yaml.dump(output, { lineWidth: 120, noRefs: true }));
-    }
-});
-cli.help();
-cli.version(pkg.version);
-cli.parse();
-// ─── interactive model pickers ──────────────────────────────────────────────
-/** Curated image models shown in the interactive picker, ordered by recommendation. */
-const FEATURED_IMAGE_MODELS = [
-    'imagen-4.0-generate-001',
-    'imagen-4.0-ultra-generate-001',
-    'imagen-4.0-fast-generate-001',
-    'gemini-2.5-flash-image',
-    'gemini-3.1-flash-image-preview',
-    'nano-banana-pro-preview',
-    'gpt-image-2',
-    'gpt-image-1.5',
-    'chatgpt-image-latest',
-    'flux-kontext-pro',
-    'flux-kontext-max',
-    'flux-pro-1.1-ultra',
-    'recraft-v4',
-    'dall-e-3',
-    'grok-imagine-image-pro',
-];
-/**
- * Resolve the image model: show interactive picker in TTY, use default otherwise.
- */
-async function resolveImageModel() {
-    const isTTY = process.stdin.isTTY && process.stderr.isTTY;
-    if (!isTTY)
-        return DEFAULT_MODEL;
-    const options = FEATURED_IMAGE_MODELS
-        .map((id) => CATALOG.find((m) => m.id === id))
-        .filter(Boolean)
-        .map((m) => {
-        const cost = m.cost.type === 'per-image'
-            ? pc.dim(`$${m.cost.perImage}/img`)
-            : m.cost.type === 'per-token'
-                ? pc.dim(`$${m.cost.outputPerM}/M out`)
-                : '';
-        return {
-            value: m.id,
-            label: `${m.name} ${cost}`,
-            hint: m.id,
-        };
-    });
-    const selected = await select({
-        message: 'Select an image model',
-        options,
-    });
-    if (isCancel(selected)) {
-        cancel('Cancelled.');
-        process.exit(0);
-    }
-    return selected;
-}
-/**
- * Resolve the video model: show interactive picker in TTY, use default otherwise.
- */
-async function resolveVideoModel() {
-    const isTTY = process.stdin.isTTY && process.stderr.isTTY;
-    if (!isTTY)
-        return DEFAULT_VIDEO_MODEL;
-    const options = VIDEO_CATALOG.map((m) => {
-        const dur = m.features.durationRangeSec
-            ? pc.dim(`${m.features.durationRangeSec.min}-${m.features.durationRangeSec.max}s`)
-            : '';
-        return {
-            value: m.id,
-            label: `${m.name} ${dur}`,
-            hint: m.id,
-        };
-    });
-    const selected = await select({
-        message: 'Select a video model',
-        options,
-    });
-    if (isCancel(selected)) {
-        cancel('Cancelled.');
-        process.exit(0);
-    }
-    return selected;
-}
-function isUrl(input) {
-    return /^https?:\/\//i.test(input);
-}
-async function readInputSource(input) {
-    if (isUrl(input)) {
-        console.error(pc.dim(`Fetching ${input}...`));
-        const res = await fetch(input);
-        if (!res.ok) {
-            console.error(pc.red(`Failed to fetch ${input}: ${res.status} ${res.statusText}`));
-            process.exit(1);
-        }
-        return new Uint8Array(await res.arrayBuffer());
-    }
-    const resolved = path.resolve(input);
-    if (!fs.existsSync(resolved)) {
-        console.error(pc.red(`File not found: ${resolved}`));
-        process.exit(1);
-    }
-    return new Uint8Array(fs.readFileSync(resolved));
-}
-async function readInputImages(inputs) {
-    if (!inputs || inputs.length === 0) {
-        return [];
-    }
-    return Promise.all(inputs.map((f) => readInputSource(f)));
-}
-// Generate using the dedicated generateImage API (Imagen models)
-async function generateWithImageModel({ prompt, model, outputPath, count, aspectRatio, seed, inputImages, maskImage, allowPeople, json, stdout, }) {
-    // Build the prompt: plain string or multimodal with reference images
-    const imagePrompt = inputImages.length > 0
-        ? { text: prompt, images: inputImages, ...(maskImage ? { mask: maskImage } : {}) }
-        : prompt;
-    const config = getModelConfig(model);
-    const imageModel = await createImageModel(model);
-    // Use the correct providerOptions key based on provider (google vs vertex)
-    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
-    if (!stdout) {
-        console.error(pc.cyan('Generating...'));
-    }
-    const result = await aiGenerateImage({
-        model: imageModel,
-        prompt: imagePrompt,
-        n: count,
-        ...(aspectRatio ? { aspectRatio } : {}),
-        ...(seed !== undefined ? { seed } : {}),
-        providerOptions: {
-            [providerOptionsKey]: {
-                ...(allowPeople ? { personGeneration: 'allow_all' } : {}),
-                ...(aspectRatio ? { aspectRatio } : {}),
-            },
-        },
-    });
-    if (stdout) {
-        // Write first image to stdout for piping
-        const image = result.images[0];
-        if (image) {
-            process.stdout.write(Buffer.from(image.uint8Array));
-        }
-        return;
-    }
-    const savedFiles = [];
-    for (let i = 0; i < result.images.length; i++) {
-        const image = result.images[i];
-        const ext = extensionFromMediaType(image.mediaType);
-        const filePath = result.images.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, image.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
-    const cost = calculateCost(config.cost, result.usage, result.images.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
-    if (json) {
-        const output = {
-            model,
-            files: savedFiles,
-            count: result.images.length,
-            cost,
-            usage: result.usage,
-            warnings: result.warnings,
-        };
-        console.log(JSON.stringify(output, null, 2));
-    }
-}
-// Generate using generateText with responseModalities (Gemini multimodal models)
-async function generateWithTextModel({ prompt, model, outputPath, inputImages, imageSize, aspectRatio, json, stdout, }) {
-    const textModel = await createTextModel(model);
-    const config = getModelConfig(model);
-    const providerOptionsKey = config.provider === 'vertex' ? 'vertex' : 'google';
-    if (!stdout) {
-        console.error(pc.cyan('Generating...'));
-    }
-    // Build messages: if we have input images, create a multimodal prompt
-    const messages = inputImages.length > 0
-        ? [
-            {
-                role: 'user',
-                content: [
-                    { type: 'text', text: prompt },
-                    ...inputImages.map((img) => ({
-                        type: 'image',
-                        image: img,
-                    })),
-                ],
-            },
-        ]
-        : undefined;
-    const result = await generateText({
-        model: textModel,
-        ...(messages ? { messages } : { prompt }),
-        providerOptions: {
-            [providerOptionsKey]: {
-                responseModalities: ['TEXT', 'IMAGE'],
-                ...(imageSize || aspectRatio
-                    ? {
-                        imageConfig: {
-                            ...(imageSize ? { imageSize } : {}),
-                            ...(aspectRatio ? { aspectRatio } : {}),
-                        },
-                    }
-                    : {}),
-            },
-        },
-    });
-    const imageFiles = result.files.filter((f) => {
-        return f.mediaType.startsWith('image/');
-    });
-    if (imageFiles.length === 0) {
-        console.error(pc.red('No images generated.'));
-        process.exit(1);
-    }
-    if (stdout) {
-        const file = imageFiles[0];
-        if (file) {
-            process.stdout.write(Buffer.from(file.uint8Array));
-        }
-        return;
-    }
-    const savedFiles = [];
-    for (let i = 0; i < imageFiles.length; i++) {
-        const file = imageFiles[i];
-        const ext = extensionFromMediaType(file.mediaType);
-        const filePath = imageFiles.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, file.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
-    const cost = calculateCost(config.cost, result.usage, imageFiles.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
-    if (result.text && !json) {
-        console.error(pc.dim(result.text));
-    }
-    if (json) {
-        const output = {
-            model,
-            files: savedFiles,
-            count: imageFiles.length,
-            text: result.text || null,
-            cost,
-            usage: result.usage,
-        };
-        console.log(JSON.stringify(output, null, 2));
-    }
-}
-// Generate using the OpenAI Responses API with imageGeneration tool.
-// Used when auth comes from ChatGPT OAuth (no Image API scope).
-async function generateWithResponsesApi({ prompt, model, outputPath, count, aspectRatio, seed, inputImages, maskImage, json, stdout, }) {
-    if (count !== 1) {
-        console.error(pc.red('ChatGPT image generation currently supports exactly one output image.'));
-        process.exit(1);
-    }
-    if (seed !== undefined) {
-        console.error(pc.red('ChatGPT image generation does not support --seed.'));
-        process.exit(1);
-    }
-    if (maskImage) {
-        console.error(pc.red('ChatGPT image generation does not support --mask yet.'));
-        process.exit(1);
-    }
-    const size = aspectRatio ? chatGptImageSizeFromAspectRatio(aspectRatio) : undefined;
-    if (aspectRatio && !size) {
-        console.error(pc.red('ChatGPT image generation only supports --aspect-ratio 1:1, 3:2, or 2:3.'));
-        process.exit(1);
-    }
-    const storedAuth = getChatGptAuth();
-    if (!storedAuth?.accountId) {
-        console.error(pc.red('Missing ChatGPT account metadata. Please run `egaki login --provider chatgpt` again.'));
-        process.exit(1);
-    }
-    const auth = await getValidChatGptAuth(storedAuth, saveChatGptAuth);
-    if (auth instanceof Error) {
-        console.error(pc.red(auth.message));
-        process.exit(1);
-    }
-    if (!stdout) {
-        console.error(pc.cyan('Generating...'));
-    }
-    const content = [
-        { type: 'input_text', text: prompt },
-        ...inputImages.map((image) => ({
-            type: 'input_image',
-            image_url: imageBytesToDataUrl(image),
-        })),
-    ];
-    const response = await fetch('https://chatgpt.com/backend-api/codex/responses', {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${auth.access}`,
-            'ChatGPT-Account-ID': auth.accountId,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            model: 'gpt-5.4',
-            instructions: 'You are Codex.',
-            input: [
-                {
-                    type: 'message',
-                    role: 'user',
-                    content,
-                },
-            ],
-            tools: [
-                {
-                    type: 'image_generation',
-                    model,
-                    size: 'auto',
-                    quality: 'auto',
-                    output_format: 'png',
-                    output_compression: 100,
-                    moderation: 'auto',
-                    ...(size ? { size } : {}),
-                },
-            ],
-            tool_choice: 'auto',
-            parallel_tool_calls: true,
-            stream: true,
-            store: false,
-            include: [],
-        }),
-    });
-    if (!response.ok || !response.body) {
-        const body = await response.text().catch(() => '');
-        console.error(pc.red(`ChatGPT image generation failed: ${response.status}`));
-        if (body)
-            console.error(pc.dim(body));
-        process.exit(1);
-    }
-    let imageBase64;
-    let revisedPrompt = null;
-    const processSseMessage = (message) => {
-        if (!message.data)
-            return;
-        try {
-            const event = JSON.parse(message.data);
-            if (event.type === 'response.image_generation_call.partial_image' &&
-                event.partial_image_b64 &&
-                !imageBase64) {
-                imageBase64 = event.partial_image_b64;
-            }
-            if (event.type === 'response.output_item.done' &&
-                event.item?.type === 'image_generation_call') {
-                if (event.item.result)
-                    imageBase64 = event.item.result;
-                revisedPrompt = event.item.revised_prompt ?? revisedPrompt;
-            }
-        }
-        catch {
-            // Ignore keepalive and partial parse noise.
-        }
-    };
-    const parser = createParser({
-        onEvent: processSseMessage,
-    });
-    const decoder = new TextDecoder();
-    for await (const chunk of response.body) {
-        parser.feed(decoder.decode(chunk, { stream: true }));
-    }
-    parser.feed(decoder.decode());
-    if (!imageBase64) {
-        console.error(pc.red('No images generated.'));
-        process.exit(1);
-    }
-    const imageBytes = Buffer.from(imageBase64, 'base64');
-    const mediaType = 'image/png';
-    if (stdout) {
-        process.stdout.write(imageBytes);
-        return;
-    }
-    const savedFiles = [];
-    const filePath = ensureExtension(outputPath, extensionFromMediaType(mediaType));
-    fs.writeFileSync(filePath, imageBytes);
-    console.error(pc.green(`Saved: ${filePath}`));
-    savedFiles.push(filePath);
-    if (revisedPrompt && !json) {
-        console.error(pc.dim(`Revised prompt: ${revisedPrompt}`));
-    }
-    if (json) {
-        const output = {
-            model,
-            files: savedFiles,
-            count: 1,
-            revisedPrompt,
-        };
-        console.log(JSON.stringify(output, null, 2));
-    }
-}
-// Generate using experimental_generateVideo (video models)
-async function generateWithVideoModel({ prompt, model, outputPath, count, aspectRatio, resolution, duration, fps, seed, inputImage, json, stdout, }) {
-    const videoModel = await createVideoModel(model);
-    if (!stdout) {
-        console.error(pc.cyan('Generating...'));
-    }
-    const result = await aiGenerateVideo({
-        model: videoModel,
-        prompt: inputImage
-            ? { image: inputImage, text: prompt }
-            : prompt,
-        n: count,
-        ...(aspectRatio ? { aspectRatio: aspectRatio } : {}),
-        ...(resolution ? { resolution: resolution } : {}),
-        ...(duration != null ? { duration } : {}),
-        ...(fps != null ? { fps } : {}),
-        ...(seed != null ? { seed } : {}),
-    });
-    if (stdout) {
-        const video = result.videos[0];
-        if (video) {
-            process.stdout.write(Buffer.from(video.uint8Array));
-        }
-        return;
-    }
-    const savedFiles = [];
-    for (let i = 0; i < result.videos.length; i++) {
-        const video = result.videos[i];
-        const ext = extensionFromMediaType(video.mediaType);
-        const filePath = result.videos.length === 1
-            ? ensureExtension(outputPath, ext)
-            : insertIndex(outputPath, i, ext);
-        fs.writeFileSync(filePath, video.uint8Array);
-        console.error(pc.green(`Saved: ${filePath}`));
-        savedFiles.push(filePath);
-    }
-    const config = getModelConfig(model);
-    const cost = calculateCost(config.cost, {
-        videosGenerated: result.videos.length,
-        durationSeconds: duration,
-        resolution,
-    }, result.videos.length);
-    if (cost != null) {
-        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
-    }
-    if (json) {
-        const output = {
-            model,
-            files: savedFiles,
-            count: result.videos.length,
-            cost,
-            warnings: result.warnings,
-            responses: result.responses,
-        };
-        console.log(JSON.stringify(output, null, 2));
-    }
-}
-// ─── cost helpers ────────────────────────────────────────────────────────────
-function calculateCost(cost, usage, count = 1) {
-    if (cost.type === 'per-image') {
-        return cost.perImage * count;
-    }
-    if (cost.type === 'per-token' && usage.inputTokens != null && usage.outputTokens != null) {
-        return ((usage.inputTokens * cost.inputPerM + usage.outputTokens * cost.outputPerM) / 1_000_000);
-    }
-    if (cost.type === 'per-video-second') {
-        const durationSec = usage.durationSeconds ?? cost.defaultDurationSec;
-        const resolution = normalizeResolutionKey(usage.resolution);
-        const tier = cost.tiers.find((t) => normalizeResolutionKey(t.resolution) === resolution) ??
-            cost.tiers[0];
-        if (!tier) {
-            return null;
-        }
-        return tier.costPerSecond * durationSec * count;
-    }
-    return null;
-}
-function formatCatalogCost(cost) {
-    if (cost.type === 'per-image') {
-        return `$${cost.perImage}/image`;
-    }
-    if (cost.type === 'per-token') {
-        return `$${cost.inputPerM}/M input, $${cost.outputPerM}/M output`;
-    }
-    if (cost.type === 'per-video-second') {
-        const tierText = cost.tiers
-            .map((t) => {
-            const parts = [
-                t.resolution,
-                t.mode ? `mode=${t.mode}` : undefined,
-                t.audio != null ? `audio=${t.audio}` : undefined,
-            ].filter(Boolean);
-            return parts.length > 0
-                ? `$${t.costPerSecond}/s (${parts.join(', ')})`
-                : `$${t.costPerSecond}/s`;
-        })
-            .join('; ');
-        return `${tierText} (default duration ${cost.defaultDurationSec}s)`;
-    }
-    return 'unknown';
-}
-function formatCost(dollars) {
-    if (dollars < 0.01) {
-        return `$${dollars.toFixed(4)}`;
-    }
-    return `$${dollars.toFixed(2)}`;
-}
-function extensionFromMediaType(mediaType) {
-    const map = {
-        'image/png': '.png',
-        'image/jpeg': '.jpg',
-        'image/webp': '.webp',
-        'image/gif': '.gif',
-        'video/mp4': '.mp4',
-        'video/webm': '.webm',
-        'video/quicktime': '.mov',
-    };
-    return map[mediaType] || (mediaType.startsWith('video/') ? '.mp4' : '.png');
-}
-function inferImageMediaType(image) {
-    if (image.length >= 8 && image[0] === 0x89 && image[1] === 0x50 && image[2] === 0x4e && image[3] === 0x47) {
-        return 'image/png';
-    }
-    if (image.length >= 3 && image[0] === 0xff && image[1] === 0xd8 && image[2] === 0xff) {
-        return 'image/jpeg';
-    }
-    if (image.length >= 12 &&
-        image[0] === 0x52 && image[1] === 0x49 && image[2] === 0x46 && image[3] === 0x46 &&
-        image[8] === 0x57 && image[9] === 0x45 && image[10] === 0x42 && image[11] === 0x50) {
-        return 'image/webp';
-    }
-    if (image.length >= 6 &&
-        image[0] === 0x47 && image[1] === 0x49 && image[2] === 0x46 && image[3] === 0x38) {
-        return 'image/gif';
-    }
-    return 'image/png';
-}
-function imageBytesToDataUrl(image) {
-    const mediaType = inferImageMediaType(image);
-    return `data:${mediaType};base64,${Buffer.from(image).toString('base64')}`;
-}
-function chatGptImageSizeFromAspectRatio(aspectRatio) {
-    switch (aspectRatio) {
-        case '1:1':
-            return '1024x1024';
-        case '3:2':
-            return '1536x1024';
-        case '2:3':
-            return '1024x1536';
-        default:
-            return undefined;
-    }
-}
-function normalizeResolutionKey(input) {
-    if (!input)
-        return undefined;
-    const normalized = input.trim().toLowerCase();
-    if (normalized === '1920x1080')
-        return '1080p';
-    if (normalized === '1280x720')
-        return '720p';
-    if (normalized === '854x480' || normalized === '848x480')
-        return '480p';
-    return normalized;
-}
-function isAspectRatio(input) {
-    return /^\d+:\d+$/.test(input);
-}
-function parseAspectRatioOption(input) {
-    if (!input || !isAspectRatio(input)) {
-        return undefined;
-    }
-    return input;
-}
-function ensureExtension(filePath, ext) {
-    const parsed = path.parse(filePath);
-    if (parsed.ext) {
-        return filePath;
-    }
-    return filePath + ext;
-}
-function insertIndex(filePath, index, ext) {
-    const parsed = path.parse(filePath);
-    const finalExt = parsed.ext || ext;
-    return path.join(parsed.dir, `${parsed.name}-${index}${finalExt}`);
-}