@wavespeed/cli 0.2.4 → 0.3.0

package/README.md

@@ -90,7 +90,9 @@ wavespeed run ... -p "..." --json | jq '.outputs[0]'
 - **`defaultModel`** — `wavespeed run -p "…"` (no model arg) uses this. Can itself be an alias name.
 - **`aliases`** — your own shortcuts. `wavespeed run hero -p "…"` expands to model + input. CLI `-i k=v` flags override. `wavespeed run hero -h` shows the resolved schema. List them with `wavespeed aliases`.
 
-Resolution: positional with `/` is a model ID; otherwise looked up as an alias. Merge order on inputs: `alias.input` → `--input-file` → `-i k=v` → `-p`. **The CLI never mutates the user's prompt or inputs** — what you pass is what hits the API.
+Resolution: positional with `/` is a model ID; otherwise looked up as an alias. Merge order on inputs: `alias.input` → `--input-file` → `-i k=v` → `-p`. **The CLI never rewrites your prompt or input values**, with one explicit exception: local file paths become hosted URLs.
+
+**Local files as inputs.** `-i image=./cat.png` uploads the file first and submits its URL — no separate `wavespeed upload` step. A bare value is only treated as a file when it has a media extension (image/video/audio) *and* exists on disk; prompt fields never auto-detect. Prefix with `@` (`-i image=@./cat.png`) to force an upload of any file — then a missing file is an error instead of a pass-through. The same file referenced twice uploads once.
 
 ## Recommended starting models
 

package/dist/commands/auth.js

@@ -33,6 +33,10 @@ async function readClipboardKey() {
 async function validateKey(apiKey, baseUrl) {
     // The platform doesn't expose a dedicated /whoami yet, so we ping a known
     // authenticated endpoint and treat anything that isn't 401/403 as "key works".
+    // Note this proves the key is live, not that it can run models: /balance is
+    // deliberately open to every key regardless of the creator's org role, so a
+    // Billing-created key logs in here and only fails at `run`, which now
+    // surfaces the API's explanation of why.
     let res = null;
     try {
         res = await fetch(`${baseUrl}/api/v3/balance`, {

package/dist/commands/run.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { requireClient } from '../lib/client.js';
 import { parseInputs } from '../lib/inputs.js';
+import { resolveLocalFiles } from '../lib/local-files.js';
 import { downloadOutputs, printOutputs } from '../lib/output.js';
 import { emitJson, emitJsonError, isJsonMode, log, setJsonMode } from '../lib/log.js';
 import { downloadOptsFromFlag } from '../lib/download-flag.js';
@@ -43,6 +44,13 @@ function failMissingModel() {
     }
     process.exit(1);
 }
+function failWith(msg) {
+    if (isJsonMode())
+        emitJsonError(msg);
+    else
+        console.error(chalk.red('Error: ') + msg);
+    process.exit(1);
+}
 function failUnknownAlias(token) {
     const msg = `"${token}" is neither a model ID (no \`/\`) nor a known alias.`;
     if (isJsonMode())
@@ -59,7 +67,7 @@ export function registerRun(program) {
         .command('run')
         .description('Run any Wavespeed model — generic invoke with --input key=value pairs')
         .argument('[model]', 'Model ID, alias name, or omit to use defaultModel.')
-        .option('-i, --input <pair...>', 'Inputs as key=value (repeatable). Use dotted keys for nested.', [])
+        .option('-i, --input <pair...>', 'Inputs as key=value (repeatable). Local media paths auto-upload; @path forces upload. Dotted keys nest.', [])
         .option('-p, --prompt <text>', 'Shorthand for --input prompt=<text>')
         .option('--input-file <path>', 'JSON file with full input object')
         .option('--download [path]', 'Save outputs locally (optional path template, e.g. "./out/{index}.{ext}")')
@@ -87,6 +95,28 @@ export function registerRun(program) {
         Object.assign(input, parseInputs(opts.input ?? []));
         if (opts.prompt)
             input.prompt = opts.prompt;
+        // Local paths become hosted URLs before submission. Uploads go straight
+        // to object storage via a presigned PUT, so this is one extra round trip
+        // per distinct file rather than a reason to make the user run `upload`
+        // first and paste the result back.
+        try {
+            const uploadSpinner = !isJsonMode() ? ora({ color: 'magenta' }) : null;
+            const resolved = await resolveLocalFiles(input, {
+                upload: (file) => client.upload(file),
+                onUpload: (file, i, total) => {
+                    uploadSpinner?.start(total > 1
+                        ? `Uploading ${path.basename(file)} (${i + 1}/${total})…`
+                        : `Uploading ${path.basename(file)}…`);
+                },
+            });
+            if (resolved.uploaded > 0) {
+                uploadSpinner?.succeed(`Uploaded ${resolved.uploaded} file${resolved.uploaded === 1 ? '' : 's'}.`);
+            }
+            input = resolved.input;
+        }
+        catch (err) {
+            failWith(err.message ?? String(err));
+        }
         log('');
         log(chalk.bold('▶ ') +
             chalk.cyan(model) +

package/dist/lib/api.js

@@ -47,7 +47,7 @@ export async function fetchModels(opts = {}) {
         headers: { Authorization: `Bearer ${apiKey}` },
     });
     if (!res.ok) {
-        throw new Error(`GET /api/v3/models failed: ${res.status} ${res.statusText}`);
+        throw await httpError(res, 'GET', '/api/v3/models');
     }
     const json = (await res.json());
     if (json.code !== 200) {
@@ -72,10 +72,29 @@ function authHeaders() {
         throw new Error('No API key configured. Run `wavespeed login`.');
     return { Authorization: `Bearer ${apiKey}` };
 }
+// Non-2xx responses still carry the platform's error envelope, and for
+// permission failures that body is the whole point: it names the role that
+// created the key and a role whose key would work. Throwing only the status
+// line turned every 403 into an unactionable "403 Forbidden".
+async function httpError(res, method, path) {
+    let detail = '';
+    try {
+        const body = (await res.json());
+        if (body?.message) {
+            detail = body.error_code ? `${body.message} [${body.error_code}]` : body.message;
+        }
+    }
+    catch {
+        /* non-JSON body (gateway error page, empty response) — fall back below */
+    }
+    if (detail)
+        return new Error(detail);
+    return new Error(`${method} ${path} failed: ${res.status} ${res.statusText}`);
+}
 async function apiGet(path) {
     const res = await fetch(`${getBaseUrl()}${path}`, { headers: authHeaders() });
     if (!res.ok)
-        throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+        throw await httpError(res, 'GET', path);
     const json = (await res.json());
     if (json.code !== 200)
         throw new Error(json.message || `API returned code ${json.code}`);
@@ -88,7 +107,7 @@ async function apiPost(path, body) {
         body: JSON.stringify(body),
     });
     if (!res.ok)
-        throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
+        throw await httpError(res, 'POST', path);
     const json = (await res.json());
     if (json.code !== 200)
         throw new Error(json.message || `API returned code ${json.code}`);

package/dist/lib/local-files.js

@@ -0,0 +1,116 @@
+// Turn local file paths in a model's input into hosted URLs.
+//
+// Uploading is cheap now that the platform hands out a presigned PUT and the
+// bytes go straight to object storage, so making the user run `upload` first
+// and paste the URL back is pure friction. This module finds the paths and
+// swaps them for URLs; run.ts does it once, right before submitting.
+//
+// Two ways to point at a file:
+//
+//   -i image=@./cat.png    explicit — always uploaded, missing file is an error
+//   -i image=./cat.png     implicit — uploaded only if it looks like media AND
+//                          exists on disk; otherwise passed through untouched
+//
+// The implicit rule is deliberately narrow. A model input that happens to
+// match a filename in the working directory must not be silently replaced by
+// a URL, so a bare value has to clear both the extension check and the
+// existence check. Anything already a URL is left alone.
+import fs from 'node:fs';
+import path from 'node:path';
+// Extensions the platform's models actually accept as inputs. Kept explicit
+// rather than "any file that exists": a bare `-i seed=1.txt` should stay a
+// string even in a directory that happens to contain 1.txt.
+const MEDIA_EXTENSIONS = new Set([
+    // images
+    '.png', '.jpg', '.jpeg', '.webp', '.gif', '.bmp', '.tiff', '.tif', '.heic', '.heif', '.avif',
+    // video
+    '.mp4', '.mov', '.webm', '.mkv', '.avi', '.m4v',
+    // audio
+    '.mp3', '.wav', '.flac', '.m4a', '.aac', '.ogg', '.opus',
+]);
+// Free-text fields never auto-detect: `-p ./notes.txt` means that literal
+// string. An explicit `@` still works if someone genuinely wants it.
+const NO_IMPLICIT_DETECTION = new Set(['prompt', 'negative_prompt', 'system_prompt']);
+function isRegularFile(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isUrl(value) {
+    return /^(https?:|data:|s3:|gs:)/i.test(value);
+}
+/**
+ * Walk the input and list every value that should become an upload. Pure over
+ * `exists`, so the decision rules can be tested without touching the disk.
+ */
+export function collectLocalFiles(input, opts = {}) {
+    const exists = opts.exists ?? isRegularFile;
+    const found = [];
+    const walk = (node, at, key) => {
+        if (Array.isArray(node)) {
+            // Arrays inherit the key of their container, so `image_urls.0` is still
+            // judged as `image_urls` — element indices are not field names.
+            node.forEach((v, i) => walk(v, at ? `${at}.${i}` : String(i), key));
+            return;
+        }
+        if (node && typeof node === 'object') {
+            for (const [k, v] of Object.entries(node)) {
+                walk(v, at ? `${at}.${k}` : k, k);
+            }
+            return;
+        }
+        if (typeof node !== 'string' || node === '')
+            return;
+        if (node.startsWith('@')) {
+            found.push({ path: node.slice(1), at, explicit: true });
+            return;
+        }
+        if (isUrl(node))
+            return;
+        if (NO_IMPLICIT_DETECTION.has(key))
+            return;
+        if (!MEDIA_EXTENSIONS.has(path.extname(node).toLowerCase()))
+            return;
+        if (!exists(node))
+            return;
+        found.push({ path: node, at, explicit: false });
+    };
+    walk(input, '', '');
+    return found;
+}
+function setAt(root, dotted, value) {
+    const parts = dotted.split('.');
+    let cur = root;
+    for (let i = 0; i < parts.length - 1; i++)
+        cur = cur[parts[i]];
+    cur[parts[parts.length - 1]] = value;
+}
+/**
+ * Replace local paths in `input` with uploaded URLs. Returns a new object;
+ * the caller's input is not mutated. Distinct paths upload once even when
+ * referenced several times — the same image passed as two fields is one
+ * upload, not two.
+ */
+export async function resolveLocalFiles(input, opts) {
+    const refs = collectLocalFiles(input, opts);
+    if (refs.length === 0)
+        return { input, uploaded: 0 };
+    const missing = refs.filter((r) => r.explicit && !(opts.exists ?? isRegularFile)(r.path));
+    if (missing.length > 0) {
+        throw new Error(`File not found: ${missing.map((m) => m.path).join(', ')}`);
+    }
+    const distinct = [...new Set(refs.map((r) => path.resolve(r.path)))];
+    const urls = new Map();
+    for (const [i, abs] of distinct.entries()) {
+        opts.onUpload?.(abs, i, distinct.length);
+        urls.set(abs, await opts.upload(abs));
+    }
+    const out = JSON.parse(JSON.stringify(input));
+    for (const ref of refs) {
+        setAt(out, ref.at, urls.get(path.resolve(ref.path)));
+    }
+    return { input: out, uploaded: distinct.length };
+}

package/package.json

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