@magicpixelart/cli 0.3.0 → 0.3.3

package/dist/api.js

@@ -1,4 +1,4 @@
-import { resolveEndpoint, getApiKey, CLI_USER_AGENT } from './config.js';
+import { resolveEndpoint, getApiKey, CLI_USER_AGENT, CLI_VERSION } from './config.js';
 import { etagForSha256, MAX_ASSET_BYTES, readBodyWithLimit, safeFetch, } from './util/security.js';
 export class ApiError extends Error {
     status;
@@ -53,8 +53,42 @@ export async function fetchManifestPage(opts) {
     if (!res.ok) {
         throw new ApiError(res.status, friendly(res.status, await res.text(), 'manifest'));
     }
+    // Hint to nudge stale CLIs. Printed once per process by sync.ts.
+    const minCli = res.headers.get('x-magicpixel-min-cli-version');
+    if (minCli)
+        maybeWarnStaleCli(minCli);
     return (await res.json());
 }
+// ----- Stale-CLI nudge ------------------------------------------------------
+// Cheap version comparison: split on dots, compare numerically. Pre-release
+// tags are ignored (treated as equal to their base) to avoid spamming devs
+// running unpublished builds.
+let staleWarned = false;
+function maybeWarnStaleCli(minVersion) {
+    if (staleWarned)
+        return;
+    const current = (CLI_VERSION || '').split('-')[0];
+    const min = (minVersion || '').split('-')[0];
+    if (!current || !min)
+        return;
+    if (compareSemver(current, min) >= 0)
+        return;
+    staleWarned = true;
+    // Use stderr so the message survives piping but doesn't pollute structured
+    // stdout consumers.
+    console.warn(`\n[magicpixel] CLI ${current} is older than the recommended ${min}.\n` +
+        `  Fix: npm i -D @magicpixelart/cli@latest (or @magicpixelart/vite)\n`);
+}
+function compareSemver(a, b) {
+    const pa = a.split('.').map((n) => parseInt(n, 10) || 0);
+    const pb = b.split('.').map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
 export async function fetchAllManifest(config, since) {
     const out = [];
     let cursor;
@@ -83,6 +117,7 @@ export async function fetchAssetBytes(config, key, knownSha) {
         headers['If-None-Match'] = etagForSha256(knownSha);
     const maxAttempts = 3;
     let lastErr = null;
+    let retryAfterMs = 0; // populated from Retry-After when present
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         try {
             const res = await safeFetch(url.href, { headers });
@@ -97,6 +132,11 @@ export async function fetchAssetBytes(config, key, knownSha) {
             // the stream so we don't leak the socket on retry.
             const bodyText = await res.text();
             if (res.status === 429 || res.status >= 500) {
+                // Honor Retry-After (seconds). Cap at 60s so a bogus header can't hang
+                // the CLI; fall back to exponential backoff when missing/invalid.
+                const ra = parseRetryAfterSeconds(res.headers.get('retry-after'));
+                if (ra > 0)
+                    retryAfterMs = Math.min(ra * 1000, 60_000);
                 lastErr = new ApiError(res.status, friendly(res.status, bodyText, `download ${key}`));
             }
             else {
@@ -109,8 +149,24 @@ export async function fetchAssetBytes(config, key, knownSha) {
                 throw e;
         }
         if (attempt < maxAttempts) {
-            await new Promise((r) => setTimeout(r, 250 * 2 ** (attempt - 1)));
+            const backoffMs = 250 * 2 ** (attempt - 1);
+            await new Promise((r) => setTimeout(r, Math.max(retryAfterMs, backoffMs)));
+            retryAfterMs = 0;
         }
     }
     throw lastErr ?? new Error(`download ${key}: unknown error`);
 }
+/** Retry-After may be seconds or an HTTP-date (RFC 7231). Accept both. */
+function parseRetryAfterSeconds(raw) {
+    if (!raw)
+        return 0;
+    const trimmed = raw.trim();
+    const n = Number(trimmed);
+    if (Number.isFinite(n) && n > 0)
+        return n;
+    const asDate = Date.parse(trimmed);
+    if (!Number.isNaN(asDate)) {
+        return Math.max(0, Math.ceil((asDate - Date.now()) / 1000));
+    }
+    return 0;
+}

package/dist/commands/sync.js

@@ -19,7 +19,13 @@ export async function syncCommand(opts) {
     await runOnce(opts);
 }
 async function watchLoop(opts) {
-    const intervalSec = typeof opts.watch === 'string' ? Math.max(2, parseInt(opts.watch, 10) || 10) : 10;
+    // Default 2s — matches the perceived-instant UX users expect when editing
+    // sprites in MagicPixel and watching them refresh in their game's dev
+    // server. Incremental polls send `?since=<lastSync>` so an empty manifest
+    // round-trip is cheap (a single HTTP HEAD-sized response with `count: 0`).
+    // Floor stays at 2s to keep accidental thrashing in check; users who need
+    // less can pass `--watch 5`.
+    const intervalSec = typeof opts.watch === 'string' ? Math.max(2, parseInt(opts.watch, 10) || 2) : 2;
     // Header — print once on start. Project/asset count is best-effort; if the
     // first manifest fetch fails we still want the loop to come up and retry.
     let headerCount = null;
@@ -41,6 +47,12 @@ async function watchLoop(opts) {
     let resolveIdle = null;
     let backoffSec = intervalSec;
     let pausedForAuth = false;
+    // Adaptive idle backoff: after a few minutes of nothing-to-do we slow the
+    // poll from 2s → 5s → 10s so a dev who walked away isn't hammering the
+    // manifest endpoint. ANY change OR error resets this back to intervalSec,
+    // so the "edit → see it" promise stays intact the moment the user comes
+    // back. Error backoff (2→60s) is separate and continues to win.
+    let consecutiveIdleTicks = 0;
     const onSigint = () => {
         if (stopping)
             return;
@@ -66,6 +78,19 @@ async function watchLoop(opts) {
             backoffSec = intervalSec;
             pausedForAuth = false;
             const changedCount = r.added.length + r.modified.length + r.removed.length + r.renamed.length;
+            if (changedCount > 0) {
+                // Snap back to the fast interval the moment anything changes.
+                consecutiveIdleTicks = 0;
+                backoffSec = intervalSec;
+            }
+            else {
+                consecutiveIdleTicks++;
+                // Thresholds in *ticks*; at intervalSec=2 these are ~3 min and ~15 min.
+                if (consecutiveIdleTicks >= 300)
+                    backoffSec = Math.max(intervalSec, 10);
+                else if (consecutiveIdleTicks >= 90)
+                    backoffSec = Math.max(intervalSec, 5);
+            }
             if (opts.quiet)
                 return;
             if (changedCount > 0) {
@@ -84,6 +109,8 @@ async function watchLoop(opts) {
             const apiErr = err instanceof ApiError ? err : null;
             const firstLine = err.message.split('\n')[0];
             process.stdout.write('\x1b[2K\r');
+            // Any error breaks the idle streak so we come back fast once it clears.
+            consecutiveIdleTicks = 0;
             if (apiErr && (apiErr.status === 401 || apiErr.status === 403)) {
                 if (!pausedForAuth) {
                     console.log(`${kleur.dim(timestamp())} ${kleur.red('✗')} Your key looks invalid or rotated.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magicpixelart/cli",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Sync MagicPixel pixel-art assets to your local project.",
   "type": "module",
   "bin": {