@magicpixelart/cli 0.5.31 → 0.5.34

package/CHANGELOG.md

@@ -5,6 +5,24 @@ All notable changes to `@magicpixelart/cli` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.5.34] - 2026-10-06
+
+### Fixed
+- `push --force` no longer fails with "Too many sprites (max 20 per request)" when more than 20 files are retried; the retry round is now sent in small batches.
+
+## [0.5.33] - 2026-10-06
+
+### Fixed
+- Local edits to game files that were never changed in MagicPixel no longer fail as "also changed in MagicPixel". Push now sends the cloud timestamp it last saw, and sync no longer records the local file as MagicPixel's copy when the server has no cached hash.
+
+### Changed
+- Watch header now reads "N game sprites connected" — it counts game PNGs matched by `connect`, not files waiting in MagicPixel.
+
+## [0.5.32] - 2026-10-05
+
+### Fixed
+- `sync --watch` status lines are clipped to the terminal width, so a long sprite path no longer wraps and leaves the previous status piled on screen.
+
 ## [0.5.31] - 2026-10-01
 
 ### Added

package/dist/api.js

@@ -423,6 +423,15 @@ function isTransientPushError(e) {
 export async function pushSpritesAdaptive(sprites, retryOpts) {
     if (sprites.length === 0)
         return [];
+    // Never send more than one batch per request — callers (e.g. the --force
+    // retry round) may hand over every refused sprite at once.
+    if (sprites.length > PUSH_BATCH_SIZE) {
+        const out = [];
+        for (let i = 0; i < sprites.length; i += PUSH_BATCH_SIZE) {
+            out.push(...(await pushSpritesAdaptive(sprites.slice(i, i + PUSH_BATCH_SIZE), retryOpts)));
+        }
+        return out;
+    }
     try {
         return await pushSprites(sprites, retryOpts);
     }

package/dist/commands/push.js

@@ -215,6 +215,7 @@ export async function runPushWith(config, state, opts = {}) {
                 assetId: a.assetId,
                 layerIdx: a.layerIdx,
                 baseSha256: a.baseSha256,
+                ...(a.baseUpdatedAt ? { baseUpdatedAt: a.baseUpdatedAt } : {}),
                 flatten: opts.flatten === true,
                 ...(opts.replace ? { replace: true } : {}),
             });

package/dist/commands/sync.js

@@ -23,7 +23,7 @@ import { maxIsoTimestamp } from '../util/iso.js';
 import { formatBytes } from '../util/format.js';
 import { computePreviousKeyOrphans } from '../util/previousKeyOrphans.js';
 import { cmd } from '../util/invoke.js';
-import { formatSlowTickLine, formatWatchSpriteLine, SLOW_TICK_HEARTBEAT_MS } from '../util/watchCopy.js';
+import { fitStatusLine, formatSlowTickLine, formatWatchSpriteLine, SLOW_TICK_HEARTBEAT_MS } from '../util/watchCopy.js';
 import { canSkipWithoutHashing, decidePull, hasNewExplicitRelease } from '../util/pullDecision.js';
 import { hasUnpushedLocalEdit } from '../util/localEdit.js';
 import { shouldReconcile } from '../util/reconcile.js';
@@ -227,7 +227,7 @@ async function watchLoop(opts) {
         const onStatus = (msg) => {
             if (opts.quiet)
                 return;
-            process.stdout.write(`\r\x1b[2K${kleur.dim(`${timestamp()} ${msg}`)}`);
+            writeStatusLine(msg);
         };
         // Heartbeat: a tick that legitimately takes minutes (huge first pull, slow
         // link) must not look like the silent hang a timeout-less fetch used to
@@ -307,7 +307,7 @@ async function watchLoop(opts) {
                 printChanges(r, /* indent */ '  ');
             }
             else {
-                process.stdout.write(`\r\x1b[2K${kleur.dim(`${timestamp()} Waiting for edits… (${r.unchanged} up to date)`)}`);
+                writeStatusLine(`Waiting for edits… (${r.unchanged} up to date)`);
             }
         }
         catch (e) {
@@ -1377,12 +1377,14 @@ async function runOnce(opts, runOpts = {}) {
         // After a write, the actual downloaded bytes are the disk/cloud baseline.
         // The manifest hash may be null or represent a cached composite while the
         // download endpoint serves storage bytes for a single-artboard document.
+        const prev = nextSynced[entry.key];
+        // Never let the local game file stand in for MagicPixel's composite when
+        // the manifest has no cached hash: keep the last real cloud baseline.
         const sha = writtenKeys.has(entry.key)
             ? await fileSha256(pathFor(entry))
-            : (entry.sha256 ?? (await fileSha256(pathFor(entry))));
+            : (entry.sha256 ?? prev?.sha256 ?? (await fileSha256(pathFor(entry))));
         if (!sha)
             continue;
-        const prev = nextSynced[entry.key];
         const diskSha256 = writtenKeys.has(entry.key)
             ? sha
             : (shaByEntryId.get(entry.id) ?? prev?.diskSha256 ?? sha);
@@ -1575,6 +1577,11 @@ function progressText(done, total, bytes) {
     const bar = '█'.repeat(filled) + '░'.repeat(barWidth - filled);
     return `${bar}  ${done}/${total}  ${kleur.dim(formatBytes(bytes))}`;
 }
+/** Rewrite the watcher's single status row, clipped so it never wraps. */
+function writeStatusLine(msg) {
+    const line = fitStatusLine(`${timestamp()} ${msg}`, process.stdout.columns);
+    process.stdout.write(`\r\x1b[2K${kleur.dim(line)}`);
+}
 function timestamp() {
     const d = new Date();
     return `[${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}:${String(d.getSeconds()).padStart(2, '0')}]`;

package/dist/util/pushPlan.js

@@ -151,6 +151,7 @@ export function planPush(candidates, synced, opts = {}) {
                 // A later explicit `push` can then safely keep the local copy without
                 // bypassing the server's optimistic-concurrency check.
                 baseSha256: known.pendingCloudSha256 ?? known.sha256,
+                ...(known.cloudUpdatedAt && !known.pendingCloudSha256 ? { baseUpdatedAt: known.cloudUpdatedAt } : {}),
             });
             continue;
         }

package/dist/util/watchCopy.js

@@ -13,10 +13,10 @@ export function formatWatchSpriteLine(c) {
     if (set === 0 && pulled === 0)
         return null;
     if (set > 0 && pulled > 0 && set !== pulled) {
-        return `   Sprites:  ${fmt(set)} in your game  ·  ${fmt(pulled)} last pulled from MagicPixel`;
+        return `   Sprites:  ${fmt(set)} game sprites connected  ·  ${fmt(pulled)} last pulled from MagicPixel`;
     }
     if (set > 0)
-        return `   Sprites:  ${fmt(set)} in your game`;
+        return `   Sprites:  ${fmt(set)} game sprites connected`;
     return `   Sprites:  ${fmt(pulled)}`;
 }
 /** How long a single watch tick may run before the heartbeat starts printing. */
@@ -39,3 +39,19 @@ export function formatSlowTickLine(elapsedSec, lastStatus) {
         ? `${what} — still working (${elapsed})`
         : `Still working (${elapsed})`;
 }
+/**
+ * Fit a carriage-return status line to one terminal row. `\r\x1b[2K` only
+ * clears the row the cursor is on, so a line that wraps leaves its first rows
+ * behind and the next status prints after them (long "Looking through your
+ * game sprites… <folder>" lines piled up this way). No width (not a TTY) →
+ * unchanged.
+ */
+export function fitStatusLine(line, columns) {
+    if (!columns || columns < 2)
+        return line;
+    const max = columns - 1; // leave the last cell free so the cursor can't wrap
+    const chars = Array.from(line);
+    if (chars.length <= max)
+        return line;
+    return `${chars.slice(0, max - 1).join('')}…`;
+}

package/package.json

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