egaki 0.3.0 → 0.4.1

package/src/cli.ts

@@ -18,8 +18,15 @@ import {
 import fs from 'node:fs'
 import path from 'node:path'
 import pc from 'picocolors'
+import { createParser, type EventSourceMessage } from 'eventsource-parser'
 import pkg from '../package.json' with { type: 'json' }
-import { injectCredentialsToEnv, PROVIDERS } from './credentials.js'
+import {
+  injectCredentialsToEnv,
+  PROVIDERS,
+  getChatGptAuth,
+  saveChatGptAuth,
+  getKeyStatus,
+} from './credentials.js'
 import {
   IMAGE_MODELS,
   VIDEO_MODELS,
@@ -29,6 +36,7 @@ import {
   createImageModel,
   createTextModel,
   createVideoModel,
+  shouldUseResponsesApi,
 } from './models.js'
 import { VIDEO_CATALOG } from './video-model-catalog.js'
 import {
@@ -44,6 +52,7 @@ import {
   unsubscribe,
   showUsage,
 } from './subscription.js'
+import { getValidChatGptAuth } from './chatgpt-auth.js'
 
 const cli = goke('egaki')
 
@@ -118,8 +127,13 @@ cli
 
     // 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())
-      loginNonInteractive({ provider: options.provider, key })
+      await loginNonInteractive({ provider: options.provider, key })
       return
     }
 
@@ -291,23 +305,21 @@ cli
   .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
+    // Inject stored API keys as env vars before calling the AI SDK.
     injectCredentialsToEnv()
 
-    const model = options.model
-    const outputPath = options.output
+    // goke infers schema .default() values via Zod's input type, which leaves
+    // options.model / options.output / options.count as `T | undefined` even
+    // though the runtime always resolves them. Apply the same defaults here.
+    const model = options.model ?? DEFAULT_MODEL
+    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}`))
-      console.error(
-        pc.dim(
-          config.strategy === 'image'
-            ? 'Mode: Image API (generateImage)'
-            : 'Mode: Text+Image (generateText)',
-        ),
-      )
     }
 
     const inputImages = await readInputImages(options.input)
@@ -315,13 +327,34 @@ cli
       ? await readInputSource(options.mask)
       : undefined
 
-    if (config.strategy === 'image') {
+    // 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: options.count,
-        aspectRatio: options.aspectRatio as `${number}:${number}` | undefined,
+        count,
+        aspectRatio: parsedAspectRatio,
         seed: options.seed,
         inputImages,
         maskImage,
@@ -422,8 +455,10 @@ cli
   .action(async (prompt, options) => {
     injectCredentialsToEnv()
 
-    const model = options.model
-    const outputPath = options.output
+    // Apply the same .default(...) values goke's input-type inference drops.
+    const model = options.model ?? DEFAULT_VIDEO_MODEL
+    const outputPath = options.output ?? 'egaki-output.mp4'
+    const count = options.count ?? 1
     const config = getModelConfig(model)
 
     if (config.strategy !== 'video') {
@@ -445,7 +480,7 @@ cli
       prompt,
       model,
       outputPath,
-      count: options.count,
+      count,
       aspectRatio: options.aspectRatio,
       resolution: options.resolution,
       duration: options.duration,
@@ -482,6 +517,9 @@ cli
   .action(async (options) => {
     const { CATALOG } = await import('./model-catalog.js')
     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
@@ -502,6 +540,7 @@ cli
       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),
@@ -782,6 +821,199 @@ async function generateWithTextModel({
   }
 }
 
+// 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,
+}: {
+  prompt: string
+  model: string
+  outputPath: string
+  count: number
+  aspectRatio?: `${number}:${number}`
+  seed?: number
+  inputImages: Uint8Array[]
+  maskImage?: Uint8Array
+  json: boolean
+  stdout: boolean
+}) {
+  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: Array<{ type: 'input_text'; text: string } | { type: 'input_image'; image_url: string }> = [
+    { type: 'input_text', text: prompt },
+    ...inputImages.map((image) => ({
+      type: 'input_image' as const,
+      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: string | undefined
+  let revisedPrompt: string | null = null
+
+  const processSseMessage = (message: EventSourceMessage) => {
+    if (!message.data) return
+    try {
+      const event = JSON.parse(message.data) as {
+        type?: string
+        partial_image_b64?: string
+        item?: { type?: string; result?: string; revised_prompt?: string | null }
+      }
+      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: string[] = []
+  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,
@@ -983,6 +1215,49 @@ function extensionFromMediaType(mediaType: string): string {
   return map[mediaType] || (mediaType.startsWith('video/') ? '.mp4' : '.png')
 }
 
+function inferImageMediaType(image: Uint8Array): string {
+  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: Uint8Array): string {
+  const mediaType = inferImageMediaType(image)
+  return `data:${mediaType};base64,${Buffer.from(image).toString('base64')}`
+}
+
+function chatGptImageSizeFromAspectRatio(
+  aspectRatio: `${number}:${number}`,
+): '1024x1024' | '1536x1024' | '1024x1536' | undefined {
+  switch (aspectRatio) {
+    case '1:1':
+      return '1024x1024'
+    case '3:2':
+      return '1536x1024'
+    case '2:3':
+      return '1024x1536'
+    default:
+      return undefined
+  }
+}
+
 function normalizeResolutionKey(input?: string): string | undefined {
   if (!input) return undefined
   const normalized = input.trim().toLowerCase()
@@ -992,6 +1267,17 @@ function normalizeResolutionKey(input?: string): string | undefined {
   return normalized
 }
 
+function isAspectRatio(input: string): input is `${number}:${number}` {
+  return /^\d+:\d+$/.test(input)
+}
+
+function parseAspectRatioOption(input?: string): `${number}:${number}` | undefined {
+  if (!input || !isAspectRatio(input)) {
+    return undefined
+  }
+  return input
+}
+
 function ensureExtension(filePath: string, ext: string): string {
   const parsed = path.parse(filePath)
   if (parsed.ext) {

package/src/credentials.ts

@@ -1,22 +1,37 @@
 // Credential storage for egaki.
 // Reads and writes API keys from ~/.config/egaki/credentials.json.
 // Keys are stored per-provider and injected as env vars at runtime.
+//
+// Most providers store a plain API key string. The 'chatgpt' provider stores
+// a structured ChatGptAuth object with OAuth tokens for the Codex backend flow.
 import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
+import type { ChatGptAuth } from './chatgpt-auth.js'
+
+export type ProviderInfo = {
+  envVar: string
+  label: string
+  hint: string
+  /** If true, this provider uses OAuth instead of a plain API key */
+  oauth?: boolean
+}
 
 // Maps provider names to their expected env var names.
 // When a key is stored, we set the corresponding env var before
 // calling the AI SDK so the provider picks it up automatically.
-export const PROVIDERS: Record<
-  string,
-  { envVar: string; label: string; hint: string }
-> = {
+export const PROVIDERS: Record<string, ProviderInfo> = {
   egaki: {
     envVar: 'EGAKI_API_KEY',
     label: 'Egaki (all models, one subscription)',
     hint: 'Subscribe at https://egaki.org/buy or run: egaki subscribe',
   },
+  chatgpt: {
+    envVar: 'OPENAI_API_KEY',
+    label: 'ChatGPT (use your subscription)',
+    hint: 'Sign in with your ChatGPT account via browser',
+    oauth: true,
+  },
   google: {
     envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
     label: 'Google AI (Gemini, Imagen)',
@@ -29,7 +44,7 @@ export const PROVIDERS: Record<
   },
   openai: {
     envVar: 'OPENAI_API_KEY',
-    label: 'OpenAI (DALL-E)',
+    label: 'OpenAI (API key)',
     hint: 'Get your key at https://platform.openai.com/api-keys',
   },
   replicate: {
@@ -57,7 +72,9 @@ function getCredentialsPath(): string {
   return path.join(getConfigDir(), 'credentials.json')
 }
 
-export type Credentials = Record<string, string>
+/** A credential value is either a plain API key string or a ChatGPT OAuth object. */
+export type CredentialValue = string | ChatGptAuth
+export type Credentials = Record<string, CredentialValue>
 
 export function readCredentials(): Credentials {
   const filePath = getCredentialsPath()
@@ -83,6 +100,21 @@ export function saveProviderKey(provider: string, key: string): void {
   writeCredentials(creds)
 }
 
+export function saveChatGptAuth(auth: ChatGptAuth): void {
+  const creds = readCredentials()
+  creds['chatgpt'] = auth
+  writeCredentials(creds)
+}
+
+export function getChatGptAuth(): ChatGptAuth | undefined {
+  const creds = readCredentials()
+  const val = creds['chatgpt']
+  if (val && typeof val === 'object') {
+    return val
+  }
+  return undefined
+}
+
 export function removeProviderKey(provider: string): void {
   const creds = readCredentials()
   delete creds[provider]
@@ -91,35 +123,56 @@ export function removeProviderKey(provider: string): void {
 
 export function getProviderKey(provider: string): string | undefined {
   const creds = readCredentials()
-  return creds[provider]
+  const val = creds[provider]
+  return typeof val === 'string' ? val : undefined
 }
 
-// Inject all stored credentials as env vars so the AI SDK
-// providers pick them up automatically. Env vars already set
-// by the user take precedence (we don't overwrite them).
+// Inject all stored non-ChatGPT credentials as env vars so the AI SDK
+// providers pick them up automatically. Env vars already set by the user take
+// precedence (we don't overwrite them).
 export function injectCredentialsToEnv(): void {
   const creds = readCredentials()
-  for (const [provider, key] of Object.entries(creds)) {
+  for (const [provider, value] of Object.entries(creds)) {
     const info = PROVIDERS[provider]
-    if (!info) {
-      continue
-    }
-    if (!process.env[info.envVar]) {
-      process.env[info.envVar] = key
+    if (!info) continue
+
+    // Skip ChatGPT OAuth entries — handled separately
+    if (provider === 'chatgpt') continue
+
+    if (typeof value === 'string' && !process.env[info.envVar]) {
+      process.env[info.envVar] = value
     }
   }
 }
 
+/**
+ * Returns true when the current run should use the ChatGPT/Codex backend flow
+ * for OpenAI image models instead of a direct OpenAI API key.
+ */
+export function shouldUseChatGptBackend(): boolean {
+  return !process.env['OPENAI_API_KEY'] && Boolean(getChatGptAuth())
+}
+
 // Check if a provider has a key available (from env or stored credentials).
 // Returns the source of the key for display purposes.
 export function getKeyStatus(provider: string): {
   available: boolean
-  source: 'env' | 'stored' | 'none'
+  source: 'env' | 'stored' | 'oauth' | 'none'
 } {
   const info = PROVIDERS[provider]
   if (!info) {
     return { available: false, source: 'none' }
   }
+
+  // ChatGPT OAuth is a special case
+  if (provider === 'chatgpt') {
+    const auth = getChatGptAuth()
+    if (auth) {
+      return { available: true, source: 'oauth' }
+    }
+    return { available: false, source: 'none' }
+  }
+
   if (process.env[info.envVar]) {
     return { available: true, source: 'env' }
   }

package/src/login.ts

@@ -1,6 +1,7 @@
 // Login command — interactive and non-interactive API key management.
 // Interactive mode uses clack prompts for provider selection and key input.
 // Non-interactive mode supports --provider + --key flags and stdin piping.
+// ChatGPT OAuth uses a browser flow instead of pasting a key.
 import {
   intro,
   outro,
@@ -17,8 +18,10 @@ import {
   saveProviderKey,
   removeProviderKey,
   getKeyStatus,
-  readCredentials,
+  getChatGptAuth,
+  saveChatGptAuth,
 } from './credentials.js'
+import { chatGptOAuthLogin, extractPlanType } from './chatgpt-auth.js'
 
 export async function loginInteractive(): Promise<void> {
   intro(pc.bold('egaki login'))
@@ -32,6 +35,11 @@ export async function loginInteractive(): Promise<void> {
       if (status.source === 'stored') {
         return pc.green('(saved)')
       }
+      if (status.source === 'oauth') {
+        const auth = getChatGptAuth()
+        const email = auth?.email
+        return pc.green(`(signed in${email ? ` as ${email}` : ''})`)
+      }
       return pc.dim('(not configured)')
     })()
     // Highlight the egaki option as recommended
@@ -61,6 +69,14 @@ export async function loginInteractive(): Promise<void> {
     process.exit(1)
   }
 
+  // ChatGPT uses browser OAuth instead of key paste
+  if (provider === 'chatgpt') {
+    const auth = await chatGptOAuthLogin()
+    saveChatGptAuth(auth)
+    outro('Done — ChatGPT OAuth saved')
+    return
+  }
+
   log.info(
     `${pc.dim('Env var:')} ${info.envVar} ${pc.dim('(also used by the CLI when set)')}`,
   )
@@ -91,13 +107,13 @@ export async function loginInteractive(): Promise<void> {
   outro('Done')
 }
 
-export function loginNonInteractive({
+export async function loginNonInteractive({
   provider,
   key,
 }: {
   provider: string
   key: string
-}): void {
+}): Promise<void> {
   const info = PROVIDERS[provider]
   if (!info) {
     const available = Object.keys(PROVIDERS).join(', ')
@@ -107,6 +123,14 @@ export function loginNonInteractive({
     process.exit(1)
   }
 
+  // ChatGPT uses browser OAuth — key flag is not needed
+  if (provider === 'chatgpt') {
+    const auth = await chatGptOAuthLogin()
+    saveChatGptAuth(auth)
+    console.log(pc.green('ChatGPT OAuth saved'))
+    return
+  }
+
   if (!key || key.trim().length === 0) {
     console.error(pc.red('API key cannot be empty'))
     process.exit(1)
@@ -121,6 +145,26 @@ export function showLoginStatus(): void {
 
   for (const [key, info] of Object.entries(PROVIDERS)) {
     const status = getKeyStatus(key)
+
+    if (key === 'chatgpt') {
+      const auth = getChatGptAuth()
+      if (auth) {
+        const plan = extractPlanType(auth)
+        const email = auth.email ?? auth.accountId ?? 'unknown'
+        const expired = auth.expires < Date.now()
+        const expiryLabel = expired
+          ? pc.yellow('(token expired, will auto-refresh)')
+          : pc.dim(`(token valid)`)
+        console.log(`${pc.green('*')} ${info.label} ${pc.green('(signed in)')}`)
+        console.log(pc.dim(`  account: ${email}${plan ? `, plan: ${plan}` : ''}`))
+        console.log(`  ${expiryLabel}`)
+      } else {
+        console.log(`${pc.dim('-')} ${info.label} ${pc.dim('(not signed in)')}`)
+        console.log(pc.dim(`  run: egaki login → select ChatGPT`))
+      }
+      continue
+    }
+
     const icon = status.available ? pc.green('*') : pc.dim('-')
     const source = (() => {
       if (status.source === 'env') {
@@ -150,7 +194,8 @@ export function removeLogin(provider: string): void {
   }
 
   removeProviderKey(provider)
-  console.log(pc.green(`${info.label} key removed`))
+  const label = provider === 'chatgpt' ? 'ChatGPT OAuth' : info.label
+  console.log(pc.green(`${label} key removed`))
 }
 
 // Read API key from stdin (for piping: echo "sk-xxx" | egaki login --provider google)