@wavespeed/cli 0.4.15 → 0.4.16

package/README.md

@@ -141,6 +141,7 @@ 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

@@ -21,6 +21,7 @@ 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';
 const program = new Command();
@@ -62,6 +63,7 @@ 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/upgrade.js

@@ -28,6 +28,15 @@ async function download(url) {
         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();
@@ -41,7 +50,7 @@ async function replaceExecutable(version) {
     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 = process.execPath;
+    const exe = realExecPath();
     const next = `${exe}.new`;
     fs.writeFileSync(next, bin, { mode: 0o755 });
     if (process.platform === 'win32') {
@@ -163,7 +172,7 @@ export function registerUpgrade(program) {
         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(process.execPath);
+            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).`);
             }
@@ -171,7 +180,7 @@ export function registerUpgrade(program) {
                 await replaceExecutable(latest);
             }
             catch (err) {
-                return fail(`Could not replace ${process.execPath}: ${err.message ?? String(err)}`);
+                return fail(`Could not replace ${realExecPath()}: ${err.message ?? String(err)}`);
             }
         }
         else {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"