egaki 0.0.1 → 0.0.2

package/src/models.ts

@@ -0,0 +1,197 @@
+// Model registry for egaki.
+// Maps model IDs to their provider and generation strategy. The enum of
+// supported models is derived from this registry so there's a single source
+// of truth for both CLI validation and runtime provider resolution.
+//
+// Two generation strategies:
+//   - 'image': uses provider.image(modelId) + generateImage()
+//   - 'text':  uses provider(modelId) + generateText() with responseModalities
+//
+// Provider resolution priority:
+//   1. Provider-specific key (e.g. GOOGLE_GENERATIVE_AI_API_KEY) → direct SDK
+//   2. Egaki API key (EGAKI_API_KEY) → route through egaki gateway
+//   3. No key → error with subscription recommendation
+//
+// Model IDs are sourced from the TypeScript types exported by each @ai-sdk/*
+// package. To add new models, check the *ModelId types in each package's
+// dist/index.d.ts and add entries here.
+import type { ImageModel, LanguageModel } from 'ai'
+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'
+
+export type { ModelEntry }
+
+export const IMAGE_MODELS = CATALOG.map((m) => m.id) as [string, ...string[]]
+
+export const DEFAULT_MODEL = 'nano-banana-pro-preview'
+
+export function getModelConfig(modelId: string): ModelEntry {
+  const entry = findModel(modelId)
+  if (!entry) {
+    console.error(pc.red(`Unknown model: ${modelId}`))
+    process.exit(1)
+  }
+  return entry
+}
+
+/**
+ * Check if the egaki gateway API key is available (from env or stored credentials).
+ */
+function hasEgakiKey(): boolean {
+  const info = PROVIDERS['egaki']
+  if (!info) return false
+  return Boolean(process.env[info.envVar])
+}
+
+/**
+ * Check if a direct provider key is available for the given provider.
+ */
+function hasDirectProviderKey(providerName: string): boolean {
+  const info = PROVIDERS[providerName]
+  if (!info) return false
+  return Boolean(process.env[info.envVar])
+}
+
+// Check that the provider's API key is available before making API calls.
+// Prints a user-friendly error with instructions on how to configure it.
+// Prioritizes egaki subscription over individual provider keys.
+export function ensureProviderKey(providerName: string): void {
+  // If direct provider key exists, we're good
+  if (hasDirectProviderKey(providerName)) return
+
+  // If egaki key exists, we'll route through the gateway
+  if (hasEgakiKey()) return
+
+  const info = PROVIDERS[providerName]
+
+  console.error('')
+  console.error(pc.red(pc.bold(`Missing API key for ${info?.label || providerName}`)))
+  console.error('')
+  console.error(`  ${pc.bold('Recommended:')} Use Egaki subscription (all models, one key)`)
+  console.error('')
+  console.error(
+    `    ${pc.cyan('egaki subscribe')}                        get started in 30 seconds`,
+  )
+  console.error('')
+  console.error(`  ${pc.dim('Or configure a provider key directly:')}`)
+  console.error('')
+  console.error(
+    `    ${pc.cyan('egaki login')}                           interactive setup`,
+  )
+  if (info) {
+    console.error(
+      `    ${pc.cyan(`${info.envVar}=...`)} egaki image ...   inline env var`,
+    )
+    console.error(
+      `    ${pc.cyan(`egaki login --provider ${providerName} --key <key>`)}`,
+    )
+    console.error('')
+    console.error(`  ${pc.dim(info.hint)}`)
+  }
+  console.error('')
+  process.exit(1)
+}
+
+/**
+ * Create a gateway-backed image model using createGateway from the AI SDK.
+ * The model ID is sent as provider/model format to the gateway.
+ */
+async function createGatewayImageModel(modelId: string, provider: string): Promise<ImageModel> {
+  const { createGateway } = await import('ai')
+  const gateway = createGateway({
+    apiKey: process.env['EGAKI_API_KEY']!,
+    baseURL: EGAKI_GATEWAY_URL,
+  })
+  // Gateway expects provider/model format for routing
+  const gatewayModelId = `${provider}/${modelId}`
+  return gateway.image(gatewayModelId)
+}
+
+/**
+ * Create a gateway-backed text model using createGateway from the AI SDK.
+ */
+async function createGatewayTextModel(modelId: string, provider: string): Promise<LanguageModel> {
+  const { createGateway } = await import('ai')
+  const gateway = createGateway({
+    apiKey: process.env['EGAKI_API_KEY']!,
+    baseURL: EGAKI_GATEWAY_URL,
+  })
+  const gatewayModelId = `${provider}/${modelId}`
+  return gateway(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.
+//
+// Priority: direct provider key > egaki gateway > error
+export async function createImageModel(modelId: string): Promise<ImageModel> {
+  const config = getModelConfig(modelId)
+  ensureProviderKey(config.provider)
+
+  // If the user has a direct provider key, use the provider SDK directly
+  if (hasDirectProviderKey(config.provider)) {
+    switch (config.provider) {
+      case 'google': {
+        const { google } = await import('@ai-sdk/google')
+        return google.image(modelId)
+      }
+      case 'openai': {
+        const { openai } = await import('@ai-sdk/openai')
+        return openai.image(modelId)
+      }
+      case 'replicate': {
+        const { replicate } = await import('@ai-sdk/replicate')
+        return replicate.image(modelId)
+      }
+      case 'fal': {
+        const { fal } = await import('@ai-sdk/fal')
+        return fal.image(modelId)
+      }
+    }
+  }
+
+  // Fall back to egaki gateway
+  if (hasEgakiKey()) {
+    return createGatewayImageModel(modelId, config.provider)
+  }
+
+  // Should not reach here — ensureProviderKey would have exited
+  console.error(pc.red(`No API key available for provider: ${config.provider}`))
+  process.exit(1)
+}
+
+export async function createTextModel(
+  modelId: string,
+): Promise<LanguageModel> {
+  const config = getModelConfig(modelId)
+  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(modelId)
+      }
+      default:
+        // Only Google supports generateText with responseModalities for images
+        console.error(
+          pc.red(
+            `Text+image generation is only supported for Google models, got provider: ${config.provider}`,
+          ),
+        )
+        process.exit(1)
+    }
+  }
+
+  // Fall back to egaki gateway
+  if (hasEgakiKey()) {
+    return createGatewayTextModel(modelId, config.provider)
+  }
+
+  console.error(pc.red(`No API key available for provider: ${config.provider}`))
+  process.exit(1)
+}

package/src/subscription.ts

@@ -0,0 +1,271 @@
+// Subscription management for egaki.
+// Handles the subscribe, unsubscribe, and usage flows.
+// Communicates with the egaki gateway API at egaki.org.
+
+import pc from 'picocolors'
+import {
+  intro,
+  outro,
+  text,
+  select,
+  confirm,
+  isCancel,
+  cancel,
+  log,
+  note,
+  spinner,
+} from '@clack/prompts'
+import { EGAKI_GATEWAY_URL, saveProviderKey, getProviderKey } from './credentials.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$/, '')
+
+type PlanInfo = {
+  id: string
+  name: string
+  price: number
+  spendingCap: number
+  markup: number
+  priceFormatted: string
+}
+
+type UsageInfo = {
+  plan: string
+  planName: string
+  dollarsUsed: number
+  spendingCap: number
+  dollarsRemaining: number
+  periodStart: number
+  status: string
+}
+
+type StatusInfo = {
+  status: string
+  plan: string
+  planName: string
+  email?: string
+  dollarsUsed: number
+  spendingCap: number
+  createdAt: number
+}
+
+// ── Subscribe ─────────────────────────────────────────────────────────────
+
+export async function subscribeInteractive(): Promise<void> {
+  intro(pc.bold('egaki subscribe'))
+
+  // Fetch available plans
+  const s = spinner()
+  s.start('Fetching plans...')
+
+  let plans: PlanInfo[]
+  try {
+    const res = await fetch(`${GATEWAY_BASE}/api/plans`)
+    if (!res.ok) throw new Error(`HTTP ${res.status}`)
+    const data = (await res.json()) as { plans: PlanInfo[] }
+    plans = data.plans
+    s.stop('Plans loaded')
+  } catch {
+    s.stop('Failed to fetch plans')
+    log.error('Could not connect to egaki.org. Check your internet connection.')
+    process.exit(1)
+  }
+
+  // Select plan
+  const planId = await select({
+    message: 'Choose a plan',
+    options: plans.map((p) => ({
+      value: p.id,
+      label: `${p.name} — ${p.priceFormatted}`,
+      hint: `$${p.spendingCap} spending cap, all models`,
+    })),
+  })
+
+  if (isCancel(planId)) {
+    cancel('Subscribe cancelled.')
+    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'
+      }
+    },
+  })
+
+  if (isCancel(email)) {
+    cancel('Subscribe cancelled.')
+    process.exit(0)
+  }
+
+  // Show checkout URL
+  const checkoutUrl = `${GATEWAY_BASE}/buy?plan=${planId}&email=${encodeURIComponent(email)}`
+
+  log.info('')
+  note(
+    [
+      `Open this URL to complete payment:`,
+      '',
+      pc.cyan(checkoutUrl),
+      '',
+      `After payment, you'll receive your API key via email.`,
+      `Then run:`,
+      '',
+      `  ${pc.cyan('egaki login --provider egaki --key egaki_...')}`,
+    ].join('\n'),
+    'Checkout',
+  )
+
+  // Ask if they want to enter the key now
+  const hasKey = await confirm({
+    message: 'Do you already have your API key?',
+  })
+
+  if (isCancel(hasKey)) {
+    outro('You can enter your key later with: egaki login --provider egaki --key <key>')
+    return
+  }
+
+  if (hasKey) {
+    const key = await text({
+      message: 'Paste your egaki API key',
+      placeholder: 'egaki_...',
+      validate: (value) => {
+        if (!value || !value.startsWith('egaki_')) {
+          return 'API key should start with egaki_'
+        }
+      },
+    })
+
+    if (isCancel(key)) {
+      outro('You can enter your key later with: egaki login --provider egaki --key <key>')
+      return
+    }
+
+    saveProviderKey('egaki', key.trim())
+    log.success('API key saved')
+    outro('You can now generate images with any model: egaki image "your prompt"')
+  } else {
+    outro('After payment, run: egaki login --provider egaki --key <your-key>')
+  }
+}
+
+export function subscribeNonInteractive(email?: string, plan?: string): void {
+  const emailParam = email ? `&email=${encodeURIComponent(email)}` : ''
+
+  if (plan) {
+    // Specific plan requested
+    const checkoutUrl = `${GATEWAY_BASE}/buy?plan=${plan}${emailParam}`
+    console.log(pc.bold('Egaki Subscription'))
+    console.log('')
+    console.log('Open this URL to complete payment:')
+    console.log('')
+    console.log(pc.cyan(checkoutUrl))
+  } else {
+    // No plan specified — show all options
+    console.log(pc.bold('Egaki Subscription'))
+    console.log('')
+    console.log('Choose a plan:')
+    console.log('')
+    console.log(`  ${pc.bold('Plus')}  $29/mo  ${pc.cyan(`${GATEWAY_BASE}/buy?plan=plus${emailParam}`)}`)
+    console.log(`  ${pc.bold('Pro')}   $99/mo  ${pc.cyan(`${GATEWAY_BASE}/buy?plan=pro${emailParam}`)}`)
+  }
+
+  console.log('')
+  console.log('After payment, you\'ll receive your API key via 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.')
+  console.log('BYOK = add provider keys (google/openai/replicate/fal) with egaki login.')
+  console.log('Subscription = one egaki key to access all models without per-provider key setup.')
+}
+
+// ── Unsubscribe ───────────────────────────────────────────────────────────
+
+export async function unsubscribe(): Promise<void> {
+  const apiKey = getProviderKey('egaki') || process.env['EGAKI_API_KEY']
+
+  if (!apiKey) {
+    console.error(pc.red('No egaki API key found.'))
+    console.error(
+      `If you have a key, set it first: ${pc.cyan('egaki login --provider egaki --key <key>')}`,
+    )
+    process.exit(1)
+  }
+
+  console.error(pc.dim('Canceling subscription...'))
+
+  try {
+    const res = await fetch(`${GATEWAY_BASE}/api/cancel`, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${apiKey}` },
+    })
+
+    const data = (await res.json()) as { success?: boolean; message?: string; error?: string }
+
+    if (!res.ok) {
+      console.error(pc.red(data.error || 'Failed to cancel subscription'))
+      process.exit(1)
+    }
+
+    console.log(pc.green(data.message || 'Subscription canceled.'))
+    console.log(pc.dim('You can resubscribe anytime with: egaki subscribe'))
+  } catch {
+    console.error(pc.red('Could not connect to egaki.org. Check your internet connection.'))
+    process.exit(1)
+  }
+}
+
+// ── Usage ─────────────────────────────────────────────────────────────────
+
+export async function showUsage(): Promise<void> {
+  const apiKey = getProviderKey('egaki') || process.env['EGAKI_API_KEY']
+
+  if (!apiKey) {
+    console.error(pc.red('No egaki API key found.'))
+    console.error(
+      `Set your key first: ${pc.cyan('egaki login --provider egaki --key <key>')}`,
+    )
+    console.error(
+      `Or subscribe: ${pc.cyan('egaki subscribe')}`,
+    )
+    process.exit(1)
+  }
+
+  try {
+    const res = await fetch(`${GATEWAY_BASE}/api/usage`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    })
+
+    if (!res.ok) {
+      const data = (await res.json()) as { error?: string }
+      console.error(pc.red(data.error || 'Failed to fetch usage'))
+      process.exit(1)
+    }
+
+    const usage = (await res.json()) as UsageInfo
+    const pct = usage.spendingCap > 0
+      ? Math.round((usage.dollarsUsed / usage.spendingCap) * 100)
+      : 0
+    const remaining = Math.max(0, usage.spendingCap - usage.dollarsUsed)
+
+    console.log(pc.bold(`Egaki ${usage.planName} Plan\n`))
+    console.log(`  Status:    ${usage.status === 'active' ? pc.green('active') : pc.red(usage.status)}`)
+    console.log(`  Spent:     $${usage.dollarsUsed.toFixed(2)} / $${usage.spendingCap.toFixed(2)} (${pct}%)`)
+    console.log(`  Remaining: $${remaining.toFixed(2)}`)
+    console.log(`  Period:    started ${new Date(usage.periodStart).toLocaleDateString()}`)
+
+    if (pct >= 90) {
+      console.log('')
+      console.log(pc.yellow('  Running low on budget! Consider upgrading your plan.'))
+      console.log(pc.dim(`  Visit: https://egaki.org/buy`))
+    }
+  } catch {
+    console.error(pc.red('Could not connect to egaki.org. Check your internet connection.'))
+    process.exit(1)
+  }
+}

package/index.js

@@ -1 +0,0 @@
-// placeholder