@magicpixelart/cli 0.5.12 → 0.5.13

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.5.13] — 2026-08-26
+
+### Fixed
+
+- **Connect no longer hangs at `0 sprites · 1 folder`.** Full Unity games
+  (`ProjectSettings` present) scan `Assets/` only — listing Library and the
+  rest of the project root blocked the spinner before any sprite was found.
+  Directory reads stream so the path keeps updating (`Assets/Sprites`), and
+  nested walks no longer deadlock on the folder limiter.
+- **`connect` copy.** Re-running `connect '**'` no longer prints
+  `connect pattern already present: **`. First-time connect says
+  `now syncing all sprites in your game`.
+
 ## [0.5.12] — 2026-08-26
 
 ### Fixed

package/dist/commands/connect.js

@@ -6,6 +6,14 @@ import { detectProjectKind, isEngineKind } from '../util/framework.js';
 import { indexGamePngs, matchConnectGlobs, GAME_INDEX_CAP_HINT, connectCapMessage, countingSpritesText } from '../util/gameScan.js';
 import { cmd } from '../util/invoke.js';
 import { runPush } from './push.js';
+/** Plain-language label for a connect glob (`**` is not meaningful to players). */
+export function describeWorkingSet(glob) {
+    const g = glob.trim();
+    if (g === '**' || g === '**/*' || g === '**/**' || g === '**/*.png' || g === '**/**/*.png') {
+        return 'all sprites in your game';
+    }
+    return g;
+}
 /**
  * Add a working-set glob and ingest matching game PNGs into Connected.
  * Sync writes edits back to the original files — not a copy under outDir.
@@ -17,10 +25,7 @@ export async function connectCommand(glob) {
     if (!already) {
         config.connect.push(pattern);
         await saveConfig(config);
-        console.log(kleur.green(`✓ added connect pattern: ${pattern}`));
-    }
-    else {
-        console.log(kleur.dim(`  connect pattern already present: ${pattern}`));
+        console.log(kleur.green(`✓ now syncing ${describeWorkingSet(pattern)}`));
     }
     const kind = await detectProjectKind();
     if (!isEngineKind(kind)) {

package/dist/commands/sync.js

@@ -413,9 +413,11 @@ async function runOnce(opts, runOpts = {}) {
                 onProgress: (p) => {
                     const n = p.pngs.toLocaleString('en-US');
                     const f = p.folders.toLocaleString('en-US');
-                    onStatus?.(p.folders > 0
-                        ? `Looking through your game sprites…  ${n} sprites · ${f} folders`
-                        : `Looking through your game sprites…  ${n}`);
+                    onStatus?.(p.current
+                        ? `Looking through your game sprites…  ${n} sprites · ${f} folders  ·  ${p.current}`
+                        : p.folders > 0
+                            ? `Looking through your game sprites…  ${n} sprites · ${f} folders`
+                            : `Looking through your game sprites…  ${n}`);
                 },
             })
             : { files: [], capped: false });

package/dist/util/gameScan.js

@@ -4,7 +4,7 @@
  * globs select a working set; sync writes back to those original paths.
  */
 import { existsSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
+import { opendir } from 'node:fs/promises';
 import { relative, resolve } from 'node:path';
 import { isEngineKind, resolveChildDir } from './framework.js';
 import { assertPathInsideRoot, sanitizeSourceRel } from './security.js';
@@ -52,8 +52,12 @@ export const MAX_GAME_INDEX = 10_000;
 export const MAX_GAME_CONNECT = MAX_GAME_INDEX;
 export const GAME_INDEX_CAP_HINT = `Game index hit ${MAX_GAME_INDEX} PNGs — later files aren't searchable or connectable.`;
 export function connectCapMessage(total, ingested) {
-    return (`${total} PNGs match the working set — ingesting the first ${ingested} (cap ${MAX_GAME_CONNECT}). ` +
-        `Narrow the glob, or add another connect pattern for the rest.`);
+    return (`${total} sprites match — syncing the first ${ingested} (cap ${MAX_GAME_CONNECT}). ` +
+        `Connect a smaller folder if you don't need all of them.`);
+}
+/** True for a full Unity game project (not an embedded UPM package). */
+function isUnityGameProject(cwd, assetRoot) {
+    return Boolean(assetRoot && existsSync(resolve(cwd, 'ProjectSettings')));
 }
 export function gameScanRoot(kind) {
     switch (kind) {
@@ -101,32 +105,58 @@ function toEntry(abs, cwdAbs, assetRoot) {
 function fmtCount(n, noun) {
     return `${n.toLocaleString('en-US')} ${noun}${n === 1 ? '' : 's'}`;
 }
+function shortPath(rel) {
+    const n = rel.replace(/\\/g, '/');
+    if (!n || n === '.')
+        return '';
+    return n.length <= 48 ? n : `…${n.slice(-47)}`;
+}
 /** Spinner / status copy while walking the game tree. */
 export function countingSpritesText(progress = 0) {
     const pngs = typeof progress === 'number' ? progress : progress.pngs;
     const folders = typeof progress === 'number' ? 0 : progress.folders;
-    if (pngs === 0 && folders === 0)
+    const current = typeof progress === 'number' ? undefined : progress.current;
+    if (pngs === 0 && folders === 0 && !current)
         return 'Counting sprites in your game…';
     const spriteBit = fmtCount(pngs, 'sprite');
+    const parts = [spriteBit];
     if (folders > 0)
-        return `Counting sprites in your game…  ${spriteBit} · ${fmtCount(folders, 'folder')}`;
-    return `Counting sprites in your game…  ${spriteBit}`;
+        parts.push(fmtCount(folders, 'folder'));
+    const where = current ? shortPath(current) : '';
+    if (where)
+        parts.push(where);
+    return `Counting sprites in your game…  ${parts.join(' · ')}`;
 }
 function bindScanProgress(onProgress) {
     if (!onProgress)
         return () => { };
     let lastAt = 0;
-    let lastPngs = -1;
-    let lastFolders = -1;
-    return (pngs, folders) => {
-        if (pngs === lastPngs && folders === lastFolders)
-            return;
+    let pending = null;
+    let timer = null;
+    const flush = (p) => {
+        pending = null;
+        lastAt = Date.now();
+        onProgress(p);
+    };
+    return (pngs, folders, current) => {
+        const next = { pngs, folders, current };
         const now = Date.now();
-        if (lastPngs < 0 || now - lastAt >= 80) {
-            lastAt = now;
-            lastPngs = pngs;
-            lastFolders = folders;
-            onProgress({ pngs, folders });
+        if (lastAt === 0 || now - lastAt >= 80) {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            flush(next);
+            return;
+        }
+        pending = next;
+        if (!timer) {
+            timer = setTimeout(() => {
+                timer = null;
+                if (pending)
+                    flush(pending);
+            }, 80 - (now - lastAt));
+            timer.unref();
         }
     };
 }
@@ -148,7 +178,11 @@ export async function indexGamePngs(kind, cwd = process.cwd(), outDir = '', opts
     const stats = { folders: 0 };
     const io = createLimit(SCAN_WALK_CONCURRENCY);
     const report = bindScanProgress(opts.onProgress);
-    await walkPngs(scanRoot, scanRoot, destNorm, found, MAX_GAME_INDEX + 1, io, report, stats, assetRoot);
+    // Full Unity games: walk Assets/ only. Listing the project root waits on
+    // Library/Packages/cloud placeholders and looks hung at "1 folder".
+    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);
     opts.onProgress?.({ pngs: found.length, folders: stats.folders });
     found.sort((a, b) => a.localeCompare(b));
     const capped = found.length > MAX_GAME_INDEX;
@@ -178,58 +212,74 @@ export function searchGameIndex(index, query) {
         return [];
     return index.files.filter((e) => e.sourceRel.toLowerCase().includes(q) || e.key.includes(q) || e.adoptRel.toLowerCase().includes(q));
 }
-async function walkPngs(dir, root, destNorm, out, limit, io, onVisit, stats, preferFirst) {
-    if (out.length >= limit)
-        return;
-    // Count the folder *before* readdir so a huge listing still shows movement.
-    stats.folders++;
-    onVisit(out.length, stats.folders);
-    let entries;
+function folderLabel(dir, root) {
+    return relative(root, dir).replace(/\\/g, '/') || '.';
+}
+/**
+ * List one directory. The limiter wraps *only* this listing so a parent does
+ * not hold a slot while waiting on children (that deadlocks wide Unity trees).
+ */
+async function listDir(dir, root, destNorm, out, limit, onVisit, stats, preferFirst, current) {
+    const preferred = [];
+    const other = [];
+    let dh;
     try {
-        entries = await readdir(dir, { withFileTypes: true });
+        dh = await opendir(dir);
     }
     catch {
-        return;
+        return { preferred, other };
     }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    const preferred = [];
-    const other = [];
-    for (const ent of entries) {
-        if (out.length >= limit)
-            return;
-        if (ent.isSymbolicLink())
-            continue;
-        const full = resolve(dir, ent.name);
-        try {
-            assertPathInsideRoot(full, root, 'scan');
-        }
-        catch {
-            continue;
-        }
-        if (ent.isDirectory()) {
-            if (shouldSkipDir(ent.name))
+    let lastBeat = Date.now();
+    try {
+        for await (const ent of dh) {
+            if (out.length >= limit)
+                break;
+            const now = Date.now();
+            if (now - lastBeat >= 80) {
+                lastBeat = now;
+                onVisit(out.length, stats.folders, current);
+            }
+            if (shouldSkipDir(ent.name) || ent.isSymbolicLink())
                 continue;
-            if (destNorm && full.replace(/\\/g, '/').toLowerCase() === destNorm)
+            const full = resolve(dir, ent.name);
+            try {
+                assertPathInsideRoot(full, root, 'scan');
+            }
+            catch {
                 continue;
-            if (preferFirst && samePath(full, preferFirst))
-                preferred.push(full);
-            else
-                other.push(full);
-        }
-        else if (ent.isFile() && ent.name.toLowerCase().endsWith('.png')) {
-            out.push(full);
-            onVisit(out.length, stats.folders);
+            }
+            if (ent.isDirectory()) {
+                if (destNorm && full.replace(/\\/g, '/').toLowerCase() === destNorm)
+                    continue;
+                if (preferFirst && samePath(full, preferFirst))
+                    preferred.push(full);
+                else
+                    other.push(full);
+            }
+            else if (ent.isFile() && ent.name.toLowerCase().endsWith('.png')) {
+                out.push(full);
+                onVisit(out.length, stats.folders, current);
+            }
         }
     }
+    catch {
+        /* unreadable mid-listing */
+    }
+    return { preferred, other };
+}
+async function walkPngs(dir, root, destNorm, out, limit, io, onVisit, stats, preferFirst) {
+    if (out.length >= limit)
+        return;
+    stats.folders++;
+    const current = folderLabel(dir, root);
+    onVisit(out.length, stats.folders, current);
+    const { preferred, other } = await io(() => listDir(dir, root, destNorm, out, limit, onVisit, stats, preferFirst, current));
     if (out.length >= limit)
         return;
-    // Engine asset tree first (Unity `Assets/`) so sprite counts appear before
-    // sibling folders like Builds/Editor. Nested walks keep preferFirst so a
-    // misplaced `Assets` dir is still prioritized if we ever see it.
     for (const d of preferred) {
         await walkPngs(d, root, destNorm, out, limit, io, onVisit, stats, null);
     }
     if (other.length === 0 || out.length >= limit)
         return;
-    await Promise.all(other.map((d) => io(() => walkPngs(d, root, destNorm, out, limit, io, onVisit, stats, null))));
+    await Promise.all(other.map((d) => walkPngs(d, root, destNorm, out, limit, io, onVisit, stats, null)));
 }

package/package.json

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