@wavespeed/cli 0.4.9 → 0.4.11

package/dist/commands/auth.js

@@ -6,6 +6,7 @@ import clipboard from 'clipboardy';
 import { userConfig, getBaseUrl, getApiKey, loadProjectConfig, PROJECT_FILE } from '../lib/config.js';
 import { LINKS } from '../lib/links.js';
 import { clientAttributionHeaders } from '../lib/client-headers.js';
+import { GET_TIMEOUT_MS } from '../lib/api.js';
 const KEY_URL = 'https://wavespeed.ai/accesskey';
 function mask(key) {
     if (key.length < 12)
@@ -42,6 +43,7 @@ async function validateKey(apiKey, baseUrl) {
     try {
         res = await fetch(`${baseUrl}/api/v3/balance`, {
             headers: { Authorization: `Bearer ${apiKey}`, ...clientAttributionHeaders() },
+            signal: AbortSignal.timeout(GET_TIMEOUT_MS),
         });
     }
     catch (err) {

package/dist/lib/api.js

@@ -46,6 +46,7 @@ export async function fetchModels(opts = {}) {
         throw new Error('No API key configured. Run `wavespeed login`.');
     const res = await fetch(`${baseUrl}/api/v3/models`, {
         headers: { Authorization: `Bearer ${apiKey}`, ...clientAttributionHeaders() },
+        signal: AbortSignal.timeout(GET_TIMEOUT_MS),
     });
     if (!res.ok) {
         throw await httpError(res, 'GET', '/api/v3/models');
@@ -66,6 +67,12 @@ export function clearModelsCache() {
         /* nothing to clear */
     }
 }
+// Per-request timeouts (no overall cap). A hung socket would otherwise stall
+// the CLI forever. Read-only GETs are far below 30s in practice (result p99.9
+// < 1s); the async submit gets more headroom because a timeout there is an
+// ambiguous outcome, not a clean failure.
+export const GET_TIMEOUT_MS = 30_000;
+export const SUBMIT_TIMEOUT_MS = 60_000;
 // --- Account + prediction endpoints (not exposed by the wavespeed SDK) ---
 function authHeaders() {
     const apiKey = getApiKey();
@@ -88,12 +95,17 @@ async function httpError(res, method, path) {
     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}`);
+    const err = detail
+        ? new Error(detail)
+        : new Error(`${method} ${path} failed: ${res.status} ${res.statusText}`);
+    err.status = res.status;
+    return err;
 }
 async function apiGet(path) {
-    const res = await fetch(`${getBaseUrl()}${path}`, { headers: authHeaders() });
+    const res = await fetch(`${getBaseUrl()}${path}`, {
+        headers: authHeaders(),
+        signal: AbortSignal.timeout(GET_TIMEOUT_MS),
+    });
     if (!res.ok)
         throw await httpError(res, 'GET', path);
     const json = (await res.json());
@@ -101,11 +113,12 @@ async function apiGet(path) {
         throw new Error(json.message || `API returned code ${json.code}`);
     return json.data;
 }
-async function apiPost(path, body) {
+async function apiPost(path, body, opts = {}) {
     const res = await fetch(`${getBaseUrl()}${path}`, {
         method: 'POST',
         headers: { ...authHeaders(), 'Content-Type': 'application/json' },
         body: JSON.stringify(body),
+        signal: opts.timeoutMs ? AbortSignal.timeout(opts.timeoutMs) : undefined,
     });
     if (!res.ok)
         throw await httpError(res, 'POST', path);
@@ -140,6 +153,32 @@ export async function fetchHistory(query = {}) {
 export async function fetchPrediction(id) {
     return apiGet(`/api/v3/predictions/${id}/result`);
 }
+// Same set as wavespeed-python. A thrown error with no HTTP status is a
+// network failure or timeout; envelope/JSON errors carry no status either but
+// never reach here as a transient fault, so only fetch-level errors count.
+const RETRYABLE_STATUS = new Set([429, 500, 502, 503, 504]);
+const MAX_POLL_RETRIES = 5;
+function isTransient(err) {
+    if (typeof err?.status === 'number')
+        return RETRYABLE_STATUS.has(err.status);
+    return err instanceof TypeError || err?.name === 'TimeoutError' || err?.name === 'AbortError';
+}
+async function fetchPredictionWithRetry(id, retryDelayMs) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await fetchPrediction(id);
+        }
+        catch (err) {
+            const reason = err?.message ?? String(err);
+            if (!isTransient(err))
+                throw new Error(`${reason} (task_id: ${id})`);
+            if (attempt >= MAX_POLL_RETRIES) {
+                throw new Error(`Status check failed after ${attempt + 1} attempts: ${reason} (task_id: ${id}) — the task may still be running`);
+            }
+            await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
+        }
+    }
+}
 export async function deletePredictions(ids) {
     await apiPost('/api/v3/predictions/delete', { ids });
 }
@@ -164,16 +203,30 @@ export async function submitPrediction(model, input, opts = {}) {
     const body = { ...input };
     if (opts.sync)
         body.enable_sync_mode = true;
-    return apiPost(`/api/v3/${model}`, body);
+    // sync mode legitimately holds the request until the task finishes, so only
+    // async submits get the per-request timeout.
+    try {
+        return await apiPost(`/api/v3/${model}`, body, {
+            timeoutMs: opts.sync ? undefined : SUBMIT_TIMEOUT_MS,
+        });
+    }
+    catch (err) {
+        // Never retried: the server may already have created (and billed) the task.
+        if (err?.name === 'TimeoutError') {
+            throw new Error(`Submission outcome unknown: no response within ${SUBMIT_TIMEOUT_MS / 1000}s. The task may have been created — run \`wavespeed history\` to check before retrying.`);
+        }
+        throw err;
+    }
 }
 /**
  * Poll a prediction until it reaches a terminal status. `onTick` fires each
- * round so the caller can keep a spinner honest.
+ * round so the caller can keep a spinner honest. Transient status-read
+ * failures are retried; submit is never retried.
  */
 export async function waitForPrediction(id, opts = {}) {
     const interval = opts.intervalMs ?? 1000;
     for (;;) {
-        const item = await fetchPrediction(id);
+        const item = await fetchPredictionWithRetry(id, opts.retryDelayMs ?? 1000);
         opts.onTick?.(item.status);
         if (item.status === 'completed')
             return item;

package/dist/lib/validate-inputs.js

@@ -16,6 +16,31 @@ export function requestSchemaProps(model) {
     const keys = Object.keys(props);
     return keys.length > 0 ? keys : null;
 }
+/**
+ * Legacy field names a model still accepts, as `legacy -> canonical`.
+ *
+ * The API renames public fields without breaking old callers by declaring the
+ * old name in the property's `x-aliases` (e.g. `last_image` carries
+ * `["end_image"]`) and folding it into the canonical name before validation.
+ * A legacy name is therefore a valid input, not a typo — it just is not listed
+ * as an accepted input, so schema-driven UIs show only the current name.
+ */
+export function requestSchemaAliases(model) {
+    const aliases = new Map();
+    const props = model?.api_schema?.api_schemas?.[0]?.request_schema?.properties;
+    if (!props)
+        return aliases;
+    for (const [name, def] of Object.entries(props)) {
+        const declared = def?.['x-aliases'];
+        if (!Array.isArray(declared))
+            continue;
+        for (const alias of declared) {
+            if (typeof alias === 'string' && alias !== name)
+                aliases.set(alias, name);
+        }
+    }
+    return aliases;
+}
 // Small edit distance for typo hints — inputs are short snake_case tokens, so
 // a full Levenshtein over ≤40 keys is nothing.
 function editDistance(a, b) {
@@ -49,7 +74,8 @@ export function findUnknownInputs(input, model) {
     if (!known)
         return null;
     const knownSet = new Set(known);
-    const unknown = Object.keys(input).filter((k) => !knownSet.has(k));
+    const aliases = requestSchemaAliases(model);
+    const unknown = Object.keys(input).filter((k) => !knownSet.has(k) && !aliases.has(k));
     if (unknown.length === 0)
         return null;
     const suggestions = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wavespeed/cli",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "WaveSpeed CLI — one command to run any WaveSpeed AI model from your terminal.",
   "publishConfig": {
     "access": "public"
@@ -56,7 +56,7 @@
     "conf": "^13.0.0",
     "open": "^10.1.0",
     "ora": "^8.1.0",
-    "wavespeed": "^0.3.0"
+    "wavespeed": "^0.3.4"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",