@wavespeed/cli 0.4.14 → 0.4.15

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,7 @@ 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)
 
 # 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,9 @@ 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 { 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 +61,7 @@ registerBillings(program);
 registerUsage(program);
 registerInit(program);
 registerSkill(program);
+registerUpgrade(program);
 program
     .command('hello', { hidden: true })
     .description('Print the WaveSpeed banner')

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,200 @@
+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());
+}
+/** 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 = process.execPath;
+    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(process.execPath);
+            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 ${process.execPath}: ${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/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.15",
   "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",