@anvil-works/anvil-cli 0.5.9 → 0.5.11

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()) {
@@ -50976,6 +50998,16 @@ var __webpack_exports__ = {};
         const selectedUrl = await logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
         return selectedUrl;
     }
+    const defaultConfigureWatchGitAuthDeps = {
+        configureCredentialHelperForUrl: configureCredentialHelperForUrl,
+        setAppAuthBinding: setAppAuthBinding
+    };
+    const defaultSyncStartDeps = {
+        pushToAnvil,
+        recreateSessionAndValidate,
+        recheckSyncStatus,
+        startWatchingWithEventHandlers
+    };
     function resolveWatchOpenPath(repoPath) {
         return external_path_default().resolve(repoPath);
     }
@@ -50985,6 +51017,17 @@ var __webpack_exports__ = {};
         await openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps);
         logger_logger.info(chalk_source.gray(`Opened ${targetPath}`));
     }
+    async function configureWatchGitAuth(options, deps = defaultConfigureWatchGitAuthDeps) {
+        await deps.configureCredentialHelperForUrl(options.repoPath, options.anvilUrl);
+        await deps.setAppAuthBinding(options.repoPath, options.appId, {
+            url: options.anvilUrl,
+            username: options.username
+        });
+    }
+    function isStaleRemotePushError(message) {
+        const normalized = message.toLowerCase();
+        return normalized.includes("fetch first") || normalized.includes("non-fast-forward") || normalized.includes("failed to push some refs") || normalized.includes("remote contains work that you do") || normalized.includes("[rejected]");
+    }
     async function selectAppId(candidates) {
         if (0 === candidates.length) {
             logger_logger.warn("Could not auto-detect app ID from repository.");
@@ -51071,11 +51114,19 @@ var __webpack_exports__ = {};
             logger_logger.progress("push", "Pushing to Anvil...");
             await git.push(pushUrl, refSpec, options.force ?? false);
             logger_logger.progressEnd("push", "Pushed to Anvil");
-            return true;
+            return {
+                success: true,
+                staleRemote: false
+            };
         } catch (e) {
+            const errorMessage = errors_getErrorMessage(e);
             logger_logger.progressEnd("push", "Push failed");
-            logger_logger.error(`Failed to push: ${errors_getErrorMessage(e)}`);
-            return false;
+            logger_logger.error(`Failed to push: ${errorMessage}`);
+            return {
+                success: false,
+                staleRemote: isStaleRemotePushError(errorMessage),
+                errorMessage
+            };
         }
     }
     async function fetchAndRebaseFromAnvil(options) {
@@ -51201,7 +51252,7 @@ var __webpack_exports__ = {};
             return false;
         }
     }
-    async function checkSyncStatusAndStart(session, options) {
+    async function checkSyncStatusAndStart(session, options, deps = defaultSyncStartDeps) {
         const syncStatus = session.syncStatus;
         const branchName = session.getBranchName() || "master";
         const hasUncommitted = session.hasUncommittedChanges;
@@ -51214,8 +51265,8 @@ var __webpack_exports__ = {};
             else {
                 shouldPush = await logger_logger.confirm("Would you like to push this branch to Anvil?", true);
                 if (shouldPush) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldPush) {
@@ -51224,15 +51275,21 @@ var __webpack_exports__ = {};
                 return false;
             }
             session.cleanup();
-            const pushed = await pushToAnvil({
+            const pushed = await deps.pushToAnvil({
                 repoPath: options.repoPath,
                 appId: options.appId,
                 anvilUrl: options.anvilUrl,
                 branchName,
                 username: options.username
             });
-            if (!pushed) return false;
-            return await recreateSessionAndValidate(options);
+            if (!pushed.success) {
+                if (pushed.staleRemote) {
+                    logger_logger.warn("Branch appeared on Anvil while pushing. Re-checking sync status...");
+                    return await deps.recreateSessionAndValidate(options);
+                }
+                return false;
+            }
+            return await deps.recreateSessionAndValidate(options);
         }
         if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
             logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
@@ -51252,8 +51309,8 @@ var __webpack_exports__ = {};
                 ], "push");
                 shouldPush = "push" === action;
                 if (shouldPush) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldPush) {
@@ -51262,15 +51319,15 @@ var __webpack_exports__ = {};
                 return false;
             }
             session.cleanup();
-            const pushed = await pushToAnvil({
+            const pushed = await deps.pushToAnvil({
                 repoPath: options.repoPath,
                 appId: options.appId,
                 anvilUrl: options.anvilUrl,
                 branchName,
                 username: options.username
             });
-            if (!pushed) return false;
-            return await recreateSessionAndValidate(options);
+            if (!pushed.success) return false;
+            return await deps.recreateSessionAndValidate(options);
         } else if (syncStatus.diverged) {
             logger_logger.warn("Your local repository has diverged from Anvil.");
             logger_logger.info(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
@@ -51293,7 +51350,7 @@ var __webpack_exports__ = {};
                     return false;
                 }
                 if (!result.success) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             const action = await logger_logger.select("How would you like to resolve this?", [
                 {
@@ -51317,8 +51374,8 @@ var __webpack_exports__ = {};
                 logger_logger.warn("Watch cancelled.");
                 return false;
             }
-            const changed = await recheckSyncStatus(stateCategory, branchName, options);
-            if (changed) return await checkSyncStatusAndStart(changed, options);
+            const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+            if (changed) return await checkSyncStatusAndStart(changed, options, deps);
             if ("rebase" === action) {
                 const result = await fetchAndRebaseFromAnvil({
                     repoPath: options.repoPath,
@@ -51335,7 +51392,7 @@ var __webpack_exports__ = {};
                     return false;
                 }
                 if (!result.success) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             if ("reset" === action) {
                 const resetWarning = hasUncommitted ? `This will discard ${syncStatus.ahead} local commit(s) and your uncommitted changes. Are you sure?` : `This will discard ${syncStatus.ahead} local commit(s). Are you sure?`;
@@ -51352,7 +51409,7 @@ var __webpack_exports__ = {};
                     username: options.username
                 });
                 if (!reset) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             if ("push" === action) {
                 const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
@@ -51360,7 +51417,7 @@ var __webpack_exports__ = {};
                     logger_logger.warn("Watch cancelled.");
                     return false;
                 }
-                const pushed = await pushToAnvil({
+                const pushed = await deps.pushToAnvil({
                     repoPath: options.repoPath,
                     appId: options.appId,
                     anvilUrl: options.anvilUrl,
@@ -51368,8 +51425,8 @@ var __webpack_exports__ = {};
                     username: options.username,
                     force: true
                 });
-                if (!pushed) return false;
-                return await recreateSessionAndValidate(options);
+                if (!pushed.success) return false;
+                return await deps.recreateSessionAndValidate(options);
             }
         } else {
             logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
@@ -51380,8 +51437,8 @@ var __webpack_exports__ = {};
             else {
                 shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
                 if (shouldSync) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldSync) {
@@ -51406,9 +51463,9 @@ var __webpack_exports__ = {};
                 logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
                 process.exit(1);
             }
-            return await recreateSessionAndValidate(options);
+            return await deps.recreateSessionAndValidate(options);
         }
-        await startWatchingWithEventHandlers(session, options);
+        await deps.startWatchingWithEventHandlers(session, options);
         return true;
     }
     async function startWatchingWithEventHandlers(session, options) {
@@ -51613,10 +51670,16 @@ 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"));
+            await configureWatchGitAuth({
+                repoPath,
+                appId: finalAppId,
+                anvilUrl,
+                username
+            });
             logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
             const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
             logger_logger.progressEnd("validate");
@@ -52803,6 +52866,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 +52940,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 +52986,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 +53012,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 +53132,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 +53182,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 +53213,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 +53268,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.11",
   "description": "CLI tool for developing Anvil apps locally",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",