egaki 0.0.1 → 0.0.2

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 0.0.2
+
+- Make subscribe messaging explicit about both auth modes.
+- Clarify BYOK provider keys vs single Egaki subscription key in CLI + docs.
+- Expand README with advanced usage and model-specific command examples.
+
+## 0.0.1
+
+- Initial public release of the `egaki` CLI.
+- Image generation command with model selection and file/stdout output.
+- Login, subscription, unsubscribe, usage, and models commands.

package/README.md

@@ -0,0 +1,166 @@
+# egaki
+
+Generate AI images from the terminal with one command.
+
+`egaki` is a TypeScript CLI built on the Vercel AI SDK and goke. It supports
+Google Imagen, Gemini image-capable models, and model discovery with pricing.
+
+## Install
+
+```bash
+pnpm add -g egaki
+```
+
+## Quick start
+
+```bash
+egaki login
+egaki image "a watercolor fox reading a map" -o fox.png
+```
+
+## CLI examples
+
+### Generate from text
+
+```bash
+egaki image "cinematic mountain village at sunrise" -o village.png
+egaki image "isometric floating city, detailed, soft colors" -m imagen-4.0-generate-001
+```
+
+### Edit with input image
+
+```bash
+egaki image "add a red scarf and make it winter" --input portrait.jpg -o portrait-winter.png
+egaki image "turn this into a manga panel" --input https://example.com/photo.jpg -o manga.png
+```
+
+### Inpainting with a mask
+
+```bash
+egaki image "replace the sky with dramatic storm clouds" --input landscape.png --mask mask.png -o storm.png
+```
+
+### Generate multiple images
+
+```bash
+egaki image "minimal logo concepts for a cat cafe" -n 4 -o logo.png
+```
+
+### Control composition
+
+```bash
+egaki image "cyberpunk alley at night" --aspect-ratio 16:9
+egaki image "polaroid-style travel photo" --aspect-ratio 4:5
+```
+
+### Pipe output to other tools
+
+```bash
+egaki image "flat icon of a fox" --stdout | magick - -resize 512x512 fox-icon.png
+```
+
+### Discover models and pricing
+
+```bash
+egaki models
+egaki models --provider google
+egaki models --json
+```
+
+### Advanced examples
+
+```bash
+# Deterministic result (models that support seed)
+egaki image "studio product shot of a ceramic mug" \
+  -m imagen-4.0-generate-001 \
+  --seed 42 \
+  -o mug-seed-42.png
+
+# High quality Gemini image generation with 4K output
+egaki image "architectural concept art, brutalist library interior" \
+  -m gemini-2.5-flash-image \
+  --image-size 4K \
+  --aspect-ratio 16:9 \
+  -o library-4k.png
+
+# Multi-reference edit (pass --input multiple times)
+egaki image "blend style from first image and color palette from second" \
+  --input style-reference.jpg \
+  --input palette-reference.jpg \
+  -m nano-banana-pro-preview \
+  -o hybrid-style.png
+
+# JSON mode for automation/pipelines
+egaki image "futuristic sneaker concept" \
+  -m gpt-image-1.5 \
+  --json \
+  -o sneaker.png
+
+# Batch generation with indexed output names
+egaki image "mascot variations, flat vector look" \
+  -m gpt-image-1-mini \
+  -n 6 \
+  -o mascot.png
+# writes mascot-0.png ... mascot-5.png
+```
+
+## Model input examples
+
+Use `egaki models --json` to see the full list. These are practical examples of
+which flags pair well with common models:
+
+| Model ID | Best for | Example command |
+| --- | --- | --- |
+| `imagen-4.0-ultra-generate-001` | High-quality prompt-to-image with seed + ratio | `egaki image "luxury perfume ad on marble" -m imagen-4.0-ultra-generate-001 --aspect-ratio 3:4 --seed 7 -o perfume.png` |
+| `gemini-3.1-flash-image-preview` | Fast, cheap text+image edits with wide aspect-ratio support | `egaki image "turn into manga splash page" -m gemini-3.1-flash-image-preview --input portrait.jpg --aspect-ratio 4:1 -o manga-wide.png` |
+| `nano-banana-pro-preview` | Highest-fidelity Google text+image output | `egaki image "fashion editorial, dramatic rim light" -m nano-banana-pro-preview --input model.jpg --image-size 2K -o editorial.png` |
+| `gpt-image-1.5` | OpenAI image generation with strong editing/inpainting support | `egaki image "replace background with neon city" -m gpt-image-1.5 --input product.png --mask bg-mask.png -o product-neon.png` |
+| `black-forest-labs/flux-fill-pro` | Inpainting-focused Flux workflow on Replicate | `egaki image "restore damaged poster corners" -m black-forest-labs/flux-fill-pro --input poster.png --mask corners-mask.png -o restored.png` |
+| `fal-ai/flux/schnell` | Very fast low-cost ideation batches | `egaki image "logo sketch, geometric fox" -m fal-ai/flux/schnell -n 8 -o fox-logo.png` |
+
+## Feature support by model family
+
+Quick rule of thumb for flags:
+
+- **Google Imagen (`imagen-*`)**: supports `--seed`, `--aspect-ratio`, `--input`, `--mask`, `-n`
+- **Google Gemini image models**: supports `--input`, `--aspect-ratio`, `--image-size`; usually no `--seed`
+- **OpenAI image models**: strong editing and inpainting; size controls are model-specific
+- **Flux/Fal/Replicate models**: broad aspect-ratio + seed support; editing/inpainting depends on exact model
+
+### Subscription and usage
+
+egaki supports **both** authentication modes:
+
+- **BYOK (bring your own keys):** add provider keys with `egaki login` per provider.
+- **Egaki subscription:** use one `egaki_...` key to access all supported models without managing keys for each provider.
+
+```bash
+# Subscribe and get a checkout URL
+egaki subscribe --email user@example.com --plan pro
+
+# Save your Egaki key after checkout
+egaki login --provider egaki --key egaki_...
+
+# BYOK example (direct provider key)
+egaki login --provider google --key AIza...
+
+# Check subscription usage / cancel
+egaki usage
+egaki unsubscribe
+```
+
+## Help
+
+```bash
+egaki --help
+egaki image --help
+```
+
+## Auth and billing
+
+- `egaki login` stores provider keys in `~/.config/egaki/credentials.json`.
+- `egaki subscribe`, `egaki usage`, and `egaki unsubscribe` manage Egaki plans.
+
+## License
+
+MIT

package/dist/chatgpt-auth.js

@@ -0,0 +1,294 @@
+// ChatGPT OAuth authentication for egaki.
+// Implements the same OAuth 2.0 PKCE browser flow used by OpenAI Codex CLI.
+// Tokens are stored inside credentials.json under the 'chatgpt' key as a
+// structured object (not a plain string like other providers).
+//
+// The access token is a standard OpenAI bearer token that works with the
+// Image API, so we can inject it as OPENAI_API_KEY for the SDK to pick up.
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { spinner, log, note } from '@clack/prompts';
+import pc from 'picocolors';
+const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
+const ISSUER = 'https://auth.openai.com';
+const OAUTH_PORT = 1455;
+const REDIRECT_URI = `http://localhost:${OAUTH_PORT}/auth/callback`;
+// ─── PKCE helpers ────────────────────────────────────────────────────────────
+function randomString(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
+    const bytes = crypto.getRandomValues(new Uint8Array(length));
+    return Array.from(bytes)
+        .map((b) => chars[b % chars.length])
+        .join('');
+}
+function base64UrlEncode(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const binary = String.fromCharCode(...bytes);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+async function generatePKCE() {
+    const verifier = randomString(43);
+    const hash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier));
+    return { verifier, challenge: base64UrlEncode(hash) };
+}
+function generateState() {
+    return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+}
+// ─── JWT parsing ─────────────────────────────────────────────────────────────
+function parseJwtClaims(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3)
+        return undefined;
+    const payload = parts[1];
+    if (!payload)
+        return undefined;
+    try {
+        return JSON.parse(Buffer.from(payload, 'base64url').toString());
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractEmail(tokens) {
+    const idClaims = tokens.id_token ? parseJwtClaims(tokens.id_token) : undefined;
+    const accessClaims = parseJwtClaims(tokens.access_token);
+    return ((typeof idClaims?.email === 'string' ? idClaims.email : undefined) ??
+        (typeof accessClaims?.email === 'string' ? accessClaims.email : undefined));
+}
+function extractAccountId(tokens) {
+    const idClaims = tokens.id_token ? parseJwtClaims(tokens.id_token) : undefined;
+    const accessClaims = parseJwtClaims(tokens.access_token);
+    const idAuth = idClaims?.['https://api.openai.com/auth'];
+    const accessAuth = accessClaims?.['https://api.openai.com/auth'];
+    return ((typeof idClaims?.chatgpt_account_id === 'string' ? idClaims.chatgpt_account_id : undefined) ??
+        (typeof idAuth?.chatgpt_account_id === 'string' ? idAuth.chatgpt_account_id : undefined) ??
+        (typeof accessClaims?.chatgpt_account_id === 'string'
+            ? accessClaims.chatgpt_account_id
+            : undefined) ??
+        (typeof accessAuth?.chatgpt_account_id === 'string'
+            ? accessAuth.chatgpt_account_id
+            : undefined));
+}
+/** Extract the ChatGPT plan type (e.g. "plus", "pro") from the access token. */
+export function extractPlanType(auth) {
+    const claims = parseJwtClaims(auth.access);
+    const authClaim = claims?.['https://api.openai.com/auth'];
+    return authClaim?.chatgpt_plan_type;
+}
+// ─── OAuth URL + token exchange ──────────────────────────────────────────────
+function buildAuthorizeUrl(pkce, state) {
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: CLIENT_ID,
+        redirect_uri: REDIRECT_URI,
+        scope: 'openid profile email offline_access',
+        code_challenge: pkce.challenge,
+        code_challenge_method: 'S256',
+        id_token_add_organizations: 'true',
+        codex_cli_simplified_flow: 'true',
+        state,
+        originator: 'egaki',
+    });
+    return `${ISSUER}/oauth/authorize?${params.toString()}`;
+}
+async function exchangeCodeForTokens(code, verifier) {
+    const response = await fetch(`${ISSUER}/oauth/token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            grant_type: 'authorization_code',
+            code,
+            redirect_uri: REDIRECT_URI,
+            client_id: CLIENT_ID,
+            code_verifier: verifier,
+        }).toString(),
+    });
+    if (!response.ok) {
+        throw new Error(`Token exchange failed: ${response.status}`);
+    }
+    return (await response.json());
+}
+// ─── local callback server ───────────────────────────────────────────────────
+const HTML_SUCCESS = `<!doctype html>
+<html><body style="font-family:system-ui;text-align:center;padding:4em">
+<h1>Authorization Successful</h1>
+<p>You can close this window and return to the terminal.</p>
+</body></html>`;
+const htmlError = (error) => `<!doctype html><html><body style="font-family:system-ui;text-align:center;padding:4em">
+<h1>Authorization Failed</h1><pre>${error}</pre></body></html>`;
+let oauthServer;
+let pendingOAuth;
+function handleOAuthRequest(req, res) {
+    const url = new URL(req.url ?? '/', `http://localhost:${OAUTH_PORT}`);
+    if (url.pathname !== '/auth/callback') {
+        res.statusCode = 404;
+        res.end('Not found');
+        return;
+    }
+    const code = url.searchParams.get('code');
+    const state = url.searchParams.get('state');
+    const error = url.searchParams.get('error');
+    const errorDescription = url.searchParams.get('error_description');
+    if (error) {
+        const message = errorDescription || error;
+        pendingOAuth?.reject(new Error(message));
+        pendingOAuth = undefined;
+        res.statusCode = 400;
+        res.setHeader('Content-Type', 'text/html');
+        res.end(htmlError(message));
+        return;
+    }
+    if (!code) {
+        const message = 'Missing authorization code';
+        pendingOAuth?.reject(new Error(message));
+        pendingOAuth = undefined;
+        res.statusCode = 400;
+        res.setHeader('Content-Type', 'text/html');
+        res.end(htmlError(message));
+        return;
+    }
+    if (!pendingOAuth || state !== pendingOAuth.state) {
+        const message = 'Invalid state — potential CSRF attack';
+        pendingOAuth?.reject(new Error(message));
+        pendingOAuth = undefined;
+        res.statusCode = 400;
+        res.setHeader('Content-Type', 'text/html');
+        res.end(htmlError(message));
+        return;
+    }
+    const current = pendingOAuth;
+    pendingOAuth = undefined;
+    exchangeCodeForTokens(code, current.verifier)
+        .then((tokens) => current.resolve(tokens))
+        .catch((err) => current.reject(err instanceof Error ? err : new Error(String(err))));
+    res.statusCode = 200;
+    res.setHeader('Content-Type', 'text/html');
+    res.end(HTML_SUCCESS);
+}
+async function startOAuthServer() {
+    if (oauthServer)
+        return;
+    oauthServer = createServer(handleOAuthRequest);
+    await new Promise((resolve, reject) => {
+        oauthServer?.once('error', reject);
+        oauthServer?.listen(OAUTH_PORT, '127.0.0.1', () => resolve());
+    });
+}
+async function stopOAuthServer() {
+    if (!oauthServer)
+        return;
+    await new Promise((resolve) => oauthServer?.close(() => resolve()));
+    oauthServer = undefined;
+}
+function waitForOAuthCallback(verifier, state) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            if (pendingOAuth) {
+                pendingOAuth = undefined;
+                reject(new Error('OAuth callback timeout — authorization took too long'));
+            }
+        }, 5 * 60 * 1000);
+        pendingOAuth = {
+            verifier,
+            state,
+            resolve: (tokens) => {
+                clearTimeout(timeout);
+                resolve(tokens);
+            },
+            reject: (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            },
+        };
+    });
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    const child = spawn(cmd, [url], { detached: true, stdio: 'ignore' });
+    child.unref();
+}
+// ─── public API ──────────────────────────────────────────────────────────────
+/**
+ * Run the full ChatGPT OAuth browser flow with clack UI.
+ * Returns the ChatGptAuth object to be stored in credentials.json.
+ */
+export async function chatGptOAuthLogin() {
+    await startOAuthServer();
+    const pkce = await generatePKCE();
+    const state = generateState();
+    const authUrl = buildAuthorizeUrl(pkce, state);
+    const callbackPromise = waitForOAuthCallback(pkce.verifier, state);
+    note(`Open this URL in your browser to sign in with your ChatGPT account:\n\n` +
+        `  ${pc.cyan(pc.underline(authUrl))}\n\n` +
+        `${pc.dim(`Listening for callback on ${REDIRECT_URI}`)}`, 'ChatGPT OAuth');
+    openBrowser(authUrl);
+    const s = spinner();
+    s.start('Waiting for authorization in browser...');
+    let tokens;
+    try {
+        tokens = await callbackPromise;
+    }
+    finally {
+        await stopOAuthServer();
+    }
+    s.stop('Authorization received');
+    const now = Date.now();
+    const auth = {
+        email: extractEmail(tokens),
+        accountId: extractAccountId(tokens),
+        refresh: tokens.refresh_token,
+        access: tokens.access_token,
+        expires: now + (tokens.expires_in ?? 3600) * 1000,
+    };
+    const plan = extractPlanType(auth);
+    const label = auth.email ?? auth.accountId ?? 'unknown';
+    log.success(`Signed in as ${pc.bold(label)}` + (plan ? ` (${pc.cyan(plan)} plan)` : ''));
+    return auth;
+}
+/**
+ * Refresh an expired ChatGPT access token using the refresh token.
+ * Returns the updated auth object, or an Error if refresh fails.
+ */
+export async function refreshChatGptToken(auth) {
+    try {
+        const response = await fetch(`${ISSUER}/oauth/token`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: auth.refresh,
+                client_id: CLIENT_ID,
+            }).toString(),
+        });
+        if (!response.ok) {
+            return new Error(`Token refresh failed: ${response.status}`);
+        }
+        const json = (await response.json());
+        return {
+            ...auth,
+            access: json.access_token,
+            refresh: json.refresh_token ?? auth.refresh,
+            expires: Date.now() + (json.expires_in ?? 3600) * 1000,
+        };
+    }
+    catch (err) {
+        return err instanceof Error ? err : new Error(String(err));
+    }
+}
+/**
+ * Get a valid access token from a ChatGptAuth object.
+ * Auto-refreshes if expired. Returns the token string or an Error.
+ * If the auth was refreshed, the `onRefresh` callback is called with
+ * the updated auth so the caller can persist it.
+ */
+export async function getValidAccessToken(auth, onRefresh) {
+    // Token still valid (with 60s buffer)
+    if (auth.expires > Date.now() + 60_000) {
+        return auth.access;
+    }
+    const refreshed = await refreshChatGptToken(auth);
+    if (refreshed instanceof Error)
+        return refreshed;
+    onRefresh?.(refreshed);
+    return refreshed.access;
+}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}