@anvil-works/anvil-cli 0.5.1 → 0.5.3

package/dist/cli.js

@@ -34509,7 +34509,7 @@ var __webpack_exports__ = {};
     };
     const eraseLine = ESC + '2K';
     const eraseLines = (lines)=>lines > 0 ? (eraseLine + cursorUp(1)).repeat(lines - 1) + eraseLine + cursorLeft : '';
-    const height = (content)=>content.split('\n').length;
+    const screen_manager_height = (content)=>content.split('\n').length;
     const lastLine = (content)=>content.split('\n').pop() ?? '';
     class ScreenManager {
         height = 0;
@@ -34538,12 +34538,12 @@ var __webpack_exports__ = {};
             if (rawPromptLine.length % width === 0) content += '\n';
             let output = content + (bottomContent ? '\n' + bottomContent : '');
             const promptLineUpDiff = Math.floor(rawPromptLine.length / width) - this.cursorPos.rows;
-            const bottomContentHeight = promptLineUpDiff + (bottomContent ? height(bottomContent) : 0);
+            const bottomContentHeight = promptLineUpDiff + (bottomContent ? screen_manager_height(bottomContent) : 0);
             if (bottomContentHeight > 0) output += cursorUp(bottomContentHeight);
             output += cursorTo(this.cursorPos.cols);
             this.write(cursorDown(this.extraLinesUnderPrompt) + eraseLines(this.height) + output);
             this.extraLinesUnderPrompt = bottomContentHeight;
-            this.height = height(output);
+            this.height = screen_manager_height(output);
         }
         checkCursorPos() {
             const cursorPos = this.rl.getCursorPos();
@@ -37768,20 +37768,20 @@ var __webpack_exports__ = {};
         }), mod);
     function pathspec(...paths) {
         const key = new String(paths);
-        cache.set(key, paths);
+        esm_cache.set(key, paths);
         return key;
     }
     function isPathSpec(path) {
-        return path instanceof String && cache.has(path);
+        return path instanceof String && esm_cache.has(path);
     }
     function toPaths(pathSpec) {
-        return cache.get(pathSpec) || [];
+        return esm_cache.get(pathSpec) || [];
     }
-    var cache;
+    var esm_cache;
     var init_pathspec = __esm({
         "src/lib/args/pathspec.ts" () {
             "use strict";
-            cache = /* @__PURE__ */ new WeakMap();
+            esm_cache = /* @__PURE__ */ new WeakMap();
         }
     });
     var GitError;
@@ -42572,6 +42572,57 @@ var __webpack_exports__ = {};
         if (preferredEditors.includes(normalized)) return preferredEditorCommandByValue[normalized];
         return preferredEditorValue;
     }
+    function extractExecutableFromCommand(command) {
+        const trimmed = command.trim();
+        if (!trimmed) return "";
+        if (trimmed.startsWith('"')) {
+            const closingIndex = trimmed.indexOf('"', 1);
+            return closingIndex > 1 ? trimmed.slice(1, closingIndex) : "";
+        }
+        if (trimmed.startsWith("'")) {
+            const closingIndex = trimmed.indexOf("'", 1);
+            return closingIndex > 1 ? trimmed.slice(1, closingIndex) : "";
+        }
+        const firstSpace = trimmed.search(/\s/);
+        return -1 === firstSpace ? trimmed : trimmed.slice(0, firstSpace);
+    }
+    function canExecutePath(filePath) {
+        try {
+            external_fs_.accessSync(filePath, "win32" === process.platform ? external_fs_.constants.F_OK : external_fs_.constants.X_OK);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    function isCommandAvailable(command, env = process.env) {
+        const executable = extractExecutableFromCommand(command);
+        if (!executable) return false;
+        const hasPathSeparator = executable.includes(external_path_default().sep) || executable.includes("/");
+        if (hasPathSeparator) return canExecutePath(executable);
+        const pathEnv = env.PATH || "";
+        if (!pathEnv) return false;
+        const pathEntries = pathEnv.split(external_path_default().delimiter).filter(Boolean);
+        const pathext = (env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+        const extensions = "win32" === process.platform ? pathext : [
+            ""
+        ];
+        const hasKnownExtension = "win32" === process.platform && pathext.some((ext)=>executable.toUpperCase().endsWith(ext.toUpperCase()));
+        for (const dir of pathEntries){
+            if ("win32" === process.platform && hasKnownExtension) {
+                const candidate = external_path_default().join(dir, executable);
+                if (canExecutePath(candidate)) return true;
+                continue;
+            }
+            for (const ext of extensions){
+                const candidate = external_path_default().join(dir, `${executable}${ext}`);
+                if (canExecutePath(candidate)) return true;
+            }
+        }
+        return false;
+    }
+    function getInstalledPreferredEditors() {
+        return preferredEditors.filter((editor)=>isCommandAvailable(getPreferredEditorCommand(editor)));
+    }
     function getAllConfig() {
         return config_config.store;
     }
@@ -42878,13 +42929,15 @@ var __webpack_exports__ = {};
                     name: "value",
                     message,
                     choices,
-                    default: defaultValue
+                    default: defaultValue,
+                    loop: false
                 }
             ]);
             return answer.value;
         }
     }
     const external_readline_namespaceObject = require("readline");
+    var external_readline_default = /*#__PURE__*/ __webpack_require__.n(external_readline_namespaceObject);
     /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */ function isNothing(subject) {
         return null == subject;
     }
@@ -47403,6 +47456,37 @@ var __webpack_exports__ = {};
             throw errors_createNetworkError.network(error.message);
         }
     }
+    async function listAppsForCheckout(options = {}) {
+        const anvilUrl = options.anvilUrl ?? anvil_api_getDefaultAnvilUrl();
+        const authToken = await auth_getValidAuthToken(anvilUrl, options.username);
+        const params = new URLSearchParams();
+        if ("number" == typeof options.limit) params.set("limit", String(options.limit));
+        if (options.cursor) params.set("cursor", options.cursor);
+        if (options.q && options.q.trim()) params.set("q", options.q.trim());
+        const query = params.toString();
+        const url = `${anvilUrl}/ide/api/_/apps${query ? `?${query}` : ""}`;
+        try {
+            const resp = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${authToken}`
+                },
+                signal: options.signal
+            });
+            if (!resp.ok) {
+                if (401 === resp.status) throw errors_createAuthError.invalid("Authentication failed");
+                throw errors_createNetworkError.server(resp.status, resp.statusText);
+            }
+            const data = await resp.json();
+            return {
+                apps: Array.isArray(data.apps) ? data.apps : [],
+                next_cursor: "string" == typeof data.next_cursor ? data.next_cursor : null
+            };
+        } catch (error) {
+            if (error.type) throw error;
+            throw errors_createNetworkError.network(error.message);
+        }
+    }
     function getGitFetchUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
         const url = new URL(anvilUrl);
         const encodedToken = encodeURIComponent(authToken);
@@ -50117,1224 +50201,1320 @@ var __webpack_exports__ = {};
         const match = normalizedPath.match(/\/git\/([A-Z0-9]+)\.git(?:$|\/)/);
         return match ? match[1] : void 0;
     }
-    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
-        if (explicitUrl) return {
-            source: "explicit",
-            url: normalizeAnvilUrl(explicitUrl)
-        };
-        if (availableUrls.length > 1) return {
-            source: "available-multiple",
-            urls: availableUrls
-        };
-        if (1 === availableUrls.length) return {
-            source: "available-single",
-            url: availableUrls[0]
-        };
-        const fromConfig = getConfig("anvilUrl");
-        if ("string" == typeof fromConfig && fromConfig.trim()) return {
-            source: "config",
-            url: normalizeAnvilUrl(fromConfig.trim())
-        };
-        return {
-            source: "default",
-            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
-        };
-    }
-    function decideUsernameForUrl(accounts) {
-        if (0 === accounts.length) return {
-            source: "none"
-        };
-        if (1 === accounts.length) return {
-            source: "single",
-            username: accounts[0]
-        };
-        return {
-            source: "multiple",
-            usernames: [
-                ...accounts
-            ]
-        };
-    }
-    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
-        if (explicitUsername) return explicitUsername;
-        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
-        if ("none" === decision.source) return;
-        if ("single" === decision.source) {
-            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
-            return decision.username;
+    const external_node_url_namespaceObject = require("node:url");
+    var external_node_child_process_ = __webpack_require__("node:child_process");
+    let isDockerCached;
+    function hasDockerEnv() {
+        try {
+            external_node_fs_.statSync('/.dockerenv');
+            return true;
+        } catch  {
+            return false;
         }
-        const choices = decision.usernames.map((acct)=>({
-                name: acct,
-                value: acct
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
-    }
-    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
-        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
-        if (null === resolvedUsername) return null;
-        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? (slower)`, true);
-        return {
-            username: resolvedUsername,
-            shouldContinue
-        };
-    }
-    async function resolveUrlForFallback(explicitUrl) {
-        const decision = decideFallbackUrl(explicitUrl);
-        if ("available-multiple" !== decision.source) return decision.url;
-        const choices = decision.urls.map((url)=>({
-                name: url,
-                value: url
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        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;
     }
-    async function selectAppId(candidates) {
-        if (0 === candidates.length) {
-            logger_logger.warn("Could not auto-detect app ID from repository.");
-            const rl = external_readline_namespaceObject.createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            const manualAppId = await new Promise((resolve)=>{
-                const handleInterrupt = ()=>{
-                    rl.close();
-                    logger_logger.warn("Operation cancelled by user.");
-                    resolve(null);
-                };
-                rl.on("SIGINT", handleInterrupt);
-                rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
-                    rl.removeListener("SIGINT", handleInterrupt);
-                    rl.close();
-                    const trimmed = answer.trim();
-                    trimmed ? resolve(trimmed) : resolve(null);
-                });
-            });
-            if (manualAppId) return {
-                appId: manualAppId,
-                source: "config",
-                description: "Manual entry"
-            };
-            return null;
-        }
-        const choices = candidates.map((candidate, index)=>({
-                name: formatCandidateLabel(candidate),
-                value: index
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
+    function hasDockerCGroup() {
         try {
-            const promptText = 1 === candidates.length ? "Confirm the detected app ID:" : "Select an app ID:";
-            const answer = await logger_logger.prompt([
-                {
-                    type: "list",
-                    name: "appId",
-                    message: promptText,
-                    choices: choices,
-                    pageSize: 10
-                }
-            ]);
-            if (null === answer.appId) {
-                const rl = external_readline_namespaceObject.createInterface({
-                    input: process.stdin,
-                    output: process.stdout
-                });
-                const manualAppId = await new Promise((resolve)=>{
-                    rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
-                        rl.close();
-                        const trimmed = answer.trim();
-                        trimmed ? resolve(trimmed) : resolve(null);
-                    });
-                });
-                if (manualAppId) return {
-                    appId: manualAppId,
-                    source: "config",
-                    description: "Manual entry"
-                };
-                return null;
-            }
-            return candidates[answer.appId];
-        } catch (error) {
-            const errorObj = error;
-            if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
-            return null;
+            return external_node_fs_.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
+        } catch  {
+            return false;
         }
     }
-    async function pushToAnvil(options) {
+    function isDocker() {
+        if (void 0 === isDockerCached) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+        return isDockerCached;
+    }
+    let cachedResult;
+    const hasContainerEnv = ()=>{
         try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
-            const git = new GitService(options.repoPath);
-            const refSpec = `${options.branchName}:${options.branchName}`;
-            logger_logger.progress("push", "Pushing to Anvil...");
-            await git.push(pushUrl, refSpec, options.force ?? false);
-            logger_logger.progressEnd("push", "Pushed to Anvil");
+            external_node_fs_.statSync('/run/.containerenv');
             return true;
-        } catch (e) {
-            logger_logger.progressEnd("push", "Push failed");
-            logger_logger.error(`Failed to push: ${errors_getErrorMessage(e)}`);
+        } catch  {
             return false;
         }
+    };
+    function isInsideContainer() {
+        if (void 0 === cachedResult) cachedResult = hasContainerEnv() || isDocker();
+        return cachedResult;
     }
-    async function fetchAndRebaseFromAnvil(options) {
-        const git = new GitService(options.repoPath);
-        const tempRef = `anvil-rebase-temp-${Date.now()}`;
-        let didStash = false;
+    const isWsl = ()=>{
+        if ('linux' !== external_node_process_.platform) return false;
+        if (external_node_os_namespaceObject.release().toLowerCase().includes('microsoft')) {
+            if (isInsideContainer()) return false;
+            return true;
+        }
         try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
-            const hasChanges = await git.hasUncommittedChanges();
-            if (hasChanges) {
-                logger_logger.progress("rebase", "Stashing uncommitted changes...");
-                didStash = await git.stash("anvil-sync: stash before rebase");
-            }
-            logger_logger.progressUpdate("rebase", "Fetching from Anvil...");
-            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
-            logger_logger.progressUpdate("rebase", "Rebasing...");
-            await git.rebase(tempRef);
-            logger_logger.progressUpdate("rebase", "Pushing rebased changes...");
-            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
-            await git.push(pushUrl, `${options.branchName}:${options.branchName}`, true);
-            logger_logger.progressEnd("rebase", "Rebased and pushed to Anvil");
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            if (didStash) try {
-                await git.stashPop();
-                logger_logger.verbose(chalk_source.green("Restored uncommitted changes"));
-            } catch (e) {
-                logger_logger.warn("Uncommitted changes were stashed but could not be restored automatically.");
-                logger_logger.info(chalk_source.gray("   Run: git stash pop"));
-            }
-            return {
-                success: true,
-                conflicted: false
-            };
-        } catch (e) {
-            const msg = errors_getErrorMessage(e);
-            if (msg.includes("rebase") && (msg.includes("conflict") || msg.includes("CONFLICT") || msg.includes("could not apply"))) {
-                try {
-                    await git.rebaseAbort();
-                } catch  {}
-                await git.deleteRef(`refs/heads/${tempRef}`);
-                if (didStash) try {
-                    await git.stashPop();
-                } catch  {
-                    logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
-                }
-                logger_logger.progressEnd("rebase", "Rebase failed - conflicts");
-                return {
-                    success: false,
-                    conflicted: true
-                };
-            }
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            if (didStash) try {
-                await git.stashPop();
-            } catch  {
-                logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
-            }
-            logger_logger.progressEnd("rebase", "Rebase failed");
-            logger_logger.error(`Failed to rebase: ${msg}`);
-            return {
-                success: false,
-                conflicted: false
-            };
-        }
-    }
-    async function fetchAndHardResetFromAnvil(options) {
-        const git = new GitService(options.repoPath);
-        const tempRef = `anvil-reset-temp-${Date.now()}`;
-        try {
-            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
-            logger_logger.progress("reset", "Fetching from Anvil...");
-            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
-            logger_logger.progressUpdate("reset", "Resetting to Anvil's version...");
-            await git.reset(tempRef, "hard");
-            logger_logger.progressEnd("reset", "Reset to Anvil's version");
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            return true;
-        } catch (e) {
-            await git.deleteRef(`refs/heads/${tempRef}`);
-            logger_logger.progressEnd("reset", "Reset failed");
-            logger_logger.error(`Failed to reset: ${errors_getErrorMessage(e)}`);
+            return external_node_fs_.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') ? !isInsideContainer() : false;
+        } catch  {
             return false;
         }
+    };
+    const is_wsl = external_node_process_.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+    const wslDrivesMountPoint = (()=>{
+        const defaultMountPoint = '/mnt/';
+        let mountPoint;
+        return async function() {
+            if (mountPoint) return mountPoint;
+            const configFilePath = '/etc/wsl.conf';
+            let isConfigFileExists = false;
+            try {
+                await external_node_fs_promises_namespaceObject.access(configFilePath, external_node_fs_promises_namespaceObject.constants.F_OK);
+                isConfigFileExists = true;
+            } catch  {}
+            if (!isConfigFileExists) return defaultMountPoint;
+            const configContent = await external_node_fs_promises_namespaceObject.readFile(configFilePath, {
+                encoding: 'utf8'
+            });
+            const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+            if (!configMountPoint) return defaultMountPoint;
+            mountPoint = configMountPoint.groups.mountPoint.trim();
+            mountPoint = mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`;
+            return mountPoint;
+        };
+    })();
+    const powerShellPathFromWsl = async ()=>{
+        const mountPoint = await wslDrivesMountPoint();
+        return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+    };
+    const powerShellPath = async ()=>{
+        if (is_wsl) return powerShellPathFromWsl();
+        return `${external_node_process_.env.SYSTEMROOT || external_node_process_.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+    };
+    function defineLazyProperty(object, propertyName, valueGetter) {
+        const define = (value)=>Object.defineProperty(object, propertyName, {
+                value,
+                enumerable: true,
+                writable: true
+            });
+        Object.defineProperty(object, propertyName, {
+            configurable: true,
+            enumerable: true,
+            get () {
+                const result = valueGetter();
+                define(result);
+                return result;
+            },
+            set (value) {
+                define(value);
+            }
+        });
+        return object;
     }
-    function getSyncStateCategory(syncStatus) {
-        if (syncStatus?.branchMissing) return "branch-missing";
-        if (syncStatus?.diverged) return "diverged";
-        if (syncStatus?.ahead && !syncStatus?.behind) return "ahead";
-        if (syncStatus?.behind && !syncStatus?.ahead) return "behind";
-        if (syncStatus?.ahead && syncStatus?.behind) return "diverged";
-        return "in-sync";
+    const execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+    async function defaultBrowserId() {
+        if ('darwin' !== external_node_process_.platform) throw new Error('macOS only');
+        const { stdout } = await execFileAsync('defaults', [
+            'read',
+            'com.apple.LaunchServices/com.apple.launchservices.secure',
+            'LSHandlers'
+        ]);
+        const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+        const browserId = match?.groups.id ?? 'com.apple.Safari';
+        if ('com.apple.safari' === browserId) return 'com.apple.Safari';
+        return browserId;
     }
-    async function recheckSyncStatus(previousCategory, previousBranch, options) {
-        try {
-            logger_logger.progress("verify", "Verifying repository status...");
-            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
-            logger_logger.progressEnd("verify");
-            const currentCategory = getSyncStateCategory(freshSession.syncStatus);
-            const currentBranch = freshSession.getBranchName() || "master";
-            if (currentCategory !== previousCategory || currentBranch !== previousBranch) {
-                logger_logger.warn("Repository status has changed. Re-evaluating...");
-                return freshSession;
-            }
-            freshSession.cleanup();
-            return null;
-        } catch (e) {
-            logger_logger.progressEnd("verify");
-            logger_logger.verbose(chalk_source.gray(`Could not re-verify status: ${errors_getErrorMessage(e)}`));
-            return null;
-        }
+    const run_applescript_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+    async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+        if ('darwin' !== external_node_process_.platform) throw new Error('macOS only');
+        const outputArguments = humanReadableOutput ? [] : [
+            '-ss'
+        ];
+        const execOptions = {};
+        if (signal) execOptions.signal = signal;
+        const { stdout } = await run_applescript_execFileAsync("osascript", [
+            '-e',
+            script,
+            outputArguments
+        ], execOptions);
+        return stdout.trim();
     }
-    async function recreateSessionAndValidate(options) {
-        logger_logger.progress("init", "Restarting watch session...");
-        try {
-            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
-            logger_logger.progressEnd("init");
-            return await checkSyncStatusAndStart(newSession, options);
-        } catch (e) {
-            logger_logger.progressEnd("init", "Failed");
-            logger_logger.error(`Failed to restart: ${errors_getErrorMessage(e)}`);
-            return false;
+    async function bundleName(bundleId) {
+        return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+    }
+    const windows_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+    const windowsBrowserProgIds = {
+        MSEdgeHTM: {
+            name: 'Edge',
+            id: 'com.microsoft.edge'
+        },
+        MSEdgeBHTML: {
+            name: 'Edge Beta',
+            id: 'com.microsoft.edge.beta'
+        },
+        MSEdgeDHTML: {
+            name: 'Edge Dev',
+            id: 'com.microsoft.edge.dev'
+        },
+        AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+            name: 'Edge',
+            id: 'com.microsoft.edge.old'
+        },
+        ChromeHTML: {
+            name: 'Chrome',
+            id: 'com.google.chrome'
+        },
+        ChromeBHTML: {
+            name: 'Chrome Beta',
+            id: 'com.google.chrome.beta'
+        },
+        ChromeDHTML: {
+            name: 'Chrome Dev',
+            id: 'com.google.chrome.dev'
+        },
+        ChromiumHTM: {
+            name: 'Chromium',
+            id: 'org.chromium.Chromium'
+        },
+        BraveHTML: {
+            name: 'Brave',
+            id: 'com.brave.Browser'
+        },
+        BraveBHTML: {
+            name: 'Brave Beta',
+            id: 'com.brave.Browser.beta'
+        },
+        BraveDHTML: {
+            name: 'Brave Dev',
+            id: 'com.brave.Browser.dev'
+        },
+        BraveSSHTM: {
+            name: 'Brave Nightly',
+            id: 'com.brave.Browser.nightly'
+        },
+        FirefoxURL: {
+            name: 'Firefox',
+            id: 'org.mozilla.firefox'
+        },
+        OperaStable: {
+            name: 'Opera',
+            id: 'com.operasoftware.Opera'
+        },
+        VivaldiHTM: {
+            name: 'Vivaldi',
+            id: 'com.vivaldi.Vivaldi'
+        },
+        'IE.HTTP': {
+            name: 'Internet Explorer',
+            id: 'com.microsoft.ie'
         }
+    };
+    new Map(Object.entries(windowsBrowserProgIds));
+    class UnknownBrowserError extends Error {
     }
-    async function checkSyncStatusAndStart(session, options) {
-        const syncStatus = session.syncStatus;
-        const branchName = session.getBranchName() || "master";
-        const hasUncommitted = session.hasUncommittedChanges;
-        const stateCategory = getSyncStateCategory(syncStatus);
-        if (syncStatus?.branchMissing) {
-            logger_logger.warn(`Branch '${branchName}' doesn't exist on Anvil yet.`);
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldPush = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing new branch to Anvil..."));
-            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);
-                }
-            }
-            if (!shouldPush) {
-                logger_logger.warn("Watch cancelled. Push your branch to Anvil, then try again.");
-                session.cleanup();
-                return false;
-            }
-            session.cleanup();
-            const pushed = await pushToAnvil({
-                repoPath: options.repoPath,
-                appId: options.appId,
-                anvilUrl: options.anvilUrl,
-                branchName,
-                username: options.username
-            });
-            if (!pushed) return false;
-            return await recreateSessionAndValidate(options);
+    async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
+        const { stdout } = await _execFileAsync('reg', [
+            'QUERY',
+            ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
+            '/v',
+            'ProgId'
+        ]);
+        const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+        if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+        const { id } = match.groups;
+        const browser = windowsBrowserProgIds[id];
+        if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
+        return browser;
+    }
+    const default_browser_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
+    const titleize = (string)=>string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase());
+    async function default_browser_defaultBrowser() {
+        if ('darwin' === external_node_process_.platform) {
+            const id = await defaultBrowserId();
+            const name = await bundleName(id);
+            return {
+                name,
+                id
+            };
         }
-        if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
-            logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldPush = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing to Anvil..."));
-            else {
-                const action = await logger_logger.select("What would you like to do?", [
-                    {
-                        name: "Push your changes to Anvil (recommended)",
-                        value: "push"
-                    },
-                    {
-                        name: "Exit and handle manually",
-                        value: "exit"
-                    }
-                ], "push");
-                shouldPush = "push" === action;
-                if (shouldPush) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+        if ('linux' === external_node_process_.platform) {
+            const { stdout } = await default_browser_execFileAsync('xdg-mime', [
+                'query',
+                'default',
+                'x-scheme-handler/http'
+            ]);
+            const id = stdout.trim();
+            const name = titleize(id.replace(/.desktop$/, '').replace('-', ' '));
+            return {
+                name,
+                id
+            };
+        }
+        if ('win32' === external_node_process_.platform) return defaultBrowser();
+        throw new Error('Only macOS, Linux, and Windows are supported');
+    }
+    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_;
+    async function getWindowsDefaultBrowserFromWsl() {
+        const powershellPath = await powerShellPath();
+        const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+        const encodedCommand = external_node_buffer_namespaceObject.Buffer.from(rawCommand, 'utf16le').toString('base64');
+        const { stdout } = await execFile(powershellPath, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-EncodedCommand',
+            encodedCommand
+        ], {
+            encoding: 'utf8'
+        });
+        const progId = stdout.trim();
+        const browserMap = {
+            ChromeHTML: 'com.google.chrome',
+            BraveHTML: 'com.brave.Browser',
+            MSEdgeHTM: 'com.microsoft.edge',
+            FirefoxURL: 'org.mozilla.firefox'
+        };
+        return browserMap[progId] ? {
+            id: browserMap[progId]
+        } : {};
+    }
+    const pTryEach = async (array, mapper)=>{
+        let latestError;
+        for (const item of array)try {
+            return await mapper(item);
+        } catch (error) {
+            latestError = error;
+        }
+        throw latestError;
+    };
+    const baseOpen = async (options)=>{
+        options = {
+            wait: false,
+            background: false,
+            newInstance: false,
+            allowNonzeroExitCode: false,
+            ...options
+        };
+        if (Array.isArray(options.app)) return pTryEach(options.app, (singleApp)=>baseOpen({
+                ...options,
+                app: singleApp
+            }));
+        let { name: app, arguments: appArguments = [] } = options.app ?? {};
+        appArguments = [
+            ...appArguments
+        ];
+        if (Array.isArray(app)) return pTryEach(app, (appName)=>baseOpen({
+                ...options,
+                app: {
+                    name: appName,
+                    arguments: appArguments
                 }
-            }
-            if (!shouldPush) {
-                logger_logger.warn("Watch cancelled.");
-                session.cleanup();
-                return false;
-            }
-            session.cleanup();
-            const pushed = await pushToAnvil({
-                repoPath: options.repoPath,
-                appId: options.appId,
-                anvilUrl: options.anvilUrl,
-                branchName,
-                username: options.username
-            });
-            if (!pushed) return false;
-            return await 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.`));
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            session.cleanup();
-            if (options.autoMode) {
-                logger_logger.info(chalk_source.cyan("→ Auto-rebasing onto Anvil's version..."));
-                const result = await fetchAndRebaseFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
+            }));
+        if ('browser' === app || 'browserPrivate' === app) {
+            const ids = {
+                'com.google.chrome': 'chrome',
+                'google-chrome.desktop': 'chrome',
+                'com.brave.Browser': 'brave',
+                'org.mozilla.firefox': 'firefox',
+                'firefox.desktop': 'firefox',
+                'com.microsoft.msedge': 'edge',
+                'com.microsoft.edge': 'edge',
+                'com.microsoft.edgemac': 'edge',
+                'microsoft-edge.desktop': 'edge'
+            };
+            const flags = {
+                chrome: '--incognito',
+                brave: '--incognito',
+                firefox: '--private-window',
+                edge: '--inPrivate'
+            };
+            const browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
+            if (browser.id in ids) {
+                const browserName = ids[browser.id];
+                if ('browserPrivate' === app) appArguments.push(flags[browserName]);
+                return baseOpen({
+                    ...options,
+                    app: {
+                        name: open_apps[browserName],
+                        arguments: appArguments
+                    }
                 });
-                if (result.conflicted) {
-                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
-                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
-                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
-                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
-                    return false;
-                }
-                if (!result.success) return false;
-                return await recreateSessionAndValidate(options);
             }
-            const action = await logger_logger.select("How would you like to resolve this?", [
-                {
-                    name: "Pull from Anvil and rebase your changes on top (recommended)",
-                    value: "rebase"
-                },
-                {
-                    name: "Discard your local commits and use Anvil's version",
-                    value: "reset"
-                },
-                {
-                    name: "Push your version to Anvil (overwrites remote)",
-                    value: "push"
-                },
-                {
-                    name: "Exit and handle manually",
-                    value: "exit"
-                }
-            ], "rebase");
-            if ("exit" === action) {
-                logger_logger.warn("Watch cancelled.");
-                return false;
+            throw new Error(`${browser.name} is not supported as a default browser`);
+        }
+        let command;
+        const cliArguments = [];
+        const childProcessOptions = {};
+        if ('darwin' === 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)) {
+            if (app) command = app;
+            else {
+                const isBundled = !open_dirname || '/' === open_dirname;
+                let exeLocalXdgOpen = false;
+                try {
+                    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);
+                command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
             }
-            const changed = await recheckSyncStatus(stateCategory, branchName, options);
-            if (changed) return await checkSyncStatusAndStart(changed, options);
-            if ("rebase" === action) {
-                const result = await fetchAndRebaseFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
-                });
-                if (result.conflicted) {
-                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
-                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
-                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
-                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
-                    return false;
-                }
-                if (!result.success) return false;
-                return await 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?`;
-                const confirmed = await logger_logger.confirm(resetWarning, false);
-                if (!confirmed) {
-                    logger_logger.warn("Watch cancelled.");
-                    return false;
-                }
-                const reset = await fetchAndHardResetFromAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username
-                });
-                if (!reset) return false;
-                return await recreateSessionAndValidate(options);
-            }
-            if ("push" === action) {
-                const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
-                if (!confirmed) {
-                    logger_logger.warn("Watch cancelled.");
-                    return false;
-                }
-                const pushed = await pushToAnvil({
-                    repoPath: options.repoPath,
-                    appId: options.appId,
-                    anvilUrl: options.anvilUrl,
-                    branchName,
-                    username: options.username,
-                    force: true
-                });
-                if (!pushed) return false;
-                return await recreateSessionAndValidate(options);
+            if (appArguments.length > 0) cliArguments.push(...appArguments);
+            if (!options.wait) {
+                childProcessOptions.stdio = 'ignore';
+                childProcessOptions.detached = true;
             }
         } else {
-            logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
-            logger_logger.verbose(chalk_source.gray("   You need to sync to the latest version before watching."));
-            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
-            let shouldSync = options.autoMode;
-            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-syncing to latest version..."));
-            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);
-                }
-            }
-            if (!shouldSync) {
-                logger_logger.warn("Watch cancelled. Please sync manually before watching.");
-                session.cleanup();
-                return false;
+            command = await powerShellPath();
+            cliArguments.push('-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand');
+            if (!is_wsl) childProcessOptions.windowsVerbatimArguments = true;
+            const encodedArguments = [
+                'Start'
+            ];
+            if (options.wait) encodedArguments.push('-Wait');
+            if (app) {
+                encodedArguments.push(`"\`"${app}\`""`);
+                if (options.target) appArguments.push(options.target);
+            } else if (options.target) encodedArguments.push(`"${options.target}"`);
+            if (appArguments.length > 0) {
+                appArguments = appArguments.map((argument)=>`"\`"${argument}\`""`);
+                encodedArguments.push('-ArgumentList', appArguments.join(','));
             }
-            session.cleanup();
-            let authToken;
-            try {
-                authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
-            } catch (e) {
-                logger_logger.error("Not logged in. Please log in first.");
-                process.exit(1);
+            options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+        }
+        if ('darwin' === 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)=>{
+            subprocess.once('error', reject);
+            subprocess.once('close', (exitCode)=>{
+                if (!options.allowNonzeroExitCode && exitCode > 0) return void reject(new Error(`Exited with code ${exitCode}`));
+                resolve(subprocess);
+            });
+        });
+        subprocess.unref();
+        return subprocess;
+    };
+    const open_open = (target, options)=>{
+        if ('string' != typeof target) throw new TypeError('Expected a `target`');
+        return baseOpen({
+            ...options,
+            target
+        });
+    };
+    function detectArchBinary(binary) {
+        if ('string' == typeof binary || Array.isArray(binary)) return binary;
+        const { [arch]: archBinary } = binary;
+        if (!archBinary) throw new Error(`${arch} is not supported`);
+        return archBinary;
+    }
+    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+        if (wsl && is_wsl) return detectArchBinary(wsl);
+        if (!platformBinary) throw new Error(`${platform} is not supported`);
+        return detectArchBinary(platformBinary);
+    }
+    const open_apps = {};
+    defineLazyProperty(open_apps, 'chrome', ()=>detectPlatformBinary({
+            darwin: 'google chrome',
+            win32: 'chrome',
+            linux: [
+                'google-chrome',
+                'google-chrome-stable',
+                'chromium'
+            ]
+        }, {
+            wsl: {
+                ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
+                x64: [
+                    '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
+                    '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'
+                ]
             }
-            logger_logger.progress("sync-latest", "Syncing to latest version from Anvil...");
-            try {
-                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
-                logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
-            } catch (e) {
-                logger_logger.progressEnd("sync-latest", "Failed");
-                logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
-                process.exit(1);
+        }));
+    defineLazyProperty(open_apps, 'brave', ()=>detectPlatformBinary({
+            darwin: 'brave browser',
+            win32: 'brave',
+            linux: [
+                'brave-browser',
+                'brave'
+            ]
+        }, {
+            wsl: {
+                ia32: '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe',
+                x64: [
+                    '/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe',
+                    '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe'
+                ]
             }
-            return await recreateSessionAndValidate(options);
+        }));
+    defineLazyProperty(open_apps, 'firefox', ()=>detectPlatformBinary({
+            darwin: 'firefox',
+            win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+            linux: 'firefox'
+        }, {
+            wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
+        }));
+    defineLazyProperty(open_apps, 'edge', ()=>detectPlatformBinary({
+            darwin: 'microsoft edge',
+            win32: 'msedge',
+            linux: [
+                'microsoft-edge',
+                'microsoft-edge-dev'
+            ]
+        }, {
+            wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
+        }));
+    defineLazyProperty(open_apps, 'browser', ()=>'browser');
+    defineLazyProperty(open_apps, 'browserPrivate', ()=>'browserPrivate');
+    const node_modules_open = open_open;
+    const defaultDeps = {
+        openSystem: async (pathToOpen)=>node_modules_open(pathToOpen),
+        isCommandAvailable: isCommandAvailable,
+        spawnShellCommand: async (commandLine)=>{
+            await new Promise((resolve, reject)=>{
+                const child = (0, external_child_process_.spawn)(commandLine, {
+                    shell: true,
+                    stdio: "inherit"
+                });
+                child.on("error", reject);
+                child.on("exit", (code)=>{
+                    if (0 === code || null === code) resolve();
+                    else reject(new Error(`Editor command exited with code ${code}`));
+                });
+            });
         }
-        await startWatchingWithEventHandlers(session, options);
-        return true;
-    }
-    async function startWatchingWithEventHandlers(session, options) {
-        const { autoMode, repoPath, appId, anvilUrl, stagedOnly } = options;
-        session.on("branch-changed", async ({ oldBranch, newBranch })=>{
-            try {
-                session.cleanup();
-                logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
-                logger_logger.info(chalk_source.cyan("→ Restarting watch on new branch..."));
-                const git = esm_default(repoPath);
-                const actualBranch = (await git.revparse([
-                    "--abbrev-ref",
-                    "HEAD"
-                ])).trim();
-                if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
-                logger_logger.progress("init", "Initializing watch session...");
-                try {
-                    const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
-                    logger_logger.progressEnd("init");
-                    const started = await checkSyncStatusAndStart(newSession, options);
-                    if (!started) process.exit(0);
-                } catch (e) {
-                    logger_logger.progressEnd("init", "Failed");
-                    logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
-                    process.exit(1);
-                }
-            } catch (error) {
-                logger_logger.error(`Error handling branch change: ${error.message}`);
-                process.exit(1);
+    };
+    function parseCommandTokens(command) {
+        const input = command.trim();
+        if (!input) return [];
+        const tokens = [];
+        let current = "";
+        let quote = null;
+        let escaping = false;
+        for(let i = 0; i < input.length; i += 1){
+            const ch = input[i];
+            if (escaping) {
+                current += ch;
+                escaping = false;
+                continue;
             }
-        });
-        session.on("validation-failed", ({ reason, currentBranch })=>{
-            logger_logger.error(chalk_source.red(`Validation failed: ${reason}`));
-            logger_logger.verbose(chalk_source.yellow(`   Current branch: ${currentBranch}`));
-            logger_logger.verbose(chalk_source.yellow("   Please restart anvil to re-validate the branch."));
-            session.cleanup();
-            process.exit(1);
-        });
-        session.on("max-retries-exceeded", async ()=>{
-            if (autoMode) {
-                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch session..."));
-                session.cleanup();
-                const restarted = await recreateSessionAndValidate(options);
-                if (!restarted) process.exit(1);
-            } else {
-                const shouldRestart = await logger_logger.confirm("Would you like to restart the watch session?", true);
-                if (shouldRestart) {
-                    session.cleanup();
-                    const restarted = await recreateSessionAndValidate(options);
-                    if (!restarted) process.exit(1);
-                }
+            if ("\\" === ch) {
+                escaping = true;
+                continue;
             }
-        });
-        if (session.hasUncommittedChanges) {
-            if (!autoMode) {
-                const shouldContinue = await logger_logger.confirm("Continue? Your uncommitted changes will be synced to Anvil.", true);
-                if (!shouldContinue) {
-                    logger_logger.warn("Watch cancelled. Commit, stash, or discard your changes, then try again.");
-                    session.cleanup();
-                    process.exit(0);
-                }
+            if (quote) {
+                if (ch === quote) quote = null;
+                else current += ch;
+                continue;
             }
-            logger_logger.progress("save", "Saving uncommitted changes to Anvil...");
-            try {
-                await session.forceSave();
-                logger_logger.progressEnd("save");
-            } catch (e) {
-                logger_logger.progressEnd("save", "Failed");
-                logger_logger.error(`Failed to save: ${errors_getErrorMessage(e)}`);
+            if ('"' === ch || "'" === ch) {
+                quote = ch;
+                continue;
+            }
+            if (/\s/.test(ch)) {
+                if (current) {
+                    tokens.push(current);
+                    current = "";
+                }
+                continue;
             }
+            current += ch;
+        }
+        if (escaping) current += "\\";
+        if (quote) throw new Error(`Unterminated quote in command: ${command}`);
+        if (current) tokens.push(current);
+        return tokens;
+    }
+    function quoteForPosixShell(value) {
+        if ("" === value) return "''";
+        return `'${value.replace(/'/g, "'\"'\"'")}'`;
+    }
+    function quoteForCmdShell(value) {
+        const escaped = value.replace(/[%^&|<>()"!]/g, "^$&");
+        return `"${escaped}"`;
+    }
+    function buildShellCommandLine(tokens) {
+        if ("win32" === process.platform) return tokens.map(quoteForCmdShell).join(" ");
+        return tokens.map(quoteForPosixShell).join(" ");
+    }
+    async function openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps = defaultDeps) {
+        if (preferredEditorCommand) if (deps.isCommandAvailable(preferredEditorCommand)) try {
+            const tokens = parseCommandTokens(preferredEditorCommand);
+            if (0 === tokens.length) throw new Error("empty command");
+            await deps.spawnShellCommand(buildShellCommandLine([
+                ...tokens,
+                targetPath
+            ]));
+            return;
+        } catch (error) {
+            logger_logger.warn(`Failed to open preferred editor '${preferredEditorCommand}': ${errors_getErrorMessage(error)}. Falling back to the system default app.`);
         }
-        await session.startWatching();
+        else logger_logger.warn(`Preferred editor command '${preferredEditorCommand}' was not found in PATH. Falling back to the system default app.`);
+        await deps.openSystem(targetPath);
     }
-    async function handleWatchCommand(options) {
-        const invoked = process.argv[2];
-        if ("sync" === invoked) {
-            logger_logger.error("'sync' has been renamed to 'watch'. Please use 'anvil watch' instead.");
-            process.exit(1);
-        }
-        const { path: repoPath = process.cwd(), appid: explicitAppId, useFirst = false, stagedOnly = false, autoMode = false, url: explicitUrl, user: explicitUsername } = options;
-        try {
-            const validationResult = await validateAnvilApp(repoPath);
-            if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
-            const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
-            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
-            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
-            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
-            let finalAppId;
-            let anvilUrl;
-            let username = explicitUsername;
-            let fallbackUrl;
-            let shouldPersistUsernameBinding = false;
-            if (explicitAppId) {
-                finalAppId = explicitAppId;
-                const binding = await getAppAuthBinding(repoPath, explicitAppId);
-                if (binding.url && !explicitUrl) {
-                    anvilUrl = normalizeAnvilUrl(binding.url);
-                    logger_logger.verbose(chalk_source.cyan("Resolved URL from binding for app ID: ") + chalk_source.bold(anvilUrl));
-                }
-                if (binding.username && !explicitUsername) {
-                    username = binding.username;
-                    logger_logger.verbose(chalk_source.cyan("Resolved username from binding for app ID: ") + chalk_source.bold(username));
-                }
-                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
-                if (remoteInfo.detectedUrl && !explicitUrl && !anvilUrl) {
-                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
-                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
-                }
-                if (remoteInfo.detectedUsername && !explicitUsername && !username) {
-                    username = remoteInfo.detectedUsername;
-                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
-                }
-            } else {
-                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
-                if (0 === filteredCandidates.length) {
-                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
-                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
-                    if (null === resolvedFallbackUrl) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
-                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
-                    if (null === lookupDecision) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    username = lookupDecision.username;
-                    if (lookupDecision.shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
-                        const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
-                            anvilUrl: fallbackUrl,
-                            username,
-                            includeRemotes: false
-                        });
-                        logger_logger.progressEnd("detect");
-                        for (const c of reverseLookupCandidates)filteredCandidates.push({
-                            ...c,
-                            detectedUrl: fallbackUrl
-                        });
-                    }
-                }
-                if (filteredCandidates.length > 0) {
-                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
-                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
-                }
-                if (useFirst && filteredCandidates.length > 0) {
-                    const selected = filteredCandidates[0];
-                    finalAppId = selected.appId;
-                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
-                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
-                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
-                } else {
-                    const selected = await selectAppId(filteredCandidates);
-                    if (!selected) {
-                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
-                        process.exit(1);
-                    }
-                    finalAppId = selected.appId;
-                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
-                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
-                }
-            }
-            const binding = await getAppAuthBinding(repoPath, finalAppId);
-            if (binding.url && !explicitUrl) {
-                anvilUrl = normalizeAnvilUrl(binding.url);
-                logger_logger.verbose(chalk_source.cyan("Using app binding URL: ") + chalk_source.bold(anvilUrl));
-            }
-            if (binding.username && !explicitUsername) {
-                username = binding.username;
-                logger_logger.verbose(chalk_source.cyan("Using app binding username: ") + chalk_source.bold(username));
-            }
-            shouldPersistUsernameBinding = !binding.username && !explicitUsername;
-            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
-            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
-            else {
-                const resolvedFallbackUrl = await resolveUrlForFallback();
-                if (null === resolvedFallbackUrl) {
-                    logger_logger.warn("Operation cancelled.");
-                    process.exit(0);
-                }
-                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
-            }
-            anvilUrl = normalizeAnvilUrl(anvilUrl);
-            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
-            if (null === resolvedUsername) {
-                logger_logger.warn("Operation cancelled.");
-                process.exit(0);
-            }
-            username = resolvedUsername;
-            if (shouldPersistUsernameBinding && username && auth_getAccountsForUrl(anvilUrl).length > 1) {
-                await setAppAuthBinding(repoPath, finalAppId, {
-                    url: anvilUrl,
-                    username
-                });
-                logger_logger.verbose(chalk_source.cyan("Saved app account binding for future non-interactive use."));
-            }
-            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
-            if (!hasTokensForUrl(anvilUrl, username)) {
-                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?:\/\//, "")}`));
-                process.exit(1);
-            }
-            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
-            logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
-            const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
-            logger_logger.progressEnd("validate");
-            if (!appIdValidation.valid) {
-                logger_logger.error(`App ID validation failed: ${appIdValidation.error}`);
-                logger_logger.verbose(chalk_source.yellow("This could mean:"));
-                logger_logger.verbose(chalk_source.yellow("  • The app ID doesn't exist on the server"));
-                logger_logger.verbose(chalk_source.yellow("  • You don't have access to this app"));
-                logger_logger.verbose(chalk_source.yellow("  • There's a network or authentication issue"));
-                process.exit(1);
-            }
-            logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
-            if (appIdValidation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${appIdValidation.app_name}`));
-            if (stagedOnly) logger_logger.info(chalk_source.yellow("▸ Staged-only mode: Only staged changes will be synced"));
-            if (autoMode) logger_logger.info(chalk_source.cyan("▸ Auto mode: Will automatically restart on branch changes and sync when behind"));
-            logger_logger.progress("init", "Initializing watch session...");
-            const session = await api_watch(repoPath, finalAppId, anvilUrl, stagedOnly, username);
-            logger_logger.progressEnd("init");
-            logger_logger.verbose(chalk_source.blue("Watching for file changes..."));
-            const started = await checkSyncStatusAndStart(session, {
-                autoMode,
-                repoPath,
-                appId: finalAppId,
-                anvilUrl,
-                stagedOnly,
-                username
-            });
-            if (!started) process.exit(1);
-        } catch (e) {
-            logger_logger.error("Error: " + errors_getErrorMessage(e));
-            process.exit(1);
-        }
-    }
-    function registerWatchCommand(program) {
-        const watchCommand = program.command("watch [path]").description("Watch for file changes and sync to Anvil").alias("sync").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-V, --verbose", "Show detailed output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options)=>{
-            if (void 0 !== options.verbose && logger_logger instanceof CLILogger) logger_logger.setVerbose(options.verbose);
-            await handleWatchCommand({
-                path,
-                appid: options.appid,
-                useFirst: options.first,
-                stagedOnly: options.stagedOnly,
-                autoMode: options.auto,
-                verbose: options.verbose,
-                url: options.url,
-                user: options.user
-            });
-        });
-        return watchCommand;
+    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
+        if (explicitUrl) return {
+            source: "explicit",
+            url: normalizeAnvilUrl(explicitUrl)
+        };
+        if (availableUrls.length > 1) return {
+            source: "available-multiple",
+            urls: availableUrls
+        };
+        if (1 === availableUrls.length) return {
+            source: "available-single",
+            url: availableUrls[0]
+        };
+        const fromConfig = getConfig("anvilUrl");
+        if ("string" == typeof fromConfig && fromConfig.trim()) return {
+            source: "config",
+            url: normalizeAnvilUrl(fromConfig.trim())
+        };
+        return {
+            source: "default",
+            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
+        };
     }
-    const external_node_url_namespaceObject = require("node:url");
-    var external_node_child_process_ = __webpack_require__("node:child_process");
-    let isDockerCached;
-    function hasDockerEnv() {
-        try {
-            external_node_fs_.statSync('/.dockerenv');
-            return true;
-        } catch  {
-            return false;
-        }
+    function decideUsernameForUrl(accounts) {
+        if (0 === accounts.length) return {
+            source: "none"
+        };
+        if (1 === accounts.length) return {
+            source: "single",
+            username: accounts[0]
+        };
+        return {
+            source: "multiple",
+            usernames: [
+                ...accounts
+            ]
+        };
     }
-    function hasDockerCGroup() {
-        try {
-            return external_node_fs_.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
-        } catch  {
-            return false;
+    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
+        if (explicitUsername) return explicitUsername;
+        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
+        if ("none" === decision.source) return;
+        if ("single" === decision.source) {
+            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
+            return decision.username;
         }
+        const choices = decision.usernames.map((acct)=>({
+                name: acct,
+                value: acct
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
     }
-    function isDocker() {
-        if (void 0 === isDockerCached) isDockerCached = hasDockerEnv() || hasDockerCGroup();
-        return isDockerCached;
+    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
+        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
+        if (null === resolvedUsername) return null;
+        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? (slower)`, true);
+        return {
+            username: resolvedUsername,
+            shouldContinue
+        };
     }
-    let cachedResult;
-    const hasContainerEnv = ()=>{
+    async function resolveUrlForFallback(explicitUrl) {
+        const decision = decideFallbackUrl(explicitUrl);
+        if ("available-multiple" !== decision.source) return decision.url;
+        const choices = decision.urls.map((url)=>({
+                name: url,
+                value: url
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        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;
+    }
+    function resolveWatchOpenPath(repoPath) {
+        return external_path_default().resolve(repoPath);
+    }
+    async function openWatchPath(targetPath, deps) {
+        const preferredEditor = String(getConfig("preferredEditor") || "").trim();
+        const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
+        await openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps);
+        logger_logger.info(chalk_source.gray(`Opened ${targetPath}`));
+    }
+    async function selectAppId(candidates) {
+        if (0 === candidates.length) {
+            logger_logger.warn("Could not auto-detect app ID from repository.");
+            const rl = external_readline_namespaceObject.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const manualAppId = await new Promise((resolve)=>{
+                const handleInterrupt = ()=>{
+                    rl.close();
+                    logger_logger.warn("Operation cancelled by user.");
+                    resolve(null);
+                };
+                rl.on("SIGINT", handleInterrupt);
+                rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
+                    rl.removeListener("SIGINT", handleInterrupt);
+                    rl.close();
+                    const trimmed = answer.trim();
+                    trimmed ? resolve(trimmed) : resolve(null);
+                });
+            });
+            if (manualAppId) return {
+                appId: manualAppId,
+                source: "config",
+                description: "Manual entry"
+            };
+            return null;
+        }
+        const choices = candidates.map((candidate, index)=>({
+                name: formatCandidateLabel(candidate),
+                value: index
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
         try {
-            external_node_fs_.statSync('/run/.containerenv');
+            const promptText = 1 === candidates.length ? "Confirm the detected app ID:" : "Select an app ID:";
+            const answer = await logger_logger.prompt([
+                {
+                    type: "list",
+                    name: "appId",
+                    message: promptText,
+                    choices: choices,
+                    pageSize: 10
+                }
+            ]);
+            if (null === answer.appId) {
+                const rl = external_readline_namespaceObject.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                const manualAppId = await new Promise((resolve)=>{
+                    rl.question(chalk_source.cyan("Please enter app ID manually (or press Enter to exit): "), (answer)=>{
+                        rl.close();
+                        const trimmed = answer.trim();
+                        trimmed ? resolve(trimmed) : resolve(null);
+                    });
+                });
+                if (manualAppId) return {
+                    appId: manualAppId,
+                    source: "config",
+                    description: "Manual entry"
+                };
+                return null;
+            }
+            return candidates[answer.appId];
+        } catch (error) {
+            const errorObj = error;
+            if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
+            return null;
+        }
+    }
+    async function pushToAnvil(options) {
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            const git = new GitService(options.repoPath);
+            const refSpec = `${options.branchName}:${options.branchName}`;
+            logger_logger.progress("push", "Pushing to Anvil...");
+            await git.push(pushUrl, refSpec, options.force ?? false);
+            logger_logger.progressEnd("push", "Pushed to Anvil");
             return true;
-        } catch  {
+        } catch (e) {
+            logger_logger.progressEnd("push", "Push failed");
+            logger_logger.error(`Failed to push: ${errors_getErrorMessage(e)}`);
             return false;
         }
-    };
-    function isInsideContainer() {
-        if (void 0 === cachedResult) cachedResult = hasContainerEnv() || isDocker();
-        return cachedResult;
     }
-    const isWsl = ()=>{
-        if ('linux' !== external_node_process_.platform) return false;
-        if (external_node_os_namespaceObject.release().toLowerCase().includes('microsoft')) {
-            if (isInsideContainer()) return false;
-            return true;
+    async function fetchAndRebaseFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-rebase-temp-${Date.now()}`;
+        let didStash = false;
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            const hasChanges = await git.hasUncommittedChanges();
+            if (hasChanges) {
+                logger_logger.progress("rebase", "Stashing uncommitted changes...");
+                didStash = await git.stash("anvil-sync: stash before rebase");
+            }
+            logger_logger.progressUpdate("rebase", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("rebase", "Rebasing...");
+            await git.rebase(tempRef);
+            logger_logger.progressUpdate("rebase", "Pushing rebased changes...");
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            await git.push(pushUrl, `${options.branchName}:${options.branchName}`, true);
+            logger_logger.progressEnd("rebase", "Rebased and pushed to Anvil");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+                logger_logger.verbose(chalk_source.green("Restored uncommitted changes"));
+            } catch (e) {
+                logger_logger.warn("Uncommitted changes were stashed but could not be restored automatically.");
+                logger_logger.info(chalk_source.gray("   Run: git stash pop"));
+            }
+            return {
+                success: true,
+                conflicted: false
+            };
+        } catch (e) {
+            const msg = errors_getErrorMessage(e);
+            if (msg.includes("rebase") && (msg.includes("conflict") || msg.includes("CONFLICT") || msg.includes("could not apply"))) {
+                try {
+                    await git.rebaseAbort();
+                } catch  {}
+                await git.deleteRef(`refs/heads/${tempRef}`);
+                if (didStash) try {
+                    await git.stashPop();
+                } catch  {
+                    logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
+                }
+                logger_logger.progressEnd("rebase", "Rebase failed - conflicts");
+                return {
+                    success: false,
+                    conflicted: true
+                };
+            }
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+            } catch  {
+                logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
+            }
+            logger_logger.progressEnd("rebase", "Rebase failed");
+            logger_logger.error(`Failed to rebase: ${msg}`);
+            return {
+                success: false,
+                conflicted: false
+            };
         }
+    }
+    async function fetchAndHardResetFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-reset-temp-${Date.now()}`;
         try {
-            return external_node_fs_.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') ? !isInsideContainer() : false;
-        } catch  {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            logger_logger.progress("reset", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("reset", "Resetting to Anvil's version...");
+            await git.reset(tempRef, "hard");
+            logger_logger.progressEnd("reset", "Reset to Anvil's version");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            return true;
+        } catch (e) {
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            logger_logger.progressEnd("reset", "Reset failed");
+            logger_logger.error(`Failed to reset: ${errors_getErrorMessage(e)}`);
             return false;
         }
-    };
-    const is_wsl = external_node_process_.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-    const wslDrivesMountPoint = (()=>{
-        const defaultMountPoint = '/mnt/';
-        let mountPoint;
-        return async function() {
-            if (mountPoint) return mountPoint;
-            const configFilePath = '/etc/wsl.conf';
-            let isConfigFileExists = false;
-            try {
-                await external_node_fs_promises_namespaceObject.access(configFilePath, external_node_fs_promises_namespaceObject.constants.F_OK);
-                isConfigFileExists = true;
-            } catch  {}
-            if (!isConfigFileExists) return defaultMountPoint;
-            const configContent = await external_node_fs_promises_namespaceObject.readFile(configFilePath, {
-                encoding: 'utf8'
-            });
-            const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
-            if (!configMountPoint) return defaultMountPoint;
-            mountPoint = configMountPoint.groups.mountPoint.trim();
-            mountPoint = mountPoint.endsWith('/') ? mountPoint : `${mountPoint}/`;
-            return mountPoint;
-        };
-    })();
-    const powerShellPathFromWsl = async ()=>{
-        const mountPoint = await wslDrivesMountPoint();
-        return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-    };
-    const powerShellPath = async ()=>{
-        if (is_wsl) return powerShellPathFromWsl();
-        return `${external_node_process_.env.SYSTEMROOT || external_node_process_.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
-    };
-    function defineLazyProperty(object, propertyName, valueGetter) {
-        const define = (value)=>Object.defineProperty(object, propertyName, {
-                value,
-                enumerable: true,
-                writable: true
-            });
-        Object.defineProperty(object, propertyName, {
-            configurable: true,
-            enumerable: true,
-            get () {
-                const result = valueGetter();
-                define(result);
-                return result;
-            },
-            set (value) {
-                define(value);
-            }
-        });
-        return object;
     }
-    const execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
-    async function defaultBrowserId() {
-        if ('darwin' !== external_node_process_.platform) throw new Error('macOS only');
-        const { stdout } = await execFileAsync('defaults', [
-            'read',
-            'com.apple.LaunchServices/com.apple.launchservices.secure',
-            'LSHandlers'
-        ]);
-        const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
-        const browserId = match?.groups.id ?? 'com.apple.Safari';
-        if ('com.apple.safari' === browserId) return 'com.apple.Safari';
-        return browserId;
-    }
-    const run_applescript_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
-    async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-        if ('darwin' !== external_node_process_.platform) throw new Error('macOS only');
-        const outputArguments = humanReadableOutput ? [] : [
-            '-ss'
-        ];
-        const execOptions = {};
-        if (signal) execOptions.signal = signal;
-        const { stdout } = await run_applescript_execFileAsync("osascript", [
-            '-e',
-            script,
-            outputArguments
-        ], execOptions);
-        return stdout.trim();
-    }
-    async function bundleName(bundleId) {
-        return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+    function getSyncStateCategory(syncStatus) {
+        if (syncStatus?.branchMissing) return "branch-missing";
+        if (syncStatus?.diverged) return "diverged";
+        if (syncStatus?.ahead && !syncStatus?.behind) return "ahead";
+        if (syncStatus?.behind && !syncStatus?.ahead) return "behind";
+        if (syncStatus?.ahead && syncStatus?.behind) return "diverged";
+        return "in-sync";
     }
-    const windows_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
-    const windowsBrowserProgIds = {
-        MSEdgeHTM: {
-            name: 'Edge',
-            id: 'com.microsoft.edge'
-        },
-        MSEdgeBHTML: {
-            name: 'Edge Beta',
-            id: 'com.microsoft.edge.beta'
-        },
-        MSEdgeDHTML: {
-            name: 'Edge Dev',
-            id: 'com.microsoft.edge.dev'
-        },
-        AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
-            name: 'Edge',
-            id: 'com.microsoft.edge.old'
-        },
-        ChromeHTML: {
-            name: 'Chrome',
-            id: 'com.google.chrome'
-        },
-        ChromeBHTML: {
-            name: 'Chrome Beta',
-            id: 'com.google.chrome.beta'
-        },
-        ChromeDHTML: {
-            name: 'Chrome Dev',
-            id: 'com.google.chrome.dev'
-        },
-        ChromiumHTM: {
-            name: 'Chromium',
-            id: 'org.chromium.Chromium'
-        },
-        BraveHTML: {
-            name: 'Brave',
-            id: 'com.brave.Browser'
-        },
-        BraveBHTML: {
-            name: 'Brave Beta',
-            id: 'com.brave.Browser.beta'
-        },
-        BraveDHTML: {
-            name: 'Brave Dev',
-            id: 'com.brave.Browser.dev'
-        },
-        BraveSSHTM: {
-            name: 'Brave Nightly',
-            id: 'com.brave.Browser.nightly'
-        },
-        FirefoxURL: {
-            name: 'Firefox',
-            id: 'org.mozilla.firefox'
-        },
-        OperaStable: {
-            name: 'Opera',
-            id: 'com.operasoftware.Opera'
-        },
-        VivaldiHTM: {
-            name: 'Vivaldi',
-            id: 'com.vivaldi.Vivaldi'
-        },
-        'IE.HTTP': {
-            name: 'Internet Explorer',
-            id: 'com.microsoft.ie'
+    async function recheckSyncStatus(previousCategory, previousBranch, options) {
+        try {
+            logger_logger.progress("verify", "Verifying repository status...");
+            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("verify");
+            const currentCategory = getSyncStateCategory(freshSession.syncStatus);
+            const currentBranch = freshSession.getBranchName() || "master";
+            if (currentCategory !== previousCategory || currentBranch !== previousBranch) {
+                logger_logger.warn("Repository status has changed. Re-evaluating...");
+                return freshSession;
+            }
+            freshSession.cleanup();
+            return null;
+        } catch (e) {
+            logger_logger.progressEnd("verify");
+            logger_logger.verbose(chalk_source.gray(`Could not re-verify status: ${errors_getErrorMessage(e)}`));
+            return null;
         }
-    };
-    new Map(Object.entries(windowsBrowserProgIds));
-    class UnknownBrowserError extends Error {
     }
-    async function defaultBrowser(_execFileAsync = windows_execFileAsync) {
-        const { stdout } = await _execFileAsync('reg', [
-            'QUERY',
-            ' HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice',
-            '/v',
-            'ProgId'
-        ]);
-        const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
-        if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
-        const { id } = match.groups;
-        const browser = windowsBrowserProgIds[id];
-        if (!browser) throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
-        return browser;
+    async function recreateSessionAndValidate(options) {
+        logger_logger.progress("init", "Restarting watch session...");
+        try {
+            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("init");
+            return await checkSyncStatusAndStart(newSession, options);
+        } catch (e) {
+            logger_logger.progressEnd("init", "Failed");
+            logger_logger.error(`Failed to restart: ${errors_getErrorMessage(e)}`);
+            return false;
+        }
     }
-    const default_browser_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_.execFile);
-    const titleize = (string)=>string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase());
-    async function default_browser_defaultBrowser() {
-        if ('darwin' === external_node_process_.platform) {
-            const id = await defaultBrowserId();
-            const name = await bundleName(id);
-            return {
-                name,
-                id
-            };
+    async function checkSyncStatusAndStart(session, options) {
+        const syncStatus = session.syncStatus;
+        const branchName = session.getBranchName() || "master";
+        const hasUncommitted = session.hasUncommittedChanges;
+        const stateCategory = getSyncStateCategory(syncStatus);
+        if (syncStatus?.branchMissing) {
+            logger_logger.warn(`Branch '${branchName}' doesn't exist on Anvil yet.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing new branch to Anvil..."));
+            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);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled. Push your branch to Anvil, then try again.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            const pushed = await pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed) return false;
+            return await recreateSessionAndValidate(options);
         }
-        if ('linux' === external_node_process_.platform) {
-            const { stdout } = await default_browser_execFileAsync('xdg-mime', [
-                'query',
-                'default',
-                'x-scheme-handler/http'
-            ]);
-            const id = stdout.trim();
-            const name = titleize(id.replace(/.desktop$/, '').replace('-', ' '));
-            return {
-                name,
-                id
-            };
+        if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
+            logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing to Anvil..."));
+            else {
+                const action = await logger_logger.select("What would you like to do?", [
+                    {
+                        name: "Push your changes to Anvil (recommended)",
+                        value: "push"
+                    },
+                    {
+                        name: "Exit and handle manually",
+                        value: "exit"
+                    }
+                ], "push");
+                shouldPush = "push" === action;
+                if (shouldPush) {
+                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            const pushed = await pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed) return false;
+            return await 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.`));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            session.cleanup();
+            if (options.autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-rebasing onto Anvil's version..."));
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await recreateSessionAndValidate(options);
+            }
+            const action = await logger_logger.select("How would you like to resolve this?", [
+                {
+                    name: "Pull from Anvil and rebase your changes on top (recommended)",
+                    value: "rebase"
+                },
+                {
+                    name: "Discard your local commits and use Anvil's version",
+                    value: "reset"
+                },
+                {
+                    name: "Push your version to Anvil (overwrites remote)",
+                    value: "push"
+                },
+                {
+                    name: "Exit and handle manually",
+                    value: "exit"
+                }
+            ], "rebase");
+            if ("exit" === action) {
+                logger_logger.warn("Watch cancelled.");
+                return false;
+            }
+            const changed = await recheckSyncStatus(stateCategory, branchName, options);
+            if (changed) return await checkSyncStatusAndStart(changed, options);
+            if ("rebase" === action) {
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await 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?`;
+                const confirmed = await logger_logger.confirm(resetWarning, false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const reset = await fetchAndHardResetFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (!reset) return false;
+                return await recreateSessionAndValidate(options);
+            }
+            if ("push" === action) {
+                const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const pushed = await pushToAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username,
+                    force: true
+                });
+                if (!pushed) return false;
+                return await recreateSessionAndValidate(options);
+            }
+        } else {
+            logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
+            logger_logger.verbose(chalk_source.gray("   You need to sync to the latest version before watching."));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldSync = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-syncing to latest version..."));
+            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);
+                }
+            }
+            if (!shouldSync) {
+                logger_logger.warn("Watch cancelled. Please sync manually before watching.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            let authToken;
+            try {
+                authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            } catch (e) {
+                logger_logger.error("Not logged in. Please log in first.");
+                process.exit(1);
+            }
+            logger_logger.progress("sync-latest", "Syncing to latest version from Anvil...");
+            try {
+                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
+                logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
+            } catch (e) {
+                logger_logger.progressEnd("sync-latest", "Failed");
+                logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
+                process.exit(1);
+            }
+            return await recreateSessionAndValidate(options);
         }
-        if ('win32' === external_node_process_.platform) return defaultBrowser();
-        throw new Error('Only macOS, Linux, and Windows are supported');
+        await startWatchingWithEventHandlers(session, options);
+        return true;
     }
-    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_;
-    async function getWindowsDefaultBrowserFromWsl() {
-        const powershellPath = await powerShellPath();
-        const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-        const encodedCommand = external_node_buffer_namespaceObject.Buffer.from(rawCommand, 'utf16le').toString('base64');
-        const { stdout } = await execFile(powershellPath, [
-            '-NoProfile',
-            '-NonInteractive',
-            '-ExecutionPolicy',
-            'Bypass',
-            '-EncodedCommand',
-            encodedCommand
-        ], {
-            encoding: 'utf8'
+    async function startWatchingWithEventHandlers(session, options) {
+        const { autoMode, repoPath, appId, anvilUrl, stagedOnly } = options;
+        session.on("branch-changed", async ({ oldBranch, newBranch })=>{
+            try {
+                session.cleanup();
+                logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
+                logger_logger.info(chalk_source.cyan("→ Restarting watch on new branch..."));
+                const git = esm_default(repoPath);
+                const actualBranch = (await git.revparse([
+                    "--abbrev-ref",
+                    "HEAD"
+                ])).trim();
+                if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
+                logger_logger.progress("init", "Initializing watch session...");
+                try {
+                    const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
+                    logger_logger.progressEnd("init");
+                    const started = await checkSyncStatusAndStart(newSession, options);
+                    if (!started) process.exit(0);
+                } catch (e) {
+                    logger_logger.progressEnd("init", "Failed");
+                    logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
+                    process.exit(1);
+                }
+            } catch (error) {
+                logger_logger.error(`Error handling branch change: ${error.message}`);
+                process.exit(1);
+            }
         });
-        const progId = stdout.trim();
-        const browserMap = {
-            ChromeHTML: 'com.google.chrome',
-            BraveHTML: 'com.brave.Browser',
-            MSEdgeHTM: 'com.microsoft.edge',
-            FirefoxURL: 'org.mozilla.firefox'
-        };
-        return browserMap[progId] ? {
-            id: browserMap[progId]
-        } : {};
+        session.on("validation-failed", ({ reason, currentBranch })=>{
+            logger_logger.error(chalk_source.red(`Validation failed: ${reason}`));
+            logger_logger.verbose(chalk_source.yellow(`   Current branch: ${currentBranch}`));
+            logger_logger.verbose(chalk_source.yellow("   Please restart anvil to re-validate the branch."));
+            session.cleanup();
+            process.exit(1);
+        });
+        session.on("max-retries-exceeded", async ()=>{
+            if (autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch session..."));
+                session.cleanup();
+                const restarted = await recreateSessionAndValidate(options);
+                if (!restarted) process.exit(1);
+            } else {
+                const shouldRestart = await logger_logger.confirm("Would you like to restart the watch session?", true);
+                if (shouldRestart) {
+                    session.cleanup();
+                    const restarted = await recreateSessionAndValidate(options);
+                    if (!restarted) process.exit(1);
+                }
+            }
+        });
+        if (session.hasUncommittedChanges) {
+            if (!autoMode) {
+                const shouldContinue = await logger_logger.confirm("Continue? Your uncommitted changes will be synced to Anvil.", true);
+                if (!shouldContinue) {
+                    logger_logger.warn("Watch cancelled. Commit, stash, or discard your changes, then try again.");
+                    session.cleanup();
+                    process.exit(0);
+                }
+            }
+            logger_logger.progress("save", "Saving uncommitted changes to Anvil...");
+            try {
+                await session.forceSave();
+                logger_logger.progressEnd("save");
+            } catch (e) {
+                logger_logger.progressEnd("save", "Failed");
+                logger_logger.error(`Failed to save: ${errors_getErrorMessage(e)}`);
+            }
+        }
+        await session.startWatching();
     }
-    const pTryEach = async (array, mapper)=>{
-        let latestError;
-        for (const item of array)try {
-            return await mapper(item);
-        } catch (error) {
-            latestError = error;
+    async function handleWatchCommand(options) {
+        const invoked = process.argv[2];
+        if ("sync" === invoked) {
+            logger_logger.error("'sync' has been renamed to 'watch'. Please use 'anvil watch' instead.");
+            process.exit(1);
         }
-        throw latestError;
-    };
-    const baseOpen = async (options)=>{
-        options = {
-            wait: false,
-            background: false,
-            newInstance: false,
-            allowNonzeroExitCode: false,
-            ...options
-        };
-        if (Array.isArray(options.app)) return pTryEach(options.app, (singleApp)=>baseOpen({
-                ...options,
-                app: singleApp
-            }));
-        let { name: app, arguments: appArguments = [] } = options.app ?? {};
-        appArguments = [
-            ...appArguments
-        ];
-        if (Array.isArray(app)) return pTryEach(app, (appName)=>baseOpen({
-                ...options,
-                app: {
-                    name: appName,
-                    arguments: appArguments
+        const { path: repoPath = process.cwd(), appid: explicitAppId, useFirst = false, stagedOnly = false, autoMode = false, url: explicitUrl, user: explicitUsername, open: openAfterValidation = false } = options;
+        try {
+            const validationResult = await validateAnvilApp(repoPath);
+            if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
+            const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
+            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
+            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
+            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
+            let finalAppId;
+            let anvilUrl;
+            let username = explicitUsername;
+            let fallbackUrl;
+            let shouldPersistUsernameBinding = false;
+            if (explicitAppId) {
+                finalAppId = explicitAppId;
+                const binding = await getAppAuthBinding(repoPath, explicitAppId);
+                if (binding.url && !explicitUrl) {
+                    anvilUrl = normalizeAnvilUrl(binding.url);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from binding for app ID: ") + chalk_source.bold(anvilUrl));
                 }
-            }));
-        if ('browser' === app || 'browserPrivate' === app) {
-            const ids = {
-                'com.google.chrome': 'chrome',
-                'google-chrome.desktop': 'chrome',
-                'com.brave.Browser': 'brave',
-                'org.mozilla.firefox': 'firefox',
-                'firefox.desktop': 'firefox',
-                'com.microsoft.msedge': 'edge',
-                'com.microsoft.edge': 'edge',
-                'com.microsoft.edgemac': 'edge',
-                'microsoft-edge.desktop': 'edge'
-            };
-            const flags = {
-                chrome: '--incognito',
-                brave: '--incognito',
-                firefox: '--private-window',
-                edge: '--inPrivate'
-            };
-            const browser = is_wsl ? await getWindowsDefaultBrowserFromWsl() : await default_browser_defaultBrowser();
-            if (browser.id in ids) {
-                const browserName = ids[browser.id];
-                if ('browserPrivate' === app) appArguments.push(flags[browserName]);
-                return baseOpen({
-                    ...options,
-                    app: {
-                        name: open_apps[browserName],
-                        arguments: appArguments
+                if (binding.username && !explicitUsername) {
+                    username = binding.username;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from binding for app ID: ") + chalk_source.bold(username));
+                }
+                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
+                if (remoteInfo.detectedUrl && !explicitUrl && !anvilUrl) {
+                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
+                }
+                if (remoteInfo.detectedUsername && !explicitUsername && !username) {
+                    username = remoteInfo.detectedUsername;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
+                }
+            } else {
+                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
+                if (0 === filteredCandidates.length) {
+                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
+                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
+                    if (null === resolvedFallbackUrl) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
                     }
-                });
+                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
+                    if (null === lookupDecision) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    username = lookupDecision.username;
+                    if (lookupDecision.shouldContinue) {
+                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
+                        const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
+                            anvilUrl: fallbackUrl,
+                            username,
+                            includeRemotes: false
+                        });
+                        logger_logger.progressEnd("detect");
+                        for (const c of reverseLookupCandidates)filteredCandidates.push({
+                            ...c,
+                            detectedUrl: fallbackUrl
+                        });
+                    }
+                }
+                if (filteredCandidates.length > 0) {
+                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
+                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
+                }
+                if (useFirst && filteredCandidates.length > 0) {
+                    const selected = filteredCandidates[0];
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
+                } else {
+                    const selected = await selectAppId(filteredCandidates);
+                    if (!selected) {
+                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
+                        process.exit(1);
+                    }
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                }
             }
-            throw new Error(`${browser.name} is not supported as a default browser`);
-        }
-        let command;
-        const cliArguments = [];
-        const childProcessOptions = {};
-        if ('darwin' === 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)) {
-            if (app) command = app;
+            const binding = await getAppAuthBinding(repoPath, finalAppId);
+            if (binding.url && !explicitUrl) {
+                anvilUrl = normalizeAnvilUrl(binding.url);
+                logger_logger.verbose(chalk_source.cyan("Using app binding URL: ") + chalk_source.bold(anvilUrl));
+            }
+            if (binding.username && !explicitUsername) {
+                username = binding.username;
+                logger_logger.verbose(chalk_source.cyan("Using app binding username: ") + chalk_source.bold(username));
+            }
+            shouldPersistUsernameBinding = !binding.username && !explicitUsername;
+            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
+            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
             else {
-                const isBundled = !open_dirname || '/' === open_dirname;
-                let exeLocalXdgOpen = false;
-                try {
-                    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);
-                command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
+                const resolvedFallbackUrl = await resolveUrlForFallback();
+                if (null === resolvedFallbackUrl) {
+                    logger_logger.warn("Operation cancelled.");
+                    process.exit(0);
+                }
+                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
             }
-            if (appArguments.length > 0) cliArguments.push(...appArguments);
-            if (!options.wait) {
-                childProcessOptions.stdio = 'ignore';
-                childProcessOptions.detached = true;
+            anvilUrl = normalizeAnvilUrl(anvilUrl);
+            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
+            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
+            if (null === resolvedUsername) {
+                logger_logger.warn("Operation cancelled.");
+                process.exit(0);
             }
-        } else {
-            command = await powerShellPath();
-            cliArguments.push('-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-EncodedCommand');
-            if (!is_wsl) childProcessOptions.windowsVerbatimArguments = true;
-            const encodedArguments = [
-                'Start'
-            ];
-            if (options.wait) encodedArguments.push('-Wait');
-            if (app) {
-                encodedArguments.push(`"\`"${app}\`""`);
-                if (options.target) appArguments.push(options.target);
-            } else if (options.target) encodedArguments.push(`"${options.target}"`);
-            if (appArguments.length > 0) {
-                appArguments = appArguments.map((argument)=>`"\`"${argument}\`""`);
-                encodedArguments.push('-ArgumentList', appArguments.join(','));
+            username = resolvedUsername;
+            if (shouldPersistUsernameBinding && username && auth_getAccountsForUrl(anvilUrl).length > 1) {
+                await setAppAuthBinding(repoPath, finalAppId, {
+                    url: anvilUrl,
+                    username
+                });
+                logger_logger.verbose(chalk_source.cyan("Saved app account binding for future non-interactive use."));
             }
-            options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
+            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
+            if (!hasTokensForUrl(anvilUrl, username)) {
+                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?:\/\//, "")}`));
+                process.exit(1);
+            }
+            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
+            logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
+            const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
+            logger_logger.progressEnd("validate");
+            if (!appIdValidation.valid) {
+                logger_logger.error(`App ID validation failed: ${appIdValidation.error}`);
+                logger_logger.verbose(chalk_source.yellow("This could mean:"));
+                logger_logger.verbose(chalk_source.yellow("  • The app ID doesn't exist on the server"));
+                logger_logger.verbose(chalk_source.yellow("  • You don't have access to this app"));
+                logger_logger.verbose(chalk_source.yellow("  • There's a network or authentication issue"));
+                process.exit(1);
+            }
+            logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
+            if (appIdValidation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${appIdValidation.app_name}`));
+            if (stagedOnly) logger_logger.info(chalk_source.yellow("▸ Staged-only mode: Only staged changes will be synced"));
+            if (autoMode) logger_logger.info(chalk_source.cyan("▸ Auto mode: Will automatically restart on branch changes and sync when behind"));
+            logger_logger.progress("init", "Initializing watch session...");
+            const session = await api_watch(repoPath, finalAppId, anvilUrl, stagedOnly, username);
+            logger_logger.progressEnd("init");
+            if (openAfterValidation) await openWatchPath(resolveWatchOpenPath(repoPath));
+            logger_logger.verbose(chalk_source.blue("Watching for file changes..."));
+            const started = await checkSyncStatusAndStart(session, {
+                autoMode,
+                repoPath,
+                appId: finalAppId,
+                anvilUrl,
+                stagedOnly,
+                username
+            });
+            if (!started) process.exit(1);
+        } catch (e) {
+            logger_logger.error("Error: " + errors_getErrorMessage(e));
+            process.exit(1);
         }
-        if ('darwin' === 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)=>{
-            subprocess.once('error', reject);
-            subprocess.once('close', (exitCode)=>{
-                if (!options.allowNonzeroExitCode && exitCode > 0) return void reject(new Error(`Exited with code ${exitCode}`));
-                resolve(subprocess);
+    }
+    function registerWatchCommand(program) {
+        const watchCommand = program.command("watch [path]").description("Watch for file changes and sync to Anvil").alias("sync").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-V, --verbose", "Show detailed output").option("-O, --open", "Open watched path in preferred editor (or default app)").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options)=>{
+            if (void 0 !== options.verbose && logger_logger instanceof CLILogger) logger_logger.setVerbose(options.verbose);
+            await handleWatchCommand({
+                path,
+                appid: options.appid,
+                useFirst: options.first,
+                stagedOnly: options.stagedOnly,
+                autoMode: options.auto,
+                verbose: options.verbose,
+                open: options.open,
+                url: options.url,
+                user: options.user
             });
         });
-        subprocess.unref();
-        return subprocess;
-    };
-    const open_open = (target, options)=>{
-        if ('string' != typeof target) throw new TypeError('Expected a `target`');
-        return baseOpen({
-            ...options,
-            target
-        });
-    };
-    function detectArchBinary(binary) {
-        if ('string' == typeof binary || Array.isArray(binary)) return binary;
-        const { [arch]: archBinary } = binary;
-        if (!archBinary) throw new Error(`${arch} is not supported`);
-        return archBinary;
-    }
-    function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
-        if (wsl && is_wsl) return detectArchBinary(wsl);
-        if (!platformBinary) throw new Error(`${platform} is not supported`);
-        return detectArchBinary(platformBinary);
+        return watchCommand;
     }
-    const open_apps = {};
-    defineLazyProperty(open_apps, 'chrome', ()=>detectPlatformBinary({
-            darwin: 'google chrome',
-            win32: 'chrome',
-            linux: [
-                'google-chrome',
-                'google-chrome-stable',
-                'chromium'
-            ]
-        }, {
-            wsl: {
-                ia32: '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe',
-                x64: [
-                    '/mnt/c/Program Files/Google/Chrome/Application/chrome.exe',
-                    '/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe'
-                ]
-            }
-        }));
-    defineLazyProperty(open_apps, 'brave', ()=>detectPlatformBinary({
-            darwin: 'brave browser',
-            win32: 'brave',
-            linux: [
-                'brave-browser',
-                'brave'
-            ]
-        }, {
-            wsl: {
-                ia32: '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe',
-                x64: [
-                    '/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe',
-                    '/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe'
-                ]
-            }
-        }));
-    defineLazyProperty(open_apps, 'firefox', ()=>detectPlatformBinary({
-            darwin: 'firefox',
-            win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
-            linux: 'firefox'
-        }, {
-            wsl: '/mnt/c/Program Files/Mozilla Firefox/firefox.exe'
-        }));
-    defineLazyProperty(open_apps, 'edge', ()=>detectPlatformBinary({
-            darwin: 'microsoft edge',
-            win32: 'msedge',
-            linux: [
-                'microsoft-edge',
-                'microsoft-edge-dev'
-            ]
-        }, {
-            wsl: '/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe'
-        }));
-    defineLazyProperty(open_apps, 'browser', ()=>'browser');
-    defineLazyProperty(open_apps, 'browserPrivate', ()=>'browserPrivate');
-    const node_modules_open = open_open;
     var external_http_ = __webpack_require__("http");
     const successPage = `<!DOCTYPE html>
   <html lang="en">
@@ -51599,9 +51779,451 @@ var __webpack_exports__ = {};
             scope: tokenData.scope
         });
     }
+    const CHECKOUT_ERROR_VALUE = "__ERROR__";
+    function isAbortLikeError(error) {
+        if (error instanceof Error && "AbortError" === error.name) return true;
+        if ("object" == typeof error && null !== error) {
+            const maybeType = error.type;
+            const maybeMessage = error.message;
+            if ("network_error" === maybeType && "string" == typeof maybeMessage && maybeMessage.toLowerCase().includes("abort")) return true;
+        }
+        const message = errors_getErrorMessage(error).toLowerCase();
+        return "aborted" === message || message.includes("aborted");
+    }
+    function normalizePickerQuery(term) {
+        return (term || "").trim();
+    }
+    function getCheckoutPickerDelayMs(anvilUrl) {
+        const raw = process.env.ANVIL_CHECKOUT_PICKER_DELAY_MS;
+        const fromEnv = null == raw ? NaN : Number(raw);
+        if (null != raw && Number.isFinite(fromEnv) && fromEnv >= 0) return fromEnv;
+        return /localhost|127\.0\.0\.1/.test(anvilUrl) ? 250 : 0;
+    }
+    function getCheckoutPickerPaginationDelayMs(anvilUrl) {
+        const raw = process.env.ANVIL_CHECKOUT_PICKER_PAGINATION_DELAY_MS;
+        const fromEnv = null == raw ? NaN : Number(raw);
+        if (null != raw && Number.isFinite(fromEnv) && fromEnv >= 0) return fromEnv;
+        return /localhost|127\.0\.0\.1/.test(anvilUrl) ? 1000 : 0;
+    }
+    function getCheckoutPickerMaxRows() {
+        const raw = process.env.ANVIL_CHECKOUT_PICKER_MAX_ROWS;
+        const fromEnv = null == raw ? NaN : Number(raw);
+        if (null != raw && Number.isFinite(fromEnv) && fromEnv >= 4) return Math.floor(fromEnv);
+        return 12;
+    }
+    function formatLastEdited(lastEdited) {
+        if (!lastEdited) return;
+        return chalk_source.gray(`Last edited: ${lastEdited}`);
+    }
+    function formatAppPickerLabel(app) {
+        const appName = app.app_name || "Unnamed App";
+        return `${chalk_source.cyan(appName)} ${chalk_source.gray(`(${app.app_id})`)}`;
+    }
+    async function waitForDebounce(ms, signal) {
+        if (ms <= 0) return;
+        if (signal.aborted) throw new Error("aborted");
+        await new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                cleanup();
+                resolve();
+            }, ms);
+            const onAbort = ()=>{
+                cleanup();
+                reject(new Error("aborted"));
+            };
+            const cleanup = ()=>{
+                clearTimeout(timer);
+                signal.removeEventListener("abort", onAbort);
+            };
+            signal.addEventListener("abort", onAbort, {
+                once: true
+            });
+        });
+    }
+    function createCheckoutPickerSource(anvilUrl, username, deps, options = {}) {
+        const pageSize = options.pageSize ?? 20;
+        const debounceMs = options.debounceMs ?? 200;
+        const staleTimeMs = options.staleTimeMs ?? 30000;
+        const maxAutoPagesPerCall = options.maxAutoPagesPerCall ?? 8;
+        const initialQuery = normalizePickerQuery(options.initialQuery);
+        const simulatedDelayMs = getCheckoutPickerDelayMs(anvilUrl);
+        const paginationDelayMs = getCheckoutPickerPaginationDelayMs(anvilUrl);
+        const cache = new Map();
+        const getState = (query)=>{
+            const existing = cache.get(query);
+            if (existing) return existing;
+            const created = {
+                items: [],
+                nextCursor: null,
+                exhausted: false,
+                lastError: null,
+                updatedAt: 0,
+                inFlight: null
+            };
+            cache.set(query, created);
+            return created;
+        };
+        const fetchPage = async (query, signal, options = {})=>{
+            const state = getState(query);
+            if (state.inFlight) return void await state.inFlight;
+            state.inFlight = (async ()=>{
+                try {
+                    if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
+                    if (options.cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
+                    const response = await deps.listAppsForCheckout({
+                        anvilUrl,
+                        username,
+                        limit: pageSize,
+                        cursor: options.cursor,
+                        q: query || void 0,
+                        signal
+                    });
+                    if (options.reset) state.items = [
+                        ...response.apps
+                    ];
+                    else state.items.push(...response.apps);
+                    state.nextCursor = response.next_cursor;
+                    state.exhausted = !response.next_cursor;
+                    state.lastError = null;
+                    state.updatedAt = Date.now();
+                } catch (e) {
+                    if (!signal.aborted && !isAbortLikeError(e)) {
+                        const message = errors_getErrorMessage(e);
+                        state.lastError = message;
+                        state.updatedAt = Date.now();
+                    }
+                } finally{
+                    state.inFlight = null;
+                }
+            })();
+            await state.inFlight;
+        };
+        const ensureLoaded = async (query, signal)=>{
+            const state = getState(query);
+            const isStale = Date.now() - state.updatedAt > staleTimeMs;
+            if (0 === state.items.length) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: false
+                });
+            } else if (state.lastError) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: true
+                });
+            } else if (isStale) {
+                await waitForDebounce(debounceMs, signal);
+                await fetchPage(query, signal, {
+                    cursor: void 0,
+                    reset: true
+                });
+            }
+            let pagesLoaded = 0;
+            while(state.nextCursor && pagesLoaded < maxAutoPagesPerCall){
+                if (signal.aborted) throw new Error("aborted");
+                const cursor = state.nextCursor;
+                await fetchPage(query, signal, {
+                    cursor,
+                    reset: false
+                });
+                pagesLoaded += 1;
+            }
+        };
+        return {
+            source: async (term, { signal })=>{
+                const query = normalizePickerQuery(term) || initialQuery;
+                if (signal.aborted) return [];
+                await ensureLoaded(query, signal);
+                const state = getState(query);
+                if (state.lastError) return [
+                    {
+                        name: `${chalk_source.yellow("Fetch failed")} ${chalk_source.gray(`(${state.lastError})`)}`,
+                        value: CHECKOUT_ERROR_VALUE,
+                        disabled: true
+                    }
+                ];
+                const summary = state.nextCursor ? chalk_source.gray(`Loaded ${state.items.length} apps • more available`) : chalk_source.gray(`Loaded ${state.items.length} apps`);
+                const choices = state.items.map((app)=>({
+                        name: formatAppPickerLabel(app),
+                        value: app.app_id,
+                        description: formatLastEdited(app.last_edited)
+                    }));
+                choices.unshift({
+                    name: summary,
+                    value: CHECKOUT_ERROR_VALUE,
+                    disabled: true
+                });
+                return choices;
+            }
+        };
+    }
+    const INLINE_SPINNER_FRAMES = [
+        "⠋",
+        "⠙",
+        "⠹",
+        "⠸",
+        "⠼",
+        "⠴",
+        "⠦",
+        "⠧",
+        "⠇",
+        "⠏"
+    ];
+    async function runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return null;
+        const pageSize = 20;
+        const staleTimeMs = 30000;
+        const debounceMs = 180;
+        const simulatedDelayMs = getCheckoutPickerDelayMs(anvilUrl);
+        const paginationDelayMs = getCheckoutPickerPaginationDelayMs(anvilUrl);
+        const maxVisibleRows = getCheckoutPickerMaxRows();
+        const cache = new Map();
+        let query = normalizePickerQuery(initialQuery);
+        let selectedIndex = 0;
+        let scrollOffset = 0;
+        let loading = false;
+        let loadingMore = false;
+        let done = false;
+        let pendingTimer = null;
+        let loadingRenderTimer = null;
+        let activeController = null;
+        let resolveResult = null;
+        const ensureState = (key)=>{
+            const existing = cache.get(key);
+            if (existing) return existing;
+            const created = {
+                items: [],
+                nextCursor: null,
+                lastError: null,
+                updatedAt: 0
+            };
+            cache.set(key, created);
+            return created;
+        };
+        const currentState = ()=>ensureState(query);
+        const clearScreen = ()=>{
+            process.stdout.write("\x1b[2J\x1b[H");
+        };
+        const visibleRows = ()=>{
+            const rows = process.stdout.rows || 24;
+            return Math.min(maxVisibleRows, Math.max(6, rows - 9));
+        };
+        const syncViewport = ()=>{
+            const items = currentState().items;
+            if (selectedIndex >= items.length) selectedIndex = Math.max(0, items.length - 1);
+            const height = visibleRows();
+            if (selectedIndex < scrollOffset) scrollOffset = selectedIndex;
+            else if (selectedIndex >= scrollOffset + height) scrollOffset = Math.max(0, selectedIndex - height + 1);
+        };
+        const render = ()=>{
+            clearScreen();
+            const state = currentState();
+            const items = state.items;
+            const activeQuery = query || chalk_source.gray("(all apps)");
+            const spinnerFrame = INLINE_SPINNER_FRAMES[Math.floor(Date.now() / 120) % INLINE_SPINNER_FRAMES.length];
+            const status = loading ? loadingMore ? chalk_source.yellow(`${spinnerFrame} Loading more apps... (${items.length} loaded)`) : chalk_source.yellow(`${spinnerFrame} Loading apps...`) : state.nextCursor ? chalk_source.gray(`Loaded ${items.length} apps • more available`) : chalk_source.gray(`Loaded ${items.length} apps`);
+            process.stdout.write(`${chalk_source.bold("Search apps by name or app ID")}\n`);
+            process.stdout.write(`${chalk_source.cyan("Query:")} ${activeQuery}\n`);
+            process.stdout.write(`${status}\n`);
+            if (state.lastError) process.stdout.write(`${chalk_source.red(`Fetch failed: ${state.lastError}`)}\n`);
+            const height = visibleRows();
+            const start = scrollOffset;
+            const end = Math.min(items.length, start + height);
+            if (0 !== items.length || loading || state.lastError) for(let i = start; i < end; i += 1){
+                const item = items[i];
+                const label = formatAppPickerLabel(item);
+                const line = i === selectedIndex ? `${chalk_source.green("❯")} ${label}` : `  ${label}`;
+                process.stdout.write(`${line}\n`);
+            }
+            else process.stdout.write(`${chalk_source.gray("No matches. Keep typing.")}\n`);
+            process.stdout.write(`\n${chalk_source.gray("↑/↓ navigate • type to search • enter select • esc/ctrl+c cancel")}\n`);
+        };
+        const fetchPage = async (key, cursor)=>{
+            const state = ensureState(key);
+            const controller = new AbortController();
+            if (!cursor && activeController) activeController.abort();
+            activeController = controller;
+            loading = true;
+            loadingMore = !!cursor;
+            startLoadingAnimation();
+            render();
+            try {
+                if (simulatedDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, simulatedDelayMs));
+                if (cursor && paginationDelayMs > 0) await new Promise((resolve)=>setTimeout(resolve, paginationDelayMs));
+                const response = await deps.listAppsForCheckout({
+                    anvilUrl,
+                    username,
+                    limit: pageSize,
+                    cursor,
+                    q: key || void 0,
+                    signal: controller.signal
+                });
+                const merged = cursor ? state.items.concat(response.apps) : response.apps;
+                cache.set(key, {
+                    items: merged,
+                    nextCursor: response.next_cursor,
+                    lastError: null,
+                    updatedAt: Date.now()
+                });
+                if (key === query) syncViewport();
+            } catch (e) {
+                if (!controller.signal.aborted && !isAbortLikeError(e)) {
+                    const message = errors_getErrorMessage(e);
+                    cache.set(key, {
+                        ...state,
+                        lastError: message,
+                        updatedAt: Date.now()
+                    });
+                }
+            } finally{
+                if (activeController === controller) activeController = null;
+                loading = false;
+                loadingMore = false;
+                stopLoadingAnimation();
+                render();
+            }
+        };
+        const ensureFresh = async (key)=>{
+            const state = ensureState(key);
+            const stale = Date.now() - state.updatedAt > staleTimeMs;
+            if (0 === state.items.length || stale || state.lastError) await fetchPage(key);
+            else render();
+        };
+        const maybeLoadMore = async ()=>{
+            const state = currentState();
+            if (!state.nextCursor || loading) return;
+            if (selectedIndex >= Math.max(0, state.items.length - 2)) await fetchPage(query, state.nextCursor || void 0);
+        };
+        const scheduleQueryFetch = ()=>{
+            if (pendingTimer) clearTimeout(pendingTimer);
+            pendingTimer = setTimeout(()=>{
+                pendingTimer = null;
+                ensureFresh(query);
+            }, debounceMs);
+        };
+        const startLoadingAnimation = ()=>{
+            if (loadingRenderTimer) return;
+            loadingRenderTimer = setInterval(()=>{
+                if (!done && loading) render();
+            }, 120);
+        };
+        const stopLoadingAnimation = ()=>{
+            if (!loadingRenderTimer) return;
+            clearInterval(loadingRenderTimer);
+            loadingRenderTimer = null;
+        };
+        const finish = (value)=>{
+            done = true;
+            if (pendingTimer) {
+                clearTimeout(pendingTimer);
+                pendingTimer = null;
+            }
+            if (activeController) {
+                activeController.abort();
+                activeController = null;
+            }
+            stopLoadingAnimation();
+            process.stdin.removeListener("keypress", onKeypress);
+            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(false);
+            process.stdin.pause();
+            clearScreen();
+            if (resolveResult) resolveResult(value);
+        };
+        const onKeypress = (_str, key)=>{
+            if (done) return;
+            if (key.ctrl && "c" === key.name) return void finish(null);
+            if ("escape" === key.name) return void finish(null);
+            if ("return" === key.name) {
+                const state = currentState();
+                const selected = state.items[selectedIndex];
+                finish(selected ? selected.app_id : null);
+                return;
+            }
+            if ("up" === key.name) {
+                if (selectedIndex > 0) {
+                    selectedIndex -= 1;
+                    syncViewport();
+                    render();
+                }
+                return;
+            }
+            if ("down" === key.name) {
+                const maxIndex = Math.max(0, currentState().items.length - 1);
+                if (selectedIndex < maxIndex) {
+                    selectedIndex += 1;
+                    syncViewport();
+                    render();
+                    maybeLoadMore();
+                }
+                return;
+            }
+            if ("backspace" === key.name || "delete" === key.name) {
+                if (query.length > 0) {
+                    query = query.slice(0, -1);
+                    selectedIndex = 0;
+                    scrollOffset = 0;
+                    render();
+                    scheduleQueryFetch();
+                }
+                return;
+            }
+            if (!key.ctrl && !key.meta && key.sequence && 1 === key.sequence.length && key.sequence >= " ") {
+                query += key.sequence;
+                selectedIndex = 0;
+                scrollOffset = 0;
+                render();
+                scheduleQueryFetch();
+            }
+        };
+        logger_logger.pause();
+        try {
+            external_readline_default().emitKeypressEvents(process.stdin);
+            if (process.stdin.isTTY && process.stdin.setRawMode) process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on("keypress", onKeypress);
+            await ensureFresh(query);
+            return await new Promise((resolve)=>{
+                resolveResult = resolve;
+            });
+        } finally{
+            logger_logger.resume();
+        }
+    }
+    async function selectAppForCheckout(anvilUrl, username, deps, initialQuery) {
+        if (!isTestMode() && "1" !== process.env.ANVIL_CHECKOUT_LEGACY_PICKER) return runCustomCheckoutPicker(anvilUrl, username, deps, initialQuery);
+        const picker = createCheckoutPickerSource(anvilUrl, username, deps, {
+            initialQuery
+        });
+        try {
+            const answer = await logger_logger.prompt([
+                {
+                    type: "search",
+                    name: "value",
+                    message: "Search apps by name or app ID",
+                    source: picker.source,
+                    pageSize: 12,
+                    loop: false,
+                    instructions: {
+                        navigation: "↑↓ navigate • type to filter",
+                        pager: "enter select • ctrl+c cancel"
+                    }
+                }
+            ]);
+            const selected = String(answer.value || "");
+            if (!selected || selected === CHECKOUT_ERROR_VALUE) return null;
+            return selected;
+        } catch (e) {
+            const err = e;
+            if ("ExitPromptError" === err.name || String(err.message || "").includes("User force closed")) return null;
+            throw e;
+        }
+    }
     const defaultCheckoutDeps = {
         getValidAuthToken: auth_getValidAuthToken,
         validateAppId: validateAppId,
+        listAppsForCheckout: listAppsForCheckout,
         runInteractiveLoginFlow: runInteractiveLoginFlow,
         clone: async (repoUrl, destinationPath, options)=>{
             const cloneArgs = [];
@@ -51615,6 +52237,9 @@ var __webpack_exports__ = {};
         },
         hardenCheckoutGitAuth: hardenCheckoutGitAuth
     };
+    function isInteractiveSession() {
+        return !!(process.stdin.isTTY && process.stdout.isTTY);
+    }
     function parseCheckoutInput(input) {
         const trimmed = input.trim();
         if (!trimmed) throw new Error("Input is required.");
@@ -51737,10 +52362,25 @@ var __webpack_exports__ = {};
         return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0]);
     }
     async function executeCheckout(options, deps = defaultCheckoutDeps) {
-        const parsed = parseCheckoutInput(options.input);
-        const anvilUrl = await resolveCheckoutUrl(options.url, parsed.detectedUrl);
+        let checkoutInput = options.input?.trim();
+        let preselectedAnvilUrl;
+        let preselectedUsername;
+        if (!checkoutInput) {
+            if (!isInteractiveSession()) throw new Error("`anvil checkout` without arguments requires an interactive TTY. Pass APP_ID or URL explicitly in non-interactive mode.");
+            const selectedUrl = await resolveCheckoutUrl(options.url);
+            if (!selectedUrl) return void logger_logger.info("Checkout cancelled.");
+            preselectedAnvilUrl = selectedUrl;
+            const selectedUsername = await resolveCheckoutUsername(selectedUrl, options.user);
+            if (null === selectedUsername) return void logger_logger.info("Checkout cancelled.");
+            preselectedUsername = selectedUsername || void 0;
+            const selectedInput = await selectAppForCheckout(selectedUrl, preselectedUsername, deps, options.query);
+            if (!selectedInput) return void logger_logger.info("Checkout cancelled.");
+            checkoutInput = selectedInput;
+        }
+        const parsed = parseCheckoutInput(checkoutInput);
+        const anvilUrl = preselectedAnvilUrl || await resolveCheckoutUrl(options.url, parsed.detectedUrl);
         if (!anvilUrl) return void logger_logger.info("Checkout cancelled.");
-        const resolvedUsername = await resolveCheckoutUsername(anvilUrl, options.user);
+        const resolvedUsername = preselectedUsername || await resolveCheckoutUsername(anvilUrl, options.user);
         if (null === resolvedUsername) return void logger_logger.info("Checkout cancelled.");
         const authToken = await ensureCheckoutAuthToken(anvilUrl, resolvedUsername, deps);
         let checkoutUsername = resolvedUsername;
@@ -51782,30 +52422,18 @@ var __webpack_exports__ = {};
         logger_logger.progressEnd("checkout", `Checked out ${parsed.appId} into ${destinationDisplay}`);
         const preferredEditor = String(getConfig("preferredEditor") || "").trim();
         const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
-        if (options.open) if (preferredEditorCommand) await openInPreferredEditor(preferredEditorCommand, destinationPath);
-        else {
-            await node_modules_open(destinationPath);
+        if (options.open) {
+            await checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand);
             logger_logger.info(chalk_source.gray(`Opened ${destinationDisplay}`));
         }
-        if (preferredEditorCommand && !options.open) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${destinationDisplay}`));
+        if (preferredEditorCommand && !options.open) if (isCommandAvailable(preferredEditorCommand)) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${destinationDisplay}`));
+        else logger_logger.warn(`Preferred editor command '${preferredEditorCommand}' was not found in PATH. Run 'anvil configure' to choose an installed editor.`);
     }
-    async function openInPreferredEditor(editorCommand, destinationPath) {
-        await new Promise((resolve, reject)=>{
-            const child = (0, external_child_process_.spawn)(editorCommand, [
-                destinationPath
-            ], {
-                shell: true,
-                stdio: "inherit"
-            });
-            child.on("error", reject);
-            child.on("exit", (code)=>{
-                if (0 === code || null === code) resolve();
-                else reject(new Error(`Editor command '${editorCommand}' exited with code ${code}`));
-            });
-        });
+    async function checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps) {
+        await openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps);
     }
     function registerCheckoutCommand(program) {
-        const checkoutCommand = program.command("checkout <input> [directory]").description("Check out an Anvil app locally from editor URL, git URL, or app ID").alias("co").option("-O, --open", "Open destination after checkout").option("-b, --branch <BRANCH>", "Checkout a specific branch").option("--depth <N>", "Create a shallow clone with history truncated to N commits", (value)=>parseInt(value, 10)).option("--single-branch", "Clone only one branch").option("--origin <NAME>", "Use a custom remote name instead of origin").option("-q, --quiet", "Suppress git clone progress output").option("--verbose", "Enable verbose git clone output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL").option("-U, --user <USERNAME>", "Specify which user account to use").option("-f, --force", "Override safety checks for destination path").action(async (input, directory, options)=>{
+        const checkoutCommand = program.command("checkout [input] [directory]").description("Check out an Anvil app locally from editor URL, git URL, app ID, or interactive selection").alias("co").option("-O, --open", "Open destination after checkout").option("-b, --branch <BRANCH>", "Checkout a specific branch").option("--depth <N>", "Create a shallow clone with history truncated to N commits", (value)=>parseInt(value, 10)).option("--single-branch", "Clone only one branch").option("--origin <NAME>", "Use a custom remote name instead of origin").option("--quiet", "Suppress git clone progress output").option("--verbose", "Enable verbose git clone output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL").option("-U, --user <USERNAME>", "Specify which user account to use").option("-f, --force", "Override safety checks for destination path").option("-Q, --query <QUERY>", "Initial search query for interactive checkout picker").action(async (input, directory, options)=>{
             try {
                 if ("number" == typeof options?.depth && (!Number.isFinite(options.depth) || options.depth <= 0)) throw new Error("--depth must be a positive integer");
                 await executeCheckout({
@@ -51820,16 +52448,17 @@ var __webpack_exports__ = {};
                     verbose: options?.verbose,
                     url: options?.url,
                     user: options?.user,
-                    force: options?.force
+                    force: options?.force,
+                    query: options?.query
                 }, defaultCheckoutDeps);
             } catch (e) {
                 logger_logger.error("Error: " + errors_getErrorMessage(e));
                 process.exit(1);
             }
         });
-        checkoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + "\n  anvil checkout http://localhost:3000/build/apps/APPID/code/assets/theme.css\n  anvil checkout https://anvil.works/git/APPID.git\n  anvil checkout APPID --url anvil.works\n  anvil checkout APPID --branch master --depth 1 --single-branch\n  anvil checkout APPID -O  # open editor/file browser after checkout\n  anvil checkout APPID my-local-folder --force\n");
+        checkoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + '\n  anvil checkout http://localhost:3000/build/apps/APPID/code/assets/theme.css\n  anvil checkout https://anvil.works/git/APPID.git\n  anvil checkout APPID --url anvil.works\n  anvil checkout APPID --branch master --depth 1 --single-branch\n  anvil checkout APPID -O  # open editor/file browser after checkout\n  anvil checkout APPID my-local-folder --force\n  anvil checkout  # interactive search/select app list\n  anvil checkout -Q "dashboard"  # preseed picker search\n');
     }
-    const defaultDeps = {
+    const gitCredential_defaultDeps = {
         getValidAuthToken: auth_getValidAuthToken,
         getAccountsForUrl: auth_getAccountsForUrl,
         getAppAuthBinding: getAppAuthBinding,
@@ -51848,7 +52477,7 @@ var __webpack_exports__ = {};
         }
         return out;
     }
-    async function buildGitCredentialResponse(operation, request, deps = defaultDeps) {
+    async function buildGitCredentialResponse(operation, request, deps = gitCredential_defaultDeps) {
         if ("get" !== operation) return null;
         if (!request.protocol || !request.host) return null;
         const appId = parseAppIdFromGitPath(request.path);
@@ -51880,7 +52509,7 @@ var __webpack_exports__ = {};
         for (const [k, v] of Object.entries(response))lines.push(`${k}=${v}`);
         process.stdout.write(lines.join("\n") + "\n\n");
     }
-    async function executeGitCredentialOperation(operation, deps = defaultDeps) {
+    async function executeGitCredentialOperation(operation, deps = gitCredential_defaultDeps) {
         const raw = await readStdin();
         const request = parseGitCredentialRequest(raw);
         const response = await buildGitCredentialResponse(operation, request, deps);
@@ -52111,14 +52740,13 @@ var __webpack_exports__ = {};
             console.log();
         });
     }
-    const onboard_defaultDeps = {
+    const configure_defaultDeps = {
         getLatestVersion: getLatestVersion,
         getAccountsForUrl: auth_getAccountsForUrl,
-        runInteractiveLoginFlow: runInteractiveLoginFlow,
-        executeCheckout: executeCheckout
+        runInteractiveLoginFlow: runInteractiveLoginFlow
     };
     const DEFAULT_ANVIL_SERVER_URL_PROMPT = "Default Anvil server URL";
-    async function getOnboardVersionStatus(currentVersion, latestVersionGetter = getLatestVersion) {
+    async function getConfigureVersionStatus(currentVersion, latestVersionGetter = getLatestVersion) {
         const latestVersion = await latestVersionGetter();
         if (!latestVersion) return {
             currentVersion,
@@ -52141,25 +52769,25 @@ var __webpack_exports__ = {};
         if (1 === accounts.length) return accounts[0];
         return `${accounts.length} accounts`;
     }
-    function isInteractiveSession() {
+    function configure_isInteractiveSession() {
         return !!(process.stdin.isTTY && process.stdout.isTTY);
     }
-    async function runOnboardFlow(version, deps = onboard_defaultDeps) {
-        if (!isInteractiveSession()) throw new Error("`anvil onboard` is interactive and requires a TTY terminal.");
+    async function runConfigureFlow(version, deps = configure_defaultDeps) {
+        if (!configure_isInteractiveSession()) throw new Error("`anvil configure` is interactive and requires a TTY terminal.");
         console.log();
-        logger_logger.info(chalk_source.cyan.bold("Anvil Onboarding"));
+        logger_logger.info(chalk_source.cyan.bold("Anvil Configuration"));
         console.log();
-        logger_logger.progress("onboard-version", "Checking CLI version...");
-        const versionStatus = await getOnboardVersionStatus(version, deps.getLatestVersion);
-        logger_logger.progressEnd("onboard-version");
+        logger_logger.progress("configure-version", "Checking CLI version...");
+        const versionStatus = await getConfigureVersionStatus(version, deps.getLatestVersion);
+        logger_logger.progressEnd("configure-version");
         logger_logger.info(chalk_source.cyan("CLI version: ") + chalk_source.bold(versionStatus.currentVersion));
         if (versionStatus.latestVersion) {
             logger_logger.info(chalk_source.cyan("Latest version: ") + chalk_source.bold(versionStatus.latestVersion));
             if (versionStatus.isOutdated) {
                 logger_logger.warn("Your anvil-cli is out of date.");
                 logger_logger.info(chalk_source.gray("Run `anvil update` to see update commands."));
-                const continueOnOldVersion = await logger_logger.confirm("Continue onboarding anyway?", true);
-                if (!continueOnOldVersion) return void logger_logger.info("Onboarding cancelled.");
+                const continueOnOldVersion = await logger_logger.confirm("Continue configuration anyway?", true);
+                if (!continueOnOldVersion) return void logger_logger.info("Configuration cancelled.");
             }
         } else logger_logger.warn("Could not determine latest published version.");
         console.log();
@@ -52177,16 +52805,23 @@ var __webpack_exports__ = {};
         setConfig("anvilUrl", configuredAnvilUrl);
         logger_logger.success(`Set default Anvil server URL (anvilUrl) = ${configuredAnvilUrl}`);
         const currentEditor = String(getConfig("preferredEditor") || "").trim().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: ""
             },
-            ...preferredEditors.map((editor)=>({
+            ...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 : "");
         setConfig("preferredEditor", selectedEditor);
         if (selectedEditor) logger_logger.success(`Set preferredEditor = ${selectedEditor}`);
@@ -52206,35 +52841,14 @@ var __webpack_exports__ = {};
             } else logger_logger.warn("Skipping login.");
         }
         console.log();
-        const shouldCheckout = await logger_logger.confirm("Check out an app now?", true);
-        if (shouldCheckout) {
-            const checkoutAnswer = await logger_logger.prompt([
-                {
-                    type: "input",
-                    name: "input",
-                    message: "App ID or app URL to checkout"
-                }
-            ]);
-            const checkoutInput = checkoutAnswer.input.trim();
-            if (checkoutInput) {
-                const preferredEditorCommand = getPreferredEditorCommand(selectedEditor);
-                let openAfterCheckout = false;
-                if (preferredEditorCommand) openAfterCheckout = await logger_logger.confirm(`Open checked out app in ${preferredEditorCommand} after checkout?`, true);
-                else logger_logger.info("No preferred editor is configured, so open-in-editor is skipped.");
-                await deps.executeCheckout({
-                    input: checkoutInput,
-                    url: configuredAnvilUrl,
-                    open: openAfterCheckout
-                });
-            } else logger_logger.info("No app provided; skipping checkout.");
-        } else logger_logger.info("Skipping checkout.");
-        console.log();
-        logger_logger.success("Onboarding complete.");
+        logger_logger.info(chalk_source.cyan("Next: anvil checkout"));
+        logger_logger.info(chalk_source.gray("Run `anvil checkout` with no arguments to search and select your app."));
+        logger_logger.success("Configuration complete.");
     }
-    function registerOnboardCommand(program, version) {
-        program.command("onboard").description("Guided setup for configuration, login, and optional app checkout").action(async ()=>{
+    function registerConfigureCommand(program, version) {
+        program.command("configure").description("Guided setup for configuration and login").action(async ()=>{
             try {
-                await runOnboardFlow(version, onboard_defaultDeps);
+                await runConfigureFlow(version, configure_defaultDeps);
             } catch (e) {
                 logger_logger.error("Error: " + errors_getErrorMessage(e));
                 process.exit(1);
@@ -52288,11 +52902,11 @@ var __webpack_exports__ = {};
             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("irm https://anvil.works/install/anvil-cli/install.ps1 | iex"));
-                console.log(chalk_source.gray("  CMD:        ") + chalk_source.white("curl -fsSL https://anvil.works/install/anvil-cli/install.cmd -o install.cmd && install.cmd && del install.cmd"));
-            } else console.log(chalk_source.gray("  macOS/Linux: ") + chalk_source.white("curl -fsSL https://anvil.works/install/anvil-cli/install.sh | sh"));
-            console.log(chalk_source.gray("  npm:         ") + chalk_source.white("npm update -g @anvil-works/anvil-cli"));
-            console.log(chalk_source.gray("  pnpm:        ") + chalk_source.white("pnpm update -g @anvil-works/anvil-cli"));
+                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();
         } catch (e) {
             logger_logger.error("Error: " + e.message);
@@ -52317,7 +52931,7 @@ var __webpack_exports__ = {};
     registerLogoutCommand(cli_program);
     registerConfigCommand(cli_program);
     registerVersionCommand(cli_program, VERSION);
-    registerOnboardCommand(cli_program, VERSION);
+    registerConfigureCommand(cli_program, VERSION);
     cli_program.command("update").description("Update anvil to the latest version").alias("u").action(async ()=>{
         await handleUpdateCommand();
     });