egaki 0.9.0 → 0.11.0

package/src/cli/cli.ts

@@ -7,7 +7,12 @@
 //   - 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,
+  type GokeExecutionContext,
+} from 'goke'
 import { z } from 'zod'
 import dedent from 'string-dedent'
 import {
@@ -19,7 +24,6 @@ import {
 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,
@@ -39,6 +43,7 @@ import {
 import {
   loginInteractive,
   loginNonInteractive,
+  resolveLoginAction,
   showLoginStatus,
   removeLogin,
   readKeyFromStdin,
@@ -116,8 +121,8 @@ cli
     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(
@@ -148,32 +153,100 @@ 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
+    }
+    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
     }
 
-    // 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 })
+    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,
+}: {
+  provider: string
+  ctx: GokeExecutionContext
+}) {
+  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 ───────────────────────────────────────────────────────
 
@@ -185,8 +258,9 @@ 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.
     `,
@@ -197,12 +271,12 @@ cli
   )
   .option(
     '--plan [plan]',
-    z.string().describe('Plan ID: starter, pro, or unlimited (default: pro)'),
+    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) => {
@@ -235,8 +309,8 @@ 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')
@@ -244,6 +318,65 @@ cli
     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
@@ -277,7 +410,7 @@ cli
     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',
+        '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(
@@ -1415,6 +1548,7 @@ const UPLOAD_GATEWAY_BASE = 'https://egaki.org'
 const MAX_UPLOAD_SIZE = 100 * 1024 * 1024
 
 cli.help()
+cli.completions()
 cli.version(pkg.version)
 
 export { cli }

package/src/cli/dev-server.test.ts

@@ -0,0 +1,109 @@
+// 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, type RunningDevServer } from './dev-server.ts'
+
+const cleanups: Array<() => Promise<void>> = []
+
+afterAll(async () => {
+  for (const cleanup of cleanups) {
+    await cleanup()
+  }
+})
+
+function makeScratchProject(): string {
+  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 as RunningDevServer
+    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/src/cli/dev-server.ts

@@ -0,0 +1,303 @@
+// 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 type { ViteDevServer } from 'vite'
+import { video } from '../vite/vite-plugin.ts'
+
+// 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'
+
+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 async function findFreePort(host = '127.0.0.1'): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const probe = net.createServer()
+    probe.once('error', reject)
+    probe.listen(0, host, () => {
+      const address = probe.address() as net.AddressInfo
+      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: string): string | undefined {
+  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(): Map<string, string> {
+  const pkgJson = JSON.parse(
+    fs.readFileSync(path.join(__pkgRoot, 'package.json'), 'utf-8'),
+  )
+  const names = new Set<string>([
+    ...Object.keys(pkgJson.dependencies ?? {}),
+    ...Object.keys(pkgJson.optionalDependencies ?? {}),
+    ...Object.keys(pkgJson.peerDependencies ?? {}),
+  ])
+  const dirs = new Map<string, string>()
+  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: string): Error | 'normal' | 'shim' {
+  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: string): string[] {
+  const roots: string[] = []
+  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: string): string[] {
+  const allow = new Set<string>([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: string | undefined): Error | { root: string; entryFile?: string } {
+  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: string, timeoutMs: number): Promise<void> {
+  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: StartDevServerOptions = {},
+): Promise<Error | RunningDevServer> {
+  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(),
+  }
+}