egaki 0.0.1 → 0.1.0

package/dist/antigravity-image.js

@@ -0,0 +1,285 @@
+// Antigravity image generation bridge for egaki.
+// Handles direct Antigravity OAuth requests without provider fallback.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import pc from 'picocolors';
+import { getAntigravityAuth, saveAntigravityAuth } from './credentials.js';
+import { getValidAntigravityAccessToken } from './antigravity-auth.js';
+export async function generateWithAntigravityModel({ prompt, model, outputPath, inputImages, aspectRatio, count, json, stdout, }) {
+    const auth = getAntigravityAuth();
+    if (!auth) {
+        console.error(pc.red('Missing Antigravity OAuth login. Run: egaki login --provider antigravity'));
+        process.exit(1);
+    }
+    const token = await getValidAntigravityAccessToken(auth, (updated) => {
+        saveAntigravityAuth(updated);
+    });
+    if (token instanceof Error) {
+        console.error(pc.red(token.message));
+        process.exit(1);
+    }
+    if (!stdout) {
+        console.error(pc.cyan('Generating...'));
+    }
+    const actualModel = resolveAntigravityModel(model);
+    const projectCandidates = [
+        process.env['ANTIGRAVITY_PROJECT_ID'],
+        token.projectId,
+        ...getGcloudProjectIds(),
+    ].filter((value, index, array) => {
+        return Boolean(value) && array.indexOf(value) === index;
+    });
+    const userParts = [{ text: prompt }];
+    for (const image of inputImages) {
+        userParts.push({
+            inlineData: {
+                mimeType: detectImageMimeType(image),
+                data: Buffer.from(image).toString('base64'),
+            },
+        });
+    }
+    const baseRequest = {
+        sessionId: `egaki-${crypto.randomUUID()}`,
+        systemInstruction: {
+            role: 'user',
+            parts: [{ text: 'You are an AI image generator. Generate images based on user descriptions.' }],
+        },
+        contents: [
+            {
+                role: 'user',
+                parts: userParts,
+            },
+        ],
+        generationConfig: {
+            candidateCount: count,
+            imageConfig: {
+                aspectRatio: aspectRatio || '1:1',
+            },
+        },
+        safetySettings: [
+            { category: 'HARM_CATEGORY_HARASSMENT', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT', threshold: 'BLOCK_ONLY_HIGH' },
+            { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_ONLY_HIGH' },
+        ],
+    };
+    const antigravityAttempts = projectCandidates.map((projectId) => {
+        return {
+            mode: `antigravity:${projectId}`,
+            endpoints: [
+                'https://daily-cloudcode-pa.sandbox.googleapis.com',
+                'https://autopush-cloudcode-pa.sandbox.googleapis.com',
+                'https://cloudcode-pa.googleapis.com',
+            ],
+            payload: {
+                project: projectId,
+                model: actualModel,
+                requestType: 'agent',
+                userAgent: 'antigravity',
+                requestId: `agent-${crypto.randomUUID()}`,
+                request: baseRequest,
+            },
+        };
+    });
+    const attemptConfigs = antigravityAttempts;
+    let lastError = 'Unknown Antigravity API error';
+    let responseBody;
+    let successfulProjectId;
+    for (const attempt of attemptConfigs) {
+        for (const endpoint of attempt.endpoints) {
+            const response = await fetch(`${endpoint}/v1internal:generateContent`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${token.accessToken}`,
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'google-api-nodejs-client/9.15.1',
+                    'X-Goog-Api-Client': 'gl-node/22.17.0',
+                    'Client-Metadata': 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI',
+                },
+                body: JSON.stringify(attempt.payload),
+            });
+            const text = await response.text();
+            if (!response.ok) {
+                lastError = formatAntigravityError({
+                    mode: attempt.mode,
+                    status: response.status,
+                    bodyText: text,
+                });
+                continue;
+            }
+            responseBody = JSON.parse(text);
+            if (typeof attempt.payload.project === 'string' && attempt.payload.project.length > 0) {
+                successfulProjectId = attempt.payload.project;
+            }
+            break;
+        }
+        if (responseBody) {
+            break;
+        }
+    }
+    if (!responseBody) {
+        console.error(pc.red(lastError));
+        process.exit(1);
+    }
+    if (successfulProjectId && successfulProjectId !== auth.projectId) {
+        saveAntigravityAuth({ ...auth, projectId: successfulProjectId });
+    }
+    const generatedImages = extractAntigravityImages(responseBody);
+    if (generatedImages.length === 0) {
+        console.error(pc.red('No images generated by Antigravity response'));
+        process.exit(1);
+    }
+    if (stdout) {
+        process.stdout.write(generatedImages[0].bytes);
+        return;
+    }
+    const savedFiles = [];
+    for (let i = 0; i < generatedImages.length; i++) {
+        const generated = generatedImages[i];
+        const filePath = generatedImages.length === 1
+            ? ensureExtension(outputPath, extensionFromMediaType(generated.mediaType))
+            : insertIndex(outputPath, i, extensionFromMediaType(generated.mediaType));
+        fs.writeFileSync(filePath, generated.bytes);
+        console.error(pc.green(`Saved: ${filePath}`));
+        savedFiles.push(filePath);
+    }
+    if (json) {
+        console.log(JSON.stringify({
+            model,
+            files: savedFiles,
+            count: savedFiles.length,
+            provider: 'antigravity',
+            projectId: token.projectId,
+        }, null, 2));
+    }
+}
+function resolveAntigravityModel(modelId) {
+    if (modelId.startsWith('antigravity-')) {
+        return modelId.slice('antigravity-'.length);
+    }
+    return modelId;
+}
+function getGcloudProjectIds() {
+    try {
+        const output = execFileSync('gcloud', ['projects', 'list', '--format=value(projectId)', '--limit=50'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function detectImageMimeType(bytes) {
+    if (bytes.length > 3 &&
+        bytes[0] === 0x89 &&
+        bytes[1] === 0x50 &&
+        bytes[2] === 0x4e &&
+        bytes[3] === 0x47) {
+        return 'image/png';
+    }
+    if (bytes.length > 2 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        return 'image/jpeg';
+    }
+    if (bytes.length > 12 &&
+        bytes[0] === 0x52 &&
+        bytes[1] === 0x49 &&
+        bytes[2] === 0x46 &&
+        bytes[3] === 0x46 &&
+        bytes[8] === 0x57 &&
+        bytes[9] === 0x45 &&
+        bytes[10] === 0x42 &&
+        bytes[11] === 0x50) {
+        return 'image/webp';
+    }
+    return 'image/png';
+}
+function extractAntigravityImages(payload) {
+    const root = payload && typeof payload === 'object' && 'response' in payload
+        ? payload.response
+        : payload;
+    if (!root || typeof root !== 'object') {
+        return [];
+    }
+    const candidates = root.candidates;
+    if (!candidates || candidates.length === 0) {
+        return [];
+    }
+    const images = [];
+    for (const candidate of candidates) {
+        for (const part of candidate.content?.parts || []) {
+            const data = part.inlineData?.data;
+            if (!data)
+                continue;
+            const mediaType = part.inlineData?.mimeType || 'image/png';
+            images.push({
+                bytes: new Uint8Array(Buffer.from(data, 'base64')),
+                mediaType,
+            });
+        }
+    }
+    return images;
+}
+function formatAntigravityError({ mode, status, bodyText, }) {
+    const payload = parseAntigravityErrorPayload(bodyText);
+    const message = payload?.error?.message || bodyText;
+    const metadata = payload?.error?.details?.find((detail) => detail.metadata)?.metadata;
+    const links = payload?.error?.details
+        ?.flatMap((detail) => detail.links || [])
+        .filter((link) => Boolean(link?.url));
+    const verificationUrl = metadata?.['validation_url']
+        || links?.find((link) => /verify/i.test(link.description || ''))?.url;
+    if (verificationUrl) {
+        return [
+            `${mode} API error ${status}: account verification required`,
+            `Verify your Google account here: ${verificationUrl}`,
+            `Backend message: ${message}`,
+        ].join('\n');
+    }
+    const activationUrl = metadata?.['activationUrl']
+        || metadata?.['activation_url']
+        || links?.find((link) => /activation|console|api/i.test(link.description || ''))?.url;
+    if (activationUrl) {
+        return [
+            `${mode} API error ${status}: API access not configured`,
+            `Enable required API here: ${activationUrl}`,
+            `Backend message: ${message}`,
+        ].join('\n');
+    }
+    return `${mode} API error ${status}: ${message}`;
+}
+function parseAntigravityErrorPayload(bodyText) {
+    try {
+        return JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+}
+function extensionFromMediaType(mediaType) {
+    const map = {
+        'image/png': '.png',
+        'image/jpeg': '.jpg',
+        'image/webp': '.webp',
+        'image/gif': '.gif',
+    };
+    return map[mediaType] || '.png';
+}
+function ensureExtension(filePath, ext) {
+    const parsed = path.parse(filePath);
+    if (parsed.ext) {
+        return filePath;
+    }
+    return filePath + ext;
+}
+function insertIndex(filePath, index, ext) {
+    const parsed = path.parse(filePath);
+    const finalExt = parsed.ext || ext;
+    return path.join(parsed.dir, `${parsed.name}-${index}${finalExt}`);
+}

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":""}