@magicpixelart/cli 0.5.13 → 0.5.20

package/dist/index.js

@@ -83,11 +83,11 @@ program
     .action(wrap("repair", async (opts) => repairCommand(opts)));
 program
     .command('sync')
-    .description('Download changed assets from MagicPixel')
+    .description('Two-way sync: pull MagicPixel edits, push your game sprites')
     .option('--no-prune', 'Keep local files not in the manifest (pruning is now on by default)')
     .option('--dry-run', 'Print the plan without writing files')
     .option('--full', 'Ignore lastSync state; re-fetch the full manifest')
-    .option('-w, --watch [seconds]', 'Poll for changes (default 2s; auto-slows to 5s after ~3min idle, 10s after ~15min)', parseWatchInterval)
+    .option('-w, --watch [seconds]', 'Poll for changes (default 2s; auto-slows to 5s after ~1min idle, 10s after ~5min)', parseWatchInterval)
     .option('-q, --quiet', 'Minimal output (for CI)')
     .option('-c, --concurrency <n>', 'Parallel downloads (1–16, default 6)', parseConcurrency)
     .addHelpText('after', '\nExamples:\n  $ magicpixel sync                # incremental sync\n  $ magicpixel sync --full         # ignore lastSync, re-check everything\n  $ magicpixel sync -w             # watch mode (2s; adaptive idle backoff; exit 2 after 5 auth failures)\n')
@@ -101,7 +101,7 @@ program
     .action(wrap("push", async (opts) => pushCommand(opts)));
 program
     .command('connect <glob>')
-    .description('Add a game-sprite glob to the working set and ingest matching PNGs')
+    .description('Limit which game folders sync (default is all sprites)')
     .addHelpText('after', '\nExamples:\n  $ magicpixel connect \'assets/Sprites/Hero/**\'\n  $ magicpixel connect Runtime/UI/hud.png\n')
     .action(wrap("connect", async (glob) => connectCommand(glob)));
 program

package/dist/util/engineConnect.js

@@ -0,0 +1,32 @@
+import { saveConfig } from '../config.js';
+import { detectProjectKind, isEngineKind } from './framework.js';
+export const DEFAULT_ENGINE_CONNECT = ['**'];
+const ALL_SPRITES_GLOBS = new Set(['**', '**/*', '**/**', '**/*.png', '**/**/*.png']);
+export function isAllSpritesGlob(glob) {
+    return ALL_SPRITES_GLOBS.has(glob.trim());
+}
+/**
+ * Next `connect` list after the user adds a glob.
+ * A specific folder replaces a default `**` (narrowing). `**` restores all
+ * sprites. Other globs accumulate. Stray `**` left over from an earlier
+ * default is dropped when narrowing so OR-matching cannot keep everything.
+ */
+export function nextConnectGlobs(current, pattern) {
+    if (isAllSpritesGlob(pattern))
+        return [...DEFAULT_ENGINE_CONNECT];
+    const withoutAll = current.filter((g) => !isAllSpritesGlob(g));
+    if (withoutAll.includes(pattern))
+        return withoutAll;
+    return [...withoutAll, pattern];
+}
+export async function ensureEngineConnect(config, cwd = process.cwd(), persist = true) {
+    if (config.connect.length > 0)
+        return config;
+    const kind = await detectProjectKind(cwd);
+    if (!isEngineKind(kind))
+        return config;
+    const next = { ...config, connect: [...DEFAULT_ENGINE_CONNECT] };
+    if (persist)
+        await saveConfig(next, cwd);
+    return next;
+}

package/dist/util/gameScan.js

@@ -36,6 +36,7 @@ export const GAME_SCAN_SKIP_HIDDEN = new Set([
     '.git',
     '.svn',
     '.hg',
+    '.godot',
     '.magicpixel',
     '.vs',
     '.vscode',
@@ -138,7 +139,7 @@ function bindScanProgress(onProgress) {
         lastAt = Date.now();
         onProgress(p);
     };
-    return (pngs, folders, current) => {
+    const visit = (pngs, folders, current) => {
         const next = { pngs, folders, current };
         const now = Date.now();
         if (lastAt === 0 || now - lastAt >= 80) {
@@ -159,6 +160,15 @@ function bindScanProgress(onProgress) {
             timer.unref();
         }
     };
+    visit.flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        if (pending)
+            flush(pending);
+    };
+    return visit;
 }
 function samePath(a, b) {
     return a.replace(/\\/g, '/').toLowerCase() === b.replace(/\\/g, '/').toLowerCase();
@@ -183,6 +193,7 @@ export async function indexGamePngs(kind, cwd = process.cwd(), outDir = '', opts
     const startAt = isUnityGameProject(cwd, assetRoot) ? assetRoot : scanRoot;
     const preferFirst = startAt === scanRoot ? assetRoot : null;
     await walkPngs(startAt, scanRoot, destNorm, found, MAX_GAME_INDEX + 1, io, report, stats, preferFirst);
+    report.flush?.();
     opts.onProgress?.({ pngs: found.length, folders: stats.folders });
     found.sort((a, b) => a.localeCompare(b));
     const capped = found.length > MAX_GAME_INDEX;

package/dist/util/localEdit.js

@@ -0,0 +1,29 @@
+/**
+ * "Was this PNG edited in the game project since we last wrote or pushed it?"
+ *
+ * The single definition of a local edit, used by two callers:
+ *
+ *   - `pullDecision` — an entry still in the manifest whose disk bytes diverged
+ *     is a conflict, not a download target.
+ *   - the prune sweep in `sync` — a path that LEFT the manifest (deselected
+ *     "Sync to Unity", trashed document, rename/previous-key cruft) must not be
+ *     deleted while it holds work MagicPixel has never seen.
+ *
+ * Without a recorded baseline (`state.synced[key].diskSha256`) we can't tell an
+ * edit from a file we never wrote, so we report "no edit" and let the caller's
+ * existing rules apply unchanged.
+ */
+import { fileSha256 } from './hash.js';
+/** Pure comparison — no filesystem access, safe for decision unit tests. */
+export function isLocalEdit(baselineDiskSha256, localSha256) {
+    if (!baselineDiskSha256 || !localSha256)
+        return false;
+    return baselineDiskSha256 !== localSha256;
+}
+/** Hashes `absPath` only when a baseline exists (nothing else can be an edit). */
+export async function hasUnpushedLocalEdit({ absPath, baselineDiskSha256, knownSha256, }) {
+    if (!baselineDiskSha256)
+        return false;
+    const sha = knownSha256 !== undefined ? knownSha256 : await fileSha256(absPath);
+    return isLocalEdit(baselineDiskSha256, sha);
+}

package/dist/util/pullDecision.js

@@ -0,0 +1,45 @@
+/**
+ * Whether a manifest entry should be written to disk.
+ *
+ * Connected game PNGs are usually *not* the same bytes as MagicPixel's
+ * re-encoded composite. Comparing those hashes would re-download the whole
+ * library on every catch-up and overwrite the originals. Pull only when the
+ * cloud composite actually changed since we last recorded it, or when there
+ * is no local file to protect.
+ *
+ * Third outcome: `conflict`. `sync` pulls before it pushes, so a PNG edited on
+ * disk *and* in MagicPixel since the last sync would be overwritten before
+ * `push` ever sees it — the local edit would vanish with no message. When the
+ * disk bytes diverge from the fingerprint we recorded when we last wrote/pushed
+ * that file, the entry is reported instead of downloaded.
+ */
+import { isLocalEdit } from './localEdit.js';
+export function decidePull(opts) {
+    const cloud = opts.cloudSha256 ?? null;
+    const local = opts.localSha256;
+    const prev = opts.previousCloudSha256;
+    // Missing on disk → restore from cloud (MagicPixel-only art and deletions).
+    if (!local)
+        return 'pull';
+    if (cloud && cloud === local)
+        return 'skip';
+    // Cloud composite unchanged since last pull/push — keep the original PNG.
+    if (cloud && prev && cloud === prev)
+        return 'skip';
+    if (opts.inWorkingSet) {
+        // Never recorded a cloud hash: disk is the source of truth (connect/ingest).
+        if (!prev)
+            return 'skip';
+        // Editor save often nulls the cached hash; treat that as a cloud change.
+        return localEdit(opts) ? 'conflict' : 'pull';
+    }
+    return localEdit(opts) ? 'conflict' : 'pull';
+}
+/**
+ * Disk bytes changed since we recorded them → someone edited the PNG in the
+ * game project. Without a recorded baseline we can't tell an edit from a file
+ * we never wrote, so we stay out of the way and let the pull proceed.
+ */
+function localEdit(opts) {
+    return isLocalEdit(opts.lastPushedDiskSha256, opts.localSha256);
+}

package/dist/util/reconcile.js

@@ -0,0 +1,23 @@
+/**
+ * When to promote an incremental sync to a full reconcile.
+ *
+ * `removed_keys` can only describe rows that still exist (trashed /
+ * componentized). A permanent delete ("Empty Trash") leaves nothing to report,
+ * so an incremental client keeps the PNG in the game project indefinitely. A
+ * periodic full pass — the manifest itself is the truth there — closes that
+ * without tombstone tables or per-tick cost.
+ */
+/** 15 minutes: bounded orphan lifetime, ~4 full manifests/hour worst case. */
+export const RECONCILE_INTERVAL_MS = 15 * 60 * 1000;
+export function shouldReconcile(lastReconcile, nowMs, intervalMs = RECONCILE_INTERVAL_MS) {
+    if (!lastReconcile)
+        return true;
+    const then = Date.parse(lastReconcile);
+    if (!Number.isFinite(then))
+        return true;
+    // Clock moved backwards (machine sleep / NTP step): reconcile rather than
+    // waiting out a bogus future timestamp.
+    if (then > nowMs)
+        return true;
+    return nowMs - then >= intervalMs;
+}

package/dist/util/security.js

@@ -96,7 +96,9 @@ export async function safeFetch(url, init = {}) {
     let current = url;
     for (let hop = 0; hop < 5; hop++) {
         const res = await fetch(current, { ...init, redirect: 'manual' });
-        if (res.status < 300 || res.status >= 400)
+        // 304 lives in the 3xx range but is a conditional-request answer, not a
+        // redirect: it carries no Location and callers handle it directly.
+        if (res.status < 300 || res.status >= 400 || res.status === 304)
             return res;
         const location = res.headers.get('location');
         await res.body?.cancel();

package/dist/util/syncPath.js

@@ -37,6 +37,37 @@ export function collectSourceRelMap(connected, synced) {
     }
     return map;
 }
+/**
+ * Ingest appends `-2`, `-3`, … to the *document* slug when the library already
+ * has that name. The live connect index still uses the unsuffixed key, so a
+ * catch-up pull would treat `ground-ice-snow-4/…` as new MagicPixel art and
+ * dump thousands of copies into outDir. Alias those keys onto the original
+ * PNG when the unsuffixed key is already in the working set.
+ */
+export function stripDocCollisionSuffix(key) {
+    const parts = key.split('/');
+    if (parts.length < 2)
+        return key;
+    const docIdx = parts.length - 2;
+    const stripped = parts[docIdx].replace(/-(\d+)$/, '');
+    if (stripped === parts[docIdx])
+        return key;
+    const next = parts.slice();
+    next[docIdx] = stripped;
+    return next.join('/');
+}
+export function aliasCollisionKeys(sourceByKey, manifestKeys) {
+    for (const key of manifestKeys) {
+        if (sourceByKey.has(key))
+            continue;
+        const base = stripDocCollisionSuffix(key);
+        if (base === key)
+            continue;
+        const rel = sourceByKey.get(base);
+        if (rel)
+            sourceByKey.set(key, rel);
+    }
+}
 /**
  * When the cloud assigned a different composite key than the index key,
  * push under the cloud key so we update instead of adopting a duplicate.

package/dist/util/unityFilter.js

@@ -1,5 +1,5 @@
 /**
- * Per-artboard Unity sync opt-in (strict).
+ * Per-artboard Unity sync opt-in (strict), with a working-set override.
  *
  * In the editor, each artboard has a "Sync to Unity" checkbox (and library
  * folders have a folder-level switch that cascades). A project may hold 100
@@ -9,8 +9,14 @@
  * Strict opt-in: `unity === true` syncs, anything else does not. A missing
  * flag means the server didn't say (older edge deploy, or a budget-starved
  * manifest backfill) — those entries are excluded and reported via
- * `unknownFlags` so the caller can warn instead of silently syncing the whole
+ * `unknown` so the caller can warn instead of silently syncing the whole
  * library into someone's game project.
+ *
+ * Exception: sprites already in the game (connect working set / previously
+ * synced keys) always pull. An editor save nulls `artboard_index` and the
+ * next manifest often omits `unity` (or rebuilds it as false because the
+ * layer JSON dropped `syncToUnity`). Those saves must still write back to
+ * the original PNG.
  */
 export function filterUnityManifest(manifest, opts = {}) {
     if (opts.syncAll)
@@ -23,3 +29,49 @@ export function filterUnityManifest(manifest, opts = {}) {
         unknown,
     };
 }
+/** Keys we already write to on disk — connect globs plus those sprites' cloud aliases. */
+export function workingSetPullKeys(sourceByKey, synced) {
+    const keys = new Set(sourceByKey.keys());
+    const assetIds = new Set();
+    if (synced) {
+        for (const [key, sprite] of Object.entries(synced)) {
+            if (!keys.has(key))
+                continue;
+            if (sprite.assetId)
+                assetIds.add(sprite.assetId);
+        }
+    }
+    return { keys, assetIds };
+}
+export function isWorkingSetEntry(entry, pull) {
+    if (entry.key && pull.keys.has(entry.key))
+        return true;
+    if (entry.previous_keys?.some((k) => pull.keys.has(k)))
+        return true;
+    if (entry.asset_id && pull.assetIds.has(entry.asset_id)) {
+        // Same document as a connected sprite. Post-save fallback (flag omitted)
+        // must still pull; explicitly unflagged sibling artboards must not dump
+        // into outDir.
+        return entry.unity !== false;
+    }
+    return false;
+}
+/**
+ * Flagged artboards, plus any working-set sprite whose Unity flag is missing
+ * or false after an editor save / index rebuild.
+ */
+export function applyUnityPullPolicy(manifest, opts = {}) {
+    const filtered = filterUnityManifest(manifest, { syncAll: opts.syncAll });
+    if (opts.syncAll || !opts.alwaysPull)
+        return filtered;
+    const already = new Set(filtered.entries);
+    const extra = manifest.filter((e) => !already.has(e) && opts.alwaysPull(e));
+    if (extra.length === 0)
+        return filtered;
+    const extraSet = new Set(extra);
+    return {
+        entries: filtered.entries.concat(extra),
+        unknown: filtered.unknown.filter((e) => !extraSet.has(e)),
+        noneFlagged: false,
+    };
+}

package/dist/util/watchCopy.js

@@ -16,6 +16,6 @@ export function formatWatchSpriteLine(c) {
         return `   Sprites:  ${fmt(set)} in your game  ·  ${fmt(pulled)} last pulled from MagicPixel`;
     }
     if (set > 0)
-        return `   Sprites:  ${fmt(set)} in your working set`;
+        return `   Sprites:  ${fmt(set)} in your game`;
     return `   Sprites:  ${fmt(pulled)}`;
 }

package/package.json

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