egaki 0.0.1 → 0.0.2

package/dist/cli.js

@@ -0,0 +1,471 @@
+#!/usr/bin/env node
+// Main CLI entrypoint for egaki - AI image and video generation.
+// Uses the Vercel AI SDK for image generation across multiple providers.
+// Designed to be called by agents and humans alike.
+//
+// Two generation paths depending on model:
+//   - imagen-* models → generateImage() with google.image()
+//   - all other models → generateText() with responseModalities: ['IMAGE']
+// The CLI auto-detects which path to use based on model ID prefix.
+import { goke } from 'goke';
+import { z } from 'zod';
+import dedent from 'string-dedent';
+import { generateImage as aiGenerateImage, generateText } from 'ai';
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import pkg from '../package.json' with { type: 'json' };
+import { injectCredentialsToEnv, PROVIDERS } from './credentials.js';
+import { IMAGE_MODELS, DEFAULT_MODEL, getModelConfig, createImageModel, createTextModel, } from './models.js';
+import { loginInteractive, loginNonInteractive, showLoginStatus, removeLogin, readKeyFromStdin, } from './login.js';
+import { subscribeInteractive, subscribeNonInteractive, unsubscribe, showUsage, } from './subscription.js';
+const cli = goke('egaki');
+process.title = 'egaki';
+// Print clean error output for unhandled rejections (e.g. AI SDK APICallError).
+// The AI SDK errors include request bodies, response headers, and other noisy
+// properties that get dumped by Node's default handler. We strip those and just
+// print the message + stack trace.
+process.on('uncaughtException', (err) => {
+    console.error(pc.red(err.message));
+    if (err.stack) {
+        const lines = err.stack.split('\n');
+        const stackOnly = lines.filter((l) => l.trimStart().startsWith('at '));
+        if (stackOnly.length > 0) {
+            console.error(pc.dim(stackOnly.join('\n')));
+        }
+    }
+    process.exit(1);
+});
+// ─── login command ───────────────────────────────────────────────────────────
+cli
+    .command('login', dedent `
+      Configure API keys for image generation providers.
+      Interactive mode: shows a provider picker and secure key input.
+      Non-interactive mode: pass --provider and --key flags, or pipe key via stdin.
+      Keys are saved to ~/.config/egaki/credentials.json (mode 0600).
+    `)
+    .option('-p, --provider [name]', z
+    .string()
+    .describe(`Provider name for non-interactive login (${Object.keys(PROVIDERS).join(', ')})`))
+    .option('-k, --key [key]', z.string().describe('API key value for non-interactive login'))
+    .option('--show', 'Show which providers are configured and their status')
+    .option('--remove [provider]', z.string().describe('Remove the stored key for a provider'))
+    .example('# Interactive login (pick provider, paste key)')
+    .example('egaki login')
+    .example('# Non-interactive login with flags')
+    .example('egaki login --provider google --key AIza...')
+    .example('# Pipe key from stdin (useful in CI/scripts)')
+    .example('echo "AIza..." | egaki login --provider google')
+    .example('# Show configured providers')
+    .example('egaki login --show')
+    .example('# Remove a stored key')
+    .example('egaki login --remove google')
+    .action(async (options) => {
+    if (options.show) {
+        showLoginStatus();
+        return;
+    }
+    if (options.remove) {
+        removeLogin(options.remove);
+        return;
+    }
+    // Non-interactive: --provider + --key or stdin
+    if (options.provider) {
+        const key = options.key || (await readKeyFromStdin());
+        loginNonInteractive({ provider: options.provider, key });
+        return;
+    }
+    // Interactive mode
+    await loginInteractive();
+});
+// ─── subscribe command ───────────────────────────────────────────────────────
+cli
+    .command('subscribe', dedent `
+      Subscribe to Egaki for access to all image models with a single API key.
+      You can also use your own provider keys (Google/OpenAI/Replicate/Fal)
+      via 'egaki login --provider <name> --key <key>' if you prefer BYOK.
+      Egaki subscription avoids managing one key per provider.
+      Three plans: Starter ($9/mo, 100 credits), Pro ($29/mo, 500 credits),
+      Unlimited ($99/mo, 2000 credits). One credit ≈ one standard image.
+      Interactive mode: pick a plan, enter email, get checkout URL.
+      Non-interactive: pass --email to get the checkout URL directly.
+    `)
+    .option('-e, --email [email]', z.string().describe('Email for the subscription (skips interactive prompt)'))
+    .option('--plan [plan]', z.string().describe('Plan ID: starter, pro, or unlimited (default: pro)'))
+    .example('# Interactive subscribe')
+    .example('egaki subscribe')
+    .example('# Non-interactive (for agents)')
+    .example('egaki subscribe --email user@example.com --plan pro')
+    .action(async (options) => {
+    const isTTY = process.stdout.isTTY && process.stdin.isTTY;
+    if (!isTTY || options.email || options.plan) {
+        subscribeNonInteractive(options.email, options.plan);
+        return;
+    }
+    await subscribeInteractive();
+});
+// ─── unsubscribe command ─────────────────────────────────────────────────────
+cli
+    .command('unsubscribe', dedent `
+      Cancel your Egaki subscription. Uses the stored API key to identify
+      the subscription. You can resubscribe anytime with 'egaki subscribe'.
+    `)
+    .example('egaki unsubscribe')
+    .action(async () => {
+    await unsubscribe();
+});
+// ─── usage command ───────────────────────────────────────────────────────────
+cli
+    .command('usage', dedent `
+      Show your current Egaki credit usage for this billing period.
+      Displays plan, credits used, credits remaining, and period info.
+    `)
+    .example('egaki usage')
+    .action(async () => {
+    await showUsage();
+});
+// ─── image command ───────────────────────────────────────────────────────────
+cli
+    .command('image <prompt>', dedent `
+      Generate images from a text prompt using AI models.
+      Supports Imagen models (dedicated image generation) and Gemini
+      multimodal models (text+image output). The model type is auto-detected
+      from the model ID: imagen-* uses the image API, everything else uses
+      the text API with image output enabled.
+    `)
+    .option('-m, --model [model]', z.enum(IMAGE_MODELS).default(DEFAULT_MODEL).describe('Model ID for generation'))
+    .option('-o, --output [path]', z
+    .string()
+    .default('egaki-output.png')
+    .describe('Output file path (index suffix added when generating multiple)'))
+    .option('-n, --count [n]', z.number().default(1).describe('Number of images to generate'))
+    .option('--aspect-ratio [ratio]', z
+    .string()
+    .describe('Aspect ratio for the generated image. Imagen supports: 1:1, 3:4, 4:3, 9:16, 16:9. Gemini supports additional ratios: 2:3, 3:2, 4:5, 5:4, 21:9'))
+    .option('--seed [seed]', z.number().describe('Seed for reproducible generation. Same seed + same prompt = same image'))
+    .option('--image-size [size]', z
+    .enum(['1K', '2K', '4K'])
+    .describe('Output resolution for Gemini text-model image generation. Only applies to gemini-*-image* models'))
+    .option('-i, --input [file]', z
+    .array(z.string())
+    .describe('Reference image for editing or variations (repeatable). Accepts local file paths or URLs (http/https). Pass one or more images along with a text prompt to edit them'))
+    .option('--mask [file]', z
+    .string()
+    .describe('Mask image for inpainting. Accepts a local file path or URL (http/https). White areas in the mask are replaced with generated content. Used together with --input'))
+    .option('--allow-people', 'Allow generating images of people (Imagen blocks people by default)')
+    .option('--json', 'Output result metadata as JSON to stdout (model, usage, warnings, file paths)')
+    .option('--stdout', 'Write raw image bytes to stdout instead of saving to a file. Useful for piping to other tools')
+    .example('# Generate a simple image')
+    .example('egaki image "a sunset over mars"')
+    .example('# Use a specific model with aspect ratio')
+    .example('egaki image "cyberpunk city at night" -m imagen-4.0-ultra-generate-001 --aspect-ratio 16:9')
+    .example('# Edit an existing image')
+    .example('egaki image "add a wizard hat to the cat" --input cat.jpg -o cat-wizard.png')
+    .example('# Edit an image from a URL')
+    .example('egaki image "make it pop art" --input https://example.com/photo.jpg')
+    .example('# Inpainting with a mask')
+    .example('egaki image "fill with flowers" --input photo.jpg --mask mask.png')
+    .example('# Generate with Gemini multimodal at 4K')
+    .example('egaki image "dreamy landscape" -m gemini-2.5-flash-image --image-size 4K')
+    .example('# Generate multiple images')
+    .example('egaki image "abstract art" -n 4 -o art.png')
+    .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
+    injectCredentialsToEnv();
+    const model = options.model;
+    const outputPath = options.output;
+    const config = getModelConfig(model);
+    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);
+    const maskImage = options.mask
+        ? await readInputSource(options.mask)
+        : undefined;
+    if (config.strategy === 'image') {
+        await generateWithImageModel({
+            prompt,
+            model,
+            outputPath,
+            count: options.count,
+            aspectRatio: options.aspectRatio,
+            seed: options.seed,
+            inputImages,
+            maskImage,
+            allowPeople: options.allowPeople || false,
+            json: options.json || false,
+            stdout: options.stdout || false,
+        });
+    }
+    else {
+        await generateWithTextModel({
+            prompt,
+            model,
+            outputPath,
+            inputImages,
+            imageSize: options.imageSize,
+            aspectRatio: options.aspectRatio,
+            json: options.json || false,
+            stdout: options.stdout || false,
+        });
+    }
+});
+// ─── models command ──────────────────────────────────────────────────────────
+cli
+    .command('models', dedent `
+      List all supported image generation models with pricing, features,
+      and provider info. Output is YAML for easy reading and piping.
+    `)
+    .option('-p, --provider [provider]', z.string().describe('Filter models by provider name (e.g. google, openai, replicate, fal)'))
+    .option('--json', 'Output as JSON instead of YAML')
+    .action(async (options) => {
+    const { CATALOG } = await import('./model-catalog.js');
+    const yaml = await import('js-yaml');
+    let models = CATALOG;
+    if (options.provider) {
+        models = models.filter((m) => m.provider === options.provider);
+        if (models.length === 0) {
+            console.error(pc.red(`No models found for provider: ${options.provider}`));
+            process.exit(1);
+        }
+    }
+    const output = models.map((m) => ({
+        id: m.id,
+        name: m.name,
+        ...(m.description ? { description: m.description } : {}),
+        provider: m.provider,
+        strategy: m.strategy,
+        released: m.released,
+        cost: m.cost.type === 'per-image'
+            ? `$${m.cost.perImage}/image`
+            : `$${m.cost.inputPerM}/M input, $${m.cost.outputPerM}/M output`,
+        features: {
+            editing: m.features.editing,
+            inpainting: m.features.inpainting,
+            seed: m.features.seed,
+            multipleImages: m.features.multipleImages,
+            aspectRatios: m.features.aspectRatios.join(', ') || 'none',
+            ...(m.features.sizes ? { sizes: m.features.sizes.join(', ') } : {}),
+        },
+    }));
+    if (options.json) {
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        console.log(yaml.dump(output, { lineWidth: 120, noRefs: true }));
+    }
+});
+cli.help();
+cli.version(pkg.version);
+cli.parse();
+function isUrl(input) {
+    return /^https?:\/\//i.test(input);
+}
+async function readInputSource(input) {
+    if (isUrl(input)) {
+        console.error(pc.dim(`Fetching ${input}...`));
+        const res = await fetch(input);
+        if (!res.ok) {
+            console.error(pc.red(`Failed to fetch ${input}: ${res.status} ${res.statusText}`));
+            process.exit(1);
+        }
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    const resolved = path.resolve(input);
+    if (!fs.existsSync(resolved)) {
+        console.error(pc.red(`File not found: ${resolved}`));
+        process.exit(1);
+    }
+    return new Uint8Array(fs.readFileSync(resolved));
+}
+async function readInputImages(inputs) {
+    if (!inputs || inputs.length === 0) {
+        return [];
+    }
+    return Promise.all(inputs.map((f) => readInputSource(f)));
+}
+// Generate using the dedicated generateImage API (Imagen models)
+async function generateWithImageModel({ prompt, model, outputPath, count, aspectRatio, seed, inputImages, maskImage, allowPeople, json, stdout, }) {
+    // Build the prompt: plain string or multimodal with reference images
+    const imagePrompt = inputImages.length > 0
+        ? { text: prompt, images: inputImages, ...(maskImage ? { mask: maskImage } : {}) }
+        : prompt;
+    const imageModel = await createImageModel(model);
+    if (!stdout) {
+        console.error(pc.cyan('Generating...'));
+    }
+    const result = await aiGenerateImage({
+        model: imageModel,
+        prompt: imagePrompt,
+        n: count,
+        ...(aspectRatio ? { aspectRatio } : {}),
+        ...(seed !== undefined ? { seed } : {}),
+        providerOptions: {
+            google: {
+                ...(allowPeople ? { personGeneration: 'allow_all' } : {}),
+                ...(aspectRatio ? { aspectRatio } : {}),
+            },
+        },
+    });
+    if (stdout) {
+        // Write first image to stdout for piping
+        const image = result.images[0];
+        if (image) {
+            process.stdout.write(Buffer.from(image.uint8Array));
+        }
+        return;
+    }
+    const savedFiles = [];
+    for (let i = 0; i < result.images.length; i++) {
+        const image = result.images[i];
+        const ext = extensionFromMediaType(image.mediaType);
+        const filePath = result.images.length === 1
+            ? ensureExtension(outputPath, ext)
+            : insertIndex(outputPath, i, ext);
+        fs.writeFileSync(filePath, image.uint8Array);
+        console.error(pc.green(`Saved: ${filePath}`));
+        savedFiles.push(filePath);
+    }
+    const config = getModelConfig(model);
+    const cost = calculateCost(config.cost, result.usage, result.images.length);
+    if (cost != null) {
+        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
+    }
+    if (json) {
+        const output = {
+            model,
+            files: savedFiles,
+            count: result.images.length,
+            cost,
+            usage: result.usage,
+            warnings: result.warnings,
+        };
+        console.log(JSON.stringify(output, null, 2));
+    }
+}
+// Generate using generateText with responseModalities (Gemini multimodal models)
+async function generateWithTextModel({ prompt, model, outputPath, inputImages, imageSize, aspectRatio, json, stdout, }) {
+    const textModel = await createTextModel(model);
+    if (!stdout) {
+        console.error(pc.cyan('Generating...'));
+    }
+    // Build messages: if we have input images, create a multimodal prompt
+    const messages = inputImages.length > 0
+        ? [
+            {
+                role: 'user',
+                content: [
+                    { type: 'text', text: prompt },
+                    ...inputImages.map((img) => ({
+                        type: 'image',
+                        image: img,
+                    })),
+                ],
+            },
+        ]
+        : undefined;
+    const result = await generateText({
+        model: textModel,
+        ...(messages ? { messages } : { prompt }),
+        providerOptions: {
+            google: {
+                responseModalities: ['TEXT', 'IMAGE'],
+                ...(imageSize || aspectRatio
+                    ? {
+                        imageConfig: {
+                            ...(imageSize ? { imageSize } : {}),
+                            ...(aspectRatio ? { aspectRatio } : {}),
+                        },
+                    }
+                    : {}),
+            },
+        },
+    });
+    const imageFiles = result.files.filter((f) => {
+        return f.mediaType.startsWith('image/');
+    });
+    if (imageFiles.length === 0) {
+        console.error(pc.red('No images generated.'));
+        process.exit(1);
+    }
+    if (stdout) {
+        const file = imageFiles[0];
+        if (file) {
+            process.stdout.write(Buffer.from(file.uint8Array));
+        }
+        return;
+    }
+    const savedFiles = [];
+    for (let i = 0; i < imageFiles.length; i++) {
+        const file = imageFiles[i];
+        const ext = extensionFromMediaType(file.mediaType);
+        const filePath = imageFiles.length === 1
+            ? ensureExtension(outputPath, ext)
+            : insertIndex(outputPath, i, ext);
+        fs.writeFileSync(filePath, file.uint8Array);
+        console.error(pc.green(`Saved: ${filePath}`));
+        savedFiles.push(filePath);
+    }
+    const config = getModelConfig(model);
+    const cost = calculateCost(config.cost, result.usage, imageFiles.length);
+    if (cost != null) {
+        console.error(pc.dim(`Cost: ${formatCost(cost)}`));
+    }
+    if (result.text && !json) {
+        console.error(pc.dim(result.text));
+    }
+    if (json) {
+        const output = {
+            model,
+            files: savedFiles,
+            count: imageFiles.length,
+            text: result.text || null,
+            cost,
+            usage: result.usage,
+        };
+        console.log(JSON.stringify(output, null, 2));
+    }
+}
+// ─── cost helpers ────────────────────────────────────────────────────────────
+function calculateCost(cost, usage, imageCount) {
+    if (cost.type === 'per-image') {
+        return cost.perImage * imageCount;
+    }
+    if (cost.type === 'per-token' && usage.inputTokens != null && usage.outputTokens != null) {
+        return ((usage.inputTokens * cost.inputPerM + usage.outputTokens * cost.outputPerM) / 1_000_000);
+    }
+    return null;
+}
+function formatCost(dollars) {
+    if (dollars < 0.01) {
+        return `$${dollars.toFixed(4)}`;
+    }
+    return `$${dollars.toFixed(2)}`;
+}
+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/credentials.d.ts

@@ -0,0 +1,18 @@
+export declare const PROVIDERS: Record<string, {
+    envVar: string;
+    label: string;
+    hint: string;
+}>;
+export declare const EGAKI_GATEWAY_URL = "https://egaki.org/v1/ai";
+export type Credentials = Record<string, string>;
+export declare function readCredentials(): Credentials;
+export declare function writeCredentials(creds: Credentials): void;
+export declare function saveProviderKey(provider: string, key: string): void;
+export declare function removeProviderKey(provider: string): void;
+export declare function getProviderKey(provider: string): string | undefined;
+export declare function injectCredentialsToEnv(): void;
+export declare function getKeyStatus(provider: string): {
+    available: boolean;
+    source: 'env' | 'stored' | 'none';
+};
+//# sourceMappingURL=credentials.d.ts.map

package/dist/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../src/credentials.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,SAAS,EAAE,MAAM,CAC5B,MAAM,EACN;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA2BhD,CAAA;AAED,eAAO,MAAM,iBAAiB,4BAA4B,CAAA;AAa1D,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEhD,wBAAgB,eAAe,IAAI,WAAW,CAO7C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAOzD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAInE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAIxD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGnE;AAKD,wBAAgB,sBAAsB,IAAI,IAAI,CAW7C;AAID,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC9C,SAAS,EAAE,OAAO,CAAA;IAClB,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAA;CAClC,CAaA"}

package/dist/credentials.js

@@ -0,0 +1,107 @@
+// 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 = {
+    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() {
+    // 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() {
+    return path.join(getConfigDir(), 'credentials.json');
+}
+export function readCredentials() {
+    const filePath = getCredentialsPath();
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+}
+export function writeCredentials(creds) {
+    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, key) {
+    const creds = readCredentials();
+    creds[provider] = key;
+    writeCredentials(creds);
+}
+export function removeProviderKey(provider) {
+    const creds = readCredentials();
+    delete creds[provider];
+    writeCredentials(creds);
+}
+export function getProviderKey(provider) {
+    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() {
+    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) {
+    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/dist/login.d.ts

@@ -0,0 +1,9 @@
+export declare function loginInteractive(): Promise<void>;
+export declare function loginNonInteractive({ provider, key, }: {
+    provider: string;
+    key: string;
+}): void;
+export declare function showLoginStatus(): void;
+export declare function removeLogin(provider: string): void;
+export declare function readKeyFromStdin(): Promise<string>;
+//# sourceMappingURL=login.d.ts.map

package/dist/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../src/login.ts"],"names":[],"mappings":"AAsBA,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CAqEtD;AAED,wBAAgB,mBAAmB,CAAC,EAClC,QAAQ,EACR,GAAG,GACJ,EAAE;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;CACZ,GAAG,IAAI,CAiBP;AAED,wBAAgB,eAAe,IAAI,IAAI,CAqBtC;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAYlD;AAGD,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAMxD"}