@magicpixelart/cli 0.3.3 → 0.4.0

package/dist/commands/list.js

@@ -1,6 +1,7 @@
 import kleur from 'kleur';
 import { loadConfig } from '../config.js';
 import { fetchAllManifest } from '../api.js';
+import { formatBytes } from '../util/format.js';
 export async function listCommand() {
     const config = await loadConfig();
     const entries = await fetchAllManifest(config);
@@ -9,15 +10,15 @@ export async function listCommand() {
         return;
     }
     const widthKey = Math.max(3, ...entries.map((e) => e.key.length));
-    const widthSize = 8;
+    const sizes = entries.map((e) => (e.size_bytes != null ? formatBytes(e.size_bytes) : '-'));
+    const widthSize = Math.max(4, ...sizes.map((s) => s.length));
     console.log(kleur.bold('KEY'.padEnd(widthKey)) + '  ' +
         kleur.bold('SIZE'.padEnd(widthSize)) + '  ' +
         kleur.bold('SHA256'));
-    for (const e of entries) {
-        const size = e.size_bytes != null ? `${e.size_bytes}B` : '-';
+    entries.forEach((e, i) => {
         const sha = e.sha256 ? e.sha256.slice(0, 12) : '-';
-        console.log(`${e.key.padEnd(widthKey)}  ${size.padEnd(widthSize)}  ${sha}`);
-    }
+        console.log(`${e.key.padEnd(widthKey)}  ${sizes[i].padEnd(widthSize)}  ${sha}`);
+    });
     console.log();
     console.log(kleur.dim(`${entries.length} asset${entries.length === 1 ? '' : 's'}`));
 }

package/dist/commands/login.js

@@ -1,11 +1,9 @@
 import kleur from 'kleur';
 import { createInterface } from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
-import { resolveEndpoint, loadConfig, defaultConfig } from '../config.js';
-import { writeCredentials, credentialsPath } from '../util/credentials.js';
-import { safeFetch } from '../util/security.js';
-import { CLI_USER_AGENT } from '../version.js';
-import { existsSync } from 'node:fs';
+import { loadConfig, defaultConfig } from '../config.js';
+import { writeCredentials } from '../util/credentials.js';
+import { assertKeyValid } from '../util/auth.js';
 import { relative } from 'node:path';
 const KEY_RE = /^mp_(live|test)_[a-f0-9]{64}$/;
 export async function loginCommand(opts = {}) {
@@ -67,32 +65,3 @@ async function promptForKey(maxAttempts, config) {
         rl.close();
     }
 }
-async function assertKeyValid(key, config) {
-    const url = new URL(`${resolveEndpoint(config)}/manifest`);
-    url.searchParams.set('limit', '1');
-    let res;
-    try {
-        res = await safeFetch(url.href, {
-            headers: { Authorization: `Bearer ${key}`, 'User-Agent': CLI_USER_AGENT },
-        });
-    }
-    catch (e) {
-        throw new Error(`Could not reach MagicPixel (${e.message}). Try again in a moment.`);
-    }
-    if (res.status === 401 || res.status === 403) {
-        await res.body?.cancel();
-        throw new Error('Key was rejected (401). Generate a fresh one at https://magicpixel.art/settings.');
-    }
-    if (!res.ok) {
-        const body = await res.text();
-        throw new Error(`Server returned ${res.status}: ${body.slice(0, 120)}`);
-    }
-    await res.body?.cancel();
-}
-// Kept here so `start` can reuse the same exact prompt-and-validate flow.
-export async function promptAndStoreKey(config) {
-    if (existsSync(credentialsPath()) && !stdin.isTTY)
-        return;
-    const key = await promptForKey(3, config);
-    await writeCredentials(key);
-}

package/dist/commands/repair.js

@@ -0,0 +1,157 @@
+import kleur from 'kleur';
+import { existsSync } from 'node:fs';
+import { rename } from 'node:fs/promises';
+import { resolve, relative } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { loadConfig, statePath, getApiKey } from '../config.js';
+import { assertKeyValid } from '../util/auth.js';
+import { listEmptyDirs, pruneEmptyDirs } from '../util/paths.js';
+import { syncCommand } from './sync.js';
+/**
+ * One-shot self-healing command. Runs the standard "turn it off and on
+ * again" recovery sequence so support can say "run `npx magicpixel repair`":
+ *
+ *   1. Validate the stored API key.
+ *   2. Quarantine `state.json` so the next sync re-derives everything.
+ *   3. Prune empty subdirectories under `outDir`.
+ *   4. Run a full sync (`--full --prune`).
+ *
+ * Idempotent. `--dry-run` reports the plan without writing. `--yes` skips the
+ * confirmation prompt for step 2.
+ */
+export async function repairCommand(opts = {}) {
+    console.log(kleur.bold('MagicPixel repair'));
+    console.log(kleur.dim('  Validates your setup, clears local sync state, and re-fetches everything.'));
+    console.log();
+    const config = await loadConfig();
+    const sPath = statePath();
+    // --- Step 1: validate API key --------------------------------------------
+    console.log(kleur.bold('1/4 ') + 'Validating API key…');
+    try {
+        const key = getApiKey();
+        await assertKeyValid(key, config);
+        console.log(`     ${kleur.green('✓')} key accepted`);
+    }
+    catch (e) {
+        // Preserve multi-line "Fix:" guidance from getApiKey()/assertKeyValid —
+        // truncating to the first line strips the exact instructions a
+        // first-time `repair` user needs.
+        const msg = e.message ?? String(e);
+        const [head, ...rest] = msg.split('\n');
+        console.log(`     ${kleur.red('✗')} ${head}`);
+        for (const line of rest)
+            console.log(`     ${line}`);
+        process.exitCode = 1;
+        return;
+    }
+    // --- Step 2: quarantine state.json ---------------------------------------
+    console.log(kleur.bold('2/4 ') + 'Resetting local sync state…');
+    const stateExists = existsSync(sPath);
+    // In dry-run we predict whether a real run *would* skip step 2: that
+    // happens only when there's no --yes AND no TTY for the prompt to come
+    // from (CI / piped input). Otherwise the prompt would run interactively
+    // and we can't know the answer from here — assume "would proceed" for
+    // the dry-run summary, matching the optimistic "plan looks good" line.
+    let skippedStep2 = false;
+    if (!stateExists) {
+        console.log(`     ${kleur.dim('— no state.json on disk; nothing to reset')}`);
+    }
+    else if (opts.dryRun) {
+        const dest = `${sPath}.repair-<ts>`;
+        console.log(`     ${kleur.dim(`would move:  ${relative(process.cwd(), sPath)}`)}`);
+        console.log(`     ${kleur.dim(`        →    ${relative(process.cwd(), dest)}`)}`);
+        if (!opts.yes && !stdin.isTTY) {
+            // Predict the skip a real run would hit, so step 4's note and the
+            // closing summary stay honest.
+            skippedStep2 = true;
+            console.log(`     ${kleur.yellow('note')} ${kleur.dim('non-TTY without --yes — a real run would skip this step. Re-run with --yes.')}`);
+        }
+    }
+    else {
+        if (!opts.yes && !(await confirm(`Move ${relative(process.cwd(), sPath)} aside? (y/N) `))) {
+            console.log(`     ${kleur.yellow('skipped')} (re-run with --yes to skip the prompt)`);
+            skippedStep2 = true;
+        }
+        else {
+            const dest = `${sPath}.repair-${Date.now()}`;
+            try {
+                await rename(sPath, dest);
+                console.log(`     ${kleur.green('✓')} moved to ${relative(process.cwd(), dest)}`);
+            }
+            catch (e) {
+                console.log(`     ${kleur.red('✗')} ${e.message}`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+    }
+    // --- Step 3: prune empty dirs --------------------------------------------
+    console.log(kleur.bold('3/4 ') + 'Pruning empty directories under outDir…');
+    const outRoot = resolve(process.cwd(), config.outDir);
+    if (!existsSync(outRoot)) {
+        console.log(`     ${kleur.dim(`— outDir doesn't exist yet (${config.outDir})`)}`);
+    }
+    else if (opts.dryRun) {
+        const empties = await listEmptyDirs(outRoot);
+        if (empties.length === 0) {
+            console.log(`     ${kleur.dim('— no empty subdirs under outDir')}`);
+        }
+        else {
+            console.log(`     ${kleur.dim(`would remove ${empties.length} empty subdir${empties.length === 1 ? '' : 's'}:`)}`);
+            for (const p of empties.slice(0, 10)) {
+                console.log(`     ${kleur.dim(`  - ${relative(process.cwd(), p)}`)}`);
+            }
+            if (empties.length > 10) {
+                console.log(`     ${kleur.dim(`  …and ${empties.length - 10} more`)}`);
+            }
+        }
+    }
+    else {
+        await pruneEmptyDirs(outRoot);
+        console.log(`     ${kleur.green('✓')} done`);
+    }
+    // --- Step 4: full sync ---------------------------------------------------
+    console.log(kleur.bold('4/4 ') + 'Running full sync…');
+    if (skippedStep2) {
+        console.log(kleur.dim('     (state was not reset — this will run a normal full sync, not a recovery)'));
+    }
+    if (opts.dryRun) {
+        console.log(`     ${kleur.dim('would run `magicpixel sync --full` (skipped in --dry-run)')}`);
+        console.log();
+        if (skippedStep2) {
+            console.log(kleur.yellow('! repair plan would skip the state reset. Re-run with --yes to apply it.'));
+        }
+        else {
+            console.log(kleur.green('✓ repair plan looks good. Re-run without --dry-run to apply.'));
+        }
+        return;
+    }
+    console.log();
+    // syncCommand sets `process.exitCode = 1` on download failures but does not
+    // throw. Snapshot the value before/after so we can honour it in the final
+    // message — otherwise we'd print a misleading green "complete" line over a
+    // run that exited non-zero. Default to 0 so an already-failed prior step
+    // doesn't mask a fresh failure (`1 === 1` would look like success).
+    const exitBefore = process.exitCode ?? 0;
+    await syncCommand({ full: true, prune: true });
+    console.log();
+    if ((process.exitCode ?? 0) > exitBefore) {
+        console.log(kleur.yellow('! repair completed with errors — re-run `magicpixel sync` to retry the failed downloads.'));
+    }
+    else {
+        console.log(kleur.green('✓ repair complete.'));
+    }
+}
+async function confirm(prompt) {
+    if (!stdin.isTTY)
+        return false; // CI/non-interactive: default to NO; require --yes.
+    const rl = createInterface({ input: stdin, output: stdout });
+    try {
+        const answer = (await rl.question(`     ${prompt}`)).trim().toLowerCase();
+        return answer === 'y' || answer === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/start.js

@@ -1,9 +1,10 @@
 import kleur from 'kleur';
 import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { createInterface } from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
 import { resolve } from 'node:path';
-import { configPath } from '../config.js';
+import { configPath, loadConfig } from '../config.js';
 import { hasPackageJson } from '../util/framework.js';
 import { findKeyInDotenv, readCredentialsSync, writeCredentials } from '../util/credentials.js';
 import { initCommand } from './init.js';
@@ -25,10 +26,23 @@ export async function startCommand(opts = {}) {
             '  Run this inside your project folder — the one with package.json.'));
         return;
     }
-    // 2. Run init non-interactively unless config already exists.
+    // 2. Run init non-interactively unless config already exists AND is valid.
+    // A broken `magicpixel.json` (hand-edited / truncated) used to slip past
+    // the existsSync check here and then explode deep inside `syncCommand`.
     const cfgPath = configPath();
     if (existsSync(cfgPath) && !opts.force) {
-        console.log(kleur.dim(`  Found existing magicpixel.json — skipping init.`));
+        try {
+            await loadConfig();
+            console.log(kleur.dim(`  Found existing magicpixel.json — skipping init.`));
+        }
+        catch (e) {
+            const msg = e.message ?? String(e);
+            console.log(kleur.yellow(`  Existing magicpixel.json is invalid:`));
+            for (const line of msg.split('\n'))
+                console.log(kleur.yellow(`    ${line}`));
+            console.log(kleur.dim('  Re-run `npx magicpixel start --force` to overwrite it, or fix the file by hand.'));
+            return;
+        }
     }
     else {
         await initCommand({ yes: true, force: opts.force });
@@ -49,35 +63,63 @@ export async function startCommand(opts = {}) {
     else {
         console.log(kleur.dim('  Using stored credentials from .magicpixel/credentials.'));
     }
-    // 5. First sync.
+    // 5. First sync. syncCommand sets `process.exitCode = 1` on download
+    //    failures without throwing — snapshot around the call so we don't
+    //    print a misleading green "you're set up" over a half-failed run.
     console.log();
     console.log(kleur.bold('Step: first sync'));
+    const exitBefore = process.exitCode ?? 0;
     await syncCommand({ full: true });
-    // 6. Tell the user how to run the watch loop.
+    const firstSyncFailed = (process.exitCode ?? 0) > exitBefore;
+    // 6. Tell the user how to run the watch loop. If `init` couldn't patch
+    //    package.json (non-standard layout, write-protected, etc.) the
+    //    `magicpixel:watch` npm script won't exist — fall back to the
+    //    `npx` form so we never instruct users to run a script they don't have.
     console.log();
-    console.log(kleur.bold('You\'re set up. ✨'));
+    if (firstSyncFailed) {
+        console.log(kleur.yellow('! first sync completed with errors.'));
+        console.log(kleur.dim('  Re-run `npx magicpixel sync` to retry the failed downloads, or `npx magicpixel doctor` to diagnose.'));
+    }
+    else {
+        console.log(kleur.bold('You\'re set up. ✨'));
+    }
     console.log();
-    console.log(`  ${kleur.green('▶')} ${kleur.bold('npm run magicpixel:watch')}   ${kleur.dim('# keeps sprites fresh while you edit them in MagicPixel')}`);
+    const hasWatch = await hasWatchScript();
+    if (hasWatch) {
+        console.log(`  ${kleur.green('▶')} ${kleur.bold('npm run magicpixel:watch')}   ${kleur.dim('# keeps sprites fresh while you edit them in MagicPixel')}`);
+    }
+    else {
+        console.log(`  ${kleur.green('▶')} ${kleur.bold('npx magicpixel sync --watch')}   ${kleur.dim('# keeps sprites fresh while you edit them in MagicPixel')}`);
+    }
     console.log();
     if (await hasDevScript()) {
+        const watchCmd = hasWatch ? 'npm run magicpixel:watch' : 'npx magicpixel sync --watch';
         console.log(kleur.dim('  Tip: run your dev server and the watcher together with'));
-        console.log(kleur.dim('       `npx concurrently "npm run dev" "npm run magicpixel:watch"`'));
+        console.log(kleur.dim(`       \`npx concurrently "npm run dev" "${watchCmd}"\``));
         console.log();
     }
 }
-async function hasDevScript() {
+async function readPkgJson() {
     try {
         const path = resolve(process.cwd(), 'package.json');
         if (!existsSync(path))
-            return false;
-        const { readFile } = await import('node:fs/promises');
-        const pkg = JSON.parse(await readFile(path, 'utf8'));
-        return typeof pkg.scripts?.dev === 'string';
+            return null;
+        return JSON.parse(await readFile(path, 'utf8'));
     }
     catch {
-        return false;
+        return null;
     }
 }
+async function hasWatchScript() {
+    const pkg = await readPkgJson();
+    const scripts = pkg?.scripts;
+    return !!scripts && typeof scripts === 'object' && typeof scripts['magicpixel:watch'] === 'string';
+}
+async function hasDevScript() {
+    const pkg = await readPkgJson();
+    const scripts = pkg?.scripts;
+    return !!scripts && typeof scripts === 'object' && typeof scripts.dev === 'string';
+}
 async function maybeMigrateDotenvKey() {
     if (process.env.MAGICPIXEL_API_KEY)
         return;

package/dist/commands/status.js

@@ -3,33 +3,61 @@ import { loadConfig, loadState, resolveEndpoint } from '../config.js';
 import { fetchAllManifest } from '../api.js';
 import { fileSha256 } from '../util/hash.js';
 import { assetDiskPath } from '../util/paths.js';
+import { readKeyForDisplay } from '../util/credentials.js';
+import { createLimit } from '../util/limit.js';
 export async function statusCommand() {
-    const config = await loadConfig();
-    const state = await loadState();
+    // Config is optional — a brand-new user can `magicpixel status` to inspect
+    // their key/env before bothering with init. Mirrors `whoami` / `login`.
+    let config = null;
+    let configErr = null;
+    try {
+        config = await loadConfig();
+    }
+    catch (e) {
+        configErr = e.message.split('\n')[0];
+    }
     console.log(kleur.bold('Config'));
-    console.log(`  outDir:   ${config.outDir}`);
-    console.log(`  include:  ${config.include.join(', ') || '(none)'}`);
-    console.log(`  exclude:  ${config.exclude.join(', ') || '(none)'}`);
-    console.log(`  endpoint: ${resolveEndpoint(config)}`);
+    if (config) {
+        console.log(`  outDir:   ${config.outDir}`);
+        console.log(`  include:  ${config.include.join(', ') || '(none)'}`);
+        console.log(`  exclude:  ${config.exclude.join(', ') || '(none)'}`);
+        console.log(`  endpoint: ${resolveEndpoint(config)}`);
+    }
+    else {
+        console.log(kleur.yellow(`  magicpixel.json: ${configErr ?? 'missing'}`));
+        console.log(kleur.dim(`  Run \`npx magicpixel init\` to create one.`));
+    }
     console.log();
+    const state = await loadState();
     console.log(kleur.bold('State'));
     console.log(`  lastSync: ${state.lastSync ?? kleur.dim('never')}`);
+    if (state.lastError)
+        console.log(`  lastError: ${kleur.yellow(state.lastError)}`);
     console.log();
     console.log(kleur.bold('Auth'));
-    const key = process.env.MAGICPIXEL_API_KEY;
-    if (!key) {
-        console.log(kleur.red('  MAGICPIXEL_API_KEY not set'));
+    // Honors the same precedence as `getApiKey()` (env wins, then file written
+    // by `magicpixel login`). The pre-Batch-B implementation only looked at the
+    // env var and falsely reported "key not set" for logged-in users.
+    const stored = readKeyForDisplay();
+    if (!stored) {
+        console.log(kleur.red('  no API key — run `magicpixel login` or set MAGICPIXEL_API_KEY'));
         return;
     }
-    console.log(`  key:      ${kleur.green('set')} (${maskKey(key)})`);
+    const sourceLabel = stored.source === 'env' ? 'env (MAGICPIXEL_API_KEY)' : 'file (.magicpixel/credentials)';
+    console.log(`  key:      ${kleur.green('set')} (${maskKey(stored.value)}) ${kleur.dim(`— ${sourceLabel}`)}`);
     console.log();
+    if (!config)
+        return; // No config, no diff to compute.
     console.log(kleur.bold('Diff vs remote'));
     try {
         const manifest = await fetchAllManifest(config);
+        // Parallelize the SHA pre-check through the same concurrency pool sync
+        // uses — on a 1k-asset project a serial loop dominates wall-clock time.
+        const limit = createLimit(6);
         let changed = 0;
         let unchanged = 0;
         let missing = 0;
-        for (const entry of manifest) {
+        await Promise.all(manifest.map((entry) => limit(async () => {
             const local = await fileSha256(assetDiskPath(config.outDir, entry));
             if (!local)
                 missing++;
@@ -37,14 +65,14 @@ export async function statusCommand() {
                 unchanged++;
             else
                 changed++;
-        }
+        })));
         console.log(`  remote assets: ${manifest.length}`);
         console.log(`  ${kleur.dim('=')} unchanged: ${unchanged}`);
         console.log(`  ${kleur.yellow('~')} changed:   ${changed}`);
         console.log(`  ${kleur.green('+')} missing:   ${missing}`);
     }
     catch (e) {
-        console.log(kleur.red(`  manifest fetch failed: ${e.message}`));
+        console.log(kleur.red(`  manifest fetch failed: ${e.message.split('\n')[0]}`));
     }
 }
 function maskKey(k) {