egaki 0.0.2 → 0.1.0

package/src/models.ts

@@ -20,15 +20,20 @@ import pc from 'picocolors'
 import { PROVIDERS, EGAKI_GATEWAY_URL } from './credentials.js'
 import { CATALOG, findModel } from './model-catalog.js'
 import type { ModelEntry } from './model-catalog.js'
+import { VIDEO_CATALOG, findVideoModel } from './video-model-catalog.js'
+import type { VideoModelEntry } from './video-model-catalog.js'
 
-export type { ModelEntry }
+export type AnyModelEntry = ModelEntry | VideoModelEntry
+export type { ModelEntry, VideoModelEntry }
 
 export const IMAGE_MODELS = CATALOG.map((m) => m.id) as [string, ...string[]]
+export const VIDEO_MODELS = VIDEO_CATALOG.map((m) => m.id) as [string, ...string[]]
 
 export const DEFAULT_MODEL = 'nano-banana-pro-preview'
+export const DEFAULT_VIDEO_MODEL = 'veo-3.1-fast-generate-001'
 
-export function getModelConfig(modelId: string): ModelEntry {
-  const entry = findModel(modelId)
+export function getModelConfig(modelId: string): AnyModelEntry {
+  const entry = findModel(modelId) ?? findVideoModel(modelId)
   if (!entry) {
     console.error(pc.red(`Unknown model: ${modelId}`))
     process.exit(1)
@@ -122,6 +127,19 @@ async function createGatewayTextModel(modelId: string, provider: string): Promis
   return gateway(gatewayModelId)
 }
 
+/**
+ * Create a gateway-backed video model using createGateway from the AI SDK.
+ */
+async function createGatewayVideoModel(modelId: string, provider: string) {
+  const { createGateway } = await import('ai')
+  const gateway = createGateway({
+    apiKey: process.env['EGAKI_API_KEY']!,
+    baseURL: EGAKI_GATEWAY_URL,
+  })
+  const gatewayModelId = `${provider}/${modelId}`
+  return gateway.video(gatewayModelId)
+}
+
 // Lazily import the provider and create the right model instance.
 // This avoids loading all provider SDKs upfront — only the one needed
 // for the selected model gets imported.
@@ -167,6 +185,10 @@ export async function createTextModel(
   modelId: string,
 ): Promise<LanguageModel> {
   const config = getModelConfig(modelId)
+  if (config.strategy !== 'text') {
+    console.error(pc.red(`Model ${modelId} is not a text model`))
+    process.exit(1)
+  }
   ensureProviderKey(config.provider)
 
   // Direct provider key takes priority
@@ -195,3 +217,42 @@ export async function createTextModel(
   console.error(pc.red(`No API key available for provider: ${config.provider}`))
   process.exit(1)
 }
+
+export async function createVideoModel(modelId: string): Promise<any> {
+  const config = getModelConfig(modelId)
+  if (config.strategy !== 'video') {
+    console.error(pc.red(`Model ${modelId} is not a video model`))
+    process.exit(1)
+  }
+
+  ensureProviderKey(config.provider)
+
+  // Direct provider key takes priority
+  if (hasDirectProviderKey(config.provider)) {
+    switch (config.provider) {
+      case 'google': {
+        const { google } = await import('@ai-sdk/google')
+        return google.video(modelId)
+      }
+      case 'fal': {
+        const { fal } = await import('@ai-sdk/fal')
+        return fal.video(modelId)
+      }
+      default:
+        console.error(
+          pc.red(
+            `Direct video generation is only supported for Google and Fal keys, got provider: ${config.provider}`,
+          ),
+        )
+        process.exit(1)
+    }
+  }
+
+  // Fall back to egaki gateway
+  if (hasEgakiKey()) {
+    return createGatewayVideoModel(modelId, config.provider)
+  }
+
+  console.error(pc.red(`No API key available for provider: ${config.provider}`))
+  process.exit(1)
+}

package/src/open-browser.ts

@@ -0,0 +1,48 @@
+// Cross-platform browser opener for URLs used by CLI flows.
+// Never throws: missing OS commands are handled gracefully.
+import { spawnSync } from 'node:child_process'
+
+type OpenCommand = {
+  command: string
+  args: string[]
+}
+
+function getOpenCommands(url: string): OpenCommand[] {
+  if (process.platform === 'darwin') {
+    return [{ command: 'open', args: [url] }]
+  }
+
+  if (process.platform === 'win32') {
+    // `start` is a cmd builtin, so invoke through cmd.exe.
+    return [{ command: 'cmd', args: ['/c', 'start', '', url] }]
+  }
+
+  return [
+    { command: 'xdg-open', args: [url] },
+    { command: 'gio', args: ['open', url] },
+  ]
+}
+
+export function openUrlInBrowser(url: string): boolean {
+  // Avoid launching browser commands in non-interactive contexts (CI/pipes).
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    return false
+  }
+
+  for (const candidate of getOpenCommands(url)) {
+    try {
+      const result = spawnSync(candidate.command, candidate.args, {
+        stdio: 'ignore',
+        windowsHide: true,
+      })
+
+      if (!result.error && result.status === 0) {
+        return true
+      }
+    } catch {
+      // Keep trying fallback commands. This helper must never crash the CLI.
+    }
+  }
+
+  return false
+}

package/src/subscription.ts

@@ -16,9 +16,10 @@ import {
   spinner,
 } from '@clack/prompts'
 import { EGAKI_GATEWAY_URL, saveProviderKey, getProviderKey } from './credentials.js'
+import { openUrlInBrowser } from './open-browser.js'
 
-// Strip /v1/ai suffix to get the base URL for non-proxy endpoints (/buy, /api/*)
-const GATEWAY_BASE = EGAKI_GATEWAY_URL.replace(/\/v1\/ai$/, '')
+// Strip /vN/ai suffix to get the base URL for non-proxy endpoints (/buy, /api/*)
+const GATEWAY_BASE = EGAKI_GATEWAY_URL.replace(/\/v\d+\/ai$/, '')
 
 type PlanInfo = {
   id: string
@@ -86,24 +87,42 @@ export async function subscribeInteractive(): Promise<void> {
     process.exit(0)
   }
 
-  // Get email
-  const email = await text({
-    message: 'Email for the subscription',
-    placeholder: 'you@example.com',
-    validate: (value) => {
-      if (!value || !value.includes('@')) {
-        return 'Please enter a valid email'
-      }
-    },
+  // Optional email prefill for checkout
+  const prefillEmail = await confirm({
+    message: 'Prefill your email in checkout URL? (optional)',
   })
 
-  if (isCancel(email)) {
+  if (isCancel(prefillEmail)) {
     cancel('Subscribe cancelled.')
     process.exit(0)
   }
 
+  let email: string | undefined
+  if (prefillEmail) {
+    const enteredEmail = await text({
+      message: 'Email for the subscription',
+      placeholder: 'you@example.com',
+      validate: (value) => {
+        if (!value || !value.includes('@')) {
+          return 'Please enter a valid email'
+        }
+      },
+    })
+
+    if (isCancel(enteredEmail)) {
+      cancel('Subscribe cancelled.')
+      process.exit(0)
+    }
+
+    email = enteredEmail
+  }
+
   // Show checkout URL
-  const checkoutUrl = `${GATEWAY_BASE}/buy?plan=${planId}&email=${encodeURIComponent(email)}`
+  const params = new URLSearchParams({ plan: planId })
+  if (email) {
+    params.set('email', email)
+  }
+  const checkoutUrl = `${GATEWAY_BASE}/buy?${params.toString()}`
 
   log.info('')
   note(
@@ -120,6 +139,13 @@ export async function subscribeInteractive(): Promise<void> {
     'Checkout',
   )
 
+  const opened = openUrlInBrowser(checkoutUrl)
+  if (opened) {
+    log.success('Opened checkout URL in your browser')
+  } else if (process.stdout.isTTY && process.stdin.isTTY) {
+    log.info('Could not auto-open a browser. Open the URL above manually.')
+  }
+
   // Ask if they want to enter the key now
   const hasKey = await confirm({
     message: 'Do you already have your API key?',
@@ -176,7 +202,8 @@ export function subscribeNonInteractive(email?: string, plan?: string): void {
   }
 
   console.log('')
-  console.log('After payment, you\'ll receive your API key via email.')
+  console.log('After payment, your API key is shown on the success page.')
+  console.log('If an email was provided to Stripe checkout, a copy is also sent by email.')
   console.log(`Then run: ${pc.cyan('egaki login --provider egaki --key egaki_...')}`)
   console.log('')
   console.log('Tip: egaki supports both BYOK and subscription mode.')

package/src/video-model-catalog.ts

@@ -0,0 +1,302 @@
+// Single source of truth for video generation models.
+// Stores provider, strategy, capabilities, and duration-based pricing metadata.
+// Gateway billing uses this catalog to estimate per-request video cost.
+
+export type VideoDurationPricingTier = {
+  /** USD per second for this variant */
+  costPerSecond: number
+  /** Optional resolution discriminator (e.g. 720p, 1080p, 4k) */
+  resolution?: string
+  /** Optional mode discriminator (e.g. std, pro) */
+  mode?: string
+  /** Optional audio discriminator */
+  audio?: boolean
+}
+
+export type PerVideoSecondCost = {
+  type: 'per-video-second'
+  /** Fallback duration when request does not specify one (seconds) */
+  defaultDurationSec: number
+  tiers: VideoDurationPricingTier[]
+}
+
+export type UnknownVideoCost = {
+  type: 'unknown'
+}
+
+export type VideoModelCost = PerVideoSecondCost | UnknownVideoCost
+
+export type VideoModelFeatures = {
+  /** Supports text prompt to video generation */
+  textToVideo: boolean
+  /** Supports image-to-video prompt object ({ image, text }) */
+  imageToVideo: boolean
+  /** Optional capabilities exposed by provider */
+  capabilities: Array<'t2v' | 'i2v' | 'r2v' | 'motion-control' | 'editing'>
+  /** Optional supported aspect ratios */
+  aspectRatios?: string[]
+  /** Optional supported resolutions */
+  resolutions?: string[]
+  /** Optional duration range in seconds */
+  durationRangeSec?: { min: number; max: number }
+  seed: boolean
+  multipleVideos: boolean
+}
+
+export type VideoModelEntry = {
+  id: string
+  name: string
+  description?: string
+  provider: string
+  strategy: 'video'
+  released: string
+  cost: VideoModelCost
+  features: VideoModelFeatures
+}
+
+const commonRatios = ['16:9', '9:16', '1:1', '4:3', '3:4']
+
+export const VIDEO_CATALOG: VideoModelEntry[] = [
+  {
+    id: 'veo-3.1-generate-001',
+    name: 'Veo 3.1',
+    provider: 'google',
+    strategy: 'video',
+    released: '2026-01',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 8,
+      tiers: [
+        { resolution: '720p', audio: false, costPerSecond: 0.2 },
+        { resolution: '720p', audio: true, costPerSecond: 0.4 },
+        { resolution: '1080p', audio: false, costPerSecond: 0.2 },
+        { resolution: '1080p', audio: true, costPerSecond: 0.4 },
+        { resolution: '4k', audio: false, costPerSecond: 0.4 },
+        { resolution: '4k', audio: true, costPerSecond: 0.6 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: ['16:9', '9:16'],
+      resolutions: ['720p', '1080p', '4k'],
+      durationRangeSec: { min: 4, max: 8 },
+      seed: true,
+      multipleVideos: true,
+    },
+  },
+  {
+    id: 'veo-3.1-fast-generate-001',
+    name: 'Veo 3.1 Fast',
+    provider: 'google',
+    strategy: 'video',
+    released: '2026-01',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 8,
+      tiers: [
+        { resolution: '720p', audio: false, costPerSecond: 0.1 },
+        { resolution: '720p', audio: true, costPerSecond: 0.15 },
+        { resolution: '1080p', audio: false, costPerSecond: 0.1 },
+        { resolution: '1080p', audio: true, costPerSecond: 0.15 },
+        { resolution: '4k', audio: false, costPerSecond: 0.3 },
+        { resolution: '4k', audio: true, costPerSecond: 0.35 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: ['16:9', '9:16'],
+      resolutions: ['720p', '1080p', '4k'],
+      durationRangeSec: { min: 4, max: 8 },
+      seed: true,
+      multipleVideos: true,
+    },
+  },
+  {
+    id: 'veo-3.0-generate-001',
+    name: 'Veo 3.0',
+    provider: 'google',
+    strategy: 'video',
+    released: '2025-12',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 8,
+      tiers: [
+        { resolution: '720p', audio: false, costPerSecond: 0.2 },
+        { resolution: '720p', audio: true, costPerSecond: 0.4 },
+        { resolution: '1080p', audio: false, costPerSecond: 0.2 },
+        { resolution: '1080p', audio: true, costPerSecond: 0.4 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: ['16:9', '9:16'],
+      resolutions: ['720p', '1080p'],
+      durationRangeSec: { min: 4, max: 8 },
+      seed: true,
+      multipleVideos: true,
+    },
+  },
+  {
+    id: 'veo-3.0-fast-generate-001',
+    name: 'Veo 3.0 Fast',
+    provider: 'google',
+    strategy: 'video',
+    released: '2025-12',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 8,
+      tiers: [
+        { resolution: '720p', audio: false, costPerSecond: 0.1 },
+        { resolution: '720p', audio: true, costPerSecond: 0.15 },
+        { resolution: '1080p', audio: false, costPerSecond: 0.1 },
+        { resolution: '1080p', audio: true, costPerSecond: 0.15 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: ['16:9', '9:16'],
+      resolutions: ['720p', '1080p'],
+      durationRangeSec: { min: 4, max: 8 },
+      seed: true,
+      multipleVideos: true,
+    },
+  },
+  {
+    id: 'grok-imagine-video',
+    name: 'Grok Imagine Video',
+    provider: 'xai',
+    strategy: 'video',
+    released: '2026-03',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 5,
+      tiers: [
+        { resolution: '480p', costPerSecond: 0.05 },
+        { resolution: '720p', costPerSecond: 0.07 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: true,
+      capabilities: ['t2v', 'i2v', 'editing'],
+      aspectRatios: ['1:1', '16:9', '9:16', '4:3', '3:4', '3:2', '2:3'],
+      resolutions: ['480p', '720p'],
+      durationRangeSec: { min: 1, max: 15 },
+      seed: false,
+      multipleVideos: false,
+    },
+  },
+  {
+    id: 'kling-v2.6-t2v',
+    name: 'Kling v2.6 T2V',
+    provider: 'klingai',
+    strategy: 'video',
+    released: '2025-12',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 5,
+      tiers: [
+        { mode: 'std', costPerSecond: 0.042 },
+        { mode: 'pro', audio: false, costPerSecond: 0.07 },
+        { mode: 'pro', audio: true, costPerSecond: 0.14 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: commonRatios,
+      durationRangeSec: { min: 5, max: 10 },
+      seed: false,
+      multipleVideos: false,
+    },
+  },
+  {
+    id: 'wan-v2.6-t2v',
+    name: 'Wan v2.6 T2V',
+    provider: 'alibaba',
+    strategy: 'video',
+    released: '2026-01',
+    cost: {
+      type: 'per-video-second',
+      defaultDurationSec: 5,
+      tiers: [
+        { resolution: '720p', costPerSecond: 0.1 },
+        { resolution: '1080p', costPerSecond: 0.15 },
+      ],
+    },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      resolutions: ['720p', '1080p'],
+      durationRangeSec: { min: 2, max: 15 },
+      seed: false,
+      multipleVideos: false,
+    },
+  },
+
+  // Fal direct BYOK models — duration pricing depends on Fal endpoint/config.
+  {
+    id: 'luma-ray-2',
+    name: 'Luma Ray 2 (Fal)',
+    provider: 'fal',
+    strategy: 'video',
+    released: '2025-11',
+    cost: { type: 'unknown' },
+    features: {
+      textToVideo: true,
+      imageToVideo: true,
+      capabilities: ['t2v', 'i2v'],
+      aspectRatios: commonRatios,
+      seed: true,
+      multipleVideos: false,
+    },
+  },
+  {
+    id: 'minimax-video',
+    name: 'MiniMax Video (Fal)',
+    provider: 'fal',
+    strategy: 'video',
+    released: '2025-10',
+    cost: { type: 'unknown' },
+    features: {
+      textToVideo: true,
+      imageToVideo: false,
+      capabilities: ['t2v'],
+      aspectRatios: commonRatios,
+      seed: false,
+      multipleVideos: false,
+    },
+  },
+  {
+    id: 'hunyuan-video',
+    name: 'Hunyuan Video (Fal)',
+    provider: 'fal',
+    strategy: 'video',
+    released: '2025-09',
+    cost: { type: 'unknown' },
+    features: {
+      textToVideo: true,
+      imageToVideo: true,
+      capabilities: ['t2v', 'i2v'],
+      aspectRatios: commonRatios,
+      seed: true,
+      multipleVideos: false,
+    },
+  },
+]
+
+const videoCatalogIndex = new Map(VIDEO_CATALOG.map((m) => [m.id, m]))
+
+export function findVideoModel(id: string): VideoModelEntry | undefined {
+  return videoCatalogIndex.get(id)
+}