@wavespeed/cli 0.1.0

package/dist/commands/models.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchModels } from '../lib/api.js';
+function priceLabel(p) {
+    if (p === undefined)
+        return '';
+    if (p === 0)
+        return chalk.green(' free ');
+    return chalk.gray(`$${p.toFixed(p < 0.1 ? 3 : 2)}`);
+}
+function filterModels(models, query, type) {
+    const q = query?.toLowerCase().trim();
+    return models.filter((m) => {
+        if (type && m.type !== type)
+            return false;
+        if (!q)
+            return true;
+        return (m.model_id.toLowerCase().includes(q) ||
+            (m.name?.toLowerCase().includes(q) ?? false) ||
+            (m.description?.toLowerCase().includes(q) ?? false));
+    });
+}
+function shortDescription(m, max = 100) {
+    if (!m.description)
+        return '';
+    const single = m.description.replace(/\s+/g, ' ').trim();
+    return single.length > max ? single.slice(0, max - 1) + '…' : single;
+}
+export function registerModels(program) {
+    program
+        .command('models')
+        .description('Browse every Wavespeed model live from api.wavespeed.ai (cached for 1h)')
+        .argument('[query]', 'Search query (matches id, name, description)')
+        .option('-t, --type <name>', 'Filter by type (text-to-image, image-to-video, …)')
+        .option('-c, --category <name>', 'Alias for --type')
+        .option('--popular', 'Show only the top-sorted models (sort_order <= 10000)')
+        .option('--refresh', 'Force a live fetch and refresh the cache')
+        .option('--no-cache', 'Skip the cache for this call (do not read or write)')
+        .option('--json', 'Emit the raw model list as JSON')
+        .action(async (query, opts) => {
+        const type = opts.type ?? opts.category;
+        const spinner = !opts.json
+            ? ora('Fetching models from api.wavespeed.ai…').start()
+            : null;
+        let payload;
+        try {
+            payload = await fetchModels({ refresh: opts.refresh, noCache: !opts.cache });
+        }
+        catch (err) {
+            spinner?.fail(err.message ?? String(err));
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ error: err.message ?? String(err) }, null, 2) + '\n');
+            }
+            process.exit(1);
+        }
+        spinner?.stop();
+        let results = filterModels(payload.models, query, type);
+        if (opts.popular) {
+            results = results
+                .filter((m) => (m.sort_order ?? 99999) <= 10000)
+                .sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
+        }
+        else {
+            results.sort((a, b) => (a.sort_order ?? 0) - (b.sort_order ?? 0));
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+            return;
+        }
+        const total = payload.models.length;
+        const shown = results.length;
+        console.log();
+        console.log(chalk.bold(`${shown.toLocaleString()} model${shown === 1 ? '' : 's'}`) +
+            chalk.gray(` of ${total.toLocaleString()} live on Wavespeed`) +
+            chalk.gray(payload.source === 'cache' ? '  ·  cached' : '  ·  fresh'));
+        console.log();
+        const byType = new Map();
+        for (const m of results) {
+            const t = m.type || 'other';
+            if (!byType.has(t))
+                byType.set(t, []);
+            byType.get(t).push(m);
+        }
+        for (const [t, models] of byType) {
+            console.log(chalk.hex('#7c5cff').bold(t) + chalk.gray(`  ${models.length}`));
+            for (const m of models) {
+                const id = chalk.cyan(m.model_id.padEnd(52));
+                const price = priceLabel(m.base_price);
+                console.log(`  ${id} ${price}`);
+                const d = shortDescription(m);
+                if (d)
+                    console.log(`    ${chalk.gray(d)}`);
+            }
+            console.log();
+        }
+        console.log(chalk.gray('Run any model with: ') +
+            chalk.cyan('wavespeed run <id> --input prompt="…"'));
+        console.log(chalk.gray('Refresh the cache:  ') + chalk.cyan('wavespeed models --refresh'));
+        console.log();
+    });
+}

package/dist/commands/run.js

@@ -0,0 +1,143 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'node:path';
+import fs from 'node:fs';
+import { requireClient } from '../lib/client.js';
+import { parseInputs } from '../lib/inputs.js';
+import { downloadOutputs, printOutputs } from '../lib/output.js';
+import { emitJson, emitJsonError, isJsonMode, log, setJsonMode } from '../lib/log.js';
+import { downloadOptsFromFlag } from '../lib/download-flag.js';
+import { resolveModelToken } from '../lib/config.js';
+function extractUrls(output) {
+    if (!output)
+        return [];
+    if (Array.isArray(output.outputs)) {
+        return output.outputs.filter((u) => typeof u === 'string');
+    }
+    if (typeof output.url === 'string')
+        return [output.url];
+    return [];
+}
+function failMissingModel() {
+    const msg = 'No model specified. Pass a model ID as the first argument, ' +
+        'set `defaultModel` in wavespeed.json, or `wavespeed config --default-model <id>`.';
+    if (isJsonMode())
+        emitJsonError(msg);
+    else {
+        console.error(chalk.red('Error: ') + msg);
+        console.error(chalk.gray('Browse models: ') + chalk.cyan('wavespeed models'));
+    }
+    process.exit(1);
+}
+function failUnknownAlias(token) {
+    const msg = `"${token}" is neither a model ID (no \`/\`) nor a known alias.`;
+    if (isJsonMode())
+        emitJsonError(msg);
+    else {
+        console.error(chalk.red('Error: ') + msg);
+        console.error(chalk.gray('  See aliases: ') + chalk.cyan('wavespeed aliases'));
+        console.error(chalk.gray('  Browse models: ') + chalk.cyan('wavespeed models'));
+    }
+    process.exit(1);
+}
+export function registerRun(program) {
+    program
+        .command('run')
+        .description('Run any Wavespeed model — generic invoke with --input key=value pairs')
+        .argument('[model]', 'Model ID, alias name, or omit to use defaultModel.')
+        .option('-i, --input <pair...>', 'Inputs as key=value (repeatable). Use dotted keys for nested.', [])
+        .option('-p, --prompt <text>', 'Shorthand for --input prompt=<text>')
+        .option('--input-file <path>', 'JSON file with full input object')
+        .option('--download [path]', 'Save outputs locally (optional path template, e.g. "./out/{index}.{ext}")')
+        .option('--sync', 'Use synchronous mode (single request, no polling)')
+        .option('--json', 'Emit a single JSON object on stdout (progress goes to stderr)')
+        .option('--output-dir <dir>', 'Directory for --download when no path is given')
+        .action(async (modelArg, opts) => {
+        setJsonMode(!!opts.json);
+        // Resolve positional → underlying model + any default input from an alias.
+        const resolved = resolveModelToken(modelArg);
+        if (!resolved) {
+            if (modelArg)
+                failUnknownAlias(modelArg);
+            failMissingModel();
+        }
+        const model = resolved.model;
+        const aliasDefaults = resolved.defaultInput ?? {};
+        const aliasName = resolved.alias;
+        const client = requireClient();
+        // Merge order: alias defaults < --input-file < --input k=v < -p prompt
+        let input = { ...aliasDefaults };
+        if (opts.inputFile) {
+            Object.assign(input, JSON.parse(fs.readFileSync(path.resolve(opts.inputFile), 'utf8')));
+        }
+        Object.assign(input, parseInputs(opts.input ?? []));
+        if (opts.prompt)
+            input.prompt = opts.prompt;
+        log('');
+        log(chalk.bold('▶ ') +
+            chalk.cyan(model) +
+            (aliasName ? chalk.gray(`  (alias: ${aliasName})`) : ''));
+        if (input.prompt)
+            log(chalk.gray('  prompt: ') + chalk.white(String(input.prompt)));
+        const spinner = ora({ text: 'Submitting…', color: 'magenta' });
+        if (!isJsonMode())
+            spinner.start();
+        const startedAt = Date.now();
+        let result;
+        try {
+            const iv = setInterval(() => {
+                const s = Math.floor((Date.now() - startedAt) / 1000);
+                spinner.text = `Generating… ${s}s`;
+            }, 200);
+            try {
+                result = await client.run(model, input, { enableSyncMode: !!opts.sync });
+            }
+            finally {
+                clearInterval(iv);
+            }
+            spinner.succeed(`Done in ${Math.floor((Date.now() - startedAt) / 1000)}s.`);
+        }
+        catch (err) {
+            spinner.fail(err.message ?? String(err));
+            if (isJsonMode())
+                emitJsonError(err.message ?? String(err));
+            process.exit(1);
+        }
+        const urls = extractUrls(result);
+        let saved = [];
+        const dlOpts = downloadOptsFromFlag(opts.download, {
+            model,
+            prompt: typeof input.prompt === 'string' ? input.prompt : undefined,
+            outputDir: opts.outputDir,
+        });
+        if (urls.length > 0 && dlOpts) {
+            const dlSpinner = ora('Downloading outputs…');
+            if (!isJsonMode())
+                dlSpinner.start();
+            try {
+                saved = await downloadOutputs(urls, dlOpts);
+                dlSpinner.succeed(`Saved ${saved.length} file${saved.length > 1 ? 's' : ''}.`);
+            }
+            catch (err) {
+                dlSpinner.fail(err.message ?? String(err));
+            }
+        }
+        if (isJsonMode()) {
+            emitJson({
+                model,
+                prompt: typeof input.prompt === 'string' ? input.prompt : undefined,
+                outputs: urls,
+                saved,
+                elapsed_ms: Date.now() - startedAt,
+                raw: result,
+            });
+            return;
+        }
+        if (urls.length === 0) {
+            log(chalk.yellow('No output URLs in response. Full payload:'));
+            log(JSON.stringify(result, null, 2));
+            return;
+        }
+        printOutputs(saved, urls);
+    });
+}

package/dist/commands/schema.js

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchModels } from '../lib/api.js';
+function getRequestSchema(model) {
+    return model.api_schema?.api_schemas?.[0]?.request_schema;
+}
+function orderedProps(schema) {
+    const all = Object.keys(schema.properties ?? {});
+    const order = schema['x-order-properties'];
+    if (!order)
+        return all;
+    const seen = new Set();
+    const out = [];
+    for (const k of order)
+        if (k in (schema.properties ?? {}) && !seen.has(k)) {
+            out.push(k);
+            seen.add(k);
+        }
+    for (const k of all)
+        if (!seen.has(k))
+            out.push(k);
+    return out;
+}
+function typeLabel(prop) {
+    if (Array.isArray(prop.type))
+        return prop.type.join('|');
+    if (prop.type === 'array' && prop.items?.type)
+        return `${prop.items.type}[]`;
+    return prop.type ?? 'any';
+}
+function wrap(text, indent, width = 88) {
+    const words = text.replace(/\s+/g, ' ').trim().split(' ');
+    const lines = [];
+    let cur = '';
+    for (const w of words) {
+        if ((cur + ' ' + w).length > width - indent.length) {
+            if (cur)
+                lines.push(cur);
+            cur = w;
+        }
+        else {
+            cur = cur ? cur + ' ' + w : w;
+        }
+    }
+    if (cur)
+        lines.push(cur);
+    return lines.map((l) => indent + chalk.gray(l)).join('\n');
+}
+function exampleValue(name, prop) {
+    if (prop.default !== undefined)
+        return JSON.stringify(prop.default);
+    if (prop.enum && prop.enum.length)
+        return JSON.stringify(prop.enum[0]);
+    const t = Array.isArray(prop.type) ? prop.type[0] : prop.type;
+    if (t === 'integer' || t === 'number')
+        return String(prop.minimum ?? 1);
+    if (t === 'boolean')
+        return 'true';
+    if (t === 'array')
+        return '"<url>"';
+    if (name.toLowerCase().includes('prompt'))
+        return '"…"';
+    if (name.toLowerCase().includes('image') || name.toLowerCase().includes('url'))
+        return '"<url>"';
+    return '"…"';
+}
+export function registerSchema(program) {
+    program
+        .command('schema')
+        .description('Show the input schema for a model — what params it accepts and which are required')
+        .argument('<model>', 'Model ID (e.g. google/nano-banana-2/edit). Run `wavespeed models` to find them.')
+        .option('--json', 'Emit the raw JSON schema on stdout')
+        .option('--refresh', 'Force a live fetch (bypass the 1h cache)')
+        .action(async (modelId, opts) => {
+        const spinner = !opts.json ? ora('Loading catalog…').start() : null;
+        let models;
+        try {
+            ({ models } = await fetchModels({ refresh: opts.refresh }));
+        }
+        catch (err) {
+            spinner?.fail(err.message ?? String(err));
+            if (opts.json) {
+                process.stdout.write(JSON.stringify({ error: err.message ?? String(err) }, null, 2) + '\n');
+            }
+            process.exit(1);
+        }
+        spinner?.stop();
+        const model = models.find((m) => m.model_id === modelId);
+        if (!model) {
+            const msg = `Unknown model "${modelId}". Run \`wavespeed models "${modelId.split('/').pop()}"\` to search.`;
+            if (opts.json)
+                process.stdout.write(JSON.stringify({ error: msg }, null, 2) + '\n');
+            else
+                console.error(chalk.red(msg));
+            process.exit(1);
+        }
+        const schema = getRequestSchema(model);
+        if (!schema) {
+            const msg = `Model "${modelId}" has no published input schema.`;
+            if (opts.json)
+                process.stdout.write(JSON.stringify({ error: msg }, null, 2) + '\n');
+            else
+                console.error(chalk.yellow(msg));
+            process.exit(1);
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(schema, null, 2) + '\n');
+            return;
+        }
+        const requiredSet = new Set(schema.required ?? []);
+        const props = schema.properties ?? {};
+        const order = orderedProps(schema);
+        console.log();
+        console.log(chalk.bold('▶ ') + chalk.cyan(model.model_id));
+        console.log(chalk.gray('  type:  ') +
+            chalk.white(model.type ?? 'unknown') +
+            (model.base_price !== undefined ? chalk.gray('   base price: ') + chalk.green(`$${model.base_price}`) : ''));
+        if (model.description) {
+            console.log(wrap(model.description, '  '));
+        }
+        console.log();
+        console.log(chalk.bold(`Inputs  ${chalk.gray(`(${order.length} field${order.length === 1 ? '' : 's'}, ${requiredSet.size} required)`)}`));
+        console.log();
+        const nameWidth = Math.max(...order.map((n) => n.length), 8);
+        for (const name of order) {
+            const p = props[name];
+            const flag = requiredSet.has(name) ? chalk.red('*') : ' ';
+            const t = chalk.magenta(typeLabel(p).padEnd(10));
+            console.log(`  ${flag} ${chalk.cyan(name.padEnd(nameWidth))}  ${t}`);
+            if (p.description)
+                console.log(wrap(p.description, '    '.padEnd(nameWidth + 6)));
+            const tail = [];
+            if (p.default !== undefined)
+                tail.push(`default: ${JSON.stringify(p.default)}`);
+            if (p.enum)
+                tail.push(`enum: ${p.enum.map((v) => String(v)).join(' | ')}`);
+            if (p.minimum !== undefined || p.maximum !== undefined)
+                tail.push(`range: ${p.minimum ?? '−∞'}..${p.maximum ?? '∞'}`);
+            if (p.minItems !== undefined || p.maxItems !== undefined)
+                tail.push(`items: ${p.minItems ?? 0}..${p.maxItems ?? '∞'}`);
+            if (tail.length)
+                console.log(' '.repeat(nameWidth + 6) + chalk.gray(tail.join('  ·  ')));
+        }
+        // Build a copy-paste run example using required fields (and prompt if present).
+        const seedFields = [...requiredSet];
+        if (!requiredSet.has('prompt') && 'prompt' in props)
+            seedFields.push('prompt');
+        const seedParts = seedFields.map((n) => `-i ${n}=${exampleValue(n, props[n])}`);
+        console.log();
+        console.log(chalk.bold('Try it:'));
+        console.log('  ' +
+            chalk.cyan(`wavespeed run ${model.model_id}` + (seedParts.length ? ' ' + seedParts.join(' ') : '')));
+        console.log();
+    });
+}

package/dist/commands/skill.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+function skillSourcePath() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // dist/commands/skill.js -> ../../skills/SKILL.md
+    return path.resolve(here, '..', '..', 'skills', 'SKILL.md');
+}
+export function writeSkill(cwd = process.cwd()) {
+    const dest = path.join(cwd, '.claude', 'skills', 'wavespeed', 'SKILL.md');
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.copyFileSync(skillSourcePath(), dest);
+    return dest;
+}
+export function registerSkill(program) {
+    const skill = program
+        .command('skill')
+        .description('Install a Wavespeed skill for Claude Code, Cursor, Codex, and other coding agents');
+    skill
+        .command('install', { isDefault: true })
+        .description('Drop a SKILL.md into .claude/skills/wavespeed/ so Claude Code, Cursor, and Codex know how to call the CLI')
+        .option('--print', 'Print the skill body to stdout instead of writing a file')
+        .action((opts) => {
+        if (opts.print) {
+            process.stdout.write(fs.readFileSync(skillSourcePath(), 'utf8'));
+            return;
+        }
+        const dest = writeSkill();
+        console.log();
+        console.log(chalk.green('Installed skill: ') + chalk.cyan(path.relative(process.cwd(), dest)));
+        console.log();
+        console.log(chalk.bold('You\'re set.'));
+        console.log(chalk.gray('  Claude Code, Cursor, and other agents auto-discover .claude/skills/*.'));
+        console.log(chalk.gray('  Agents will call the CLI directly — no MCP server, no extra config.'));
+        console.log();
+        console.log(chalk.gray('  Quick check: ask the agent to run ') + chalk.cyan('wavespeed models') + chalk.gray('.'));
+        console.log();
+    });
+}

package/dist/commands/upload.js

@@ -0,0 +1,51 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'node:fs';
+import { requireClient } from '../lib/client.js';
+export function registerUpload(program) {
+    program
+        .command('upload')
+        .description('Upload one or more local files to Wavespeed and print their CDN URLs')
+        .argument('<file...>', 'Path(s) to file(s)')
+        .option('--json', 'Emit a JSON object on stdout')
+        .action(async (files, opts) => {
+        for (const f of files) {
+            if (!fs.existsSync(f)) {
+                const msg = `File not found: ${f}`;
+                if (opts.json)
+                    process.stdout.write(JSON.stringify({ error: msg }, null, 2) + '\n');
+                else
+                    console.error(chalk.red(msg));
+                process.exit(1);
+            }
+        }
+        const client = requireClient();
+        const urls = [];
+        const errors = [];
+        for (const file of files) {
+            const spinner = !opts.json ? ora(`Uploading ${file}…`).start() : null;
+            try {
+                const url = await client.upload(file);
+                urls.push(url);
+                spinner?.succeed(`${file} → ${url}`);
+            }
+            catch (err) {
+                const message = err.message ?? String(err);
+                errors.push({ file, error: message });
+                spinner?.fail(`${file}: ${message}`);
+            }
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(files.length === 1 && urls.length === 1 && errors.length === 0
+                ? { url: urls[0] }
+                : { urls, errors }, null, 2) + '\n');
+        }
+        else if (!opts.json && files.length === 1 && urls.length === 1) {
+            console.log();
+            console.log(chalk.cyan(urls[0]));
+            console.log();
+        }
+        if (errors.length > 0)
+            process.exit(1);
+    });
+}

package/dist/lib/api.js

@@ -0,0 +1,67 @@
+// Thin direct-API helpers for endpoints not exposed by the `wavespeed` SDK.
+// The SDK only covers run() + upload(). For the catalog and balance we hit the
+// REST API directly.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getApiKey, getBaseUrl } from './config.js';
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+function cachePath() {
+    return path.join(os.homedir(), '.cache', 'wavespeed', 'models.json');
+}
+function readCache(baseUrl) {
+    try {
+        const raw = fs.readFileSync(cachePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.base_url !== baseUrl)
+            return null;
+        if (Date.now() - parsed.fetched_at > CACHE_TTL_MS)
+            return null;
+        return parsed.models;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(baseUrl, models) {
+    try {
+        fs.mkdirSync(path.dirname(cachePath()), { recursive: true });
+        const body = { fetched_at: Date.now(), base_url: baseUrl, models };
+        fs.writeFileSync(cachePath(), JSON.stringify(body));
+    }
+    catch {
+        /* best-effort cache; ignore failures */
+    }
+}
+export async function fetchModels(opts = {}) {
+    const baseUrl = getBaseUrl();
+    if (!opts.noCache && !opts.refresh) {
+        const cached = readCache(baseUrl);
+        if (cached)
+            return { models: cached, source: 'cache' };
+    }
+    const apiKey = getApiKey();
+    if (!apiKey)
+        throw new Error('No API key configured. Run `wavespeed login`.');
+    const res = await fetch(`${baseUrl}/api/v3/models`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) {
+        throw new Error(`GET /api/v3/models failed: ${res.status} ${res.statusText}`);
+    }
+    const json = (await res.json());
+    if (json.code !== 200) {
+        throw new Error(json.message || `API returned code ${json.code}`);
+    }
+    if (!opts.noCache)
+        writeCache(baseUrl, json.data);
+    return { models: json.data, source: 'live' };
+}
+export function clearModelsCache() {
+    try {
+        fs.unlinkSync(cachePath());
+    }
+    catch {
+        /* nothing to clear */
+    }
+}

package/dist/lib/banner.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+const LOGO = `
+  ██╗    ██╗ █████╗ ██╗   ██╗███████╗███████╗██████╗ ███████╗███████╗██████╗
+  ██║    ██║██╔══██╗██║   ██║██╔════╝██╔════╝██╔══██╗██╔════╝██╔════╝██╔══██╗
+  ██║ █╗ ██║███████║██║   ██║█████╗  ███████╗██████╔╝█████╗  █████╗  ██║  ██║
+  ██║███╗██║██╔══██║╚██╗ ██╔╝██╔══╝  ╚════██║██╔═══╝ ██╔══╝  ██╔══╝  ██║  ██║
+  ╚███╔███╔╝██║  ██║ ╚████╔╝ ███████╗███████║██║     ███████╗███████╗██████╔╝
+   ╚══╝╚══╝ ╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝╚═╝     ╚══════╝╚══════╝╚═════╝
+`;
+export function printBanner() {
+    process.stdout.write(chalk.hex('#7c5cff')(LOGO));
+    process.stdout.write(chalk.gray('  Every WaveSpeed model — image, video, audio, 3D — from your terminal.\n\n'));
+}

package/dist/lib/client.js

@@ -0,0 +1,19 @@
+import { Client } from 'wavespeed';
+import chalk from 'chalk';
+import { getApiKey, getBaseUrl } from './config.js';
+export function requireClient() {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.error(chalk.red('\nNo API key configured.'));
+        console.error(chalk.gray('Run ') + chalk.cyan('wavespeed login') + chalk.gray(' to get started.'));
+        console.error(chalk.gray('Or set ') + chalk.cyan('WAVESPEED_API_KEY') + chalk.gray(' in your environment.\n'));
+        process.exit(1);
+    }
+    return new Client(apiKey, { baseUrl: getBaseUrl() });
+}
+export function maybeClient() {
+    const apiKey = getApiKey();
+    if (!apiKey)
+        return null;
+    return new Client(apiKey, { baseUrl: getBaseUrl() });
+}

package/dist/lib/config.js

@@ -0,0 +1,86 @@
+import Conf from 'conf';
+import path from 'node:path';
+import fs from 'node:fs';
+export const DEFAULTS = {
+    baseUrl: 'https://api.wavespeed.ai',
+    outputDir: 'wavespeed-output',
+};
+export const userConfig = new Conf({
+    projectName: 'wavespeed',
+    defaults: {},
+});
+export const PROJECT_FILE = 'wavespeed.json';
+export function loadProjectConfig(cwd = process.cwd()) {
+    let dir = cwd;
+    while (true) {
+        const candidate = path.join(dir, PROJECT_FILE);
+        if (fs.existsSync(candidate)) {
+            try {
+                return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+            }
+            catch {
+                return null;
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export function getApiKey() {
+    return process.env.WAVESPEED_API_KEY || userConfig.get('apiKey');
+}
+export function getBaseUrl() {
+    return userConfig.get('baseUrl') || DEFAULTS.baseUrl;
+}
+export function resolveOutputDir() {
+    const project = loadProjectConfig();
+    return project?.outputDir || userConfig.get('outputDir') || DEFAULTS.outputDir;
+}
+export function resolveDefaultModel() {
+    const project = loadProjectConfig();
+    return project?.defaultModel || userConfig.get('defaultModel');
+}
+/**
+ * All defined aliases, project taking precedence over user-level.
+ */
+export function loadAliases() {
+    const userAliases = userConfig.get('aliases') ?? {};
+    const projectAliases = loadProjectConfig()?.aliases ?? {};
+    return { ...userAliases, ...projectAliases };
+}
+export function findAlias(name) {
+    return loadAliases()[name];
+}
+/**
+ * Resolve a positional that may be a model_id, an alias, or undefined.
+ * Returns the underlying model_id and any default input the alias supplied.
+ *
+ * Rules:
+ *  - tokens containing `/` are always treated as model_ids (never alias-resolved)
+ *  - otherwise check aliases
+ *  - if neither: try defaultModel, which itself may be an alias name
+ */
+export function resolveModelToken(token) {
+    const tryResolve = (value, source) => {
+        if (value.includes('/'))
+            return { model: value, source };
+        const alias = findAlias(value);
+        if (alias)
+            return { model: alias.model, defaultInput: alias.input, source: 'alias', alias: value };
+        return null;
+    };
+    if (token) {
+        const direct = tryResolve(token, 'positional');
+        if (direct)
+            return direct;
+        // Unknown bare name — not a model_id, not an alias. Surface this to the caller
+        // so it can show a helpful error instead of silently picking the default.
+        return null;
+    }
+    const def = resolveDefaultModel();
+    if (!def)
+        return null;
+    return tryResolve(def, 'default');
+}