@magicpixelart/cli 0.4.0 → 0.5.2

package/CHANGELOG.md

@@ -7,7 +7,81 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.5.2] — 2026-06-02
+
+### Fixed
+
+- **Instant HMR for synced assets (regression from 0.5.1).** 0.5.1 routed
+  the per-asset PNG writer through `atomicWrite`, which stages a
+  `<name>.<pid>.<hex>.tmp` file and `rename()`s over the target. Vite's
+  chokidar watcher only collapses the resulting unlink/add pair when the
+  tmp filename starts with `.` or ends with `~` — ours matches neither, so
+  the target was observed as an `add` rather than a `change` and Vite did
+  not re-push the new image URL to the open browser. Users had to hard
+  refresh to see freshly-synced assets (e.g. after renaming an artboard).
+  The asset writer is back to a direct `writeFile(diskPath, bytes)` —
+  same inode, single `change` event, immediate HMR. Atomicity is not
+  needed for asset bytes (a torn write is self-healing on the next watch
+  tick via sha mismatch); `atomicWrite` remains in use for `state.json`,
+  credentials, `AGENTS.md`, `package.json`, and `magicpixel.json`, where
+  torn writes WOULD corrupt cross-run state. A regression-guard test
+  (`tests/sync.assetWriterDirect.test.ts`) pins this contract.
+
+## [0.5.1] — 2026-06-02
+
+### Fixed
+
+- **`.tmp` file leak in `atomicWrite` and the asset writer.** Every CLI write
+  that goes through `atomicWrite` (`state.json`, `package.json`,
+  `magicpixel.json`, credentials, `AGENTS.md`, the generated index) and the
+  inline tmp+rename in `sync` previously skipped cleanup when `rename()`
+  threw (FS hiccup, AV scan, racing writer, ENOSPC). Because `saveState`
+  fires every watch tick, even a low failure rate accumulated hundreds of
+  `<file>.<pid>.<hex>.tmp` files inside `.magicpixel/` and
+  `src/assets/magicpixel/<folder>/` — and they were invisible to the
+  `*.png`-only orphan walker. `atomicWrite` now wraps the write/chmod/rename
+  body in a `try { … } catch { unlink(tmp); throw }` block; the asset writer
+  in `sync` is reduced to a single `atomicWrite(diskPath, bytes)` call so
+  there's only one staging path left.
+- **Renamed artboard left the old PNG on disk in incremental mode.** When
+  `state.json` was stale (e.g. a victim of the `.tmp` leak above) the
+  rename detector couldn't correlate the new manifest entry to the prior
+  key, and the incremental code path skips the full orphan sweep. Sync now
+  has a sha-based fallback: for each download-bound entry whose `sha256`
+  matches a stranded local PNG (one whose disk path is not in the current
+  manifest), we record a synthetic `RenameInfo` and prune the stale PNG.
+  Same-bytes + manifest-no-longer-references-that-path is unambiguous
+  evidence of a rename and never deletes anything the user still owns.
+
+### Added
+
+- **Startup `.tmp` janitor.** `magicpixel sync` (one-shot and `--watch`)
+  sweeps stale `<file>.<pid>.<hex>.tmp` files left over from prior crashed
+  or killed runs across `outDir/**`, `.magicpixel/`, and the project root.
+  Pattern is anchored (`\.\d+\.[0-9a-f]{16}\.tmp$`) so user files with
+  `.tmp` in the name are never touched, and a 30-second age floor prevents
+  any race with a concurrent in-flight write.
+- **`atomicWrite` now accepts `Uint8Array` in addition to `string`** so the
+  asset-bytes writer in `sync` can share the same cleanup-guaranteed
+  staging logic as every other writer.
+
+## [0.5.0] — 2026-06-02
+
+### Added
+- **Legacy slug-folder sweep.** When a server-side slug rule change renames
+  a doc (e.g. `cards-2` → `cards`) and the prior id→key snapshot is missing
+  (fresh clone, CI runner, snapshot wipe), `sync` now detects top-level
+  `outDir` folders matching `<currentSlug>-<n>` for any slug known from the
+  manifest OR the prior persisted snapshot, and prunes them whole. Always
+  prints a `Legacy slug folders removed — update your imports:` block with
+  find/replace hints so users fix any source code references. Runs in both
+  full and incremental mode; respects `--no-prune`. Sibling slugs that are
+  themselves valid (e.g. a user-named `tiles-2/` next to `tiles/`) are
+  never deleted because the "known slugs" set unions the live manifest
+  with the persisted id→key map.
+
 ### Fixed
+
 - **`sync --watch 1` silently coerced to 2.** The commander validator
   accepted `1–3600` but the watch loop enforced a 2s floor via
   `Math.max(2, …)`, so `--watch 1` quietly ran at 2s with no warning.

package/dist/commands/sync.js

@@ -1,7 +1,7 @@
 import kleur from 'kleur';
 import ora from 'ora';
 import { createHash } from 'node:crypto';
-import { mkdir, writeFile, unlink, rename } from 'node:fs/promises';
+import { mkdir, unlink, readdir, rm, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, relative, resolve } from 'node:path';
 import { loadConfig, loadState, saveState } from '../config.js';
@@ -10,11 +10,23 @@ import { fileSha256 } from '../util/hash.js';
 import { assetDiskPath, assetDiskPathFromKey, pruneEmptyDirs, walkOutDirPngs } from '../util/paths.js';
 import { createLimit } from '../util/limit.js';
 import { emitTypedIndex, ensureAgentsDoc, scanDiskAssets } from '../util/emitIndex.js';
-import { assertPathInsideRoot, tmpPathFor } from '../util/security.js';
+import { assertPathInsideRoot } from '../util/security.js';
+import { runTmpJanitor } from '../util/tmpJanitor.js';
 import { friendlyFsError } from '../util/errors.js';
 import { maxIsoTimestamp } from '../util/iso.js';
 import { formatBytes } from '../util/format.js';
 export async function syncCommand(opts) {
+    // Sweep any leaked `<file>.<pid>.<hex>.tmp` files left behind by a prior
+    // crashed/killed CLI run before they pile up. Runs once per CLI invocation
+    // (watch mode included) and only touches files older than 30s, so it can
+    // never race a concurrent in-flight write. See util/tmpJanitor.ts.
+    try {
+        const cfg = await loadConfig();
+        await runTmpJanitor(cfg.outDir);
+    }
+    catch {
+        /* janitor is best-effort — never let it block a sync */
+    }
     if (opts.watch) {
         await watchLoop(opts);
         return;
@@ -354,11 +366,58 @@ async function runOnce(opts, runOpts = {}) {
     // Orphan detection only when we have the full picture.
     // (Renames also produce a stale path on disk — collected separately below.)
     let orphans = [];
+    const remoteDiskPaths = new Set(manifest.map((e) => pathFor(e)));
+    // We walk local PNGs even in incremental mode so the sha-based rename
+    // fallback below has something to match against. The full-orphan path is
+    // still gated on `!since` to preserve incremental-mode safety (we never
+    // delete files outside what the current manifest delta touches).
+    const localPngs = await walkOutDirPngs(config.outDir);
     if (!since) {
-        const remoteDiskPaths = new Set(manifest.map((e) => pathFor(e)));
-        const localPngs = await walkOutDirPngs(config.outDir);
         orphans = localPngs.map((a) => a.abs).filter((p) => !remoteDiskPaths.has(p));
     }
+    // Heuristic-rename fallback for incremental mode.
+    //
+    // If `state.json` was lost or got out of sync (rare, but the 0.5.x leak of
+    // `state.json.<pid>.<hex>.tmp` files proved it happens in practice — see
+    // CHANGELOG 0.5.1), `previousAssets` won't have the mapping needed to mark
+    // a renamed artboard. The old `<oldSlug>.png` then lingers forever next to
+    // the new `<newSlug>.png` because incremental mode skips the full orphan
+    // sweep.
+    //
+    // Bridge that gap: for every download-bound entry, look for a stranded
+    // local PNG (path not in this manifest) whose sha256 matches the entry's.
+    // Same bytes + manifest no longer references that path = same artboard,
+    // renamed. We add the stranded path to `renameStalePaths` and record a
+    // RenameInfo so the CLI prints the migration hint.
+    if (since && toDownload.length > 0) {
+        const strandedBySha = new Map();
+        for (const local of localPngs) {
+            if (remoteDiskPaths.has(local.abs))
+                continue;
+            const sha = await fileSha256(local.abs);
+            if (sha)
+                strandedBySha.set(sha, local.abs);
+        }
+        if (strandedBySha.size > 0) {
+            const outRoot = resolve(process.cwd(), config.outDir);
+            const seenRenameIds = new Set(renamed.map((r) => r.id));
+            for (const entry of toDownload) {
+                if (!entry.sha256)
+                    continue;
+                if (seenRenameIds.has(entry.id))
+                    continue;
+                const strandedPath = strandedBySha.get(entry.sha256);
+                if (!strandedPath)
+                    continue;
+                // Derive the disk key from the stranded path so the rename hint reads
+                // naturally (`cards/artboard-1 → cards/tree`).
+                const rel = relative(outRoot, strandedPath).replace(/\\/g, '/');
+                const oldKey = rel.endsWith('.png') ? rel.slice(0, -4) : rel;
+                renamed.push({ id: entry.id, oldKey, newKey: entry.key });
+                seenRenameIds.add(entry.id);
+            }
+        }
+    }
     // Stale paths from detected renames (always pruned, even in incremental mode —
     // otherwise the old PNG silently lingers next to the renamed copy).
     const renameStalePaths = renamed
@@ -369,6 +428,38 @@ async function runOnce(opts, runOpts = {}) {
     for (const p of renameStalePaths)
         orphanSet.add(p);
     orphans = [...orphanSet];
+    // Legacy-suffix folder sweep — always runs, even in incremental mode.
+    //
+    // Background: server-side slug uniqueness rules have changed over time
+    // (e.g. per-user → per-project). A doc that used to live under
+    // `outDir/cards-2/` may now report slug `cards` in the manifest. If the
+    // CLI's prior snapshot doesn't have the old id→key mapping (fresh clone,
+    // CI runner, snapshot wipe), rename detection finds nothing and the stale
+    // folder lingers next to the current one, breaking the user's imports of
+    // `@/assets/.../cards-2/...`.
+    //
+    // We detect this by looking for top-level disk folders whose name matches
+    // `<currentSlug>-<n>` for any slug currently in the manifest. Those are
+    // unambiguously legacy suffix collisions. We prune the whole folder
+    // (when --prune is on) and surface a clear "update your imports" notice
+    // so the user knows their source code references must be migrated.
+    // Build the "known top-level slugs" set from BOTH the current manifest AND
+    // the prior id→key snapshot. In incremental (`--watch`) mode the manifest
+    // only contains rows changed since `lastSync`, so a user with two
+    // legitimate sibling slugs (`tiles/` + `tiles-2/`) would lose `tiles-2/`
+    // the moment only `tiles` appeared in a delta. Pulling from
+    // `previousAssets` (the persisted full snapshot) closes that hole.
+    const knownFolderSlugs = new Set();
+    for (const e of manifest) {
+        if (e.folder)
+            knownFolderSlugs.add(e.folder.split('/')[0]);
+    }
+    for (const key of Object.values(previousAssets)) {
+        const top = key.split('/')[0];
+        if (top)
+            knownFolderSlugs.add(top);
+    }
+    const legacyFolders = await findLegacySuffixFolders(config.outDir, knownFolderSlugs);
     if (verbose) {
         console.log();
         console.log(kleur.bold('Plan:'));
@@ -376,6 +467,10 @@ async function runOnce(opts, runOpts = {}) {
         console.log(`  ${kleur.dim('=')} unchanged ${unchanged}${bytesSaved ? kleur.dim(` (~${formatBytes(bytesSaved)} saved)`) : ''}`);
         if (renamed.length)
             console.log(`  ${kleur.cyan('↪')} renamed ${renamed.length}`);
+        if (legacyFolders.length) {
+            const verb = shouldPrune ? kleur.red('delete') : kleur.yellow('keep');
+            console.log(`  ${verb} ${legacyFolders.length} legacy slug folder${legacyFolders.length === 1 ? '' : 's'}`);
+        }
         if (since && !renamed.length) {
             console.log(`  ${kleur.dim('orphan check skipped (incremental — use --full)')}`);
         }
@@ -392,6 +487,8 @@ async function runOnce(opts, runOpts = {}) {
                 printRenames(renamed, { withHints: false });
             if (orphans.length > 0)
                 printOrphans(orphans);
+            if (legacyFolders.length > 0)
+                printLegacyFolders(legacyFolders);
         }
         return {
             added: [],
@@ -448,14 +545,23 @@ async function runOnce(opts, runOpts = {}) {
                         throw new Error(`sha256 mismatch (expected ${entry.sha256.slice(0, 12)}…, got ${actual.slice(0, 12)}…)`);
                     }
                 }
-                // Wrap any of mkdir/writeFile/rename so the user sees a friendly
+                // Wrap any of mkdir/writeFile so the user sees a friendly
                 // multi-line diagnostic instead of a raw `EACCES: permission denied`.
+                //
+                // NOTE: Asset PNGs deliberately use a direct writeFile rather than
+                // atomicWrite. Vite's chokidar watcher only suppresses atomic-rename
+                // unlink/add pairs when the tmp filename starts with '.' or ends
+                // with '~'; our pattern <name>.<pid>.<hex>.tmp matches neither, so
+                // rename-over emits unlink+add instead of change, which breaks
+                // instant HMR for image imports in the browser (user has to hard
+                // refresh to see the new asset). A torn write here is self-healing
+                // on the next watch tick (re-download by sha mismatch), so the
+                // atomicity guarantee isn't worth the HMR regression. Do not
+                // "fix" this back to atomicWrite without also changing the
+                // tmp-name pattern AND verifying HMR end-to-end in a consumer app.
                 try {
                     await mkdir(dirname(diskPath), { recursive: true });
-                    const tmp = tmpPathFor(diskPath);
-                    assertPathInsideRoot(tmp, resolve(process.cwd(), config.outDir), 'outDir');
-                    await writeFile(tmp, bytes);
-                    await rename(tmp, diskPath);
+                    await writeFile(diskPath, bytes);
                 }
                 catch (fsErr) {
                     throw friendlyFsError(fsErr, {
@@ -523,6 +629,36 @@ async function runOnce(opts, runOpts = {}) {
     else if (verbose && orphans.length > 0) {
         printOrphans(orphans);
     }
+    // Legacy-suffix folder sweep. Runs in BOTH full and incremental mode so a
+    // user who is hot off a server-side slug rule change recovers without
+    // having to remember `--full`. Folders are deleted whole (children
+    // included) because every PNG inside is, by definition, stale; their
+    // canonical copies live under the de-suffixed folder we just downloaded.
+    if (shouldPrune && legacyFolders.length > 0) {
+        const outRoot = resolve(process.cwd(), config.outDir);
+        for (const lf of legacyFolders) {
+            assertPathInsideRoot(lf.abs, outRoot, 'outDir');
+            try {
+                await rm(lf.abs, { recursive: true, force: true });
+                // Push a synthetic key so the watch loop's changedCount picks this up
+                // (otherwise a tick that ONLY swept legacy folders reports "no changes").
+                result.removed.push(`${lf.legacyName}/ (legacy)`);
+                if (verbose) {
+                    console.log(`  ${kleur.red('-')} ${relative(process.cwd(), lf.abs)} ${kleur.dim(`(legacy slug — now ${lf.currentSlug}/)`)}`);
+                }
+            }
+            catch (e) {
+                if (verbose)
+                    console.log(`  ${kleur.yellow('!')} failed to remove legacy folder ${relative(process.cwd(), lf.abs)}: ${e.message}`);
+            }
+        }
+        // Always surface the import-update notice — even in --quiet/watch mode
+        // — because user source code now references paths that no longer exist.
+        printLegacyFolders(legacyFolders);
+    }
+    else if (verbose && legacyFolders.length > 0) {
+        printLegacyFolders(legacyFolders);
+    }
     // Always persist the id → key snapshot so rename detection survives even
     // when `emitIndex` is toggled off-then-on. `lastSync` only advances on a
     // clean run, so partial-failure syncs are retried from the prior cursor.
@@ -687,5 +823,62 @@ function printOrphans(orphans) {
     }
     console.log(kleur.dim('  You passed --no-prune, so these were kept. Remove the flag to delete them.'));
 }
+/**
+ * Find top-level disk folders whose name matches `<currentSlug>-<n>` for some
+ * slug present in the manifest. These are unambiguously legacy artifacts
+ * from a server-side slug rule change (e.g. per-user → per-project
+ * uniqueness) — the canonical copy now lives under `<currentSlug>/`, and the
+ * suffixed folder's PNGs are stale.
+ *
+ * Only scans the FIRST level under outDir; nested folders are user content.
+ * Returns `[]` when outDir doesn't exist or when no remote slugs are known
+ * (defensive — never wipe folders when we have no manifest to compare to).
+ */
+export async function findLegacySuffixFolders(outDir, knownFolderSlugs, cwd = process.cwd()) {
+    if (knownFolderSlugs.size === 0)
+        return [];
+    const root = resolve(cwd, outDir);
+    if (!existsSync(root))
+        return [];
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const ent of entries) {
+        if (!ent.isDirectory())
+            continue;
+        if (ent.name.startsWith('.'))
+            continue;
+        // Skip folders that ARE known slugs — only suffixed siblings are suspect.
+        if (knownFolderSlugs.has(ent.name))
+            continue;
+        const m = /^(.+)-(\d+)$/.exec(ent.name);
+        if (!m)
+            continue;
+        const base = m[1];
+        if (!knownFolderSlugs.has(base))
+            continue;
+        out.push({
+            abs: resolve(root, ent.name),
+            legacyName: ent.name,
+            currentSlug: base,
+        });
+    }
+    return out;
+}
+function printLegacyFolders(legacy) {
+    if (legacy.length === 0)
+        return;
+    console.log();
+    console.log(kleur.bold('Legacy slug folders removed — update your imports:'));
+    for (const lf of legacy) {
+        console.log(`  ${kleur.red('-')} ${lf.legacyName}/  ${kleur.dim(`→ now ${lf.currentSlug}/`)}`);
+        console.log(`    ${kleur.dim(`Find/replace in your project:  ${lf.legacyName}/  →  ${lf.currentSlug}/`)}`);
+    }
+}
 // Note: orphan scan delegates to `walkOutDirPngs` in util/paths.ts (shared
 // with the typed-index emitter). `maxIsoTimestamp` lives in util/iso.ts.

package/dist/util/atomicWrite.js

@@ -1,25 +1,57 @@
-import { writeFile, rename, chmod } from 'node:fs/promises';
+import { writeFile, rename, chmod, unlink } from 'node:fs/promises';
 import { tmpPathFor } from './security.js';
 /**
  * Stage-and-rename file write. A crash mid-write can never leave a truncated
  * file on disk — the rename is atomic on every POSIX FS and on NTFS. Used
  * everywhere a corrupted target would break the project (state.json,
- * package.json, magicpixel.json, credentials, AGENTS.md, generated index files).
+ * package.json, magicpixel.json, credentials, AGENTS.md, generated index files,
+ * asset PNGs from `sync`).
+ *
+ * Accepts `string | Uint8Array` so the asset-bytes writer in `sync` can reuse
+ * this instead of duplicating the staging logic (one of the two prior leak
+ * sites — see CHANGELOG 0.5.1).
+ *
+ * CRITICAL: On ANY failure between staging and rename, the tmp file is
+ * unlinked before the original error is rethrown. Without this, every rare
+ * `rename` failure (FS hiccup, AV scan, racing writer, ENOSPC) leaks a
+ * `<path>.<pid>.<hex>.tmp` file forever — `saveState` runs every watch tick,
+ * so even a low failure rate accumulates hundreds of stale tmps over a long
+ * dev session and they're invisible to the `.png`-only orphan walker.
  */
 export async function atomicWrite(path, contents, opts = {}) {
     const tmp = tmpPathFor(path);
-    const writeOpts = opts.mode !== undefined ? { encoding: 'utf8', mode: opts.mode } : 'utf8';
-    await writeFile(tmp, contents, writeOpts);
-    if (opts.mode !== undefined) {
-        // Belt-and-suspenders: writeFile's `mode` only applies on create. If the
-        // tmp path was somehow pre-existing (collision is vanishingly unlikely
-        // given the pid+random suffix) the chmod ensures the perms land.
+    try {
+        if (typeof contents === 'string') {
+            const writeOpts = opts.mode !== undefined ? { encoding: 'utf8', mode: opts.mode } : 'utf8';
+            await writeFile(tmp, contents, writeOpts);
+        }
+        else {
+            const writeOpts = opts.mode !== undefined ? { mode: opts.mode } : undefined;
+            await writeFile(tmp, contents, writeOpts);
+        }
+        if (opts.mode !== undefined) {
+            // Belt-and-suspenders: writeFile's `mode` only applies on create. If the
+            // tmp path was somehow pre-existing (collision is vanishingly unlikely
+            // given the pid+random suffix) the chmod ensures the perms land.
+            try {
+                await chmod(tmp, opts.mode);
+            }
+            catch {
+                // Windows / read-only FS — ignore.
+            }
+        }
+        await rename(tmp, path);
+    }
+    catch (err) {
+        // Best-effort cleanup. We don't want a cleanup failure (e.g. tmp was
+        // never created because writeFile threw on the very first syscall) to
+        // mask the real error the caller cares about.
         try {
-            await chmod(tmp, opts.mode);
+            await unlink(tmp);
         }
         catch {
-            // Windows / read-only FS — ignore.
+            /* ignore — tmp may not exist */
         }
+        throw err;
     }
-    await rename(tmp, path);
 }

package/dist/util/tmpJanitor.js

@@ -0,0 +1,80 @@
+import { readdir, stat, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+/**
+ * Pattern produced by `tmpPathFor`: `<basename>.<pid>.<16-hex>.tmp`.
+ * Anchored at both ends to avoid matching user files that happen to contain
+ * the substring.
+ */
+const TMP_SUFFIX_RE = /\.\d+\.[0-9a-f]{16}\.tmp$/;
+/**
+ * Stale-tmp age threshold. Any tmp file modified within this window could
+ * still belong to a concurrent writer (another CLI process, or an in-flight
+ * write in this process whose `rename` is about to land). Skipping recent
+ * files is the safety net that makes the janitor side-effect-free for the
+ * happy path.
+ */
+const MIN_STALE_AGE_MS = 30_000;
+/**
+ * Walk `dirs` recursively (one level deep is enough for our layout — the
+ * outDir is `src/assets/magicpixel/<folder>/*.png` and state lives in
+ * `.magicpixel/`). Returns absolute paths of removed files. Errors during
+ * readdir/unlink are swallowed individually so one unreadable directory
+ * can't abort the whole sweep.
+ *
+ * Exported for tests; the entry point used by sync is `runTmpJanitor`.
+ */
+export async function sweepTmpFiles(dir, now = Date.now(), minAgeMs = MIN_STALE_AGE_MS) {
+    const removed = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return removed;
+    }
+    for (const ent of entries) {
+        const full = join(dir, ent.name);
+        if (ent.isDirectory()) {
+            // One level of recursion (e.g. outDir/<folder>/). Deeper trees are not
+            // produced by atomicWrite callers.
+            const nested = await sweepTmpFiles(full, now, minAgeMs);
+            for (const p of nested)
+                removed.push(p);
+            continue;
+        }
+        if (!ent.isFile())
+            continue;
+        if (!TMP_SUFFIX_RE.test(ent.name))
+            continue;
+        try {
+            const st = await stat(full);
+            if (now - st.mtimeMs < minAgeMs)
+                continue;
+            await unlink(full);
+            removed.push(full);
+        }
+        catch {
+            /* ignore — file may have just been renamed away by a concurrent writer */
+        }
+    }
+    return removed;
+}
+/**
+ * Run the janitor across the directories that atomicWrite targets land in:
+ *   - `<outDir>/**` — asset PNGs (one level of folders).
+ *   - `<cwd>/.magicpixel/` — state.json + credentials.
+ *   - `<cwd>/` — package.json, magicpixel.json, AGENTS.md.
+ *
+ * Side-effect-free for the happy path: the `MIN_STALE_AGE_MS` floor prevents
+ * any race with a concurrent in-flight write.
+ */
+export async function runTmpJanitor(outDir, cwd = process.cwd()) {
+    const dirs = [outDir, join(cwd, '.magicpixel'), cwd];
+    const all = [];
+    for (const d of dirs) {
+        const r = await sweepTmpFiles(d);
+        for (const p of r)
+            all.push(p);
+    }
+    return all;
+}

package/package.json

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