@wavespeed/cli 0.4.16 → 0.4.17

package/README.md

@@ -141,7 +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)
+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/commands/setup.js

@@ -2,16 +2,22 @@ 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, applyJson, claudeEdits, opencodeEdits, revertCodexToml, revertJson, validateModel, } from '../lib/setup-agents.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) {
@@ -43,14 +49,14 @@ export async function selfCheck(apiKey, model) {
         return { ok: false, detail: err.message ?? String(err) };
     }
 }
-function readJson(file) {
+function readJson(file, json5 = false) {
     if (!fs.existsSync(file))
         return {};
     const raw = fs.readFileSync(file, 'utf8');
     if (raw.trim() === '')
         return {};
     try {
-        const v = JSON.parse(raw);
+        const v = json5 ? JSON5.parse(raw) : JSON.parse(raw);
         if (v && typeof v === 'object' && !Array.isArray(v))
             return v;
     }
@@ -76,7 +82,7 @@ function envHint() {
 export function registerSetup(program) {
     program
         .command('setup [agent]')
-        .description('Point a coding agent (claude, codex, opencode) at the WaveSpeed LLM gateway')
+        .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")
@@ -108,6 +114,12 @@ export function registerSetup(program) {
         // ----- 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`);
@@ -116,17 +128,33 @@ export function registerSetup(program) {
                     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 state = userConfig.get('setup')?.[agent.id];
-                    if (!state)
-                        return fail(`No recorded ${agent.name} setup to undo`);
-                    const doc = readJson(state.file);
+                    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);
-                        const rest = { ...(userConfig.get('setup') ?? {}) };
-                        delete rest[agent.id];
-                        userConfig.set('setup', rest);
+                        forget();
                     }
                 }
             }
@@ -149,16 +177,28 @@ export function registerSetup(program) {
         catch (err) {
             return fail(err.message);
         }
-        let next;
+        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 result = applyJson(readJson(agent.file), agent.id === 'claude' ? claudeEdits(model, apiKey) : opencodeEdits(model));
-                previous = result.previous;
-                next = JSON.stringify(result.doc, null, 2) + '\n';
+                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) {
@@ -180,8 +220,21 @@ export function registerSetup(program) {
             if (!(await confirm({ message: 'Continue?', default: false })))
                 return fail('Cancelled; nothing written.');
         }
-        writeFile(agent.file, next, agent.keyInFile);
-        if (agent.kind === 'json')
+        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) {

package/dist/lib/setup-agents.js

@@ -12,6 +12,7 @@ export function validateModel(model) {
     }
     return model;
 }
+import { parseDocument } from 'yaml';
 function isObj(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
@@ -86,6 +87,178 @@ export function opencodeEdits(model) {
         { 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 <<<';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.16",
+  "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",