@wavespeed/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WaveSpeedAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,158 @@
+<div align="center">
+  <a href="https://wavespeed.ai" target="_blank">
+    <img src="https://raw.githubusercontent.com/WaveSpeedAI/waverless/main/docs/images/wavespeed-dark-logo.png" alt="WaveSpeedAI Logo" width="200"/>
+  </a>
+
+  <h1>WaveSpeed CLI</h1>
+  <p><strong>One command, every WaveSpeed model. Image, video, audio, 3D — from your terminal.</strong></p>
+  <p>
+    <a href="https://wavespeed.ai">🌐 wavespeed.ai</a> •
+    <a href="https://wavespeed.ai/models">📚 Models</a> •
+    <a href="https://wavespeed.ai/docs">📖 Docs</a> •
+    <a href="https://github.com/WaveSpeedAI/cli/issues">🐛 Issues</a>
+  </p>
+  <p>
+    <a href="https://www.npmjs.com/package/@wavespeed/cli"><img alt="npm" src="https://img.shields.io/npm/v/@wavespeed/cli?style=flat-square&color=7c5cff"></a>
+    <a href="LICENSE"><img alt="license" src="https://img.shields.io/badge/license-MIT-7c5cff?style=flat-square"></a>
+    <img alt="node" src="https://img.shields.io/badge/node-%E2%89%A518-7c5cff?style=flat-square">
+  </p>
+</div>
+
+---
+
+## Features
+
+- 🚀 **Every WaveSpeed model** — image, video, audio, 3D; the full live catalog, not a curated subset
+- 🧬 **Dynamic per-model help** — `wavespeed run <id> -h` introspects the real input schema
+- 🔗 **Aliases** — named shortcuts in `wavespeed.json` that bundle a model + default inputs
+- 🤖 **Agent-native** — pipe-safe `--json`, drops a `SKILL.md` for Claude Code / Cursor / Codex
+- ✨ **Zero-friction auth** — browser-launching, clipboard-aware login with live key validation
+
+## Install
+
+```bash
+# npm
+npm install -g @wavespeed/cli
+
+# or curl
+curl -fsSL https://wavespeed.ai/install | bash
+
+# sign in (opens the access-key page, paste to confirm)
+wavespeed login
+```
+
+## Quick start
+
+```bash
+# 1. Browse the catalog
+wavespeed models                              # browse the full live catalog, grouped by type
+wavespeed models "nano banana"                # search
+wavespeed models --type text-to-video         # filter by modality
+
+# 2. Inspect a model's inputs (dynamic — fetched live)
+wavespeed run google/nano-banana-2/text-to-image -h
+
+# 3. Run it (URLs print to stdout; no files unless you ask)
+wavespeed run google/nano-banana-2/text-to-image \
+  -p "a cyberpunk skyline at golden hour" \
+  -i aspect_ratio="16:9" -i resolution="2k"
+
+# Save outputs locally
+wavespeed run ... -p "..." --download                       # → ./wavespeed-output/
+wavespeed run ... -p "..." --download "./hero.png"          # exact path
+wavespeed run ... -p "..." --download "./out/{index}.{ext}" # templated for batches
+
+# Pipe-safe JSON
+wavespeed run ... -p "..." --json | jq '.outputs[0]'
+```
+
+## Project config (`wavespeed.json`)
+
+`wavespeed init` writes one. Drop it into git so the whole team shares the same defaults.
+
+```jsonc
+{
+  "defaultModel": "google/nano-banana-2/text-to-image",
+  "outputDir": "wavespeed-output",
+  "aliases": {
+    "hero":   { "model": "google/nano-banana-2/text-to-image",
+                "input": { "aspect_ratio": "16:9", "resolution": "2k" } },
+    "social": { "model": "google/nano-banana-2/text-to-image",
+                "input": { "aspect_ratio": "1:1",  "resolution": "1k" } },
+    "vid":    { "model": "bytedance/seedance-2.0/text-to-video",
+                "input": { "resolution": "720p", "duration": 5 } }
+  }
+}
+```
+
+- **`defaultModel`** — `wavespeed run -p "…"` (no model arg) uses this. Can itself be an alias name.
+- **`aliases`** — your own shortcuts. `wavespeed run hero -p "…"` expands to model + input. CLI `-i k=v` flags override. `wavespeed run hero -h` shows the resolved schema. List them with `wavespeed aliases`.
+
+Resolution: positional with `/` is a model ID; otherwise looked up as an alias. Merge order on inputs: `alias.input` → `--input-file` → `-i k=v` → `-p`. **The CLI never mutates the user's prompt or inputs** — what you pass is what hits the API.
+
+## Recommended starting models
+
+| Use case | Model |
+|---|---|
+| Text → image | `google/nano-banana-2/text-to-image` |
+| Image edit | `google/nano-banana-2/edit` |
+| Text → video | `bytedance/seedance-2.0/text-to-video` |
+| Image → video | `bytedance/seedance-2.0/image-to-video` |
+
+Browse alternatives with `wavespeed models <query>`.
+
+## Use from coding agents
+
+No MCP server, no daemon. The CLI **is** the interface — agents already know how to run shell commands.
+
+```bash
+wavespeed skill install        # writes .claude/skills/wavespeed/SKILL.md
+```
+
+The skill teaches the agent the three-step pattern: `models` to find, `run <id> -h` to discover params, `run <id> -p "…" --json` to execute. Every command supports `--json` for clean piping.
+
+## Commands
+
+```
+wavespeed login                          Browser + paste-key wizard (clipboard-aware)
+wavespeed logout                         Clear stored API key
+wavespeed status                         Show masked key, base URL, paths
+wavespeed config [--default-model …]     View / update CLI defaults
+
+wavespeed run [model|alias] -p "…"       Run any model or alias (uses defaultModel if omitted)
+wavespeed run <model|alias> -h           Dynamic schema-based help (alias-aware)
+wavespeed schema <model>                 Pretty-print a model's input schema
+wavespeed models [query]                 Browse the live catalog (cached 1h)
+wavespeed aliases                        List aliases from wavespeed.json + user config
+
+wavespeed upload <file...>               Upload local file(s) → CDN URLs
+wavespeed download <url...>              Save URLs to disk
+
+wavespeed init                           Create a wavespeed.json with defaults + alias stubs
+wavespeed skill install                  Drop SKILL.md for coding agents
+```
+
+## Auth
+
+| | Use when |
+|---|---|
+| `wavespeed login` | Persistent, one machine, one user. Stored in `~/.config/wavespeed-nodejs/config.json`. |
+| `WAVESPEED_API_KEY=… wavespeed run …` | CI, scripts, one-off shells. Env var wins over stored config. |
+
+Get a key at [wavespeed.ai/accesskey](https://wavespeed.ai/accesskey).
+
+## Development
+
+```bash
+git clone https://github.com/WaveSpeedAI/cli.git
+cd cli
+npm install
+npm run dev -- run google/nano-banana-2/text-to-image -p "a serene mountain lake"
+npm run build && npm link
+```
+
+Stack: TypeScript, Commander, Inquirer, Chalk, Ora, the official `wavespeed` SDK.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { printBanner } from './lib/banner.js';
+import { registerAuth } from './commands/auth.js';
+import { registerRun } from './commands/run.js';
+import { registerUpload } from './commands/upload.js';
+import { registerDownload } from './commands/download.js';
+import { registerModels } from './commands/models.js';
+import { registerSchema } from './commands/schema.js';
+import { registerAliases } from './commands/aliases.js';
+import { registerInit } from './commands/init.js';
+import { registerSkill } from './commands/skill.js';
+import { detectRunHelp, printDynamicRunHelp } from './lib/dynamic-help.js';
+// Read version from package.json at runtime so a bump in package.json is
+// reflected automatically (no second place to keep in sync).
+const VERSION = (() => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // dist/cli.js → ../package.json (one level up because files: ["dist", ...])
+    const pkgPath = path.resolve(here, '..', 'package.json');
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
+})();
+const program = new Command();
+program
+    .name('wavespeed')
+    .description('WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.')
+    .version(VERSION, '-v, --version', 'Print the CLI version')
+    .addHelpText('beforeAll', chalk.hex('#7c5cff').bold('\n  wavespeed  ') + chalk.gray(`v${VERSION}  ·  every WaveSpeed model  ·  open source\n`))
+    .addHelpText('after', `
+${chalk.bold('Quick start:')}
+  ${chalk.cyan('$ wavespeed login')}
+  ${chalk.cyan('$ wavespeed models                                                # browse the catalog')}
+  ${chalk.cyan('$ wavespeed run google/nano-banana-2/text-to-image -h             # see the model\'s flags')}
+  ${chalk.cyan('$ wavespeed run google/nano-banana-2/text-to-image -p "a cyberpunk skyline"')}
+  ${chalk.cyan('$ wavespeed run bytedance/seedance-2.0/text-to-video -p "drone shot over snowy peaks"')}
+
+${chalk.bold('Use from any coding agent (Claude Code, Cursor, Codex):')}
+  ${chalk.cyan('$ wavespeed skill install')}   ${chalk.gray('# drops a SKILL.md so the agent knows how to call wavespeed')}
+  ${chalk.gray('# agents just shell out: `wavespeed run <id> --json` — no MCP setup.')}
+
+${chalk.gray('Docs:')} ${chalk.cyan('https://wavespeed.ai/docs')}    ${chalk.gray('Models:')} ${chalk.cyan('https://wavespeed.ai/models')}
+`);
+registerAuth(program);
+registerRun(program);
+registerUpload(program);
+registerDownload(program);
+registerModels(program);
+registerSchema(program);
+registerAliases(program);
+registerInit(program);
+registerSkill(program);
+program
+    .command('hello', { hidden: true })
+    .description('Print the WaveSpeed banner')
+    .action(() => printBanner());
+// Show banner + help when run with no args
+if (process.argv.length <= 2) {
+    printBanner();
+    program.outputHelp();
+    process.exit(0);
+}
+async function main() {
+    // Intercept `wavespeed run <model> --help` so we can introspect the model's
+    // schema and print model-specific flags instead of Commander's static help.
+    const dynamicModel = detectRunHelp(process.argv);
+    if (dynamicModel) {
+        await printDynamicRunHelp(dynamicModel);
+        // If schema lookup failed, fall through to Commander's static help.
+    }
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    console.error(chalk.red('Error: ') + (err.message ?? String(err)));
+    process.exit(1);
+});

package/dist/commands/aliases.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { loadAliases, loadProjectConfig, PROJECT_FILE, userConfig } from '../lib/config.js';
+export function registerAliases(program) {
+    program
+        .command('aliases')
+        .description('List model aliases defined in wavespeed.json + user config')
+        .option('--json', 'Emit the alias map as JSON')
+        .action((opts) => {
+        const aliases = loadAliases();
+        const project = loadProjectConfig();
+        const userMap = userConfig.get('aliases') ?? {};
+        const projectMap = project?.aliases ?? {};
+        if (opts.json) {
+            process.stdout.write(JSON.stringify(aliases, null, 2) + '\n');
+            return;
+        }
+        const names = Object.keys(aliases);
+        if (names.length === 0) {
+            console.log();
+            console.log(chalk.gray('No aliases defined yet.'));
+            console.log();
+            console.log(chalk.bold('Add one to ' + chalk.cyan(PROJECT_FILE) + ':'));
+            console.log(chalk.gray(JSON.stringify({
+                aliases: {
+                    hero: {
+                        model: 'google/nano-banana-2/text-to-image',
+                        input: { aspect_ratio: '16:9', resolution: '2k' },
+                    },
+                },
+            }, null, 2)));
+            console.log();
+            return;
+        }
+        console.log();
+        console.log(chalk.bold(`${names.length} alias${names.length === 1 ? '' : 'es'}`));
+        console.log();
+        const width = Math.max(...names.map((n) => n.length));
+        for (const name of names) {
+            const a = aliases[name];
+            const origin = name in projectMap ? chalk.gray('  · project') : name in userMap ? chalk.gray('  · user') : '';
+            console.log('  ' + chalk.cyan(name.padEnd(width)) + '  ' + chalk.white(a.model) + origin);
+            if (a.description)
+                console.log('  ' + ' '.repeat(width) + '  ' + chalk.gray(a.description));
+            if (a.input && Object.keys(a.input).length > 0) {
+                console.log('  ' + ' '.repeat(width) + '  ' + chalk.gray(JSON.stringify(a.input)));
+            }
+        }
+        console.log();
+        console.log(chalk.gray('Use: ') + chalk.cyan('wavespeed run <alias> -p "…"'));
+        console.log(chalk.gray('Inspect: ') + chalk.cyan('wavespeed run <alias> -h'));
+        console.log();
+    });
+}

package/dist/commands/auth.js

@@ -0,0 +1,175 @@
+import { password, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import open from 'open';
+import ora from 'ora';
+import clipboard from 'clipboardy';
+import { userConfig, getBaseUrl, getApiKey, loadProjectConfig, PROJECT_FILE } from '../lib/config.js';
+const KEY_URL = 'https://wavespeed.ai/accesskey';
+function mask(key) {
+    if (key.length < 12)
+        return '••••';
+    return key.slice(0, 5) + '…' + key.slice(-4);
+}
+function looksLikeKey(s) {
+    if (!s)
+        return false;
+    const t = s.trim();
+    // WaveSpeed access keys are long hex strings (~64 chars). Be liberal:
+    // any 40+ char single-line token of [a-zA-Z0-9_-] counts.
+    return /^[A-Za-z0-9_-]{40,}$/.test(t);
+}
+async function readClipboardKey() {
+    try {
+        const value = await clipboard.read();
+        if (looksLikeKey(value))
+            return value.trim();
+    }
+    catch {
+        /* no clipboard access — that's fine */
+    }
+    return null;
+}
+async function validateKey(apiKey, baseUrl) {
+    // The platform doesn't expose a dedicated /whoami yet, so we ping a known
+    // authenticated endpoint and treat anything that isn't 401/403 as "key works".
+    let res = null;
+    try {
+        res = await fetch(`${baseUrl}/api/v3/balance`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+    }
+    catch (err) {
+        return { ok: false, reason: `Could not reach ${baseUrl}: ${err.message}` };
+    }
+    if (res.status === 401 || res.status === 403) {
+        return { ok: false, status: res.status, reason: 'API rejected the key (401/403).' };
+    }
+    return { ok: true, status: res.status };
+}
+async function loginFlow(opts) {
+    console.log();
+    console.log(chalk.hex('#7c5cff').bold('  Welcome to WaveSpeed.'));
+    console.log(chalk.gray('  Sign in once and you\'re set on this machine.\n'));
+    let apiKey = opts.apiKey?.trim();
+    if (!apiKey && opts.browser) {
+        console.log(chalk.bold('  1.') + ' Opening ' + chalk.cyan(KEY_URL) + chalk.gray(' (sign in if needed)'));
+        try {
+            await open(KEY_URL);
+        }
+        catch {
+            console.log(chalk.gray('     (browser launch failed — open the link manually)'));
+        }
+        console.log(chalk.bold('  2.') + ' Click ' + chalk.bold('Create key') + chalk.gray(' and copy it'));
+        console.log(chalk.bold('  3.') + ' Paste below — we\'ll detect & validate it for you');
+        console.log();
+    }
+    // Try clipboard first — major UX win.
+    let detected = null;
+    if (!apiKey) {
+        detected = await readClipboardKey();
+    }
+    if (!apiKey && detected) {
+        const useIt = await confirm({
+            message: `Detected a key on your clipboard (${mask(detected)}). Use it?`,
+            default: true,
+        });
+        if (useIt)
+            apiKey = detected;
+    }
+    if (!apiKey) {
+        apiKey = await password({
+            message: 'Paste your API key:',
+            mask: '*',
+            validate: (v) => (v.trim().length > 8 ? true : 'API key looks too short.'),
+        });
+        apiKey = apiKey.trim();
+    }
+    const spinner = ora({ text: 'Validating with api.wavespeed.ai…', color: 'magenta' }).start();
+    const result = await validateKey(apiKey, getBaseUrl());
+    if (!result.ok) {
+        spinner.fail(result.reason ?? 'The key did not authenticate.');
+        console.log();
+        console.log(chalk.gray('  Double-check at ') + chalk.cyan(KEY_URL));
+        console.log(chalk.gray('  Or set ') + chalk.cyan('WAVESPEED_API_KEY') + chalk.gray(' in your shell and skip login altogether.'));
+        console.log();
+        process.exit(1);
+    }
+    spinner.succeed('Signed in.');
+    userConfig.set('apiKey', apiKey);
+    console.log();
+    console.log('  ' + chalk.gray('Key:    ') + chalk.green(mask(apiKey)));
+    console.log('  ' + chalk.gray('Stored: ') + chalk.cyan(userConfig.path));
+    console.log();
+    console.log(chalk.bold('Try it:'));
+    console.log('  ' + chalk.cyan('wavespeed models                       # browse the catalog'));
+    console.log('  ' + chalk.cyan('wavespeed run google/nano-banana-2/text-to-image -p "a cyberpunk skyline at golden hour"'));
+    console.log('  ' + chalk.cyan('wavespeed run bytedance/seedance-2.0/text-to-video -p "drone shot over snowy peaks"'));
+    console.log();
+}
+export function registerAuth(program) {
+    program
+        .command('login')
+        .description('Sign in to Wavespeed on this machine (browser + paste-key wizard)')
+        .option('--api-key <key>', 'Pre-fill the API key (skips the prompt)')
+        .option('--no-browser', 'Skip opening the access-key page in a browser')
+        .action(async (opts) => {
+        await loginFlow(opts);
+    });
+    program
+        .command('logout')
+        .description('Clear the stored API key')
+        .action(() => {
+        userConfig.delete('apiKey');
+        console.log(chalk.green('Signed out.'));
+    });
+    program
+        .command('status')
+        .description('Show the active account, base URL, and where the key is stored')
+        .action(() => {
+        const key = getApiKey();
+        const baseUrl = getBaseUrl();
+        console.log();
+        console.log(chalk.bold('WaveSpeed CLI status'));
+        console.log('  ' + chalk.gray('API key:    ') + (key ? chalk.green(mask(key)) : chalk.red('not set — run `wavespeed login`')));
+        console.log('  ' + chalk.gray('Base URL:   ') + chalk.cyan(baseUrl));
+        console.log('  ' + chalk.gray('Config:     ') + chalk.cyan(userConfig.path));
+        console.log('  ' +
+            chalk.gray('Source:     ') +
+            (process.env.WAVESPEED_API_KEY
+                ? chalk.yellow('WAVESPEED_API_KEY env var (overrides stored config)')
+                : chalk.gray('stored config')));
+        const project = loadProjectConfig();
+        if (project) {
+            console.log('  ' + chalk.gray('Project:    ') + chalk.cyan(PROJECT_FILE) + chalk.gray(' detected'));
+        }
+        console.log();
+    });
+    program
+        .command('config')
+        .description('View or change CLI defaults (base URL, default model, output dir)')
+        .option('--base-url <url>', 'Override API base URL')
+        .option('--default-model <id>', 'Default model used by `wavespeed run` when no model is given')
+        .option('--output-dir <dir>', 'Where to save outputs when --download has no path')
+        .option('--reset', 'Reset all CLI config to defaults')
+        .action((opts) => {
+        if (opts.reset) {
+            userConfig.clear();
+            console.log(chalk.green('Config reset.'));
+            return;
+        }
+        if (opts.baseUrl)
+            userConfig.set('baseUrl', opts.baseUrl);
+        if (opts.defaultModel)
+            userConfig.set('defaultModel', opts.defaultModel);
+        if (opts.outputDir)
+            userConfig.set('outputDir', opts.outputDir);
+        const store = userConfig.store;
+        console.log();
+        console.log(chalk.bold('Stored config:'));
+        for (const [k, v] of Object.entries(store)) {
+            const printed = k === 'apiKey' && typeof v === 'string' ? mask(v) : JSON.stringify(v);
+            console.log('  ' + chalk.gray(k.padEnd(22)) + chalk.cyan(printed));
+        }
+        console.log();
+    });
+}

package/dist/commands/download.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'node:fs';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import { resolveOutputDir } from '../lib/config.js';
+import { downloadOutputs } from '../lib/output.js';
+async function downloadOne(url, dest) {
+    const res = await fetch(url);
+    if (!res.ok || !res.body) {
+        throw new Error(`HTTP ${res.status} ${res.statusText} for ${url}`);
+    }
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    await pipeline(Readable.fromWeb(res.body), fs.createWriteStream(dest));
+}
+export function registerDownload(program) {
+    program
+        .command('download')
+        .description('Download one or more remote URLs to your output directory')
+        .argument('<url...>', 'Remote URL(s) to fetch')
+        .option('-o, --output <path>', 'Write to this exact path (only valid with a single URL)')
+        .option('--output-dir <dir>', 'Directory to save into (default: wavespeed-output/)')
+        .option('--json', 'Emit a single JSON object on stdout')
+        .action(async (urls, opts) => {
+        if (opts.output && urls.length > 1) {
+            const msg = '`-o/--output` only works with a single URL. Use `--output-dir` for batches.';
+            if (opts.json)
+                process.stdout.write(JSON.stringify({ error: msg }, null, 2) + '\n');
+            else
+                console.error(chalk.red(msg));
+            process.exit(1);
+        }
+        let saved = [];
+        if (opts.output) {
+            const spinner = !opts.json ? ora(`Downloading ${urls[0]}…`).start() : null;
+            try {
+                const dest = path.resolve(opts.output);
+                await downloadOne(urls[0], dest);
+                saved = [dest];
+                spinner?.succeed(`Saved ${path.relative(process.cwd(), dest)}`);
+            }
+            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);
+            }
+        }
+        else {
+            const dir = opts.outputDir || resolveOutputDir();
+            const spinner = !opts.json ? ora(`Downloading ${urls.length} file${urls.length > 1 ? 's' : ''}…`).start() : null;
+            try {
+                saved = await downloadOutputs(urls, { outputDir: dir });
+                spinner?.succeed(`Saved ${saved.length} file${saved.length > 1 ? 's' : ''}.`);
+            }
+            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);
+            }
+        }
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({ outputs: urls, saved }, null, 2) + '\n');
+            return;
+        }
+        console.log();
+        for (const f of saved)
+            console.log('  ' + chalk.cyan(path.relative(process.cwd(), f)));
+        console.log();
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,63 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import { input, confirm } from '@inquirer/prompts';
+import { PROJECT_FILE } from '../lib/config.js';
+const STARTER_MODEL = 'google/nano-banana-2/text-to-image';
+export function registerInit(program) {
+    program
+        .command('init')
+        .description('Create a wavespeed.json with a defaultModel + alias stubs in this directory')
+        .option('-y, --yes', 'Skip prompts, write sensible defaults')
+        .option('-f, --force', 'Overwrite an existing wavespeed.json')
+        .action(async (opts) => {
+        const target = path.resolve(PROJECT_FILE);
+        if (fs.existsSync(target) && !opts.force) {
+            console.log(chalk.yellow(`${PROJECT_FILE} already exists.`) + chalk.gray('  Pass --force to overwrite.'));
+            process.exit(1);
+        }
+        let project;
+        if (opts.yes) {
+            project = {
+                $schema: 'https://wavespeed.ai/schema/cli.json',
+                defaultModel: STARTER_MODEL,
+                outputDir: 'wavespeed-output',
+                aliases: {},
+            };
+        }
+        else {
+            console.log();
+            console.log(chalk.bold('Project config'));
+            console.log(chalk.gray('Sets the per-project defaults the team can share via git. You can edit wavespeed.json anytime.'));
+            console.log();
+            const defaultModel = await input({
+                message: 'Default model (browse with `wavespeed models`):',
+                default: STARTER_MODEL,
+            });
+            const outputDir = await input({ message: 'Output directory (for --download):', default: 'wavespeed-output' });
+            project = {
+                $schema: 'https://wavespeed.ai/schema/cli.json',
+                defaultModel,
+                outputDir,
+                aliases: {},
+            };
+        }
+        fs.writeFileSync(target, JSON.stringify(project, null, 2) + '\n');
+        console.log();
+        console.log(chalk.green('Wrote ') + chalk.cyan(PROJECT_FILE));
+        console.log();
+        console.log(chalk.gray('Now try:'));
+        console.log('  ' + chalk.cyan('wavespeed run -p "a serene mountain lake at sunrise"'));
+        console.log(chalk.gray('Add aliases by editing wavespeed.json — see ') + chalk.cyan('wavespeed aliases'));
+        console.log();
+        if (!opts.yes) {
+            const tellAgent = await confirm({
+                message: 'Add a Claude/Cursor skill so agents can call Wavespeed too?',
+                default: true,
+            });
+            if (tellAgent) {
+                await import('./skill.js').then(({ writeSkill }) => writeSkill(process.cwd()));
+            }
+        }
+    });
+}