egaki 0.0.1 → 0.0.2

package/src/credentials.ts

@@ -0,0 +1,126 @@
+// 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.
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+// 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 }
+> = {
+  egaki: {
+    envVar: 'EGAKI_API_KEY',
+    label: 'Egaki (all models, one subscription)',
+    hint: 'Subscribe at https://egaki.org/buy or run: egaki subscribe',
+  },
+  google: {
+    envVar: 'GOOGLE_GENERATIVE_AI_API_KEY',
+    label: 'Google AI (Gemini, Imagen)',
+    hint: 'Get your key at https://aistudio.google.com/apikey',
+  },
+  openai: {
+    envVar: 'OPENAI_API_KEY',
+    label: 'OpenAI (DALL-E)',
+    hint: 'Get your key at https://platform.openai.com/api-keys',
+  },
+  replicate: {
+    envVar: 'REPLICATE_API_TOKEN',
+    label: 'Replicate (Flux, SDXL)',
+    hint: 'Get your token at https://replicate.com/account/api-tokens',
+  },
+  fal: {
+    envVar: 'FAL_KEY',
+    label: 'fal.ai (Flux, SDXL, Recraft)',
+    hint: 'Get your key at https://fal.ai/dashboard/keys',
+  },
+}
+
+export const EGAKI_GATEWAY_URL = 'https://egaki.org/v1/ai'
+
+function getConfigDir(): string {
+  // XDG_CONFIG_HOME or ~/.config/egaki
+  const xdg = process.env['XDG_CONFIG_HOME']
+  const base = xdg || path.join(os.homedir(), '.config')
+  return path.join(base, 'egaki')
+}
+
+function getCredentialsPath(): string {
+  return path.join(getConfigDir(), 'credentials.json')
+}
+
+export type Credentials = Record<string, string>
+
+export function readCredentials(): Credentials {
+  const filePath = getCredentialsPath()
+  if (!fs.existsSync(filePath)) {
+    return {}
+  }
+  const raw = fs.readFileSync(filePath, 'utf-8')
+  return JSON.parse(raw) as Credentials
+}
+
+export function writeCredentials(creds: Credentials): void {
+  const dir = getConfigDir()
+  fs.mkdirSync(dir, { recursive: true })
+  const filePath = getCredentialsPath()
+  fs.writeFileSync(filePath, JSON.stringify(creds, null, 2) + '\n', {
+    mode: 0o600,
+  })
+}
+
+export function saveProviderKey(provider: string, key: string): void {
+  const creds = readCredentials()
+  creds[provider] = key
+  writeCredentials(creds)
+}
+
+export function removeProviderKey(provider: string): void {
+  const creds = readCredentials()
+  delete creds[provider]
+  writeCredentials(creds)
+}
+
+export function getProviderKey(provider: string): string | undefined {
+  const creds = readCredentials()
+  return creds[provider]
+}
+
+// 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).
+export function injectCredentialsToEnv(): void {
+  const creds = readCredentials()
+  for (const [provider, key] of Object.entries(creds)) {
+    const info = PROVIDERS[provider]
+    if (!info) {
+      continue
+    }
+    if (!process.env[info.envVar]) {
+      process.env[info.envVar] = key
+    }
+  }
+}
+
+// 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'
+} {
+  const info = PROVIDERS[provider]
+  if (!info) {
+    return { available: false, source: 'none' }
+  }
+  if (process.env[info.envVar]) {
+    return { available: true, source: 'env' }
+  }
+  const stored = getProviderKey(provider)
+  if (stored) {
+    return { available: true, source: 'stored' }
+  }
+  return { available: false, source: 'none' }
+}

package/src/login.ts

@@ -0,0 +1,163 @@
+// 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.
+import {
+  intro,
+  outro,
+  select,
+  password,
+  isCancel,
+  cancel,
+  log,
+  note,
+} from '@clack/prompts'
+import pc from 'picocolors'
+import {
+  PROVIDERS,
+  saveProviderKey,
+  removeProviderKey,
+  getKeyStatus,
+  readCredentials,
+} from './credentials.js'
+
+export async function loginInteractive(): Promise<void> {
+  intro(pc.bold('egaki login'))
+
+  const providerOptions = Object.entries(PROVIDERS).map(([key, info]) => {
+    const status = getKeyStatus(key)
+    const statusLabel = (() => {
+      if (status.source === 'env') {
+        return pc.green('(set via env)')
+      }
+      if (status.source === 'stored') {
+        return pc.green('(saved)')
+      }
+      return pc.dim('(not configured)')
+    })()
+    // Highlight the egaki option as recommended
+    const label = key === 'egaki'
+      ? `${pc.bold(info.label)} ${pc.cyan('← recommended')} ${statusLabel}`
+      : `${info.label} ${statusLabel}`
+    return {
+      value: key,
+      label,
+      hint: info.hint,
+    }
+  })
+
+  const provider = await select({
+    message: 'Select a provider to configure',
+    options: providerOptions,
+  })
+
+  if (isCancel(provider)) {
+    cancel('Login cancelled.')
+    process.exit(0)
+  }
+
+  const info = PROVIDERS[provider]
+  if (!info) {
+    log.error(`Unknown provider: ${provider}`)
+    process.exit(1)
+  }
+
+  log.info(
+    `${pc.dim('Env var:')} ${info.envVar} ${pc.dim('(also used by the CLI when set)')}`,
+  )
+  log.info(`${pc.dim('Get key:')} ${info.hint}`)
+
+  const key = await password({
+    message: `Paste your ${info.label} API key`,
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return 'API key cannot be empty'
+      }
+    },
+  })
+
+  if (isCancel(key)) {
+    cancel('Login cancelled.')
+    process.exit(0)
+  }
+
+  saveProviderKey(provider, key.trim())
+
+  log.success(`${info.label} key saved`)
+  note(
+    `You can also set ${pc.bold(info.envVar)} as an env var.\nThe CLI reads it automatically, so you can pass it inline too:\n  ${pc.dim(`${info.envVar}=... egaki generate "prompt"`)}`,
+    'Tip',
+  )
+
+  outro('Done')
+}
+
+export function loginNonInteractive({
+  provider,
+  key,
+}: {
+  provider: string
+  key: string
+}): void {
+  const info = PROVIDERS[provider]
+  if (!info) {
+    const available = Object.keys(PROVIDERS).join(', ')
+    console.error(
+      pc.red(`Unknown provider: ${provider}. Available: ${available}`),
+    )
+    process.exit(1)
+  }
+
+  if (!key || key.trim().length === 0) {
+    console.error(pc.red('API key cannot be empty'))
+    process.exit(1)
+  }
+
+  saveProviderKey(provider, key.trim())
+  console.log(pc.green(`${info.label} key saved`))
+}
+
+export function showLoginStatus(): void {
+  console.log(pc.bold('Configured providers:\n'))
+
+  for (const [key, info] of Object.entries(PROVIDERS)) {
+    const status = getKeyStatus(key)
+    const icon = status.available ? pc.green('*') : pc.dim('-')
+    const source = (() => {
+      if (status.source === 'env') {
+        return pc.cyan('(from env)')
+      }
+      if (status.source === 'stored') {
+        return pc.green('(saved)')
+      }
+      return pc.dim('(not set)')
+    })()
+    const envHint = pc.dim(
+      `  env: ${info.envVar} (set in shell or pass inline to CLI)`,
+    )
+    console.log(`${icon} ${info.label} ${source}`)
+    console.log(envHint)
+  }
+}
+
+export function removeLogin(provider: string): void {
+  const info = PROVIDERS[provider]
+  if (!info) {
+    const available = Object.keys(PROVIDERS).join(', ')
+    console.error(
+      pc.red(`Unknown provider: ${provider}. Available: ${available}`),
+    )
+    process.exit(1)
+  }
+
+  removeProviderKey(provider)
+  console.log(pc.green(`${info.label} key removed`))
+}
+
+// Read API key from stdin (for piping: echo "sk-xxx" | egaki login --provider google)
+export async function readKeyFromStdin(): Promise<string> {
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk as Buffer)
+  }
+  return Buffer.concat(chunks).toString('utf-8').trim()
+}