egaki 0.9.0 → 0.11.0

package/dist/cli/cli.js

@@ -7,19 +7,18 @@
 //   - 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 { colors as pc, goke, isAgent, } from 'goke';
 import { z } from 'zod';
 import dedent from 'string-dedent';
 import { APICallError, NoImageGeneratedError, NoVideoGeneratedError, RetryError, } from 'ai';
 import { select, isCancel, cancel } from '@clack/prompts';
 import fs from 'node:fs';
 import path from 'node:path';
-import pc from 'picocolors';
 import pkg from '../../package.json' with { type: 'json' };
 import { injectCredentialsToEnv, PROVIDERS, getKeyStatus, } from './credentials.js';
 import { DEFAULT_MODEL, DEFAULT_VIDEO_MODEL, getModelConfig, } from './models.js';
 import { CATALOG, VIDEO_CATALOG, describeProviderValues, } from './model-catalog.js';
-import { loginInteractive, loginNonInteractive, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
+import { loginInteractive, loginNonInteractive, resolveLoginAction, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
 import { subscribeInteractive, subscribeNonInteractive, unsubscribe, showUsage, } from './subscription.js';
 import { generateImageUncached as generateImage, generateVideoUncached as generateVideo, calculateCost, ValidationError, } from './generate.js';
 import { generateSpeechUncached as generateSpeech, } from './speech-generate.js';
@@ -47,8 +46,8 @@ 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).
+      Non-interactive mode: pass \`--provider\` and \`--key\`, or pipe the key via stdin.
+      Browser OAuth runs in the background for AI agents and non-TTY shells.
     `)
     .option('-p, --provider [name]', z
     .string()
@@ -67,29 +66,84 @@ cli
     .example('egaki login --show')
     .example('# Remove a stored key')
     .example('egaki login --remove google')
-    .action(async (options) => {
-    if (options.show) {
-        showLoginStatus();
+    .action(async (options, ctx) => {
+    const action = resolveLoginAction({
+        options,
+        daemonProvider: ctx.daemon.isDaemon
+            ? ctx.process.env.EGAKI_LOGIN_PROVIDER
+            : undefined,
+        isAgent: isAgent || !process.stdin.isTTY,
+    });
+    if (action instanceof Error) {
+        ctx.console.error(action.message);
+        ctx.process.exit(1);
         return;
     }
-    if (options.remove) {
-        removeLogin(options.remove);
+    if (action.type === 'show') {
+        showLoginStatus({ loginRunning: await ctx.daemon.isRunning() });
         return;
     }
-    // Non-interactive: --provider + --key or stdin
-    if (options.provider) {
-        // OAuth providers use browser flow — skip key reading
-        if (options.provider === 'chatgpt' || options.provider === 'xai-oauth') {
-            await loginNonInteractive({ provider: options.provider, key: '' });
-            return;
-        }
-        const key = options.key || (await readKeyFromStdin());
-        await loginNonInteractive({ provider: options.provider, key });
+    if (action.type === 'remove') {
+        removeLogin(action.provider);
+        return;
+    }
+    if (action.type === 'oauth-daemon') {
+        await loginNonInteractive({
+            provider: action.provider,
+            key: '',
+            background: true,
+        });
+        return;
+    }
+    if (action.type === 'oauth-client') {
+        await startOAuthLogin({ provider: action.provider, ctx });
+        return;
+    }
+    if (action.type === 'api-key') {
+        await loginNonInteractive({
+            provider: action.provider,
+            key: action.key || (await readKeyFromStdin()),
+        });
+        return;
+    }
+    await loginInteractive({
+        loginOAuth: (provider) => startOAuthLogin({ provider, ctx }),
+    });
+});
+cli
+    .command('login status <provider>', 'Check one provider login. Exits with status 1 when login is not complete.')
+    .example('egaki login status chatgpt')
+    .example('egaki login status xai-oauth')
+    .action(async (provider, _options, ctx) => {
+    const info = PROVIDERS[provider];
+    if (!info) {
+        ctx.console.error(`Unknown provider: ${provider}`);
+        ctx.process.exit(1);
+        return;
+    }
+    const status = getKeyStatus(provider);
+    if (status.available) {
+        ctx.console.log(`${info.label} is configured.`);
         return;
     }
-    // Interactive mode
-    await loginInteractive();
+    const loginRunning = await ctx.daemon.forCommand('login').isRunning();
+    ctx.console.error(loginRunning
+        ? `An OAuth login is running, but ${info.label} is not configured yet.`
+        : `${info.label} is not configured.`);
+    ctx.process.exit(1);
 });
+async function startOAuthLogin({ provider, ctx, }) {
+    const runInBackground = isAgent || !process.stdin.isTTY;
+    await ctx.daemon.start({
+        attach: !runInBackground,
+        timeoutMs: 10 * 60 * 1000,
+        env: { EGAKI_LOGIN_PROVIDER: provider },
+    });
+    if (!runInBackground)
+        return;
+    ctx.console.log('Login is running in the background and the browser will open.');
+    ctx.console.log(`After approval, verify with: egaki login status ${provider}`);
+}
 // ─── subscribe command ───────────────────────────────────────────────────────
 cli
     .command('subscribe', dedent `
@@ -97,17 +151,18 @@ cli
       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.
+      Two plans: Plus ($29/mo) and Pro ($99/mo). Each plan includes a
+      monthly dollar budget of generation usage equal to its price;
+      generations count their marked-up provider cost against the budget.
       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)'))
+    .option('--plan [plan]', z.enum(['plus', 'pro']).describe('Plan ID: plus ($29/mo) or pro ($99/mo)'))
     .example('# Interactive subscribe')
     .example('egaki subscribe')
     .example('# Non-interactive (for agents)')
-    .example('egaki subscribe --email user@example.com --plan pro')
+    .example('egaki subscribe --email user@example.com --plan plus')
     .example('# Non-interactive without email prefill')
     .example('egaki subscribe --plan pro')
     .action(async (options) => {
@@ -131,13 +186,61 @@ cli
 // ─── 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.
+      Show your current Egaki usage for this billing period.
+      Displays plan, dollars spent, remaining budget, and period info.
     `)
     .example('egaki usage')
     .action(async () => {
     await showUsage();
 });
+// ─── dev command ─────────────────────────────────────────────────────────────
+cli
+    .command('dev [entry]', dedent `
+      Start the MDX video dev server with zero setup.
+      Pass an .mdx file (or a directory containing one) — no package.json,
+      vite.config.ts, or npm install needed. All dependencies (react,
+      remotion, vite) come from the egaki CLI's own installation.
+      Uses a random free port unless --port is given.
+    `)
+    .option('-p, --port [port]', z.coerce.number().int().describe('Fixed port (default: random free port)'))
+    .option('--host [host]', z.string().describe('Host to bind (default: localhost)'))
+    .option('--open', 'Open the player in the default browser')
+    .example('# Serve a single MDX file, no project setup')
+    .example('egaki dev video.mdx')
+    .example('# Serve the current directory (auto-discovers video.mdx)')
+    .example('egaki dev')
+    .example('# Fixed port + open browser')
+    .example('egaki dev intro.mdx --port 5199 --open')
+    .action(async (entry, options) => {
+    const { startDevServer } = await import('./dev-server.js');
+    const result = await startDevServer({
+        entry,
+        port: options.port,
+        host: options.host,
+    });
+    if (result instanceof Error) {
+        console.error(pc.red(result.message));
+        process.exit(1);
+    }
+    console.log();
+    console.log(`  ${pc.green('➜')}  egaki dev server running`);
+    console.log(`  ${pc.dim('root:')} ${result.root}`);
+    console.log(`  ${pc.dim('url:')}  ${pc.cyan(result.url)}`);
+    console.log();
+    console.log(`  ${pc.dim('SDK available in browser console as')} ${pc.yellow('window.egakiSDK')}`);
+    console.log(`    ${pc.dim('.seekTo(frame)')}       ${pc.dim('jump to a frame')}`);
+    console.log(`    ${pc.dim('.screenshot()')}        ${pc.dim('capture frame as data URL')}`);
+    console.log(`    ${pc.dim('.filmstrip({...})')}     ${pc.dim('grid of frames across scenes')}`);
+    console.log(`    ${pc.dim('.export({...})')}        ${pc.dim('render MP4 via WebCodecs')}`);
+    console.log(`    ${pc.dim('.getInfo()')}            ${pc.dim('composition metadata')}`);
+    console.log();
+    console.log(`  ${pc.dim('Docs:')} ${pc.cyan('https://raw.githubusercontent.com/remorses/egaki/main/cli/skills/egaki/SKILL.md')}`);
+    console.log();
+    if (options.open) {
+        const { openUrlInBrowser } = await import('./open-browser.js');
+        await openUrlInBrowser(result.url);
+    }
+});
 // ─── image command ───────────────────────────────────────────────────────────
 cli
     .command('image <prompt>', dedent `
@@ -155,7 +258,7 @@ cli
     .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'))
+    .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. OpenAI models (gpt-image-*, dall-e-*) have no native aspect ratio parameter, so the ratio is snapped to the closest supported size and stated in the prompt text'))
     .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'])
@@ -973,6 +1076,7 @@ const UPLOAD_GATEWAY_BASE = 'https://egaki.org';
 /** Max upload size in bytes (must match gateway limit). */
 const MAX_UPLOAD_SIZE = 100 * 1024 * 1024;
 cli.help();
+cli.completions();
 cli.version(pkg.version);
 export { cli };
 async function runProviderCall(operation, call) {

package/dist/cli/dev-server.d.ts

@@ -0,0 +1,30 @@
+import type { ViteDevServer } from 'vite';
+export interface StartDevServerOptions {
+    /** Path to an .mdx entry file, or a directory containing .mdx files.
+     *  Defaults to the current working directory (auto-discovers video.mdx
+     *  > index.mdx > first .mdx alphabetically). */
+    entry?: string;
+    /** Fixed port. When omitted, a random free port is chosen. */
+    port?: number;
+    /** Host to bind. Defaults to localhost. */
+    host?: string;
+}
+export interface RunningDevServer {
+    url: string;
+    port: number;
+    root: string;
+    server: ViteDevServer;
+    close: () => Promise<void>;
+}
+/** Find a random free TCP port by binding to port 0. */
+export declare function findFreePort(host?: string): Promise<number>;
+/** Ensure bare imports resolve from the project root.
+ *
+ *  - egaki already resolvable from root → real project, do nothing
+ *  - no node_modules (or a CLI-owned shim) → (re)create the shim
+ *  - foreign node_modules without egaki → error with guidance
+ */
+export declare function ensureDependencyShim(root: string): Error | 'normal' | 'shim';
+/** Start the zero-config dev server. Returns Error | RunningDevServer. */
+export declare function startDevServer(options?: StartDevServerOptions): Promise<Error | RunningDevServer>;
+//# sourceMappingURL=dev-server.d.ts.map

package/dist/cli/dev-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../src/cli/dev-server.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAUzC,MAAM,WAAW,qBAAqB;IACpC;;oDAEgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,CAAA;IACrB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B;AAED,wDAAwD;AACxD,wBAAsB,YAAY,CAAC,IAAI,SAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAStE;AAiDD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CA4C5E;AAuFD,0EAA0E;AAC1E,wBAAsB,cAAc,CAClC,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,KAAK,GAAG,gBAAgB,CAAC,CA8CnC"}

package/dist/cli/dev-server.js

@@ -0,0 +1,266 @@
+// Zero-config dev server for egaki MDX videos.
+//
+// `egaki dev video.mdx` boots a Vite dev server with inline config
+// (configFile: false) — no package.json, vite.config.ts, or npm install
+// needed in the user's folder.
+//
+// Dependency resolution: when the folder has no usable node_modules, a
+// shim node_modules is created containing symlinks to egaki itself and
+// every egaki dependency (react, remotion, vite, ...) resolved from the
+// CLI's own installation. A plain fallback resolveId plugin is NOT enough
+// because Vite's dep optimizer resolves optimizeDeps.include entries with
+// an internal resolver (alias + vite:resolve only) that skips user
+// plugins — without real node_modules those includes fail and CJS deps
+// like safe-mdx break in the browser. The shim makes standard node
+// resolution work everywhere (vite:resolve, optimizer, tailwind scans).
+// The shim dir contains a .egaki-shim marker so it can be refreshed
+// idempotently and recognized as CLI-owned.
+//
+// Vite's cache dir is placed under ~/.cache/egaki/vite/<hash> so repeated
+// runs reuse the prebundle without polluting the user's folder further.
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { video } from "../vite/vite-plugin.js";
+// Package root: this file runs from src/cli/ (dev) or dist/cli/ (published).
+// Going up 2 levels reaches the egaki package root either way.
+const __pkgRoot = path.resolve(fileURLToPath(new URL('.', import.meta.url)), '../..');
+const egakiRequire = createRequire(path.join(__pkgRoot, 'package.json'));
+const SHIM_MARKER = '.egaki-shim';
+/** Find a random free TCP port by binding to port 0. */
+export async function findFreePort(host = '127.0.0.1') {
+    return new Promise((resolve, reject) => {
+        const probe = net.createServer();
+        probe.once('error', reject);
+        probe.listen(0, host, () => {
+            const address = probe.address();
+            probe.close(() => resolve(address.port));
+        });
+    });
+}
+/** Locate the real directory of a package installed in egaki's own tree.
+ *  Tries pkg/package.json first (works for most packages), then falls
+ *  back to resolving the main entry and walking up to the package root
+ *  (for packages whose exports map hides ./package.json). */
+function packageDirFromEgaki(pkg) {
+    try {
+        return path.dirname(fs.realpathSync(egakiRequire.resolve(`${pkg}/package.json`)));
+    }
+    catch {
+        // Fall through to entry-based lookup
+    }
+    try {
+        let dir = path.dirname(fs.realpathSync(egakiRequire.resolve(pkg)));
+        while (true) {
+            const pkgJsonPath = path.join(dir, 'package.json');
+            if (fs.existsSync(pkgJsonPath)) {
+                const name = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8')).name;
+                if (name === pkg)
+                    return dir;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/** All packages the shim should link: egaki itself plus every dependency
+ *  and (present) optional/peer dependency of the egaki package. */
+function shimPackageDirs() {
+    const pkgJson = JSON.parse(fs.readFileSync(path.join(__pkgRoot, 'package.json'), 'utf-8'));
+    const names = new Set([
+        ...Object.keys(pkgJson.dependencies ?? {}),
+        ...Object.keys(pkgJson.optionalDependencies ?? {}),
+        ...Object.keys(pkgJson.peerDependencies ?? {}),
+    ]);
+    const dirs = new Map();
+    dirs.set('egaki', fs.realpathSync(__pkgRoot));
+    for (const name of names) {
+        const dir = packageDirFromEgaki(name);
+        if (dir)
+            dirs.set(name, dir);
+    }
+    return dirs;
+}
+/** Ensure bare imports resolve from the project root.
+ *
+ *  - egaki already resolvable from root → real project, do nothing
+ *  - no node_modules (or a CLI-owned shim) → (re)create the shim
+ *  - foreign node_modules without egaki → error with guidance
+ */
+export function ensureDependencyShim(root) {
+    const nodeModulesDir = path.join(root, 'node_modules');
+    const isShim = fs.existsSync(path.join(nodeModulesDir, SHIM_MARKER));
+    if (!isShim) {
+        // Walk up from root looking for node_modules/egaki — a plain fs walk
+        // instead of createRequire().resolve() because test runners (tsx,
+        // vitest) patch Node's resolver and make it resolve 'egaki' from the
+        // wrong context, silently skipping shim creation.
+        let dir = root;
+        while (true) {
+            if (fs.existsSync(path.join(dir, 'node_modules', 'egaki', 'package.json'))) {
+                return 'normal';
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+        if (fs.existsSync(nodeModulesDir)) {
+            return new Error(`${nodeModulesDir} exists but 'egaki' is not installed there.\n` +
+                `Either run 'npm install egaki' in ${root}, or remove node_modules ` +
+                `to let 'egaki dev' manage dependencies automatically.`);
+        }
+    }
+    fs.mkdirSync(nodeModulesDir, { recursive: true });
+    fs.writeFileSync(path.join(nodeModulesDir, SHIM_MARKER), 'This node_modules was generated by `egaki dev`. Safe to delete.\n');
+    for (const [name, targetDir] of shimPackageDirs()) {
+        const linkPath = path.join(nodeModulesDir, name);
+        fs.mkdirSync(path.dirname(linkPath), { recursive: true });
+        const existing = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+        if (existing) {
+            if (!existing.isSymbolicLink())
+                continue;
+            if (fs.readlinkSync(linkPath) === targetDir)
+                continue;
+            fs.unlinkSync(linkPath);
+        }
+        fs.symlinkSync(targetDir, linkPath, 'dir');
+    }
+    return 'shim';
+}
+/** Walk up from a real path and collect the parent of every ancestor
+ *  directory named node_modules. These parents are safe fs.allow roots
+ *  that cover hoisted/pnpm-store dependency locations. */
+function nodeModulesAncestorRoots(realPath) {
+    const roots = [];
+    let dir = realPath;
+    while (true) {
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        if (path.basename(dir) === 'node_modules')
+            roots.push(parent);
+        dir = parent;
+    }
+    return roots;
+}
+/** Compute fs.allow roots so Vite can serve framework + dependency files
+ *  that live outside the user's project root (in the CLI's install tree). */
+function computeFsAllow(root) {
+    const allow = new Set([root]);
+    const probes = [path.join(__pkgRoot, 'package.json')];
+    for (const id of ['react', 'react-dom', 'remotion', 'vite', 'spiceflow']) {
+        try {
+            probes.push(egakiRequire.resolve(id));
+        }
+        catch {
+            // Probe missing: skip
+        }
+    }
+    for (const probe of probes) {
+        try {
+            const real = fs.realpathSync(probe);
+            allow.add(path.dirname(real));
+            for (const ancestorRoot of nodeModulesAncestorRoots(real)) {
+                allow.add(ancestorRoot);
+            }
+        }
+        catch {
+            // Probe missing: skip
+        }
+    }
+    allow.add(fs.realpathSync(__pkgRoot));
+    return [...allow];
+}
+/** Resolve the entry option to { root, entryFile }.
+ *  Accepts a file path, a directory, or nothing (cwd). */
+function resolveEntry(entry) {
+    const target = path.resolve(process.cwd(), entry ?? '.');
+    if (!fs.existsSync(target)) {
+        return new Error(`entry not found: ${target}`);
+    }
+    const stat = fs.statSync(target);
+    if (stat.isDirectory()) {
+        const hasMdx = fs
+            .readdirSync(target)
+            .some((name) => name.endsWith('.mdx'));
+        if (!hasMdx) {
+            return new Error(`no .mdx files found in ${target}\nCreate a video.mdx file or pass one explicitly: egaki dev path/to/video.mdx`);
+        }
+        return { root: target };
+    }
+    if (!/\.mdx$/.test(target)) {
+        return new Error(`entry must be an .mdx file or a directory, got: ${target}`);
+    }
+    return { root: path.dirname(target), entryFile: target };
+}
+/** Warm up the server: the very first request can 500 transiently while
+ *  the dep optimizer discovers new deps and reloads the ssr program (a
+ *  browser recovers via auto-reload, but agents/tests hit the URL once).
+ *  Retry until the page serves 200 so the returned URL is ready to use. */
+async function warmUp(url, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            const response = await fetch(url);
+            if (response.ok)
+                return;
+        }
+        catch {
+            // Server not accepting connections yet
+        }
+        await new Promise((resolve) => setTimeout(resolve, 300));
+    }
+    console.warn(`[egaki] dev server warmup did not reach 200 within ${timeoutMs}ms`);
+}
+/** Start the zero-config dev server. Returns Error | RunningDevServer. */
+export async function startDevServer(options = {}) {
+    const entryResult = resolveEntry(options.entry);
+    if (entryResult instanceof Error)
+        return entryResult;
+    const { root, entryFile } = entryResult;
+    const shimResult = ensureDependencyShim(root);
+    if (shimResult instanceof Error)
+        return shimResult;
+    const host = options.host ?? 'localhost';
+    const port = options.port ?? (await findFreePort());
+    const rootHash = crypto.createHash('sha256').update(root).digest('hex').slice(0, 12);
+    const cacheDir = path.join(os.homedir(), '.cache', 'egaki', 'vite', rootHash);
+    const { createServer } = await import('vite');
+    const server = await createServer({
+        configFile: false,
+        root,
+        cacheDir,
+        plugins: [video(entryFile ? { entry: entryFile } : undefined)],
+        resolve: {
+            dedupe: ['react', 'react-dom', 'remotion', '@remotion/player', '@remotion/media'],
+        },
+        server: {
+            port,
+            strictPort: true,
+            host,
+            fs: {
+                allow: computeFsAllow(root),
+            },
+        },
+    });
+    await server.listen();
+    const url = `http://${host}:${port}/`;
+    await warmUp(url, 60_000);
+    return {
+        url,
+        port,
+        root,
+        server,
+        close: () => server.close(),
+    };
+}

package/dist/cli/dev-server.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dev-server.test.d.ts.map

package/dist/cli/dev-server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-server.test.d.ts","sourceRoot":"","sources":["../../src/cli/dev-server.test.ts"],"names":[],"mappings":""}

package/dist/cli/dev-server.test.js

@@ -0,0 +1,95 @@
+// Tests for the zero-config dev server (egaki dev).
+//
+// Creates a temp directory containing ONLY a video.mdx file — no
+// package.json, no vite.config.ts, no node_modules — and verifies the
+// dev server boots, serves HTML at /, and resolves all framework deps
+// from the CLI's own installation.
+import { describe, test, expect, afterAll } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import dedent from 'string-dedent';
+import { startDevServer, findFreePort } from "./dev-server.js";
+const cleanups = [];
+afterAll(async () => {
+    for (const cleanup of cleanups) {
+        await cleanup();
+    }
+});
+function makeScratchProject() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'egaki-dev-test-'));
+    const MDX = dedent `
+    ---
+    width: 1920
+    height: 1080
+    fps: 30
+    ---
+
+    # Hello duration=2
+
+    Zero-config dev server test.
+  `;
+    fs.writeFileSync(path.join(dir, 'video.mdx'), MDX);
+    cleanups.push(async () => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+    return dir;
+}
+describe('findFreePort', () => {
+    test('returns a valid port number', async () => {
+        const port = await findFreePort();
+        expect(port).toBeGreaterThan(0);
+        expect(port).toBeLessThan(65536);
+    });
+});
+describe('startDevServer', () => {
+    test('returns Error for missing entry', async () => {
+        const result = await startDevServer({ entry: '/nonexistent/path/video.mdx' });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('entry not found');
+        }
+    });
+    test('returns Error for directory without mdx files', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'egaki-dev-empty-'));
+        cleanups.push(async () => {
+            fs.rmSync(dir, { recursive: true, force: true });
+        });
+        const result = await startDevServer({ entry: dir });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('no .mdx files found');
+        }
+    });
+    test('returns Error for non-mdx file entry', async () => {
+        const dir = makeScratchProject();
+        const txtPath = path.join(dir, 'notes.txt');
+        fs.writeFileSync(txtPath, 'hi');
+        const result = await startDevServer({ entry: txtPath });
+        expect(result).toBeInstanceOf(Error);
+        if (result instanceof Error) {
+            expect(result.message).toContain('must be an .mdx file');
+        }
+    });
+    test('serves a scratch mdx file with no package.json or node_modules', async () => {
+        const dir = makeScratchProject();
+        const result = await startDevServer({
+            entry: path.join(dir, 'video.mdx'),
+        });
+        expect(result).not.toBeInstanceOf(Error);
+        const running = result;
+        cleanups.push(() => running.close());
+        expect(running.root).toBe(dir);
+        expect(running.url).toMatch(/^http:\/\/localhost:\d+\/$/);
+        const response = await fetch(running.url);
+        expect(response.status).toBe(200);
+        expect(response.headers.get('content-type')).toContain('text/html');
+        const html = await response.text();
+        // RSC streaming: the doctype shell arrives in a separate flush, so
+        // assert on stable player UI markup instead of '<html'.
+        expect(html).toContain('Export MP4');
+        // The dependency shim was created and is CLI-owned
+        expect(fs.existsSync(path.join(dir, 'node_modules', '.egaki-shim'))).toBe(true);
+        expect(fs.lstatSync(path.join(dir, 'node_modules', 'egaki')).isSymbolicLink()).toBe(true);
+    }, 120_000);
+});

package/dist/cli/generate.d.ts

@@ -114,6 +114,14 @@ export declare function calculateCost(cost: {
     resolution?: string;
     hasVideoInput?: boolean;
 }, count?: number): number | null;
+/**
+ * Translate an aspect ratio request into a prompt prefix + concrete `size` for
+ * models that have no native aspect ratio parameter.
+ */
+export declare function aspectRatioFallback(prompt: string, aspectRatio: `${number}:${number}` | undefined, sizes: readonly string[]): {
+    prompt: string;
+    size?: `${number}x${number}`;
+};
 /**
  * Generate images from a text prompt. Auto-detects which generation strategy
  * to use (image API, text model, or ChatGPT Responses API) based on model ID.