@wavespeed/cli 0.4.14 → 0.4.16

package/README.md

@@ -42,6 +42,10 @@ npm install -g @wavespeed/cli
 # friendlier error path)
 curl -fsSL https://raw.githubusercontent.com/WaveSpeedAI/wavespeed-cli/main/install.sh | bash
 
+# no Node.js/npm? install.sh falls back to a standalone executable on macOS/Linux;
+# on Windows (PowerShell):
+irm https://raw.githubusercontent.com/WaveSpeedAI/wavespeed-cli/main/install.ps1 | iex
+
 # sign in (opens the access-key page, paste to confirm)
 wavespeed login
 ```
@@ -136,6 +140,8 @@ wavespeed login                          Browser + paste-key wizard (clipboard-a
 wavespeed logout                         Clear stored API key
 wavespeed status                         Show masked key, base URL, useful links
 wavespeed config [--default-model …]     View / update CLI defaults
+wavespeed upgrade [--check] [--json]     Upgrade to the latest version (--check only reports)
+wavespeed setup [claude|codex|opencode]  Point a coding agent at the WaveSpeed LLM gateway (--dry-run, --undo, --model)
 
 # generation
 wavespeed run [model|alias] -p "…"       Run any model or alias (uses defaultModel if omitted)

package/dist/cli.js

@@ -1,9 +1,6 @@
 #!/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';
@@ -23,15 +20,10 @@ import { registerDelete } from './commands/delete.js';
 import { registerOpen } from './commands/open.js';
 import { registerBillings } from './commands/billings.js';
 import { registerUsage } from './commands/usage.js';
+import { registerUpgrade } from './commands/upgrade.js';
+import { registerSetup } from './commands/setup.js';
+import { VERSION } from './lib/version.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')
@@ -70,6 +62,8 @@ registerBillings(program);
 registerUsage(program);
 registerInit(program);
 registerSkill(program);
+registerUpgrade(program);
+registerSetup(program);
 program
     .command('hello', { hidden: true })
     .description('Print the WaveSpeed banner')

package/dist/commands/setup.js

@@ -0,0 +1,203 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { confirm } from '@inquirer/prompts';
+import { getApiKey, userConfig } from '../lib/config.js';
+import { clientAttributionHeaders } from '../lib/client-headers.js';
+import { emitJson, emitJsonError, info, setJsonMode } from '../lib/log.js';
+import { DEFAULT_MODEL, KEY_ENV, LLM_BASE_URL, applyCodexToml, applyJson, claudeEdits, opencodeEdits, revertCodexToml, revertJson, validateModel, } from '../lib/setup-agents.js';
+const home = os.homedir();
+const AGENTS = [
+    { id: 'claude', name: 'Claude Code', file: path.join(home, '.claude', 'settings.json'), command: 'claude', kind: 'json', keyInFile: true },
+    { id: 'codex', name: 'Codex', file: path.join(home, '.codex', 'config.toml'), command: 'codex', kind: 'toml', keyInFile: false },
+    { id: 'opencode', name: 'OpenCode', file: path.join(home, '.config', 'opencode', 'opencode.json'), command: 'opencode', kind: 'json', keyInFile: false },
+];
+const shown = (p) => p.replace(home, '~');
+function onPath(cmd) {
+    const exts = process.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    return (process.env.PATH ?? '').split(path.delimiter).some((d) => d && exts.some((e) => fs.existsSync(path.join(d, cmd + e))));
+}
+/** One streamed request to the same endpoint family the agents use; proves key, model and streaming work. */
+export async function selfCheck(apiKey, model) {
+    const base = process.env.WAVESPEED_LLM_BASE_URL || LLM_BASE_URL;
+    try {
+        const res = await fetch(`${base}/chat/completions`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}`, ...clientAttributionHeaders() },
+            // Reasoning models spend tokens thinking first; leave room for a visible reply.
+            body: JSON.stringify({ model, stream: true, max_tokens: 256, messages: [{ role: 'user', content: 'Reply with the single word READY.' }] }),
+            signal: AbortSignal.timeout(60_000),
+        });
+        if (!res.ok)
+            return { ok: false, detail: `HTTP ${res.status}: ${(await res.text()).slice(0, 200)}` };
+        const text = await res.text();
+        const chunks = text.split('\n').filter((l) => l.startsWith('data: ') && !l.includes('[DONE]'));
+        if (chunks.length === 0)
+            return { ok: false, detail: 'stream returned no data' };
+        if (chunks.some((l) => l.includes('"error"')))
+            return { ok: false, detail: 'stream contained an error' };
+        return { ok: true, detail: `${chunks.length} stream chunks` };
+    }
+    catch (err) {
+        return { ok: false, detail: err.message ?? String(err) };
+    }
+}
+function readJson(file) {
+    if (!fs.existsSync(file))
+        return {};
+    const raw = fs.readFileSync(file, 'utf8');
+    if (raw.trim() === '')
+        return {};
+    try {
+        const v = JSON.parse(raw);
+        if (v && typeof v === 'object' && !Array.isArray(v))
+            return v;
+    }
+    catch {
+        /* fall through */
+    }
+    throw new Error(`${shown(file)} is not plain JSON (comments or trailing commas?). Edit it by hand using the snippet at https://wavespeed.ai/llm/agents`);
+}
+function writeFile(file, content, secret) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const bak = `${file}.wavespeed.bak`;
+    if (fs.existsSync(file) && !fs.existsSync(bak))
+        fs.copyFileSync(file, bak);
+    fs.writeFileSync(file, content, secret ? { mode: 0o600 } : undefined);
+    if (secret)
+        fs.chmodSync(file, 0o600);
+}
+function envHint() {
+    return process.platform === 'win32'
+        ? `setx ${KEY_ENV} "<your key>"   (then open a new terminal)`
+        : `export ${KEY_ENV}="<your key>"   # add to ~/.zshrc or ~/.bashrc`;
+}
+export function registerSetup(program) {
+    program
+        .command('setup [agent]')
+        .description('Point a coding agent (claude, codex, opencode) at the WaveSpeed LLM gateway')
+        .option('--model <id>', `Model to use (default: ${DEFAULT_MODEL})`)
+        .option('--dry-run', 'Show what would change without writing anything')
+        .option('--undo', "Restore the agent's config to what it was before setup")
+        .option('-y, --yes', 'Do not ask for confirmation')
+        .option('--no-check', 'Skip the live request that verifies the setup')
+        .option('--json', 'Emit JSON')
+        .action(async (agentId, opts) => {
+        setJsonMode(!!opts.json);
+        const fail = (message) => {
+            if (opts.json)
+                emitJsonError(message);
+            else
+                console.error(chalk.red('Error: ') + message);
+            process.exit(1);
+        };
+        if (!agentId) {
+            const rows = AGENTS.map((a) => ({ agent: a.id, name: a.name, config: shown(a.file), installed: onPath(a.command) }));
+            if (opts.json)
+                return emitJson(rows);
+            info(chalk.bold('Agents:'));
+            for (const r of rows)
+                info(`  ${chalk.cyan(r.agent.padEnd(9))} ${r.name.padEnd(12)} ${chalk.gray(r.config)}  ${r.installed ? chalk.green('found') : chalk.gray('not on PATH')}`);
+            info('\nRun ' + chalk.cyan('wavespeed setup <agent>') + ' (add --dry-run to preview, --undo to revert).');
+            return;
+        }
+        const agent = AGENTS.find((a) => a.id === agentId);
+        if (!agent)
+            return fail(`Unknown agent "${agentId}". Choose one of: ${AGENTS.map((a) => a.id).join(', ')}`);
+        // ----- undo -----
+        if (opts.undo) {
+            try {
+                if (agent.kind === 'toml') {
+                    if (!fs.existsSync(agent.file))
+                        return fail(`${shown(agent.file)} does not exist; nothing to undo`);
+                    const before = fs.readFileSync(agent.file, 'utf8');
+                    const after = revertCodexToml(before);
+                    if (!opts.dryRun && after !== before)
+                        fs.writeFileSync(agent.file, after);
+                }
+                else {
+                    const state = userConfig.get('setup')?.[agent.id];
+                    if (!state)
+                        return fail(`No recorded ${agent.name} setup to undo`);
+                    const doc = readJson(state.file);
+                    const after = JSON.stringify(revertJson(doc, state.previous), null, 2) + '\n';
+                    if (!opts.dryRun) {
+                        fs.writeFileSync(state.file, after);
+                        const rest = { ...(userConfig.get('setup') ?? {}) };
+                        delete rest[agent.id];
+                        userConfig.set('setup', rest);
+                    }
+                }
+            }
+            catch (err) {
+                return fail(err.message ?? String(err));
+            }
+            if (opts.json)
+                return emitJson({ agent: agent.id, undone: !opts.dryRun, file: agent.file });
+            info(chalk.green(opts.dryRun ? `Would restore ${shown(agent.file)}.` : `Restored ${shown(agent.file)}.`));
+            return;
+        }
+        // ----- apply -----
+        const apiKey = getApiKey();
+        if (!apiKey)
+            return fail('No API key. Run `wavespeed login` first.');
+        let model;
+        try {
+            model = validateModel(opts.model ?? DEFAULT_MODEL);
+        }
+        catch (err) {
+            return fail(err.message);
+        }
+        let next;
+        let previous = [];
+        try {
+            if (agent.kind === 'toml') {
+                next = applyCodexToml(fs.existsSync(agent.file) ? fs.readFileSync(agent.file, 'utf8') : '', model);
+            }
+            else {
+                const result = applyJson(readJson(agent.file), agent.id === 'claude' ? claudeEdits(model, apiKey) : opencodeEdits(model));
+                previous = result.previous;
+                next = JSON.stringify(result.doc, null, 2) + '\n';
+            }
+        }
+        catch (err) {
+            return fail(err.message ?? String(err));
+        }
+        const exists = fs.existsSync(agent.file);
+        if (opts.dryRun) {
+            if (opts.json)
+                return emitJson({ agent: agent.id, model, file: agent.file, dry_run: true, will_create: !exists });
+            info(chalk.bold(`Would ${exists ? 'update' : 'create'} ${shown(agent.file)}`) + chalk.gray(` (model ${model}${agent.keyInFile ? '; your API key would be stored in this file' : ''})`));
+            info(chalk.gray('Nothing written.'));
+            return;
+        }
+        if (agent.keyInFile && !opts.yes) {
+            if (!process.stdin.isTTY)
+                return fail(`${agent.name} needs your API key stored in ${shown(agent.file)}. Re-run with --yes to allow that.`);
+            info(chalk.yellow(`${agent.name} will use WaveSpeed instead of its own login for every session, and your API key will be stored in ${shown(agent.file)}.`));
+            info(chalk.gray(`Undo any time with: wavespeed setup ${agent.id} --undo`));
+            if (!(await confirm({ message: 'Continue?', default: false })))
+                return fail('Cancelled; nothing written.');
+        }
+        writeFile(agent.file, next, agent.keyInFile);
+        if (agent.kind === 'json')
+            userConfig.set('setup', { ...(userConfig.get('setup') ?? {}), [agent.id]: { file: agent.file, previous } });
+        const check = opts.check ? await selfCheck(apiKey, model) : null;
+        if (opts.json) {
+            emitJson({ agent: agent.id, model, file: agent.file, written: true, check: check ? { ok: check.ok, detail: check.detail } : 'skipped', needs_env: agent.keyInFile ? null : KEY_ENV });
+            if (check && !check.ok)
+                process.exit(1);
+            return;
+        }
+        info(chalk.green(`Updated ${shown(agent.file)}`) + chalk.gray(` (model ${model})`));
+        if (check)
+            info(check.ok ? chalk.green(`Verified: streamed reply from ${model} (${check.detail}).`) : chalk.red(`Check failed: ${check.detail}`));
+        if (!agent.keyInFile) {
+            info(`\nThe key is read from ${chalk.bold(KEY_ENV)}; set it in the shell that launches ${agent.command}:\n  ${chalk.cyan(envHint())}\n  Keys: https://wavespeed.ai/accesskey`);
+        }
+        info(`\nStart it with ${chalk.cyan(agent.command)}. Revert with ${chalk.cyan(`wavespeed setup ${agent.id} --undo`)}.`);
+        if (check && !check.ok)
+            process.exit(1);
+    });
+}

package/dist/commands/skill.js

@@ -2,6 +2,11 @@ import chalk from 'chalk';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+function skillBody() {
+    if (typeof __WS_SKILL__ === 'string')
+        return __WS_SKILL__;
+    return fs.readFileSync(skillSourcePath(), 'utf8');
+}
 function skillSourcePath() {
     const here = path.dirname(fileURLToPath(import.meta.url));
     // dist/commands/skill.js -> ../../skills/SKILL.md
@@ -16,7 +21,7 @@ export function writeSkills(cwd = process.cwd()) {
     return SKILL_ROOTS.map((root) => {
         const dest = path.join(cwd, root, 'skills', 'wavespeed', 'SKILL.md');
         fs.mkdirSync(path.dirname(dest), { recursive: true });
-        fs.copyFileSync(skillSourcePath(), dest);
+        fs.writeFileSync(dest, skillBody());
         return dest;
     });
 }
@@ -34,7 +39,7 @@ export function registerSkill(program) {
         .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'));
+            process.stdout.write(skillBody());
             return;
         }
         const dests = writeSkills();

package/dist/commands/upgrade.js

@@ -0,0 +1,209 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { IS_STANDALONE, PACKAGE_NAME, VERSION, assetName, isNewer } from '../lib/version.js';
+import { emitJson, emitJsonError, info, setJsonMode } from '../lib/log.js';
+const REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PACKAGE_NAME)}/latest`;
+const RELEASES_URL = 'https://github.com/WaveSpeedAI/wavespeed-cli/releases';
+// The standalone executable is distributed through GitHub Releases (the npm
+// publish workflow creates the release right after publishing).
+async function fetchLatestReleaseVersion() {
+    const res = await fetch('https://api.github.com/repos/WaveSpeedAI/wavespeed-cli/releases/latest', {
+        headers: { accept: 'application/vnd.github+json', 'user-agent': 'wavespeed-cli' },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok)
+        throw new Error(`GitHub releases returned HTTP ${res.status}`);
+    const tag = (await res.json()).tag_name;
+    if (!tag)
+        throw new Error('GitHub release response had no tag');
+    return tag.replace(/^v/, '');
+}
+async function download(url) {
+    const res = await fetch(url, { signal: AbortSignal.timeout(300_000), redirect: 'follow' });
+    if (!res.ok)
+        throw new Error(`download of ${url} failed: HTTP ${res.status}`);
+    return Buffer.from(await res.arrayBuffer());
+}
+// process.execPath may be a symlink (e.g. /usr/local/bin/wavespeed -> Cellar/...); act on the real file.
+function realExecPath() {
+    try {
+        return fs.realpathSync(process.execPath);
+    }
+    catch {
+        return process.execPath;
+    }
+}
+/** Replace the running executable with the release asset, after checking its SHA-256. */
+async function replaceExecutable(version) {
+    const asset = assetName();
+    const base = `${RELEASES_URL}/download/v${version}`;
+    const [bin, sums] = await Promise.all([download(`${base}/${asset}`), download(`${base}/SHA256SUMS`)]);
+    const expected = sums
+        .toString('utf8')
+        .split('\n')
+        .map((l) => l.trim().split(/\s+/))
+        .find((p) => p[1]?.replace(/^\*/, '') === asset)?.[0];
+    const actual = crypto.createHash('sha256').update(bin).digest('hex');
+    if (!expected || expected.toLowerCase() !== actual)
+        throw new Error(`checksum mismatch for ${asset}; not installing`);
+    const exe = realExecPath();
+    const next = `${exe}.new`;
+    fs.writeFileSync(next, bin, { mode: 0o755 });
+    if (process.platform === 'win32') {
+        // A running .exe cannot be overwritten but can be renamed out of the way.
+        const old = `${exe}.old`;
+        fs.rmSync(old, { force: true });
+        fs.renameSync(exe, old);
+    }
+    fs.renameSync(next, exe);
+}
+export async function fetchLatestVersion() {
+    if (IS_STANDALONE)
+        return fetchLatestReleaseVersion();
+    const res = await fetch(REGISTRY_URL, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!res.ok)
+        throw new Error(`npm registry returned HTTP ${res.status}`);
+    const body = (await res.json());
+    if (!body.version)
+        throw new Error('npm registry response had no version');
+    return body.version;
+}
+function runNpmInstall() {
+    return new Promise((resolve, reject) => {
+        // Child output goes to stderr so `--json` keeps stdout clean.
+        const child = spawn('npm', ['install', '-g', `${PACKAGE_NAME}@latest`], {
+            stdio: ['ignore', 2, 2],
+            shell: process.platform === 'win32', // npm is npm.cmd on Windows
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+/** Skill files written by `wavespeed skill install` are a snapshot; flag the ones in this directory. */
+function installedSkillRoots(cwd = process.cwd()) {
+    return ['.claude', '.agents']
+        .map((root) => path.join(root, 'skills', 'wavespeed', 'SKILL.md'))
+        .filter((rel) => fs.existsSync(path.join(cwd, rel)));
+}
+/**
+ * Other `wavespeed` executables on PATH besides the one running (e.g. an npm
+ * install shadowing a standalone one). Upgrading one of them while the other
+ * wins on PATH makes the upgrade look like it did nothing.
+ */
+export function otherInstalls(pathEnv = process.env.PATH ?? '', self = process.argv[1] ?? '') {
+    const names = process.platform === 'win32' ? ['wavespeed.exe', 'wavespeed.cmd', 'wavespeed.ps1'] : ['wavespeed'];
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return null;
+    } };
+    const mine = new Set([real(process.execPath), real(self)].filter(Boolean));
+    const seen = new Set();
+    const found = [];
+    for (const dir of pathEnv.split(path.delimiter).filter(Boolean)) {
+        for (const name of names) {
+            const full = path.join(dir, name);
+            const r = real(full);
+            if (!r || seen.has(r))
+                continue;
+            seen.add(r);
+            // The npm shim and the package entry both count as "this" install.
+            if (!mine.has(r) && !(!IS_STANDALONE && r.includes(`${path.sep}@wavespeed${path.sep}cli${path.sep}`)))
+                found.push(full);
+        }
+    }
+    return found;
+}
+function warnOtherInstalls(json) {
+    const others = otherInstalls();
+    if (others.length && !json) {
+        info(chalk.yellow('Note: another wavespeed is also on your PATH, so the version you run may not be the one just upgraded:'));
+        for (const o of others)
+            info(chalk.gray('  ' + o.replace(os.homedir(), '~')));
+    }
+    return others;
+}
+export function registerUpgrade(program) {
+    program
+        .command('upgrade')
+        .alias('update')
+        .description('Upgrade the CLI to the latest published version')
+        .option('--check', 'Only report whether a newer version exists; do not install')
+        .option('--json', 'Emit JSON: {current, latest, update_available, upgraded}')
+        .action(async (opts) => {
+        setJsonMode(!!opts.json);
+        const fail = (message) => {
+            if (opts.json)
+                emitJsonError(message, { current: VERSION });
+            else
+                console.error(chalk.red('Error: ') + message);
+            process.exit(1);
+        };
+        let latest;
+        try {
+            latest = await fetchLatestVersion();
+        }
+        catch (err) {
+            return fail(`Could not check for updates: ${err.message ?? String(err)}`);
+        }
+        const updateAvailable = isNewer(latest, VERSION);
+        let others = [];
+        if (!updateAvailable || opts.check) {
+            if (opts.json) {
+                emitJson({ current: VERSION, latest, update_available: updateAvailable, upgraded: false, other_installs: otherInstalls() });
+            }
+            else if (!updateAvailable) {
+                info(chalk.green(`Already up to date (v${VERSION}).`));
+                warnOtherInstalls(opts.json);
+            }
+            else {
+                info(`Update available: v${VERSION} → ${chalk.bold('v' + latest)}. Run ${chalk.cyan('wavespeed upgrade')}.`);
+            }
+            return;
+        }
+        info(chalk.gray(`Upgrading v${VERSION} → v${latest}…`));
+        if (IS_STANDALONE) {
+            // Installed by a package manager: let it own the upgrade.
+            const managed = /[\\/](Cellar|homebrew|Homebrew|WinGet|scoop)[\\/]/.exec(realExecPath());
+            if (managed) {
+                return fail(`This copy is managed by ${managed[1]}; upgrade it with your package manager (e.g. brew upgrade wavespeed).`);
+            }
+            try {
+                await replaceExecutable(latest);
+            }
+            catch (err) {
+                return fail(`Could not replace ${realExecPath()}: ${err.message ?? String(err)}`);
+            }
+        }
+        else {
+            let code;
+            try {
+                code = await runNpmInstall();
+            }
+            catch (err) {
+                return fail(`Could not run npm: ${err.message ?? String(err)}`);
+            }
+            if (code !== 0) {
+                return fail(`npm install -g exited with code ${code}. If it is a permissions error, fix npm's prefix or re-run with sudo: npm install -g ${PACKAGE_NAME}@latest`);
+            }
+        }
+        others = warnOtherInstalls(opts.json);
+        const skills = installedSkillRoots();
+        if (opts.json) {
+            emitJson({ current: VERSION, latest, update_available: true, upgraded: true, stale_skill_files: skills, other_installs: others });
+            return;
+        }
+        info(chalk.green(`Upgraded to v${latest}.`));
+        if (skills.length) {
+            info(chalk.gray('  Skill files here are from the old version: ') + chalk.cyan('wavespeed skill install') + chalk.gray(' to refresh.'));
+        }
+    });
+}

package/dist/lib/client-headers.js

@@ -2,24 +2,9 @@
 // for the CLI's direct REST calls, matching the convention wavespeed-desktop
 // uses. Calls that go through the `wavespeed` SDK get the same headers from
 // the SDK itself (via the clientName option in client.ts).
-import fs from 'node:fs';
-import path from 'node:path';
 import os from 'node:os';
-import { fileURLToPath } from 'node:url';
+import { VERSION } from './version.js';
 export const CLI_CLIENT_NAME = 'wavespeed-cli';
-// Read version from package.json at runtime so a bump in package.json is
-// reflected automatically (same approach as cli.ts).
-function cliVersion() {
-    try {
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        // dist/lib/client-headers.js → ../../package.json
-        const pkgPath = path.resolve(here, '..', '..', 'package.json');
-        return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
-    }
-    catch {
-        return '0.0.0';
-    }
-}
 // Lowercase OS name: darwin / linux / windows (win32 is reported as windows).
 function operatingSystem() {
     const platform = os.platform();
@@ -34,7 +19,7 @@ export function resolveClientName() {
 export function clientAttributionHeaders() {
     return {
         'X-Client-Name': resolveClientName(),
-        'X-Client-Version': cliVersion(),
+        'X-Client-Version': VERSION,
         'X-Client-OS': operatingSystem(),
     };
 }

package/dist/lib/setup-agents.js

@@ -0,0 +1,148 @@
+// Pure helpers for `wavespeed setup`: build and revert the config edits for each
+// coding agent. No file or network access here, so everything is unit-testable.
+// Endpoint/protocol choices mirror api-dashboard/app/[locale]/llm/agents/data.ts.
+export const LLM_BASE_URL = 'https://llm.wavespeed.ai/v1';
+export const CLAUDE_BASE_URL = 'https://llm.wavespeed.ai';
+export const DEFAULT_MODEL = 'deepseek/deepseek-v4.1-flash-1017';
+export const KEY_ENV = 'WAVESPEED_API_KEY';
+const MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/;
+export function validateModel(model) {
+    if (!MODEL_PATTERN.test(model)) {
+        throw new Error('Model may only contain letters, numbers, _ . / : - (max 256 characters)');
+    }
+    return model;
+}
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Set each path, remembering what was there so `revertJson` can put it back. */
+export function applyJson(doc, edits) {
+    const previous = [];
+    for (const { path, value } of edits) {
+        let cur = doc;
+        for (const key of path.slice(0, -1)) {
+            if (!isObj(cur[key]))
+                cur[key] = {};
+            cur = cur[key];
+        }
+        const last = path[path.length - 1];
+        const existed = Object.prototype.hasOwnProperty.call(cur, last);
+        previous.push({ path, existed, value: existed ? cur[last] : undefined });
+        cur[last] = value;
+    }
+    return { doc, previous };
+}
+export function revertJson(doc, previous) {
+    for (const { path, existed, value } of [...previous].reverse()) {
+        const parents = [doc];
+        let cur = doc;
+        for (const key of path.slice(0, -1)) {
+            cur = isObj(cur) ? cur[key] : undefined;
+            if (!isObj(cur))
+                break;
+            parents.push(cur);
+        }
+        if (parents.length !== path.length)
+            continue; // structure changed since setup; leave it
+        const holder = parents[parents.length - 1];
+        const last = path[path.length - 1];
+        if (existed)
+            holder[last] = value;
+        else
+            delete holder[last];
+        // Drop containers we created and that are now empty.
+        for (let i = parents.length - 1; i > 0; i--) {
+            if (Object.keys(parents[i]).length === 0)
+                delete parents[i - 1][path[i - 1]];
+            else
+                break;
+        }
+    }
+    return doc;
+}
+export function claudeEdits(model, apiKey) {
+    const m = validateModel(model);
+    return [
+        ['ANTHROPIC_AUTH_TOKEN', apiKey],
+        ['ANTHROPIC_BASE_URL', CLAUDE_BASE_URL],
+        ['ANTHROPIC_MODEL', m],
+        ['ANTHROPIC_DEFAULT_OPUS_MODEL', m],
+        ['ANTHROPIC_DEFAULT_SONNET_MODEL', m],
+        ['ANTHROPIC_DEFAULT_HAIKU_MODEL', m],
+    ].map(([k, v]) => ({ path: ['env', k], value: v }));
+}
+export function opencodeEdits(model) {
+    const m = validateModel(model);
+    return [
+        {
+            path: ['provider', 'wavespeed'],
+            value: {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'WaveSpeedAI',
+                options: { baseURL: LLM_BASE_URL, apiKey: `{env:${KEY_ENV}}` },
+                models: { [m]: { name: m, tool_call: true } },
+            },
+        },
+        { path: ['model'], value: `wavespeed/${m}` },
+    ];
+}
+// ---------- Codex (TOML, edited as text so the user's comments survive) ----------
+const TOP_OPEN = '# >>> wavespeed (managed by `wavespeed setup`) >>>';
+const TOP_CLOSE = '# <<< wavespeed <<<';
+const TAIL_OPEN = '# >>> wavespeed provider >>>';
+const TAIL_CLOSE = '# <<< wavespeed provider <<<';
+const DISABLED = '# [wavespeed-setup disabled] ';
+function stripBlock(text, open, close) {
+    const lines = text.split('\n');
+    const out = [];
+    let skipping = false;
+    for (const line of lines) {
+        if (line.trim() === open) {
+            skipping = true;
+            continue;
+        }
+        if (skipping) {
+            if (line.trim() === close)
+                skipping = false;
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+export function revertCodexToml(text) {
+    let t = stripBlock(text, TOP_OPEN, TOP_CLOSE);
+    t = stripBlock(t, TAIL_OPEN, TAIL_CLOSE);
+    t = t.split('\n').map((l) => (l.startsWith(DISABLED) ? l.slice(DISABLED.length) : l)).join('\n');
+    t = t.replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '').replace(/\n+$/, '');
+    return t === '' ? '' : t + '\n';
+}
+export function applyCodexToml(text, model) {
+    const m = validateModel(model);
+    const base = revertCodexToml(text);
+    if (/^\s*\[model_providers\.wavespeed\]/m.test(base)) {
+        throw new Error('config.toml already defines [model_providers.wavespeed] outside wavespeed setup; edit it by hand');
+    }
+    // Top-level keys live before the first table header; comment out the ones we replace.
+    const lines = base.split('\n');
+    let inTop = true;
+    const edited = lines.map((l) => {
+        if (/^\s*\[/.test(l))
+            inTop = false;
+        return inTop && /^\s*(model|model_provider)\s*=/.test(l) ? DISABLED + l : l;
+    });
+    const top = [TOP_OPEN, `model = ${JSON.stringify(m)}`, 'model_provider = "wavespeed"', TOP_CLOSE, ''];
+    const tail = [
+        '',
+        TAIL_OPEN,
+        '[model_providers.wavespeed]',
+        'name = "WaveSpeedAI"',
+        `base_url = "${LLM_BASE_URL}"`,
+        `env_key = "${KEY_ENV}"`,
+        'wire_api = "responses"',
+        TAIL_CLOSE,
+        '',
+    ];
+    const body = edited.join('\n').replace(/\n+$/, '');
+    return [...top, body, ...tail].join('\n').replace(/\n{3,}/g, '\n\n');
+}

package/dist/lib/version.js

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const PACKAGE_NAME = '@wavespeed/cli';
+/** True when running as the standalone executable rather than under Node + npm. */
+export const IS_STANDALONE = typeof __WS_VERSION__ === 'string';
+// Otherwise read package.json at runtime so a bump is reflected automatically
+// (no second place to keep in sync).
+export const VERSION = IS_STANDALONE ? __WS_VERSION__ : (() => {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // dist/lib/version.js (or src/lib/version.ts) → ../../package.json
+    const pkgPath = path.resolve(here, '..', '..', 'package.json');
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version;
+})();
+/** Parse "1.2.3" (optionally "v"-prefixed / with a -prerelease or +build tail) into numbers. */
+function parse(v) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)/.exec(v.trim());
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+/** True when `latest` is strictly newer than `current`. Unparseable input → false. */
+export function isNewer(latest, current) {
+    const a = parse(latest);
+    const b = parse(current);
+    if (!a || !b)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] > b[i];
+    }
+    return false;
+}
+/** Release asset name for this platform, e.g. wavespeed-linux-x64, wavespeed-windows-x64.exe. */
+export function assetName(platform = process.platform, arch = process.arch) {
+    const os = platform === 'win32' ? 'windows' : platform;
+    return `wavespeed-${os}-${arch}${platform === 'win32' ? '.exe' : ''}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"
@@ -60,6 +60,8 @@
   },
   "devDependencies": {
     "@types/node": "^20.14.0",
+    "esbuild": "^0.28.2",
+    "postject": "^1.0.0-alpha.6",
     "prettier": "^3.3.0",
     "tsx": "^4.19.0",
     "typescript": "^5.5.0",