@newrelic/preflight 1.0.6 → 1.0.8

package/dist/install/cli.js

@@ -4,17 +4,20 @@
  * Dynamically imported from collector-script.ts when argv[2] is install/uninstall,
  * so commander and other heavy deps are never loaded on the hot hook path.
  */
-import { execSync, execFileSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { existsSync, copyFileSync, realpathSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { Command } from 'commander';
+import { createLogger } from '../shared/index.js';
 import { mergeSettings, removeSettings, mergeMcpConfig, removeMcpConfig, detectSettingsPath, detectMcpConfigPath, generateNrConfig, } from './install-helper.js';
 import { isWsl, resolveWindowsHome } from './platform.js';
 import { validateConfigFile, DEFAULT_STORAGE_PATH, ConfigFileSchema } from '../config.js';
 import { migrateStoragePath } from './migrate.js';
 import { installSchedule, removeSchedule, getScheduleStatus, removeDashboardDaemon, getDashboardDaemonStatus, resolveBinaryPath, } from './schedule.js';
-import { readJsonFile, readJsonFileStrict, writeJsonFile } from './json-utils.js';
+import { readJsonFileStrict, writeJsonFile, errMsg } from './json-utils.js';
+const logger = createLogger('cli');
 const NR_CONFIG_PATH = resolve(DEFAULT_STORAGE_PATH, 'config.json');
 // ---------------------------------------------------------------------------
 // Platform persistence helpers — read/write platformTarget in config.json
@@ -31,7 +34,7 @@ function clearSavedPlatform() {
         writeJsonFile(NR_CONFIG_PATH, rest, DEFAULT_STORAGE_PATH);
     }
     catch (err) {
-        eprint(`\n⚠ Could not clear saved platform target: ${err instanceof Error ? err.message : String(err)}`);
+        eprint(`\n⚠ Could not clear saved platform target: ${errMsg(err)}`);
         eprint('  The next install may use the stale platform target. Fix the issue and re-run uninstall.');
     }
 }
@@ -110,13 +113,7 @@ function eprint(msg = '') {
 // PATH verification
 // ---------------------------------------------------------------------------
 export function verifyBinaryOnPath() {
-    try {
-        execSync('which preflight', { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return resolveBinaryPath() !== null;
 }
 function printPathWarning() {
     print('\n⚠ preflight is not on your PATH.');
@@ -154,10 +151,54 @@ function handleUpdate() {
         print('✗ Could not locate the repo root. Run this command from within the cloned repo or after npm link.');
         process.exit(1);
     }
+    let gitRoot;
+    try {
+        gitRoot = execFileSync('git', ['-C', repoRoot, 'rev-parse', '--show-toplevel'], {
+            stdio: 'pipe',
+            env: { ...process.env, GIT_DIR: undefined, GIT_WORK_TREE: undefined },
+        })
+            .toString()
+            .trim();
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            print('✗ git is not installed or not found on PATH.');
+            print('  Install git (https://git-scm.com) then retry: preflight update');
+        }
+        else {
+            print('✗ preflight was installed via a package manager, not cloned from source.');
+            print('  (If your .git directory is missing or corrupt, re-clone the repo instead.)');
+            print('  To update, reinstall using your package manager, e.g.:');
+            print('    npm install -g @newrelic/preflight@latest');
+            print('    pnpm add -g @newrelic/preflight@latest');
+        }
+        process.exit(1);
+    }
+    // If repoRoot sits below a node_modules directory within the git tree,
+    // preflight is installed as a dependency — not a source clone.
+    // path.relative() normalises separators on all platforms (robust on Windows).
+    if (relative(gitRoot, repoRoot).split(sep).includes('node_modules')) {
+        print('✗ preflight was installed via a package manager, not cloned from source.');
+        print('  To update, reinstall using your package manager, e.g.:');
+        print('    npm install -g @newrelic/preflight@latest');
+        print('    pnpm add -g @newrelic/preflight@latest');
+        process.exit(1);
+    }
     print(`Updating Preflight from ${repoRoot}...\n`);
     try {
         print('→ git pull');
         execFileSync('git', ['pull'], { cwd: repoRoot, stdio: 'inherit' });
+    }
+    catch {
+        print('\n✗ git pull failed. Check the output above for details.');
+        print('  If the output shows diverged branches and you have no local commits to keep,');
+        print('  you can reset to the remote HEAD (replace <branch> with your default branch):');
+        print(`    git -C "${repoRoot}" fetch origin`);
+        print(`    git -C "${repoRoot}" reset --hard origin/<branch>`);
+        print('  WARNING: reset --hard permanently discards any local commits not yet on origin.');
+        process.exit(1);
+    }
+    try {
         print('\n→ npm run build');
         execFileSync('npm', ['run', 'build'], { cwd: repoRoot, stdio: 'inherit' });
         print('\n✓ Update complete.');
@@ -165,7 +206,7 @@ function handleUpdate() {
         print('  Run `preflight install` to update the MCP server key in ~/.mcp.json.');
     }
     catch {
-        print('\n✗ Update failed. Check the output above for details.');
+        print('\n✗ Build failed. Check the output above for details.');
         process.exit(1);
     }
 }
@@ -178,9 +219,14 @@ function handleSchedule(options) {
         process.exit(1);
     }
     if (options.disable) {
-        const wasInstalled = getScheduleStatus().installed;
-        removeSchedule();
-        print(wasInstalled ? '✓ Auto-update schedule removed.' : 'No schedule was installed.');
+        try {
+            const removed = removeSchedule();
+            print(removed ? '✓ Auto-update schedule removed.' : 'No schedule was installed.');
+        }
+        catch (err) {
+            eprint(`⚠ Could not remove schedule: ${errMsg(err)}`);
+            process.exitCode = 1;
+        }
         return;
     }
     if (options.time !== undefined) {
@@ -210,10 +256,15 @@ function handleSchedule(options) {
     // No flags — show status.
     const status = getScheduleStatus();
     if (status.installed) {
-        const hh = String(status.hour ?? 0).padStart(2, '0');
-        const mm = String(status.minute ?? 0).padStart(2, '0');
-        print(`Auto-update schedule: ${hh}:${mm} daily`);
-        print(`  Binary: ${status.binaryPath ?? 'unknown'}`);
+        if (status.readable === false) {
+            print('Auto-update schedule: installed (plist unreadable — reinstall with: preflight schedule --time HH:MM)');
+        }
+        else {
+            const hh = String(status.hour ?? 0).padStart(2, '0');
+            const mm = String(status.minute ?? 0).padStart(2, '0');
+            print(`Auto-update schedule: ${hh}:${mm} daily`);
+            print(`  Binary: ${status.binaryPath ?? 'unknown'}`);
+        }
         print('  To change: preflight schedule --time HH:MM');
         print('  To remove: preflight schedule --disable');
     }
@@ -248,13 +299,13 @@ function handleInstall(options) {
     catch (err) {
         const isSyntaxError = err instanceof SyntaxError;
         if (isSyntaxError || (inWsl && !explicitPlatform) || credentialsProvided) {
-            eprint(`\n✗ Cannot read existing NR config to determine install target: ${err instanceof Error ? err.message : String(err)}`);
+            eprint(`\n✗ Cannot read existing NR config to determine install target: ${errMsg(err)}`);
             eprint(isSyntaxError
                 ? '  config.json contains invalid JSON — fix or delete it, then re-run install.'
                 : '  Fix file permissions then re-run install.');
             throw err;
         }
-        eprint(`\n⚠ Could not read existing NR config to persist platform target: ${err instanceof Error ? err.message : String(err)}`);
+        eprint(`\n⚠ Could not read existing NR config to persist platform target: ${errMsg(err)}`);
         eprint('  Platform target not persisted — hook installation will continue. Re-run to save it.');
         skipNrConfigWrite = true;
     }
@@ -268,21 +319,21 @@ function handleInstall(options) {
         mergedMcp = mergeMcpConfig(readJsonFileStrict(mcpPath), binPath, { platform });
     }
     catch (err) {
-        eprint(`\n✗ Failed to prepare config: ${err instanceof Error ? err.message : String(err)}`);
+        eprint(`\n✗ Failed to prepare config: ${errMsg(err)}`);
         throw err;
     }
     try {
         writeJsonFile(settingsPath, mergedSettings, allowedBase);
     }
     catch (err) {
-        eprint(`\n✗ Failed to write hooks config (${settingsPath}): ${err instanceof Error ? err.message : String(err)}`);
+        eprint(`\n✗ Failed to write hooks config (${settingsPath}): ${errMsg(err)}`);
         throw err;
     }
     try {
         writeJsonFile(mcpPath, mergedMcp, allowedBase);
     }
     catch (err) {
-        eprint(`\n✗ Failed to write MCP config (${mcpPath}): ${err instanceof Error ? err.message : String(err)}`);
+        eprint(`\n✗ Failed to write MCP config (${mcpPath}): ${errMsg(err)}`);
         throw err;
     }
     // Persist platformTarget (and credentials if provided) — only after both hook files written.
@@ -298,10 +349,10 @@ function handleInstall(options) {
         }
         catch (err) {
             if (credentialsProvided) {
-                eprint(`\n✗ Failed to save New Relic config: ${err instanceof Error ? err.message : String(err)}`);
+                eprint(`\n✗ Failed to save New Relic config: ${errMsg(err)}`);
                 throw err;
             }
-            eprint(`\n⚠ Could not persist platform target: ${err instanceof Error ? err.message : String(err)}`);
+            eprint(`\n⚠ Could not persist platform target: ${errMsg(err)}`);
             eprint('  The next install will re-detect the target platform from scratch.');
         }
     }
@@ -344,9 +395,12 @@ function handleInstall(options) {
     print('  to check your config file for typos or unsupported fields.');
 }
 // ---------------------------------------------------------------------------
-// Uninstall handler
+// Uninstall helpers
 // ---------------------------------------------------------------------------
-function handleUninstall(options) {
+// Resolves which settings and MCP config paths to clean based on platform
+// flags and the saved install target. Calls process.exit(1) on invalid
+// flag combinations or unresolvable state.
+function resolveUninstallPaths(options) {
     const scope = options.project ? 'project' : 'user';
     if (options.windowsCc && options.linuxCc) {
         print('\n  ⚠ --windows-cc and --linux-cc are mutually exclusive. Pass only one.');
@@ -448,68 +502,255 @@ function handleUninstall(options) {
         settingsPathsToClean.set(detectSettingsPath(scope, null), undefined);
         mcpPathsToClean.set(detectMcpConfigPath(scope, null), undefined);
     }
-    print('');
-    let settingsFound = false;
+    return { settingsPathsToClean, mcpPathsToClean };
+}
+// Backs up a config file then writes the transformed result. Returns whether
+// the write succeeded and any error encountered — never throws.
+function backupAndWrite(path, allowedBase, transform, errorLabel) {
+    const backup = `${path}.backup-${Date.now()}`;
+    try {
+        const data = readJsonFileStrict(path);
+        copyFileSync(path, backup);
+        print(`  Backup saved: ${backup}`);
+        writeJsonFile(path, transform(data), allowedBase);
+        return { written: true, error: null };
+    }
+    catch (err) {
+        // If copyFileSync and writeJsonFile both succeeded the backup is no longer
+        // needed (the write path handles it). If copyFileSync succeeded but
+        // writeJsonFile failed, the backup is the user's only recovery copy —
+        // preserve it. If readJsonFileStrict failed, no backup was created and the
+        // original is untouched, so there is nothing to recover.
+        const error = err instanceof Error ? err : new Error(String(err));
+        eprint(`\n✗ Failed to clean ${errorLabel} (${path}): ${errMsg(err)}`);
+        process.exitCode = 1;
+        return { written: false, error };
+    }
+}
+// Removes preflight hooks and MCP config entries from the given paths.
+// Returns a RemovalResult — never throws. Partial completion is possible:
+// removed=true even when error is non-null if at least one file succeeded.
+function removeClaudeCodeConfig(settingsPathsToClean, mcpPathsToClean) {
+    let removed = false;
+    let firstError = null;
+    let hadSettingsFile = false;
     for (const [settingsPath, allowedBase] of settingsPathsToClean) {
-        if (existsSync(settingsPath)) {
-            const backup = `${settingsPath}.backup-${Date.now()}`;
-            copyFileSync(settingsPath, backup);
-            print(`  Backup saved: ${backup}`);
-            try {
-                writeJsonFile(settingsPath, removeSettings(readJsonFileStrict(settingsPath)), allowedBase);
-            }
-            catch (err) {
-                eprint(`\n✗ Failed to clean hooks config (${settingsPath}): ${err instanceof Error ? err.message : String(err)}`);
-                throw err;
-            }
-            settingsFound = true;
+        if (!existsSync(settingsPath))
+            continue;
+        hadSettingsFile = true;
+        const { written, error } = backupAndWrite(settingsPath, allowedBase, removeSettings, 'hooks config');
+        if (written) {
+            removed = true;
             print(`✓ Hooks removed: ${settingsPath}`);
         }
+        else {
+            firstError ??= error;
+        }
     }
-    if (!settingsFound) {
+    if (!hadSettingsFile) {
         print(`No settings file found at ${[...settingsPathsToClean.keys()].join(', ')}. Skipping hooks.`);
     }
-    let mcpFound = false;
+    let hadMcpFile = false;
     for (const [mcpPath, allowedBase] of mcpPathsToClean) {
-        if (existsSync(mcpPath)) {
-            const backup = `${mcpPath}.backup-${Date.now()}`;
-            copyFileSync(mcpPath, backup);
-            print(`  Backup saved: ${backup}`);
-            try {
-                writeJsonFile(mcpPath, removeMcpConfig(readJsonFileStrict(mcpPath)), allowedBase);
-            }
-            catch (err) {
-                eprint(`\n✗ Failed to clean MCP config (${mcpPath}): ${err instanceof Error ? err.message : String(err)}`);
-                throw err;
-            }
-            mcpFound = true;
+        if (!existsSync(mcpPath))
+            continue;
+        hadMcpFile = true;
+        const { written, error } = backupAndWrite(mcpPath, allowedBase, removeMcpConfig, 'MCP config');
+        if (written) {
+            removed = true;
             print(`✓ MCP server removed: ${mcpPath}`);
         }
+        else {
+            firstError ??= error;
+        }
     }
-    if (!mcpFound) {
+    if (!hadMcpFile) {
         print(`No MCP config found at ${[...mcpPathsToClean.keys()].join(', ')}. Skipping MCP server.`);
     }
-    // Update persisted platform after cleanup.
-    // --windows-cc or bare: clear savedPlatform so the next install re-detects from scratch.
-    //   After --windows-cc uninstall, the user must pass --windows-cc again to reinstall
-    //   Windows CC mode — re-detection has no heuristic for Windows CC intent.
-    // --linux-cc: leave savedPlatform untouched — this only cleans Linux-side paths and must
-    //   not destroy a wsl-windows-cc record that the user still intends to use.
+    return { label: 'Claude Code config', removed, error: firstError, requiresRestart: true };
+}
+// Runs a single uninstall step. Returns a RemovalResult — never throws.
+// process.exitCode is set to 1 and a warning is printed on error.
+function runStep(label, requiresRestart, fn) {
+    try {
+        const removed = fn();
+        return { label, removed, error: null, requiresRestart };
+    }
+    catch (err) {
+        process.exitCode = 1;
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.warn('uninstall step failed', { label, error });
+        eprint(`⚠ Could not remove ${label}: ${error.message}`);
+        return { label, removed: false, error, requiresRestart };
+    }
+}
+// Prompts the user for uninstall confirmation. Returns one of four outcomes.
+async function promptConfirm(yes) {
+    if (yes)
+        return 'confirmed';
+    if (process.stdin.isTTY !== true)
+        return 'non-interactive';
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question('Continue? [y/N]: ')).trim().toLowerCase();
+        return answer === 'y' || answer === 'yes' ? 'confirmed' : 'declined';
+    }
+    catch {
+        return 'stdin-closed';
+    }
+    finally {
+        rl.close();
+    }
+}
+// Handles a promptConfirm result: prints cancellation message and sets
+// exitCode=1 on any non-confirmed outcome. Returns true only when confirmed.
+function handleConfirm(result) {
+    if (result === 'confirmed')
+        return true;
+    const message = result === 'non-interactive'
+        ? 'Uninstall cancelled (non-interactive stdin — rerun with --yes to confirm).'
+        : result === 'stdin-closed'
+            ? 'Uninstall cancelled (stdin closed).'
+            : 'Uninstall cancelled.';
+    print(message);
+    process.exitCode = 1;
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Uninstall handler
+// ---------------------------------------------------------------------------
+async function handleUninstall(options) {
+    // --daemon: targeted removal of just the background dashboard daemon plist.
+    // Does not touch hooks, MCP config, schedules, or session history.
+    if (options.daemon) {
+        if (options.project || options.windowsCc || options.linuxCc) {
+            print('  ⚠ --daemon cannot be combined with --project, --windows-cc, or --linux-cc.');
+            print('  Use bare `preflight uninstall` to remove hooks and the daemon together.');
+            process.exit(1);
+        }
+        const daemonStatus = getDashboardDaemonStatus();
+        if (!daemonStatus.installed) {
+            print('No background dashboard daemon installed — nothing to remove.');
+            return;
+        }
+        print('preflight uninstall --daemon will remove the background dashboard daemon.\n');
+        if (!handleConfirm(await promptConfirm(options.yes ?? false)))
+            return;
+        const step = runStep('background dashboard daemon', false, () => removeDashboardDaemon());
+        if (step.error !== null) {
+            print('\nUninstall incomplete — see errors above.\n');
+            return;
+        }
+        if (!step.removed) {
+            process.exitCode = 1;
+            print('Background dashboard daemon already absent — nothing to remove.');
+            return;
+        }
+        print('✓ Background dashboard daemon removed.');
+        print('  The dashboard is now only available while Claude Code is running.');
+        print('  To reinstall, run: preflight setup');
+        return;
+    }
+    const { settingsPathsToClean, mcpPathsToClean } = resolveUninstallPaths(options);
+    // Build a human-readable summary of what will change, then ask for
+    // confirmation before touching anything.
+    const changeSummary = [];
+    let hadConfigFiles = false;
+    for (const settingsPath of settingsPathsToClean.keys()) {
+        if (existsSync(settingsPath)) {
+            changeSummary.push(`  • Remove hooks from ${settingsPath}`);
+            hadConfigFiles = true;
+        }
+    }
+    for (const mcpPath of mcpPathsToClean.keys()) {
+        if (existsSync(mcpPath)) {
+            changeSummary.push(`  • Remove MCP server from ${mcpPath}`);
+            hadConfigFiles = true;
+        }
+    }
+    const scheduleStatus = getScheduleStatus();
+    const daemonStatus = getDashboardDaemonStatus();
+    if (scheduleStatus.installed) {
+        const action = scheduleStatus.readable
+            ? 'Unload and delete'
+            : 'Remove (plist unreadable — label removal)';
+        changeSummary.push(`  • ${action} auto-update schedule`);
+    }
+    if (daemonStatus.installed) {
+        const action = daemonStatus.readable
+            ? 'Unload and delete'
+            : 'Remove (plist unreadable — label removal)';
+        changeSummary.push(`  • ${action} background dashboard daemon`);
+    }
+    if (changeSummary.length === 0) {
+        print('Nothing installed — no changes to make.');
+        return;
+    }
+    print('preflight uninstall will make the following changes:\n');
+    for (const line of changeSummary)
+        print(line);
+    print('');
+    print(`  Your session history and config at ${DEFAULT_STORAGE_PATH} will NOT be deleted.`);
+    print('');
+    if (!handleConfirm(await promptConfirm(options.yes ?? false)))
+        return;
+    print('');
+    const configStep = removeClaudeCodeConfig(settingsPathsToClean, mcpPathsToClean);
     if (options.windowsCc) {
         print('  To reinstall Windows Claude Code mode, re-run: preflight install --windows-cc');
     }
-    if (!options.linuxCc) {
+    const scheduleStep = runStep('auto-update schedule', false, () => {
+        const removed = removeSchedule();
+        if (removed)
+            print('✓ Auto-update schedule removed');
+        else if (scheduleStatus.installed) {
+            // Plist vanished between status-check and removal (TOCTOU). Throw so
+            // runStep captures this as an error and anyFailed reflects it.
+            throw new Error('Auto-update schedule already absent — may have been removed by another process');
+        }
+        return removed;
+    });
+    const daemonStep = runStep('background dashboard daemon', false, () => {
+        const removed = removeDashboardDaemon();
+        if (removed)
+            print('✓ Background dashboard daemon removed');
+        else if (daemonStatus.installed) {
+            // Plist vanished between status-check and removal (TOCTOU). Throw so
+            // runStep captures this as an error and anyFailed reflects it — without
+            // this, process.exitCode=1 and the success message are contradictory.
+            throw new Error('Background dashboard daemon already absent — may have been removed by another process');
+        }
+        return removed;
+    });
+    const steps = [configStep, scheduleStep, daemonStep];
+    const anyRemoved = steps.some((s) => s.removed);
+    const anyFailed = steps.some((s) => s.error !== null);
+    const requiresRestart = steps.some((s) => s.removed && s.requiresRestart);
+    // Clear the saved platform record when hooks/MCP config was removed (even if
+    // schedule/daemon cleanup also failed — those are independent). Also clear on
+    // schedule/daemon-only removal when config files existed on disk at status-check
+    // time: absent config files mean hooks were never written (or already manually
+    // deleted) and the platform record should be preserved for a re-install attempt.
+    // Skip on --linux-cc (sibling wsl-windows-cc record may still be in use).
+    const shouldClearPlatform = configStep.removed || (anyRemoved && !anyFailed && hadConfigFiles);
+    if (!options.linuxCc && shouldClearPlatform) {
         clearSavedPlatform();
     }
-    print('\nRestart Claude Code for changes to take effect.\n');
-    const scheduleWasInstalled = getScheduleStatus().installed;
-    removeSchedule();
-    if (scheduleWasInstalled)
-        print('✓ Auto-update schedule removed');
-    const daemonWasInstalled = getDashboardDaemonStatus().installed;
-    removeDashboardDaemon();
-    if (daemonWasInstalled)
-        print('✓ Background dashboard daemon removed');
+    if (requiresRestart) {
+        if (anyFailed) {
+            print('\nRestart Claude Code to apply hook changes. Uninstall incomplete — see errors above.\n');
+        }
+        else {
+            print('\nRestart Claude Code for changes to take effect.\n');
+        }
+    }
+    else if (anyRemoved) {
+        // Schedule/daemon only — launchd unloaded immediately; no restart needed.
+        print(anyFailed ? '\nUninstall incomplete — see errors above.\n' : '\nUninstall complete.\n');
+    }
+    else if (anyFailed) {
+        print('\nUninstall incomplete — see errors above.\n');
+    }
 }
 // ---------------------------------------------------------------------------
 // Validate handler
@@ -556,8 +797,7 @@ function handleValidate(options) {
 async function handleDoctor(options) {
     const { runDiagnostics } = await import('./diagnostics.js');
     const configPath = options.config ?? resolve(DEFAULT_STORAGE_PATH, 'config.json');
-    const raw = readJsonFile(configPath);
-    const storagePath = typeof raw.storagePath === 'string' ? raw.storagePath : undefined;
+    const storagePath = process.env.NEW_RELIC_AI_MCP_STORAGE_PATH ?? undefined;
     print('Running diagnostics...');
     const checks = await runDiagnostics({ configPath, storagePath });
     const ICON = { ok: '✓', warn: '⚠', fail: '✗', skip: '-' };
@@ -605,6 +845,8 @@ export function createInstallProgram() {
         .option('--project', 'Remove from project-level .claude/settings.json instead of user-level')
         .option('--windows-cc', 'Remove Windows Claude Code hooks only (WSL only)')
         .option('--linux-cc', 'Remove Linux Claude Code hooks only (WSL only)')
+        .option('--daemon', 'Remove only the background dashboard daemon (preserves hooks, MCP config, and session history)')
+        .option('--yes', 'Skip the confirmation prompt (useful for scripts and CI)')
         .action(handleUninstall);
     program
         .command('setup')
@@ -615,7 +857,7 @@ export function createInstallProgram() {
             await runSetupWizard();
         }
         catch (err) {
-            print(`\n✗ Setup failed: ${err instanceof Error ? err.message : String(err)}`);
+            print(`\n✗ Setup failed: ${errMsg(err)}`);
             process.exitCode = 1;
         }
     });