@anvil-works/anvil-cli 0.5.9 → 0.5.10

package/dist/cli.js

@@ -42538,6 +42538,13 @@ var __webpack_exports__ = {};
     function getConfig(key) {
         return config_config.get(key);
     }
+    function deleteConfig(key) {
+        if (key in configDefaults) config_config.set(key, configDefaults[key]);
+        else {
+            const store = config_config.store;
+            if (store && "object" == typeof store && key in store) config_config.delete(key);
+        }
+    }
     function resetConfig() {
         for (const [key, value] of Object.entries(configDefaults))config_config.set(key, value);
         const currentStore = config_config.store;
@@ -42670,7 +42677,7 @@ var __webpack_exports__ = {};
             ...config
         };
     }
-    function globalConfig_getGlobalOutputConfig() {
+    function getGlobalOutputConfig() {
         return globalOutputConfig;
     }
     const logger_timestamp = ()=>new Date().toISOString();
@@ -42691,10 +42698,20 @@ var __webpack_exports__ = {};
     function writeJson(entry) {
         console.log(JSON.stringify(entry));
     }
+    function logJsonResult(success, options) {
+        if (getGlobalOutputConfig().jsonMode) writeJson({
+            type: "result",
+            success,
+            message: options?.message,
+            data: options?.data,
+            error: options?.error,
+            timestamp: logger_timestamp()
+        });
+    }
     class DefaultLogger {
         paused = false;
         get jsonMode() {
-            return globalConfig_getGlobalOutputConfig().jsonMode;
+            return getGlobalOutputConfig().jsonMode;
         }
         log(...args) {
             if (this.paused) return;
@@ -42796,7 +42813,7 @@ var __webpack_exports__ = {};
             this.sessionVerbose = options.verbose ?? false;
         }
         get jsonMode() {
-            return globalConfig_getGlobalOutputConfig().jsonMode;
+            return getGlobalOutputConfig().jsonMode;
         }
         isVerbose() {
             return this.sessionVerbose || getConfig("verbose");
@@ -50593,7 +50610,7 @@ var __webpack_exports__ = {};
     const execFile = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
     const open_dirname = external_node_path_.dirname((0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__));
     const localXdgOpenPath = external_node_path_.join(open_dirname, 'xdg-open');
-    const { platform, arch } = external_node_process_;
+    const { platform: open_platform, arch } = external_node_process_;
     async function getWindowsDefaultBrowserFromWsl() {
         const powershellPath = await powerShellPath();
         const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
@@ -50686,13 +50703,13 @@ var __webpack_exports__ = {};
         let command;
         const cliArguments = [];
         const childProcessOptions = {};
-        if ('darwin' === platform) {
+        if ('darwin' === open_platform) {
             command = 'open';
             if (options.wait) cliArguments.push('--wait-apps');
             if (options.background) cliArguments.push('--background');
             if (options.newInstance) cliArguments.push('--new');
             if (app) cliArguments.push('-a', app);
-        } else if ('win32' !== platform && (!is_wsl || isInsideContainer() || app)) {
+        } else if ('win32' !== open_platform && (!is_wsl || isInsideContainer() || app)) {
             if (app) command = app;
             else {
                 const isBundled = !open_dirname || '/' === open_dirname;
@@ -50701,7 +50718,7 @@ var __webpack_exports__ = {};
                     await external_node_fs_promises_namespaceObject.access(localXdgOpenPath, external_node_fs_promises_namespaceObject.constants.X_OK);
                     exeLocalXdgOpen = true;
                 } catch  {}
-                const useSystemXdgOpen = external_node_process_.versions.electron ?? ('android' === platform || isBundled || !exeLocalXdgOpen);
+                const useSystemXdgOpen = external_node_process_.versions.electron ?? ('android' === open_platform || isBundled || !exeLocalXdgOpen);
                 command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
             }
             if (appArguments.length > 0) cliArguments.push(...appArguments);
@@ -50727,7 +50744,7 @@ var __webpack_exports__ = {};
             }
             options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
         }
-        if ('darwin' === platform && appArguments.length > 0) cliArguments.push('--args', ...appArguments);
+        if ('darwin' === open_platform && appArguments.length > 0) cliArguments.push('--args', ...appArguments);
         if (options.target) cliArguments.push(options.target);
         const subprocess = external_node_child_process_.spawn(command, cliArguments, childProcessOptions);
         if (options.wait) return new Promise((resolve, reject)=>{
@@ -50753,9 +50770,9 @@ var __webpack_exports__ = {};
         if (!archBinary) throw new Error(`${arch} is not supported`);
         return archBinary;
     }
-    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+    function detectPlatformBinary({ [open_platform]: platformBinary }, { wsl }) {
         if (wsl && is_wsl) return detectArchBinary(wsl);
-        if (!platformBinary) throw new Error(`${platform} is not supported`);
+        if (!platformBinary) throw new Error(`${open_platform} is not supported`);
         return detectArchBinary(platformBinary);
     }
     const open_apps = {};
@@ -50882,6 +50899,11 @@ var __webpack_exports__ = {};
         if ("win32" === process.platform) return tokens.map(quoteForCmdShell).join(" ");
         return tokens.map(quoteForPosixShell).join(" ");
     }
+    function formatFallbackEditorLabel(preferredEditorCommand) {
+        const trimmed = preferredEditorCommand.trim();
+        if (!trimmed) return "your editor";
+        return trimmed;
+    }
     async function openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps = defaultDeps) {
         if (preferredEditorCommand) if (deps.isCommandAvailable(preferredEditorCommand)) try {
             const tokens = parseCommandTokens(preferredEditorCommand);
@@ -50892,9 +50914,9 @@ var __webpack_exports__ = {};
             ]));
             return;
         } catch (error) {
-            logger_logger.warn(`Failed to open preferred editor '${preferredEditorCommand}': ${errors_getErrorMessage(error)}. Falling back to the system default app.`);
+            logger_logger.warn(`Failed to open ${formatFallbackEditorLabel(preferredEditorCommand)} automatically: ${errors_getErrorMessage(error)}.`);
         }
-        else logger_logger.warn(`Preferred editor command '${preferredEditorCommand}' was not found in PATH. Falling back to the system default app.`);
+        else logger_logger.info(`Open ${formatFallbackEditorLabel(preferredEditorCommand)} to edit your app.`);
         await deps.openSystem(targetPath);
     }
     function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
@@ -51613,7 +51635,7 @@ var __webpack_exports__ = {};
                 if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
                 else logger_logger.error(`Not logged in to ${anvilUrl}`);
                 logger_logger.verbose(chalk_source.yellow("Please log in first:"));
-                console.log(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
+                logger_logger.info(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
                 process.exit(1);
             }
             logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
@@ -52803,6 +52825,54 @@ var __webpack_exports__ = {};
         await deps.logout();
         deps.resetConfig();
     }
+    function performConfigDelete(key) {
+        const allConfig = getAllConfig();
+        const existed = Object.prototype.hasOwnProperty.call(allConfig, key);
+        deleteConfig(key);
+        return {
+            existed
+        };
+    }
+    function getConfigListData() {
+        const allConfig = getAllConfig();
+        const resolvedUrl = resolveAnvilUrl();
+        const defaultUrl = isDevMode() ? "http://localhost:3000" : "https://anvil.works";
+        const authTokens = allConfig.authTokens;
+        const urls = authTokens && "object" == typeof authTokens ? Object.keys(authTokens).sort() : [];
+        const accounts = [];
+        for (const url of urls){
+            const urlData = authTokens?.[url];
+            if (!(!urlData || "object" != typeof urlData || Array.isArray(urlData))) for (const username of Object.keys(urlData).sort()){
+                const accountData = urlData[username];
+                const hasConfigTokens = !!(accountData?.authToken || accountData?.refreshToken);
+                const hasAnyTokens = hasTokensForUrl(url, username);
+                accounts.push({
+                    url,
+                    username,
+                    status: hasConfigTokens ? "config" : hasAnyTokens ? "keychain" : "none"
+                });
+            }
+        }
+        const skipKeys = new Set([
+            "anvilUrl",
+            "authTokens"
+        ]);
+        const values = {};
+        for (const [key, value] of Object.entries(allConfig))if (!skipKeys.has(key)) values[key] = value;
+        return {
+            anvilUrl: {
+                value: resolvedUrl,
+                defaultValue: defaultUrl,
+                isDefault: resolvedUrl === defaultUrl
+            },
+            authTokens: {
+                totalUrls: urls.length,
+                totalAccounts: accounts.filter((account)=>"none" !== account.status).length,
+                accounts
+            },
+            values
+        };
+    }
     function registerConfigCommand(program) {
         const configCommand = program.command("config").description("Manage configuration").alias("c");
         configCommand.command("get <key>").description("Get a configuration value").action(async (key)=>{
@@ -52829,49 +52899,35 @@ var __webpack_exports__ = {};
                 process.exit(1);
             }
         });
+        configCommand.command("delete <key>").alias("unset").description("Delete a configuration value or reset it to its default").action(async (key)=>{
+            try {
+                const result = performConfigDelete(key);
+                if (result.existed) logger_logger.success(`Deleted ${key}`);
+                else logger_logger.warn(`Key '${key}' was not set; applied default/empty value if applicable.`);
+            } catch (error) {
+                logger_logger.error(error instanceof Error ? error.message : String(error));
+                process.exit(1);
+            }
+        });
         configCommand.command("list").description("List all configuration values").action(async ()=>{
             try {
-                const allConfig = getAllConfig();
+                const configData = getConfigListData();
+                if (getGlobalOutputConfig().jsonMode) return void logJsonResult(true, {
+                    data: configData
+                });
                 console.log(chalk_source.bold("\nConfiguration:"));
                 console.log(chalk_source.gray("─".repeat(50)));
-                const resolvedUrl = resolveAnvilUrl();
-                const defaultUrl = isDevMode() ? "http://localhost:3000" : "https://anvil.works";
-                const defaultHint = resolvedUrl === defaultUrl ? "" : chalk_source.gray(` (default: ${defaultUrl})`);
-                console.log(chalk_source.cyan("anvilUrl") + ` = ${resolvedUrl}${defaultHint}`);
-                const authTokens = allConfig.authTokens;
-                if (authTokens && "object" == typeof authTokens) {
-                    const urls = Object.keys(authTokens).sort();
-                    if (urls.length > 0) {
-                        let totalAccounts = 0;
-                        for (const url of urls){
-                            const urlData = authTokens[url];
-                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
-                                const usernames = Object.keys(urlData);
-                                totalAccounts += usernames.filter((username)=>hasTokensForUrl(url, username)).length;
-                            }
-                        }
-                        console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${totalAccounts} logged-in account(s) across ${urls.length} URL(s)`)}`);
-                        for (const url of urls){
-                            const urlData = authTokens[url];
-                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
-                                const usernames = Object.keys(urlData).sort();
-                                if (usernames.length > 0) for (const username of usernames){
-                                    const accountData = urlData[username];
-                                    const hasConfigTokens = !!(accountData?.authToken || accountData?.refreshToken);
-                                    const hasAnyTokens = hasTokensForUrl(url, username);
-                                    const status = hasConfigTokens ? chalk_source.green("✓ logged in (config)") : hasAnyTokens ? chalk_source.green("✓ logged in (keychain)") : chalk_source.gray("(no tokens)");
-                                    console.log(chalk_source.gray(`  ${url}: ${username} ${status}`));
-                                }
-                            }
-                        }
-                    } else console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray("(no accounts)")}`);
+                const defaultHint = configData.anvilUrl.isDefault ? "" : chalk_source.gray(` (default: ${configData.anvilUrl.defaultValue})`);
+                console.log(chalk_source.cyan("anvilUrl") + ` = ${configData.anvilUrl.value}${defaultHint}`);
+                if (configData.authTokens.totalUrls > 0) {
+                    console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${configData.authTokens.totalAccounts} logged-in account(s) across ${configData.authTokens.totalUrls} URL(s)`)}`);
+                    for (const account of configData.authTokens.accounts){
+                        const status = "config" === account.status ? chalk_source.green("✓ logged in (config)") : "keychain" === account.status ? chalk_source.green("✓ logged in (keychain)") : chalk_source.gray("(no tokens)");
+                        console.log(chalk_source.gray(`  ${account.url}: ${account.username} ${status}`));
+                    }
                 } else console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray("(none)")}`);
-                const skipKeys = new Set([
-                    "anvilUrl",
-                    "authTokens"
-                ]);
-                for (const [k, v] of Object.entries(allConfig))if (!skipKeys.has(k)) if (null === v) console.log(chalk_source.cyan(k) + ` = ${chalk_source.gray("null")}`);
-                else console.log(chalk_source.cyan(k) + ` = ${v}`);
+                for (const [key, value] of Object.entries(configData.values))if (null === value) console.log(chalk_source.cyan(key) + ` = ${chalk_source.gray("null")}`);
+                else console.log(chalk_source.cyan(key) + ` = ${value}`);
                 console.log(chalk_source.gray("─".repeat(50)));
                 console.log();
             } catch (e) {
@@ -52889,11 +52945,23 @@ var __webpack_exports__ = {};
             }
         });
     }
+    function getVersionInfo(version) {
+        return {
+            version,
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch
+        };
+    }
     function registerVersionCommand(program, version) {
         program.command("version").description("Show version information").action(()=>{
-            console.log(chalk_source.cyan.bold(`\n⚙ anvil ${version}`));
-            console.log(chalk_source.gray(`   Node.js ${process.version}`));
-            console.log(chalk_source.gray(`   Platform: ${process.platform} ${process.arch}`));
+            const info = getVersionInfo(version);
+            if (getGlobalOutputConfig().jsonMode) return void logJsonResult(true, {
+                data: info
+            });
+            console.log(chalk_source.cyan.bold(`\n⚙ anvil ${info.version}`));
+            console.log(chalk_source.gray(`   Node.js ${info.nodeVersion}`));
+            console.log(chalk_source.gray(`   Platform: ${info.platform} ${info.arch}`));
             console.log();
         });
     }
@@ -52903,6 +52971,68 @@ var __webpack_exports__ = {};
         runInteractiveLoginFlow: runInteractiveLoginFlow
     };
     const DEFAULT_ANVIL_SERVER_URL_PROMPT = "Default Anvil server URL";
+    const CUSTOM_EDITOR_CHOICE = "__custom_editor_command__";
+    function formatCustomEditorChoice(currentEditor) {
+        if (!currentEditor) return "Enter custom editor command";
+        return `Custom editor command (${currentEditor})`;
+    }
+    async function promptForPreferredEditor(currentEditor, installedEditors, ui) {
+        if (0 === installedEditors.length) {
+            ui.warn("No supported editor command was found in PATH.");
+            ui.info(chalk_source.gray("If your editor is installed, its shell command may not be available in this terminal."));
+            const action = await ui.select("Preferred editor", [
+                {
+                    name: "None",
+                    value: ""
+                },
+                {
+                    name: formatCustomEditorChoice(currentEditor),
+                    value: CUSTOM_EDITOR_CHOICE
+                }
+            ], currentEditor ? CUSTOM_EDITOR_CHOICE : "");
+            if (action !== CUSTOM_EDITOR_CHOICE) return action;
+            const customDefault = currentEditor && !preferredEditors.includes(currentEditor) ? currentEditor : "";
+            const answer = await ui.prompt([
+                {
+                    type: "input",
+                    name: "preferredEditorCommand",
+                    message: "Custom editor command",
+                    default: customDefault
+                }
+            ]);
+            return answer.preferredEditorCommand.trim();
+        }
+        if (installedEditors.length < preferredEditors.length) {
+            const unavailableCount = preferredEditors.length - installedEditors.length;
+            ui.verbose(chalk_source.gray(`${unavailableCount} supported editor(s) are not installed and were hidden.`));
+        }
+        const editorChoices = [
+            {
+                name: "None",
+                value: ""
+            },
+            ...installedEditors.map((editor)=>({
+                    name: editor,
+                    value: editor
+                })),
+            {
+                name: formatCustomEditorChoice(currentEditor),
+                value: CUSTOM_EDITOR_CHOICE
+            }
+        ];
+        const defaultValue = editorChoices.some((choice)=>choice.value === currentEditor) ? currentEditor : currentEditor ? CUSTOM_EDITOR_CHOICE : "";
+        const selectedEditor = await ui.select("Preferred editor", editorChoices, defaultValue);
+        if (selectedEditor !== CUSTOM_EDITOR_CHOICE) return selectedEditor;
+        const answer = await ui.prompt([
+            {
+                type: "input",
+                name: "preferredEditorCommand",
+                message: "Custom editor command",
+                default: currentEditor && !installedEditors.includes(currentEditor) ? currentEditor : ""
+            }
+        ]);
+        return answer.preferredEditorCommand.trim();
+    }
     async function getConfigureVersionStatus(currentVersion, latestVersionGetter = getLatestVersion) {
         const latestVersion = await latestVersionGetter();
         if (!latestVersion) return {
@@ -52961,25 +53091,11 @@ var __webpack_exports__ = {};
         const configuredAnvilUrl = parseConfigSetValue("anvilUrl", urlAnswer.anvilUrl);
         setConfig("anvilUrl", configuredAnvilUrl);
         logger_logger.success(`Set default Anvil server URL (anvilUrl) = ${configuredAnvilUrl}`);
-        const currentEditor = String(getConfig("preferredEditor") || "").trim().toLowerCase();
+        const currentEditor = String(getConfig("preferredEditor") || "").trim();
+        const currentEditorNormalized = currentEditor.toLowerCase();
         const installedEditors = getInstalledPreferredEditors();
-        if (0 === installedEditors.length) logger_logger.warn("No supported editor command was found in PATH. Leaving preferredEditor unset is recommended.");
-        else if (installedEditors.length < preferredEditors.length) {
-            const unavailableCount = preferredEditors.length - installedEditors.length;
-            logger_logger.verbose(chalk_source.gray(`${unavailableCount} supported editor(s) are not installed and were hidden.`));
-        }
-        const editorChoices = [
-            {
-                name: "None",
-                value: ""
-            },
-            ...installedEditors.map((editor)=>({
-                    name: editor,
-                    value: editor
-                }))
-        ];
-        if (currentEditor && !editorChoices.some((choice)=>choice.value === currentEditor)) logger_logger.warn(`Configured preferredEditor '${currentEditor}' is not currently available in PATH.`);
-        const selectedEditor = await logger_logger.select("Preferred editor", editorChoices, editorChoices.some((choice)=>choice.value === currentEditor) ? currentEditor : "");
+        if (currentEditor && installedEditors.length > 0 && !installedEditors.includes(currentEditorNormalized)) logger_logger.warn(`Configured preferredEditor '${currentEditor}' is not currently available in PATH.`);
+        const selectedEditor = await promptForPreferredEditor(currentEditor, installedEditors, logger_logger);
         setConfig("preferredEditor", selectedEditor);
         if (selectedEditor) logger_logger.success(`Set preferredEditor = ${selectedEditor}`);
         else logger_logger.info("Left preferredEditor unset.");
@@ -53025,11 +53141,23 @@ var __webpack_exports__ = {};
         getLatestVersion().then((latestVersion)=>{
             if (latestVersion && semver_default().valid(VERSION) && semver_default().valid(latestVersion) && semver_default().lt(VERSION, latestVersion)) {
                 logger_logger.warn("A new version of anvil is available!");
-                console.log(chalk_source.gray(`   Current: ${VERSION} → Latest: ${latestVersion}`) + chalk_source.cyan("\n   Run 'anvil update' to see update commands."));
-                console.log();
+                logger_logger.info(chalk_source.gray(`   Current: ${VERSION} → Latest: ${latestVersion}`) + chalk_source.cyan("\n   Run 'anvil update' to see update commands."));
             }
         }).catch(()=>{});
     }
+    function getUpdateInstructions(platform) {
+        if ("win32" === platform) return [
+            "try { irm https://anvil.works/install-cli.ps1 | iex } catch { npm install -g @anvil-works/anvil-cli@latest }",
+            "curl -fsSL https://anvil.works/install-cli.cmd -o install.cmd && install.cmd && del install.cmd || npm install -g @anvil-works/anvil-cli@latest",
+            "npm install -g @anvil-works/anvil-cli@latest",
+            "pnpm add -g @anvil-works/anvil-cli@latest"
+        ];
+        return [
+            "curl -fsSL https://anvil.works/install-cli.sh | sh || npm install -g @anvil-works/anvil-cli@latest",
+            "npm install -g @anvil-works/anvil-cli@latest",
+            "pnpm add -g @anvil-works/anvil-cli@latest"
+        ];
+    }
     async function handleUpdateCommand() {
         try {
             logger_logger.progress("update", "Checking for updates...");
@@ -53044,26 +53172,54 @@ var __webpack_exports__ = {};
                 process.exit(1);
             }
             if (semver_default().eq(VERSION, latestVersion)) {
-                logger_logger.success(`You're already using the latest version: ${VERSION}`);
-                console.log();
+                if (getGlobalOutputConfig().jsonMode) logJsonResult(true, {
+                    data: {
+                        currentVersion: VERSION,
+                        latestVersion,
+                        status: "up-to-date"
+                    }
+                });
+                else {
+                    logger_logger.success(`You're already using the latest version: ${VERSION}`);
+                    console.log();
+                }
                 return;
             }
             if (semver_default().gt(VERSION, latestVersion)) {
-                logger_logger.warn(`You're using version ${VERSION}, which is newer than the latest published version ${latestVersion}.`);
-                console.log(chalk_source.gray("   This might be a development build."));
-                console.log();
+                if (getGlobalOutputConfig().jsonMode) logJsonResult(true, {
+                    data: {
+                        currentVersion: VERSION,
+                        latestVersion,
+                        status: "ahead",
+                        note: "This might be a development build."
+                    }
+                });
+                else {
+                    logger_logger.warn(`You're using version ${VERSION}, which is newer than the latest published version ${latestVersion}.`);
+                    console.log(chalk_source.gray("   This might be a development build."));
+                    console.log();
+                }
                 return;
             }
+            const instructions = getUpdateInstructions(process.platform);
+            if (getGlobalOutputConfig().jsonMode) return void logJsonResult(true, {
+                data: {
+                    currentVersion: VERSION,
+                    latestVersion,
+                    status: "update-available",
+                    instructions
+                }
+            });
             logger_logger.warn(`↑ Update available: ${VERSION} → ${latestVersion}`);
             console.log();
             console.log(chalk_source.cyan("To update, run one of the following commands:"));
             console.log();
             if ("win32" === process.platform) {
-                console.log(chalk_source.gray("  PowerShell: ") + chalk_source.white("try { irm https://anvil.works/install-cli.ps1 | iex } catch { npm install -g @anvil-works/anvil-cli@latest }"));
-                console.log(chalk_source.gray("  CMD:        ") + chalk_source.white("curl -fsSL https://anvil.works/install-cli.cmd -o install.cmd && install.cmd && del install.cmd || npm install -g @anvil-works/anvil-cli@latest"));
-            } else console.log(chalk_source.gray("  macOS/Linux: ") + chalk_source.white("curl -fsSL https://anvil.works/install-cli.sh | sh || npm install -g @anvil-works/anvil-cli@latest"));
-            console.log(chalk_source.gray("  npm:         ") + chalk_source.white("npm install -g @anvil-works/anvil-cli@latest"));
-            console.log(chalk_source.gray("  pnpm:        ") + chalk_source.white("pnpm add -g @anvil-works/anvil-cli@latest"));
+                console.log(chalk_source.gray("  PowerShell: ") + chalk_source.white(instructions[0]));
+                console.log(chalk_source.gray("  CMD:        ") + chalk_source.white(instructions[1]));
+            } else console.log(chalk_source.gray("  macOS/Linux: ") + chalk_source.white(instructions[0]));
+            console.log(chalk_source.gray("  npm:         ") + chalk_source.white(instructions[instructions.length - 2]));
+            console.log(chalk_source.gray("  pnpm:        ") + chalk_source.white(instructions[instructions.length - 1]));
             console.log();
         } catch (e) {
             logger_logger.error("Error: " + e.message);
@@ -53071,7 +53227,7 @@ var __webpack_exports__ = {};
         }
     }
     function addGlobalOptionsHelp(command) {
-        if ("help" !== command.name()) command.addHelpText("after", "\n" + chalk_source.bold("Global Options:") + "\n  -V, --verbose  Show detailed output\n");
+        if ("help" !== command.name()) command.addHelpText("after", "\n" + chalk_source.bold("Global Options:") + "\n  --json         Output in JSON format (NDJSON) for scripting/LLM consumption\n  -V, --verbose  Show detailed output\n");
         command.commands.forEach((subcommand)=>addGlobalOptionsHelp(subcommand));
     }
     function buildProgram() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anvil-works/anvil-cli",
-  "version": "0.5.9",
+  "version": "0.5.10",
   "description": "CLI tool for developing Anvil apps locally",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",