@wavespeed/cli 0.4.15 → 0.4.17

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 [agent]                  Point claude, codex, opencode, openclaw, hermes or cline 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,256 @@
+import chalk from 'chalk';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { confirm } from '@inquirer/prompts';
+import JSON5 from 'json5';
+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, applyHermesYaml, applyJson, claudeEdits, openclawEdits, opencodeEdits, revertCodexToml, revertHermesYaml, 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 },
+    { id: 'openclaw', name: 'OpenClaw', file: path.join(home, '.openclaw', 'openclaw.json'), command: 'openclaw', kind: 'json5', keyInFile: false },
+    { id: 'hermes', name: 'Hermes', file: path.join(home, '.hermes', 'config.yaml'), command: 'hermes', kind: 'yaml', keyInFile: false },
+    // Cline's CLI keeps provider settings (including the key) in this file; we write it only through `cline auth`.
+    { id: 'cline', name: 'Cline', file: path.join(home, '.cline', 'data', 'settings', 'providers.json'), command: 'cline', kind: 'cline', keyInFile: true },
+];
+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, json5 = false) {
+    if (!fs.existsSync(file))
+        return {};
+    const raw = fs.readFileSync(file, 'utf8');
+    if (raw.trim() === '')
+        return {};
+    try {
+        const v = json5 ? JSON5.parse(raw) : 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, openclaw, hermes, cline) 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 {
+                const state = userConfig.get('setup')?.[agent.id];
+                const forget = () => {
+                    const rest = { ...(userConfig.get('setup') ?? {}) };
+                    delete rest[agent.id];
+                    userConfig.set('setup', rest);
+                };
+                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 if (!state) {
+                    return fail(`No recorded ${agent.name} setup to undo`);
+                }
+                else if (agent.kind === 'cline') {
+                    const bak = `${agent.file}.wavespeed.bak`;
+                    if (!opts.dryRun) {
+                        if (state.previous.existed && fs.existsSync(bak))
+                            fs.copyFileSync(bak, agent.file);
+                        else
+                            fs.rmSync(agent.file, { force: true });
+                        fs.rmSync(bak, { force: true });
+                        forget();
+                    }
+                }
+                else if (agent.kind === 'yaml') {
+                    const after = revertHermesYaml(fs.readFileSync(state.file, 'utf8'), state.previous);
+                    if (!opts.dryRun) {
+                        fs.writeFileSync(state.file, after);
+                        forget();
+                    }
+                }
+                else {
+                    const doc = readJson(state.file, agent.kind === 'json5');
+                    const after = JSON.stringify(revertJson(doc, state.previous), null, 2) + '\n';
+                    if (!opts.dryRun) {
+                        fs.writeFileSync(state.file, after);
+                        forget();
+                    }
+                }
+            }
+            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 if (agent.kind === 'yaml') {
+                const r = applyHermesYaml(fs.existsSync(agent.file) ? fs.readFileSync(agent.file, 'utf8') : '', model);
+                next = r.text;
+                previous = r.previous;
+            }
+            else if (agent.kind === 'cline') {
+                previous = { existed: fs.existsSync(agent.file) };
+                if (!onPath('cline'))
+                    throw new Error('Cline CLI not found. Install it with `npm i -g cline`. (The VS Code extension has no config file; set it up in its settings UI.)');
+            }
+            else {
+                const base = readJson(agent.file, agent.kind === 'json5');
+                const edits = agent.id === 'claude' ? claudeEdits(model, apiKey) : agent.id === 'openclaw' ? openclawEdits(model, base) : opencodeEdits(model);
+                const r = applyJson(base, edits);
+                previous = r.previous;
+                next = JSON.stringify(r.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.');
+        }
+        if (agent.kind === 'cline') {
+            const bak = `${agent.file}.wavespeed.bak`;
+            if (fs.existsSync(agent.file) && !fs.existsSync(bak))
+                fs.copyFileSync(agent.file, bak);
+            const r = spawnSync('cline', ['auth', '-p', 'openai-compatible', '-k', apiKey, '-b', LLM_BASE_URL, '-m', model], { stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf8', shell: process.platform === 'win32' });
+            if (r.status !== 0)
+                return fail(`cline auth failed: ${(r.stderr || r.error?.message || '').trim().slice(0, 300)}`);
+        }
+        else {
+            const hadComments = agent.kind === 'json5' && exists && /^\s*\/\/|\/\*/m.test(fs.readFileSync(agent.file, 'utf8'));
+            writeFile(agent.file, next, agent.keyInFile);
+            if (hadComments)
+                info(chalk.yellow(`Comments in ${shown(agent.file)} were not kept; the original is saved as ${shown(agent.file)}.wavespeed.bak`));
+        }
+        if (agent.kind !== 'toml')
+            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,321 @@
+// 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;
+}
+import { parseDocument } from 'yaml';
+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}` },
+    ];
+}
+export function openclawEdits(model, doc) {
+    const m = validateModel(model);
+    const edits = [
+        { path: ['agents', 'defaults', 'model', 'primary'], value: `wavespeed/${m}` },
+        { path: ['models', 'mode'], value: 'merge' },
+        {
+            path: ['models', 'providers', 'wavespeed'],
+            value: {
+                baseUrl: LLM_BASE_URL,
+                apiKey: `\${${KEY_ENV}}`,
+                api: 'openai-completions',
+                models: [{ id: m, name: m, contextWindow: 200000, maxTokens: 32000 }],
+            },
+        },
+    ];
+    // A user-maintained model allowlist would otherwise reject the new model.
+    const agents = doc.agents;
+    const defaults = agents?.defaults;
+    if (isObj(defaults?.models))
+        edits.push({ path: ['agents', 'defaults', 'models', `wavespeed/${m}`], value: {} });
+    return edits;
+}
+const lineStart = (t, off) => t.lastIndexOf('\n', off - 1) + 1;
+const lineEnd = (t, off) => {
+    const i = t.indexOf('\n', off);
+    return i < 0 ? t.length : i + 1;
+};
+/** End of the line holding the last real character before `off` (a node's range can run over trailing blank lines). */
+const contentLineEnd = (t, off) => lineEnd(t, t.slice(0, off).trimEnd().length - 1);
+function applyEdits(text, edits) {
+    return [...edits].sort((x, y) => y.start - x.start).reduce((t, e) => t.slice(0, e.start) + e.text + t.slice(e.end), text);
+}
+function entryLines(pad) {
+    return [
+        `${pad}- name: wavespeed`,
+        `${pad}  base_url: ${LLM_BASE_URL}`,
+        `${pad}  key_env: ${KEY_ENV}`,
+        `${pad}  api_mode: chat_completions`,
+        '',
+    ].join('\n');
+}
+function dashPad(text, itemStart) {
+    const dash = text.lastIndexOf('-', itemStart - 1);
+    return { dash, pad: ' '.repeat(dash - lineStart(text, dash)) };
+}
+function parseYaml(text) {
+    const doc = parseDocument(text);
+    if (doc.errors.length)
+        throw new Error(`config.yaml is not valid YAML: ${doc.errors[0].message}`);
+    return doc;
+}
+export function applyHermesYaml(input, model) {
+    const m = validateModel(model);
+    let text = input;
+    if (text !== '' && !text.endsWith('\n'))
+        text += '\n';
+    const doc = parseYaml(text);
+    const edits = [];
+    let tail = '';
+    const previous = { hadModelBlock: false, hadList: false };
+    const want = { default: JSON.stringify(m), provider: '"wavespeed"' };
+    const root = doc.contents;
+    const modelNode = root?.get?.('model', true);
+    if (modelNode === undefined || modelNode === null) {
+        tail += `model:\n  default: ${want.default}\n  provider: ${want.provider}\n`;
+    }
+    else if (modelNode.items) {
+        previous.hadModelBlock = true;
+        const missing = [];
+        for (const key of ['default', 'provider']) {
+            const v = modelNode.get?.(key, true);
+            if (v && v.range) {
+                const raw = text.slice(v.range[0], v.range[1]);
+                if (key === 'default')
+                    previous.defaultRaw = raw;
+                else
+                    previous.providerRaw = raw;
+                edits.push({ start: v.range[0], end: v.range[1], text: want[key] });
+            }
+            else {
+                missing.push(key);
+            }
+        }
+        if (missing.length) {
+            const first = modelNode.items[0]?.key?.range?.[0];
+            if (first === undefined)
+                throw new Error('model: block in config.yaml is empty or inline; edit it by hand');
+            const pad = ' '.repeat(first - lineStart(text, first));
+            edits.push({ start: lineStart(text, first), end: lineStart(text, first), text: missing.map((k) => `${pad}${k}: ${want[k]}\n`).join('') });
+        }
+    }
+    else {
+        throw new Error('model: in config.yaml is not a block; edit it by hand');
+    }
+    const list = root?.get?.('custom_providers', true);
+    if (list === undefined || list === null) {
+        tail += `custom_providers:\n${entryLines('  ')}`;
+    }
+    else if (list.items && list.flow !== true) {
+        previous.hadList = true;
+        const mine = list.items.find((it) => it?.get?.('name') === 'wavespeed');
+        if (mine?.range) {
+            const { dash, pad } = dashPad(text, mine.range[0]);
+            const end = contentLineEnd(text, mine.range[1]);
+            previous.entryRaw = text.slice(lineStart(text, dash), end);
+            edits.push({ start: lineStart(text, dash), end, text: entryLines(pad) });
+        }
+        else if (list.items.length > 0) {
+            const last = list.items[list.items.length - 1];
+            const { pad } = dashPad(text, list.items[0].range[0]);
+            const at = contentLineEnd(text, last.range[1]);
+            edits.push({ start: at, end: at, text: entryLines(pad) });
+        }
+        else {
+            throw new Error('custom_providers: in config.yaml is empty; edit it by hand');
+        }
+    }
+    else if (list.range && list.value === null) {
+        // `custom_providers:` with nothing under it
+        previous.hadList = false;
+        const at = lineEnd(text, list.range[0]);
+        edits.push({ start: at, end: at, text: entryLines('  ') });
+    }
+    else {
+        throw new Error('custom_providers: in config.yaml is not a block list; edit it by hand');
+    }
+    return { text: applyEdits(text, edits) + tail, previous };
+}
+export function revertHermesYaml(input, previous) {
+    let text = input;
+    if (!previous.hadModelBlock) {
+        text = text.replace(/^model:\n {2}default: "[^\n]*"\n {2}provider: "wavespeed"\n/m, '');
+    }
+    else {
+        const doc = parseYaml(text);
+        const modelNode = doc.contents?.get?.('model', true);
+        const edits = [];
+        for (const [key, raw] of [['default', previous.defaultRaw], ['provider', previous.providerRaw]]) {
+            const v = modelNode?.get?.(key, true);
+            if (!v?.range)
+                continue;
+            if (raw !== undefined) {
+                edits.push({ start: v.range[0], end: v.range[1], text: raw });
+            }
+            else {
+                const pair = modelNode.items.find((p) => p.key?.value === key);
+                const ks = pair.key.range[0];
+                edits.push({ start: lineStart(text, ks), end: lineEnd(text, v.range[1]), text: '' });
+            }
+        }
+        text = applyEdits(text, edits);
+    }
+    const doc = parseYaml(text);
+    const list = doc.contents?.get?.('custom_providers', true);
+    if (list?.items) {
+        const mine = list.items.find((it) => it?.get?.('name') === 'wavespeed');
+        if (mine?.range) {
+            const { dash } = dashPad(text, mine.range[0]);
+            const start = lineStart(text, dash);
+            const end = contentLineEnd(text, mine.range[1]);
+            text = text.slice(0, start) + (previous.entryRaw ?? '') + text.slice(end);
+        }
+        if (!previous.hadList) {
+            const again = parseYaml(text);
+            const l2 = again.contents?.get?.('custom_providers', true);
+            if (l2?.items?.length === 0 || (l2 && l2.items === undefined)) {
+                text = text.replace(/^custom_providers:[ \t]*\n?/m, '');
+            }
+        }
+    }
+    return text;
+}
+// ---------- 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.17",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"
@@ -54,9 +54,11 @@
     "clipboardy": "^4.0.0",
     "commander": "^12.1.0",
     "conf": "^13.0.0",
+    "json5": "^2.2.3",
     "open": "^10.1.0",
     "ora": "^8.1.0",
-    "wavespeed": "^0.3.4"
+    "wavespeed": "^0.3.4",
+    "yaml": "^2.9.1"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",