@anvil-works/anvil-cli 0.6.4 → 0.7.0-canary.2

package/dist/index.js

@@ -1,7 +1,4 @@
 /*! For license information please see index.js.LICENSE.txt */
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
 var __webpack_modules__ = {
     "./node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js" (__unused_rspack_module, exports1, __webpack_require__) {
         "use strict";
@@ -31351,20 +31348,20 @@ var __webpack_exports__ = {};
         validateCheckoutDestination: ()=>validateCheckoutDestination,
         DeviceAuthorizationResponse: ()=>oauth_login_namespaceObject.DeviceAuthorizationResponse,
         OAuthTokenResponse: ()=>oauth_login_namespaceObject.OAuthTokenResponse,
+        WatchSession: ()=>WatchSession_WatchSession,
         parseConfigSetValue: ()=>parseConfigSetValue,
         requestDeviceAuthorization: ()=>requestDeviceAuthorization,
-        validateAnvilApp: ()=>validation_validateAnvilApp,
         getGitPushUrl: ()=>anvil_api_getGitPushUrl,
         setAuthTokensForAccount: ()=>setAccountTokens,
+        validateAnvilApp: ()=>validation_validateAnvilApp,
         ValidateAppIdResponse: ()=>anvil_api_namespaceObject.ValidateAppIdResponse,
         formatValidationPath: ()=>formatValidationPath,
         resolveAnvilUrl: ()=>resolveAnvilUrl,
         parseCheckoutInput: ()=>parseCheckoutInput,
-        login: ()=>login,
+        login: ()=>auth_login,
         resetConfig: ()=>resetConfig,
-        resolveCheckoutUsername: ()=>resolveCheckoutUsername,
-        detectAppIdsByCommitLookup: ()=>anvil_api_detectAppIdsByCommitLookup,
         FormTemplateValidationResult: ()=>validators_namespaceObject.FormTemplateValidationResult,
+        detectAppIdsByCommitLookup: ()=>anvil_api_detectAppIdsByCommitLookup,
         ValidationTarget: ()=>validators_namespaceObject.ValidationTarget,
         sanitizeDirectoryName: ()=>sanitizeDirectoryName,
         validatePath: ()=>validatePath,
@@ -31374,15 +31371,13 @@ var __webpack_exports__ = {};
         CheckoutAppListItem: ()=>anvil_api_namespaceObject.CheckoutAppListItem,
         getConfig: ()=>config_getConfig,
         CheckoutExecutionDeps: ()=>checkout_namespaceObject.CheckoutExecutionDeps,
-        openPathInEditorOrDefault: ()=>checkout_openPathInEditorOrDefault,
+        ValidateBranchSyncStatusOptions: ()=>validation_namespaceObject.ValidateBranchSyncStatusOptions,
         BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus,
         getLatestVersion: ()=>getLatestVersion,
         isDirectoryNonEmpty: ()=>isDirectoryNonEmpty,
         syncToLatest: ()=>src_api_syncToLatest,
         filterCandidates: ()=>anvil_api_filterCandidates,
-        runInteractiveLoginFlow: ()=>runInteractiveLoginFlow,
         CheckoutOptions: ()=>checkout_namespaceObject.CheckoutOptions,
-        ensureCheckoutAuthToken: ()=>ensureCheckoutAuthToken,
         isPathInsideGitRepo: ()=>isPathInsideGitRepo,
         normalizeAnvilUrl: ()=>config_normalizeAnvilUrl,
         ValidationIssue: ()=>validators_namespaceObject.ValidationIssue,
@@ -31405,20 +31400,21 @@ var __webpack_exports__ = {};
         detectAppIdsFromAllRemotes: ()=>anvil_api_detectAppIdsFromAllRemotes,
         getWebSocketUrl: ()=>getWebSocketUrl,
         getAllConfig: ()=>getAllConfig,
-        isCommandAvailable: ()=>isCommandAvailable,
+        isCommandAvailable: ()=>config_isCommandAvailable,
         validateAppId: ()=>anvil_api_validateAppId,
         pollDeviceAuthorization: ()=>pollDeviceAuthorization,
         getValidAuthToken: ()=>auth_getValidAuthToken,
         watch: ()=>src_api_watch,
         deleteConfig: ()=>deleteConfig,
         getGitFetchUrl: ()=>anvil_api_getGitFetchUrl,
-        resolveCheckoutUrl: ()=>resolveCheckoutUrl,
         PreferredEditor: ()=>config_namespaceObject.PreferredEditor,
         getAvailableAnvilUrls: ()=>getAvailableAnvilUrls,
         validateAnvilYaml: ()=>validateAnvilYaml,
         CheckoutCloneOptions: ()=>checkout_namespaceObject.CheckoutCloneOptions,
+        ANVIL_SYNC_CLIENT_ID: ()=>ANVIL_SYNC_CLIENT_ID,
         formatCandidateLabel: ()=>anvil_api_formatCandidateLabel,
         StoredTokens: ()=>auth_namespaceObject.StoredTokens,
+        CheckoutResult: ()=>checkout_namespaceObject.CheckoutResult,
         ParsedCheckoutInput: ()=>checkout_namespaceObject.ParsedCheckoutInput,
         getDefaultDestinationDirectory: ()=>getDefaultDestinationDirectory,
         lookupByCommit: ()=>lookupByCommit,
@@ -31434,9 +31430,9 @@ var __webpack_exports__ = {};
         WL: ()=>getInstalledPreferredEditors,
         uB: ()=>config_getPreferredEditorCommand,
         Bc: ()=>getSettableConfigKeys,
-        P$: ()=>isCommandAvailable,
+        P$: ()=>config_isCommandAvailable,
         n: ()=>config_isDevMode,
-        Wj: ()=>isTestMode,
+        Wj: ()=>config_isTestMode,
         Vl: ()=>config_normalizeAnvilUrl,
         PW: ()=>parseConfigSetValue,
         cx: ()=>preferredEditors,
@@ -31448,12 +31444,13 @@ var __webpack_exports__ = {};
     var auth_namespaceObject = {};
     __webpack_require__.r(auth_namespaceObject);
     __webpack_require__.d(auth_namespaceObject, {
+        fg: ()=>ANVIL_SYNC_CLIENT_ID,
         Fr: ()=>auth_getAccountsForUrl,
         u5: ()=>getAvailableAnvilUrls,
         BG: ()=>getTokensForUrl,
         _p: ()=>auth_getValidAuthToken,
         Fi: ()=>auth_hasTokensForUrl,
-        iD: ()=>login,
+        iD: ()=>auth_login,
         ri: ()=>logout,
         _d: ()=>auth_verifyAuth
     });
@@ -31492,21 +31489,16 @@ var __webpack_exports__ = {};
     __webpack_require__.r(oauth_login_namespaceObject);
     __webpack_require__.d(oauth_login_namespaceObject, {
         T_: ()=>pollDeviceAuthorization,
-        Z6: ()=>requestDeviceAuthorization,
-        Pe: ()=>runInteractiveLoginFlow
+        Z6: ()=>requestDeviceAuthorization
     });
     var checkout_namespaceObject = {};
     __webpack_require__.r(checkout_namespaceObject);
     __webpack_require__.d(checkout_namespaceObject, {
-        oy: ()=>ensureCheckoutAuthToken,
         sF: ()=>executeCheckout,
         RD: ()=>getDefaultDestinationDirectory,
         A9: ()=>isDirectoryNonEmpty,
         oU: ()=>isPathInsideGitRepo,
-        GJ: ()=>checkout_openPathInEditorOrDefault,
         Qx: ()=>parseCheckoutInput,
-        GK: ()=>resolveCheckoutUrl,
-        XM: ()=>resolveCheckoutUsername,
         KV: ()=>sanitizeDirectoryName,
         Bc: ()=>validateCheckoutDestination
     });
@@ -32792,13 +32784,13 @@ var __webpack_exports__ = {};
             values
         };
     }
-    function esm_configFilePath(filePath) {
+    function configFilePath(filePath) {
         return filePath.replace(/^(file):/, "");
     }
     function* configParser(text, requestedKey = null) {
         const lines = text.split("\0");
         for(let i = 0, max = lines.length - 1; i < max;){
-            const file = esm_configFilePath(lines[i++]);
+            const file = configFilePath(lines[i++]);
             let value = lines[i++];
             let key = requestedKey;
             if (value.includes("\n")) {
@@ -39802,7 +39794,7 @@ var __webpack_exports__ = {};
         return `anvil-cli:${url}`;
     }
     function keychainGet(url, username) {
-        if (isTestMode()) return null;
+        if (config_isTestMode()) return null;
         const Ctor = loadKeyring();
         if (!Ctor) return null;
         try {
@@ -39818,7 +39810,7 @@ var __webpack_exports__ = {};
         }
     }
     function keychainSet(url, username, secrets) {
-        if (isTestMode()) return false;
+        if (config_isTestMode()) return false;
         const Ctor = loadKeyring();
         if (!Ctor) return false;
         try {
@@ -39830,7 +39822,7 @@ var __webpack_exports__ = {};
         }
     }
     function keychainDelete(url, username) {
-        if (isTestMode()) return;
+        if (config_isTestMode()) return;
         const Ctor = loadKeyring();
         if (!Ctor) return;
         try {
@@ -39841,12 +39833,13 @@ var __webpack_exports__ = {};
     const EMPTY_TOKENS = {
         authToken: null,
         refreshToken: null,
-        authTokenExpiresAt: null
+        authTokenExpiresAt: null,
+        clientId: null
     };
     function isAccountTokens(value) {
         if (!value || "object" != typeof value || Array.isArray(value)) return false;
         const obj = value;
-        return ("authToken" in obj || "refreshToken" in obj || "authTokenExpiresAt" in obj) && (null === obj.authToken || "string" == typeof obj.authToken) && (null === obj.refreshToken || "string" == typeof obj.refreshToken) && (null === obj.authTokenExpiresAt || "number" == typeof obj.authTokenExpiresAt);
+        return ("authToken" in obj || "refreshToken" in obj || "authTokenExpiresAt" in obj) && (null === obj.authToken || "string" == typeof obj.authToken) && (null === obj.refreshToken || "string" == typeof obj.refreshToken) && (null === obj.authTokenExpiresAt || "number" == typeof obj.authTokenExpiresAt) && (!("clientId" in obj) || null === obj.clientId || "string" == typeof obj.clientId);
     }
     function isUrlTokens(value) {
         if (!value || "object" != typeof value || Array.isArray(value)) return false;
@@ -39910,7 +39903,8 @@ var __webpack_exports__ = {};
         if (keychainOk) store[normalized][username] = {
             authToken: null,
             refreshToken: null,
-            authTokenExpiresAt: tokens.authTokenExpiresAt
+            authTokenExpiresAt: tokens.authTokenExpiresAt,
+            clientId: tokens.clientId ?? null
         };
         else store[normalized][username] = tokens;
         setTokenStore(store);
@@ -40009,7 +40003,7 @@ var __webpack_exports__ = {};
         "verbose",
         "preferredEditor"
     ];
-    function isTestMode() {
+    function config_isTestMode() {
         return "test" === process.env.NODE_ENV || !!process.env.RSTEST;
     }
     function setupConfConfig() {
@@ -40042,7 +40036,7 @@ var __webpack_exports__ = {};
         return wrapper;
     }
     let config_config;
-    config_config = isTestMode() ? setupMockConfConfig() : setupConfConfig();
+    config_config = config_isTestMode() ? setupMockConfConfig() : setupConfConfig();
     function setConfig(key, value) {
         config_config.set(key, value);
     }
@@ -40129,7 +40123,7 @@ var __webpack_exports__ = {};
             return false;
         }
     }
-    function isCommandAvailable(command, env = process.env) {
+    function config_isCommandAvailable(command, env = process.env) {
         const executable = extractExecutableFromCommand(command);
         if (!executable) return false;
         const hasPathSeparator = executable.includes(external_path_default().sep) || executable.includes("/");
@@ -40156,7 +40150,7 @@ var __webpack_exports__ = {};
         return false;
     }
     function getInstalledPreferredEditors() {
-        return preferredEditors.filter((editor)=>isCommandAvailable(config_getPreferredEditorCommand(editor)));
+        return preferredEditors.filter((editor)=>config_isCommandAvailable(config_getPreferredEditorCommand(editor)));
     }
     function getAllConfig() {
         return config_config.store;
@@ -40174,7 +40168,7 @@ var __webpack_exports__ = {};
     function resolveAnvilUrl() {
         const fromConfig = config_getConfig("anvilUrl");
         if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
-        if (isTestMode()) return process.env.ANVIL_API_ORIGIN || "http://localhost:3000";
+        if (config_isTestMode()) return process.env.ANVIL_API_ORIGIN || "http://localhost:3000";
         return config_isDevMode() ? "http://localhost:3000" : "https://anvil.works";
     }
     function config_isDevMode() {
@@ -40188,6 +40182,10 @@ var __webpack_exports__ = {};
     function globalConfig_getGlobalOutputConfig() {
         return globalOutputConfig;
     }
+    function globalConfig_assertCanPrompt(action = "This command", explicitAlternative = "Pass explicit flags instead.") {
+        if (globalOutputConfig.jsonMode) throw new Error(`${action} requires interactive input, but --json disables prompts. ${explicitAlternative}`);
+        if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error(`${action} requires interactive input, but stdin/stdout is not a TTY. ${explicitAlternative}`);
+    }
     const logger_timestamp = ()=>new Date().toISOString();
     const logger_verboseTimestamp = ()=>{
         const now = new Date();
@@ -40225,11 +40223,11 @@ var __webpack_exports__ = {};
             });
         }
         debug(...args) {
-            if (config_isDevMode() && !isTestMode()) if (this.jsonMode) this.logJson("debug", args.map(String).join(" "));
+            if (config_isDevMode() && !config_isTestMode()) if (this.jsonMode) this.logJson("debug", args.map(String).join(" "));
             else this.log(chalk_source.gray("[DEV]"), ...args);
         }
         verbose(...args) {
-            if (config_getConfig("verbose") && !isTestMode()) if (this.jsonMode) this.logJson("verbose", args.map(String).join(" "));
+            if (config_getConfig("verbose") && !config_isTestMode()) if (this.jsonMode) this.logJson("verbose", args.map(String).join(" "));
             else this.log(chalk_source.gray(`[${logger_verboseTimestamp()}]`), ...args);
         }
         info(...args) {
@@ -40284,14 +40282,32 @@ var __webpack_exports__ = {};
         resume() {
             this.paused = false;
         }
-        async prompt(questions) {
+        async prompt(questions, options) {
+            globalConfig_assertCanPrompt(options?.action ?? "Prompt", options?.nonInteractiveHint);
             throw new Error("Prompting not supported in DefaultLogger. Use CLILogger for interactive prompts.");
         }
-        async confirm(message, defaultValue = true) {
-            throw new Error("Prompting not supported in DefaultLogger. Use CLILogger for interactive prompts.");
+        async confirm(message, defaultValue = true, options) {
+            const answer = await this.prompt([
+                {
+                    type: "confirm",
+                    name: "value",
+                    message,
+                    default: defaultValue
+                }
+            ], options);
+            return answer.value;
         }
-        async select(message, choices, defaultValue) {
-            throw new Error("Prompting not supported in DefaultLogger. Use CLILogger for interactive prompts.");
+        async select(message, choices, defaultValue, options) {
+            const answer = await this.prompt([
+                {
+                    type: "list",
+                    name: "value",
+                    message,
+                    choices,
+                    default: defaultValue
+                }
+            ], options);
+            return answer.value;
         }
     }
     let logger_logger = new DefaultLogger();
@@ -42480,6 +42496,7 @@ var __webpack_exports__ = {};
     function getDefaultAnvilUrl() {
         return resolveAnvilUrl();
     }
+    const ANVIL_SYNC_CLIENT_ID = "anvil-sync";
     async function auth_verifyAuth(authToken, anvilUrl = getDefaultAnvilUrl()) {
         try {
             const resp = await fetch(`${anvilUrl}/ide/api/_/user`, {
@@ -42499,7 +42516,7 @@ var __webpack_exports__ = {};
             throw createAuthError.invalid(`Network error: ${e.message}`);
         }
     }
-    async function refreshAccessToken(refreshToken, anvilUrl = getDefaultAnvilUrl()) {
+    async function refreshAccessToken(refreshToken, anvilUrl = getDefaultAnvilUrl(), clientId = ANVIL_SYNC_CLIENT_ID) {
         try {
             const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
                 method: "POST",
@@ -42509,7 +42526,7 @@ var __webpack_exports__ = {};
                 body: new URLSearchParams({
                     grant_type: "refresh_token",
                     refresh_token: refreshToken,
-                    client_id: "anvil-sync"
+                    client_id: clientId
                 })
             });
             if (!tokenResponse.ok) {
@@ -42535,7 +42552,8 @@ var __webpack_exports__ = {};
         if (!tokens.authToken && !tokens.refreshToken) throw createAuthError.required("Not logged in. Please log in first.");
         const isExpired = null !== tokens.authTokenExpiresAt && tokens.authTokenExpiresAt <= Math.floor(Date.now() / 1000) + 60;
         if (tokens.refreshToken && isExpired) try {
-            const tokenData = await refreshAccessToken(tokens.refreshToken, normalized);
+            const clientId = tokens.clientId ?? ANVIL_SYNC_CLIENT_ID;
+            const tokenData = await refreshAccessToken(tokens.refreshToken, normalized, clientId);
             const newExpiresAt = Math.floor(Date.now() / 1000) + tokenData.expires_in;
             let accountUsername = username;
             if (!accountUsername) {
@@ -42552,7 +42570,8 @@ var __webpack_exports__ = {};
             setAccountTokens(normalized, accountUsername, {
                 authToken: tokenData.access_token,
                 refreshToken: tokenData.refresh_token,
-                authTokenExpiresAt: newExpiresAt
+                authTokenExpiresAt: newExpiresAt,
+                clientId
             });
             return tokenData.access_token;
         } catch (e) {
@@ -42570,14 +42589,15 @@ var __webpack_exports__ = {};
             if (account) deleteAccountTokens(normalized, account);
         }
     }
-    async function login(anvilUrl, tokenData) {
+    async function auth_login(anvilUrl, tokenData) {
         const normalized = config_normalizeAnvilUrl(anvilUrl);
         const expiresAt = Math.floor(Date.now() / 1000) + tokenData.expires_in;
         const username = await auth_verifyAuth(tokenData.access_token, normalized);
         setAccountTokens(normalized, username, {
             authToken: tokenData.access_token,
             refreshToken: tokenData.refresh_token,
-            authTokenExpiresAt: expiresAt
+            authTokenExpiresAt: expiresAt,
+            clientId: ANVIL_SYNC_CLIENT_ID
         });
         return {
             success: true,
@@ -44020,7 +44040,9 @@ var __webpack_exports__ = {};
         };
         return null;
     }
-    async function loadFormTemplateData(repoPath, relativePath, stagedOnly, kind, format) {
+    async function loadFormTemplateData(relativePath, templateInfo, context) {
+        const { repoPath, stagedOnly = false } = context;
+        const { kind, format } = templateInfo;
         try {
             const content = await readFileContent(repoPath, relativePath, stagedOnly);
             if ("yaml" === format) {
@@ -44108,7 +44130,8 @@ var __webpack_exports__ = {};
         if (formTemplateInfo) return "forms";
         return null;
     }
-    async function validateRename(fromPath, toPath, repoPath, editorYaml) {
+    async function validateRename(fromPath, toPath, context) {
+        const { repoPath, editorYaml } = context;
         const fromEntityType = await getEntityTypeFromPath(repoPath, fromPath, editorYaml);
         const toEntityType = await getEntityTypeFromPath(repoPath, toPath, editorYaml);
         if (null === fromEntityType || null === toEntityType) return {
@@ -44266,7 +44289,8 @@ var __webpack_exports__ = {};
         }
         return filtered;
     }
-    async function routeFileChange(repoPath, relativePath, changeType, editorYaml, stagedOnly = false, fromPath) {
+    async function routeFileChange(change, context) {
+        const { relativePath, changeType, fromPath } = change;
         logger_logger.verbose(chalk_source.gray(`Routing ${changeType}: ${relativePath}${fromPath ? ` (from: ${fromPath})` : ""}`));
         if (isGitRelatedFile(relativePath)) return {
             type: "ignore",
@@ -44279,9 +44303,12 @@ var __webpack_exports__ = {};
                 type: "ignore",
                 reason: "Rename operation missing from path"
             };
-            return await handleRename(repoPath, fromPath, relativePath, editorYaml, stagedOnly);
+            return await handleRename({
+                fromPath,
+                toPath: relativePath
+            }, context);
         }
-        return await routeSavableChange(repoPath, relativePath, changeType, editorYaml, stagedOnly);
+        return await routeSavableChange(change, context);
     }
     function isGitRelatedFile(relativePath) {
         return ".git" === relativePath || relativePath.startsWith(".git/") || relativePath.endsWith("/.git");
@@ -44300,47 +44327,60 @@ var __webpack_exports__ = {};
                 const parts = relativePath.split("/");
                 return 2 === parts.length;
             },
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleScriptsChange(repoPath, relativePath, editorYaml, changeType, stagedOnly)
+            handle: handleScriptsChange
         },
         {
             matches: (relativePath)=>relativePath.startsWith("server_code/") && relativePath.endsWith(".py"),
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleServerCodeChange(repoPath, relativePath, editorYaml, changeType, stagedOnly)
+            handle: handleServerCodeChange
         },
         {
             matches: (relativePath)=>relativePath.startsWith("client_code/") && relativePath.endsWith(".py"),
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleClientCodeChange(repoPath, relativePath, editorYaml, changeType, stagedOnly)
+            handle: handleClientCodeChange
         },
         {
             matches: (relativePath)=>null !== detectFormTemplate(relativePath),
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleFormTemplateChange(repoPath, relativePath, editorYaml, changeType, stagedOnly)
+            handle: handleFormTemplateChange
         },
         {
             matches: (relativePath)=>"theme/parameters.yaml" === relativePath,
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleThemeParametersChange(repoPath, relativePath, stagedOnly)
+            handle: handleThemeParametersChange
         },
         {
             matches: (relativePath)=>relativePath.startsWith("theme/assets/"),
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleAssetChange(repoPath, relativePath, changeType, editorYaml, stagedOnly)
+            handle: handleAssetChange
         },
         {
             matches: ()=>true,
-            handle: (repoPath, relativePath, changeType, editorYaml, stagedOnly)=>handleExtraFileChange(repoPath, relativePath, stagedOnly)
+            handle: handleExtraFileChange
         }
     ];
-    async function handleRename(repoPath, fromPath, toPath, editorYaml, stagedOnly) {
-        const validation = await validateRename(fromPath, toPath, repoPath, editorYaml);
+    async function handleRename(rename, context) {
+        const { fromPath, toPath } = rename;
+        const validation = await validateRename(fromPath, toPath, context);
         if (!validation.valid) {
             logger_logger.verbose(chalk_source.yellow(`Rename invalid (${validation.reason}), falling back to unlink + add`));
-            const unlinkResult = await routeFileChange(repoPath, fromPath, "unlink", editorYaml, stagedOnly);
-            const addResult = await routeFileChange(repoPath, toPath, "add", editorYaml, stagedOnly);
+            const unlinkResult = await routeFileChange({
+                relativePath: fromPath,
+                changeType: "unlink"
+            }, context);
+            const addResult = await routeFileChange({
+                relativePath: toPath,
+                changeType: "add"
+            }, context);
             return [
                 unlinkResult,
                 addResult
             ].flat();
         }
-        return await handleRenameOperation(repoPath, fromPath, toPath, validation.entityType, editorYaml, stagedOnly);
+        return await handleRenameOperation({
+            fromPath,
+            toPath,
+            entityType: validation.entityType
+        }, context);
     }
-    async function handleRenameOperation(repoPath, fromPath, toPath, entityType, editorYaml, stagedOnly) {
+    async function handleRenameOperation(rename, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { fromPath, toPath, entityType } = rename;
         let oldName;
         let newName;
         let prefix = [];
@@ -44349,10 +44389,10 @@ var __webpack_exports__ = {};
         let isPackage = false;
         let actualToPath = toPath;
         if ("scripts" === entityType) {
-            const toRenameResult = await handlePathRenaming(repoPath, toPath, "scripts", stagedOnly);
+            const toRenameResult = await handlePathRenaming(toPath, "scripts", context);
             if (toRenameResult.ignoreResult) return toRenameResult.ignoreResult;
             actualToPath = toRenameResult.newRelativePath;
-            const fromRenameResult = await handlePathRenaming(repoPath, fromPath, "scripts", stagedOnly);
+            const fromRenameResult = await handlePathRenaming(fromPath, "scripts", context);
             oldName = fromRenameResult.pythonifiedName;
             newName = toRenameResult.pythonifiedName;
             prefix = [
@@ -44364,10 +44404,10 @@ var __webpack_exports__ = {};
                     code
                 });
         } else if ("server_modules" === entityType) {
-            const toRenameResult = await handlePathRenaming(repoPath, toPath, "server_code", stagedOnly);
+            const toRenameResult = await handlePathRenaming(toPath, "server_code", context);
             if (toRenameResult.ignoreResult) return toRenameResult.ignoreResult;
             actualToPath = toRenameResult.newRelativePath;
-            const fromRenameResult = await handlePathRenaming(repoPath, fromPath, "server_code", stagedOnly);
+            const fromRenameResult = await handlePathRenaming(fromPath, "server_code", context);
             oldName = fromRenameResult.pythonifiedName;
             newName = toRenameResult.pythonifiedName;
             prefix = [
@@ -44381,10 +44421,10 @@ var __webpack_exports__ = {};
                     is_package: isPackage
                 });
         } else if ("modules" === entityType) {
-            const toRenameResult = await handlePathRenaming(repoPath, toPath, "client_code", stagedOnly);
+            const toRenameResult = await handlePathRenaming(toPath, "client_code", context);
             if (toRenameResult.ignoreResult) return toRenameResult.ignoreResult;
             actualToPath = toRenameResult.newRelativePath;
-            const fromRenameResult = await handlePathRenaming(repoPath, fromPath, "client_code", stagedOnly);
+            const fromRenameResult = await handlePathRenaming(fromPath, "client_code", context);
             oldName = fromRenameResult.pythonifiedName;
             newName = toRenameResult.pythonifiedName;
             isPackage = actualToPath.endsWith("__init__.py");
@@ -44402,10 +44442,10 @@ var __webpack_exports__ = {};
                 type: "ignore",
                 reason: "Form template rename to .yaml file is only supported when entire form is renamed"
             };
-            const toRenameResult = await handlePathRenaming(repoPath, toPath, "client_code", stagedOnly);
+            const toRenameResult = await handlePathRenaming(toPath, "client_code", context);
             if (toRenameResult.ignoreResult) return toRenameResult.ignoreResult;
             actualToPath = toRenameResult.newRelativePath;
-            const fromRenameResult = await handlePathRenaming(repoPath, fromPath, "client_code", stagedOnly);
+            const fromRenameResult = await handlePathRenaming(fromPath, "client_code", context);
             oldName = fromRenameResult.pythonifiedName;
             const isPackageInit = actualToPath.endsWith("__init__.py");
             const kind = isPackageInit ? "package" : "module";
@@ -44414,7 +44454,10 @@ var __webpack_exports__ = {};
                 type: "ignore",
                 reason: "Form template not found for rename destination"
             };
-            const result = await buildFormTemplateData(repoPath, templateInfo.relativePath, stagedOnly, kind, templateInfo.format);
+            const result = await buildFormTemplateData(templateInfo.relativePath, {
+                kind,
+                format: templateInfo.format
+            }, context);
             if (result.ignoreResult) return result.ignoreResult;
             newName = result.className;
             prefix = [
@@ -44462,7 +44505,9 @@ var __webpack_exports__ = {};
             content: payload
         };
     }
-    async function routeSavableChange(repoPath, relativePath, changeType, editorYaml, stagedOnly = false) {
+    async function routeSavableChange(change, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { relativePath, changeType } = change;
         if ("anvil.yaml" === relativePath) return {
             type: "ignore",
             reason: "anvil.yaml handled specially (multiple save paths)"
@@ -44506,13 +44551,15 @@ var __webpack_exports__ = {};
             };
         }
         if ("unlink" === changeType) return await handleFileDeletion(repoPath, relativePath, editorYaml);
-        for (const route of ROUTES)if (route.matches(relativePath)) return await route.handle(repoPath, relativePath, changeType, editorYaml, stagedOnly);
+        for (const route of ROUTES)if (route.matches(relativePath)) return await route.handle(change, context);
         return {
             type: "ignore",
             reason: "Not a recognized Anvil file type"
         };
     }
-    async function handleThemeParametersChange(repoPath, relativePath, stagedOnly = false) {
+    async function handleThemeParametersChange(change, context) {
+        const { repoPath, stagedOnly = false } = context;
+        const { relativePath } = change;
         const content = await readFileContent(repoPath, relativePath, stagedOnly);
         const parametersData = jsYaml.load(content);
         return {
@@ -44524,7 +44571,9 @@ var __webpack_exports__ = {};
             content: parametersData
         };
     }
-    async function handleExtraFileChange(repoPath, relativePath, stagedOnly = false) {
+    async function handleExtraFileChange(change, context) {
+        const { repoPath, stagedOnly = false } = context;
+        const { relativePath } = change;
         const content = await readBinaryFileContent(repoPath, relativePath, stagedOnly);
         const base64Content = content.toString("base64");
         const pathParts = [
@@ -44537,7 +44586,9 @@ var __webpack_exports__ = {};
             content: base64Content
         };
     }
-    async function handleDirectoryRenaming(repoPath, originalParts, pythonifiedParts, baseDir) {
+    async function handleDirectoryRenaming(rename, context) {
+        const { repoPath } = context;
+        const { originalParts, pythonifiedParts, baseDir } = rename;
         const needsRename = originalParts.some((part, idx)=>part !== pythonifiedParts[idx]);
         if (!needsRename) return null;
         const needsDirRename = originalParts.slice(0, -1).some((part, idx)=>part !== pythonifiedParts[idx]);
@@ -44555,7 +44606,9 @@ var __webpack_exports__ = {};
         }
         return null;
     }
-    async function renameIfNeeded(repoPath, relativePath, originalNameOrParts, baseDir) {
+    async function renameIfNeeded(rename, context) {
+        const { repoPath } = context;
+        const { relativePath, originalNameOrParts, baseDir } = rename;
         let pythonifiedName;
         let pythonifiedParts;
         let needsRename;
@@ -44593,8 +44646,10 @@ var __webpack_exports__ = {};
             ignoreResult
         };
     }
-    async function handleScriptsChange(repoPath, relativePath, editorYaml, changeType, stagedOnly = false) {
-        const renameResult = await handlePathRenaming(repoPath, relativePath, "scripts", stagedOnly);
+    async function handleScriptsChange(change, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { relativePath, changeType } = change;
+        const renameResult = await handlePathRenaming(relativePath, "scripts", context);
         if (renameResult.ignoreResult) return renameResult.ignoreResult;
         const actualPath = renameResult.newRelativePath;
         const content = await readFileContent(repoPath, actualPath, stagedOnly);
@@ -44616,8 +44671,10 @@ var __webpack_exports__ = {};
             ]
         });
     }
-    async function handleServerCodeChange(repoPath, relativePath, editorYaml, changeType, stagedOnly = false) {
-        const renameResult = await handlePathRenaming(repoPath, relativePath, "server_code", stagedOnly);
+    async function handleServerCodeChange(change, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { relativePath, changeType } = change;
+        const renameResult = await handlePathRenaming(relativePath, "server_code", context);
         if (renameResult.ignoreResult) return renameResult.ignoreResult;
         const actualPath = renameResult.newRelativePath;
         const isPackage = actualPath.endsWith("__init__.py");
@@ -44642,8 +44699,10 @@ var __webpack_exports__ = {};
             ]
         });
     }
-    async function handleClientCodeFormChange(repoPath, relativePath, className, templatePath, format, kind, changeType, editorYaml, stagedOnly) {
-        const result = await buildFormTemplateData(repoPath, templatePath, stagedOnly, kind, format);
+    async function handleClientCodeFormChange(options, context) {
+        const { editorYaml } = context;
+        const { templatePath, templateInfo, changeType } = options;
+        const result = await buildFormTemplateData(templatePath, templateInfo, context);
         if (result.ignoreResult) return result.ignoreResult;
         const { formData, className: extractedClassName } = result;
         return handleIdBasedOperation({
@@ -44661,30 +44720,47 @@ var __webpack_exports__ = {};
             ]
         });
     }
-    async function handlePathRenaming(repoPath, relativePath, baseDir, stagedOnly) {
+    async function handlePathRenaming(relativePath, baseDir, context) {
         const parts = relativePath.slice(0, -3).split("/");
         const originalParts = parts.slice(1);
         const pythonifiedParts = originalParts.map(pythonifyName);
         const pythonifiedName = extractPythonName(relativePath);
-        const dirRenameResult = await handleDirectoryRenaming(repoPath, originalParts, pythonifiedParts, baseDir);
+        const dirRenameResult = await handleDirectoryRenaming({
+            originalParts,
+            pythonifiedParts,
+            baseDir
+        }, context);
         if (dirRenameResult) return {
             pythonifiedName,
             pythonifiedParts,
             newRelativePath: relativePath,
             ignoreResult: dirRenameResult
         };
-        const renameResult = await renameIfNeeded(repoPath, relativePath, originalParts, baseDir);
+        const renameResult = await renameIfNeeded({
+            relativePath,
+            originalNameOrParts: originalParts,
+            baseDir
+        }, context);
         return renameResult;
     }
-    async function handleClientCodeChange(repoPath, relativePath, editorYaml, changeType, stagedOnly = false) {
-        const renameResult = await handlePathRenaming(repoPath, relativePath, "client_code", stagedOnly);
+    async function handleClientCodeChange(change, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { relativePath, changeType } = change;
+        const renameResult = await handlePathRenaming(relativePath, "client_code", context);
         if (renameResult.ignoreResult) return renameResult.ignoreResult;
         const actualPath = renameResult.newRelativePath;
         const isPackageInit = actualPath.endsWith("__init__.py");
         const kind = isPackageInit ? "package" : "module";
         const className = renameResult.pythonifiedName;
         const templateInfo = findFormTemplateForCodePath(repoPath, actualPath, kind);
-        if (templateInfo) return await handleClientCodeFormChange(repoPath, actualPath, className, templateInfo.relativePath, templateInfo.format, kind, changeType, editorYaml, stagedOnly);
+        if (templateInfo) return await handleClientCodeFormChange({
+            templatePath: templateInfo.relativePath,
+            templateInfo: {
+                format: templateInfo.format,
+                kind
+            },
+            changeType
+        }, context);
         const content = await readFileContent(repoPath, actualPath, stagedOnly);
         return handleIdBasedOperation({
             entityType: "modules",
@@ -44719,8 +44795,10 @@ var __webpack_exports__ = {};
         }
         return formData;
     }
-    async function buildFormTemplateData(repoPath, relativePath, stagedOnly, kind, format) {
-        const loadResult = await loadFormTemplateData(repoPath, relativePath, stagedOnly, kind, format);
+    async function buildFormTemplateData(relativePath, templateInfo, context) {
+        const { repoPath, stagedOnly = false } = context;
+        const { kind } = templateInfo;
+        const loadResult = await loadFormTemplateData(relativePath, templateInfo, context);
         if (false === loadResult.ok) return {
             formData: {},
             className: "",
@@ -44754,7 +44832,9 @@ var __webpack_exports__ = {};
             ignoreResult: null
         };
     }
-    async function handleFormTemplateChange(repoPath, relativePath, editorYaml, changeType, stagedOnly) {
+    async function handleFormTemplateChange(change, context) {
+        const { editorYaml } = context;
+        const { relativePath, changeType } = change;
         const templateInfo = detectFormTemplate(relativePath);
         if (!templateInfo) return {
             type: "ignore",
@@ -44762,7 +44842,10 @@ var __webpack_exports__ = {};
         };
         const kind = templateInfo.kind;
         const format = templateInfo.format;
-        const result = await buildFormTemplateData(repoPath, relativePath, stagedOnly, kind, format);
+        const result = await buildFormTemplateData(relativePath, {
+            kind,
+            format
+        }, context);
         if (result.ignoreResult) return result.ignoreResult;
         const { formData, className } = result;
         return handleIdBasedOperation({
@@ -44778,7 +44861,9 @@ var __webpack_exports__ = {};
             subPathForCodeUpdate: null
         });
     }
-    async function handleAssetChange(repoPath, relativePath, changeType, editorYaml, stagedOnly = false) {
+    async function handleAssetChange(change, context) {
+        const { repoPath, editorYaml, stagedOnly = false } = context;
+        const { relativePath, changeType } = change;
         const assetPath = relativePath.replace(/^theme[\/\\]assets[\/\\]/, "");
         const fileBuffer = await readBinaryFileContent(repoPath, relativePath, stagedOnly);
         const base64Content = fileBuffer.toString("base64");
@@ -45205,7 +45290,15 @@ var __webpack_exports__ = {};
                     originalFilePaths.push(change.path);
                     continue;
                 }
-                const routeResult = await routeFileChange(this.config.repoPath, change.path, change.type, this.config.editorYaml, this.config.stagedOnly, change.from);
+                const routeResult = await routeFileChange({
+                    relativePath: change.path,
+                    changeType: change.type,
+                    fromPath: change.from
+                }, {
+                    repoPath: this.config.repoPath,
+                    editorYaml: this.config.editorYaml,
+                    stagedOnly: this.config.stagedOnly
+                });
                 const results = Array.isArray(routeResult) ? routeResult : [
                     routeResult
                 ];
@@ -45392,7 +45485,15 @@ var __webpack_exports__ = {};
             const newSaveArray = [];
             const newFilePaths = [];
             for (const change of changes){
-                const routeResult = await routeFileChange(this.config.repoPath, change.path, change.type, this.config.editorYaml, this.config.stagedOnly, change.from);
+                const routeResult = await routeFileChange({
+                    relativePath: change.path,
+                    changeType: change.type,
+                    fromPath: change.from
+                }, {
+                    repoPath: this.config.repoPath,
+                    editorYaml: this.config.editorYaml,
+                    stagedOnly: this.config.stagedOnly
+                });
                 const results = Array.isArray(routeResult) ? routeResult : [
                     routeResult
                 ];
@@ -45790,6 +45891,12 @@ var __webpack_exports__ = {};
             this.startLocalChangeFallbackPolling();
             await new Promise(()=>{});
         }
+        startWatchingInBackground(onError) {
+            this.startWatching().catch((error)=>{
+                this.cleanup();
+                onError?.(error);
+            });
+        }
         async initializeLocalChangeFingerprint() {
             if (this.stagedOnly) return;
             try {
@@ -45926,22 +46033,28 @@ var __webpack_exports__ = {};
             appName
         };
     }
-    async function validation_validateBranchSyncStatus(git, branchName, appId, anvilUrl, username) {
+    async function validation_validateBranchSyncStatus(git, branchName, options) {
+        const { appId, anvilUrl, username } = options;
         logger_logger.verbose(chalk_source.blue("Checking branch sync status..."));
         let authToken;
         try {
             authToken = await auth_getValidAuthToken(anvilUrl, username);
         } catch (e) {
-            return validateViaAnvilServer(git, branchName, appId, anvilUrl, username);
+            return validateViaAnvilServer(git, branchName, options);
         }
         try {
-            return await validateViaGitFetch(git, branchName, appId, anvilUrl, authToken);
+            return await validateViaGitFetch(git, branchName, {
+                appId,
+                anvilUrl,
+                authToken
+            });
         } catch (e) {
             logger_logger.verbose(chalk_source.yellow("Git fetch failed, trying server validation..."));
-            return validateViaAnvilServer(git, branchName, appId, anvilUrl, username);
+            return validateViaAnvilServer(git, branchName, options);
         }
     }
-    async function validateViaGitFetch(git, branchName, appId, anvilUrl, authToken) {
+    async function validateViaGitFetch(git, branchName, options) {
+        const { appId, anvilUrl, authToken } = options;
         const baseUrl = new URL(anvilUrl);
         const encodedToken = encodeURIComponent(authToken);
         const gitPath = `/git/${appId}.git`;
@@ -46002,7 +46115,8 @@ var __webpack_exports__ = {};
             throw errors_createGitError.fetchFailed(e.message);
         }
     }
-    async function validateViaAnvilServer(git, branchName, appId, anvilUrl, username) {
+    async function validateViaAnvilServer(git, branchName, options) {
+        const { appId, anvilUrl, username } = options;
         logger_logger.verbose(chalk_source.blue("Validating sync status with Anvil server..."));
         const authToken = await auth_getValidAuthToken(anvilUrl, username);
         let commitId;
@@ -46047,676 +46161,13 @@ var __webpack_exports__ = {};
             throw createNetworkError.network(e.message);
         }
     }
-    var external_http_ = __webpack_require__("http");
-    const external_readline_namespaceObject = require("readline");
-    var external_readline_default = /*#__PURE__*/ __webpack_require__.n(external_readline_namespaceObject);
-    const external_node_url_namespaceObject = require("node:url");
-    const external_node_child_process_namespaceObject = require("node:child_process");
-    let isDockerCached;
-    function hasDockerEnv() {
-        try {
-            external_node_fs_.statSync('/.dockerenv');
-            return true;
-        } catch  {
-            return false;
-        }
-    }
-    function hasDockerCGroup() {
-        try {
-            return external_node_fs_.readFileSync('/proc/self/cgroup', 'utf8').includes('docker');
-        } catch  {
-            return false;
-        }
-    }
-    function isDocker() {
-        if (void 0 === isDockerCached) isDockerCached = hasDockerEnv() || hasDockerCGroup();
-        return isDockerCached;
-    }
-    let cachedResult;
-    const hasContainerEnv = ()=>{
-        try {
-            external_node_fs_.statSync('/run/.containerenv');
-            return true;
-        } catch  {
-            return false;
-        }
-    };
-    function isInsideContainer() {
-        if (void 0 === cachedResult) cachedResult = hasContainerEnv() || isDocker();
-        return cachedResult;
-    }
-    const isWsl = ()=>{
-        if ('linux' !== external_node_process_namespaceObject.platform) return false;
-        if (external_node_os_namespaceObject.release().toLowerCase().includes('microsoft')) {
-            if (isInsideContainer()) return false;
-            return true;
-        }
-        try {
-            return external_node_fs_.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft') ? !isInsideContainer() : false;
-        } catch  {
-            return false;
-        }
-    };
-    const is_wsl = external_node_process_namespaceObject.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_namespaceObject.env.SYSTEMROOT || external_node_process_namespaceObject.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_namespaceObject.execFile);
-    async function defaultBrowserId() {
-        if ('darwin' !== external_node_process_namespaceObject.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_namespaceObject.execFile);
-    async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-        if ('darwin' !== external_node_process_namespaceObject.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")`);
-    }
-    const windows_execFileAsync = (0, external_node_util_namespaceObject.promisify)(external_node_child_process_namespaceObject.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 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_namespaceObject.execFile);
-    const titleize = (string)=>string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x)=>x.toUpperCase());
-    async function default_browser_defaultBrowser() {
-        if ('darwin' === external_node_process_namespaceObject.platform) {
-            const id = await defaultBrowserId();
-            const name = await bundleName(id);
-            return {
-                name,
-                id
-            };
-        }
-        if ('linux' === external_node_process_namespaceObject.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_namespaceObject.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_namespaceObject.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: open_platform, arch } = external_node_process_namespaceObject;
-    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 ('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
-                    }
-                });
-            }
-            throw new Error(`${browser.name} is not supported as a default browser`);
-        }
-        let command;
-        const cliArguments = [];
-        const childProcessOptions = {};
-        if ('darwin' === open_platform) {
-            command = 'open';
-            if (options.wait) cliArguments.push('--wait-apps');
-            if (options.background) cliArguments.push('--background');
-            if (options.newInstance) cliArguments.push('--new');
-            if (app) cliArguments.push('-a', app);
-        } else if ('win32' !== open_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_namespaceObject.versions.electron ?? ('android' === open_platform || isBundled || !exeLocalXdgOpen);
-                command = useSystemXdgOpen ? 'xdg-open' : localXdgOpenPath;
-            }
-            if (appArguments.length > 0) cliArguments.push(...appArguments);
-            if (!options.wait) {
-                childProcessOptions.stdio = 'ignore';
-                childProcessOptions.detached = true;
-            }
-        } 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(','));
-            }
-            options.target = external_node_buffer_namespaceObject.Buffer.from(encodedArguments.join(' '), 'utf16le').toString('base64');
-        }
-        if ('darwin' === open_platform && appArguments.length > 0) cliArguments.push('--args', ...appArguments);
-        if (options.target) cliArguments.push(options.target);
-        const subprocess = external_node_child_process_namespaceObject.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({ [open_platform]: platformBinary }, { wsl }) {
-        if (wsl && is_wsl) return detectArchBinary(wsl);
-        if (!platformBinary) throw new Error(`${open_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'
-                ]
-            }
-        }));
-    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;
-    const successPage = `<!DOCTYPE html>
-  <html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>Anvil Sync • Login Complete</title>
-      <link rel="preconnect" href="https://fonts.googleapis.com">
-      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
-      <style>
-        * { box-sizing: border-box; }
-        html, body { height: 100%; margin: 0; }
-        body {
-          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-          color: #555555;
-          background: #f7fdff;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          padding: 20px;
-        }
-        .card {
-          width: min(480px, 100%);
-          background: #ffffff;
-          border-radius: 12px;
-          padding: 48px 40px;
-          text-align: center;
-          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
-        }
-        .icon {
-          display: inline-flex;
-          align-items: center;
-          justify-content: center;
-          width: 56px;
-          height: 56px;
-          margin: 0 auto 24px;
-          border-radius: 50%;
-          background: #1bb0ee;
-          color: white;
-        }
-        .icon svg {
-          width: 28px;
-          height: 28px;
-        }
-        h1 {
-          font-size: 24px;
-          font-weight: 600;
-          line-height: 1.3;
-          margin: 0 0 12px;
-          color: #1a1a1a;
-        }
-        p {
-          color: #555555;
-          font-size: 15px;
-          line-height: 1.5;
-          margin: 0;
-        }
-      </style>
-    </head>
-    <body>
-      <main class="card" role="status" aria-live="polite">
-        <div class="icon" aria-hidden="true">
-          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-            <path d="M20 7L9 18l-5-5" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
-          </svg>
-        </div>
-        <h1>Anvil login complete</h1>
-        <p>Close this window and return to your terminal to continue.</p>
-      </main>
-    </body>
-  </html>`;
-    function errorPage(errorMsg) {
-        return `<!DOCTYPE html>
-<html lang="en">
-    <head>
-      <meta charset="utf-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1" />
-      <title>Anvil Sync • Login Error</title>
-      <link rel="preconnect" href="https://fonts.googleapis.com">
-      <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-      <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;500;600;700&display=swap" rel="stylesheet">
-      <style>
-        * { box-sizing: border-box; }
-        html, body { height: 100%; margin: 0; }
-        body {
-          font-family: Poppins, -apple-system, system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-          color: #555555;
-          background: #f7fdff;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          padding: 20px;
-        }
-        .card {
-          width: min(480px, 100%);
-          background: #ffffff;
-          border-radius: 12px;
-          padding: 48px 40px;
-          text-align: center;
-          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
-        }
-        .icon {
-          display: inline-flex;
-          align-items: center;
-          justify-content: center;
-          width: 56px;
-          height: 56px;
-          margin: 0 auto 24px;
-          border-radius: 50%;
-          background: #ef4444;
-          color: white;
-        }
-        .icon svg {
-          width: 28px;
-          height: 28px;
-        }
-        h1 {
-          font-size: 24px;
-          font-weight: 600;
-          line-height: 1.3;
-          margin: 0 0 16px;
-          color: #1a1a1a;
-        }
-        p {
-          color: #555555;
-          font-size: 15px;
-          line-height: 1.5;
-          margin: 16px 0 0;
-        }
-        .details {
-          color: #666666;
-          font-size: 13px;
-          word-break: break-word;
-          font-weight: 500;
-          font-family: ui-monospace, "SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace;
-          margin: 16px 0 0;
-          padding: 12px;
-          background: #f8f9fa;
-          border-radius: 6px;
-          text-align: left;
-        }
-      </style>
-    </head>
-    <body>
-      <main class="card" role="status" aria-live="polite">
-        <div class="icon" aria-hidden="true">
-          <svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
-            <path d="M15 9l-6 6M9 9l6 6" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
-          </svg>
-        </div>
-        <h1>Anvil login failed</h1>
-        <div id="details" class="details">${errorMsg}</div>
-        <p>Close this window and return to your terminal to retry.</p>
-      </main>
-    </body>
-  </html>`;
-    }
-    const CLIENT_ID = "anvil-sync";
+    __webpack_require__("http");
+    require("readline");
+    const CLIENT_ID = ANVIL_SYNC_CLIENT_ID;
     const SCOPES = "apps:read apps:write user:read";
-    function oauth_login_base64url(buf) {
-        return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-    }
     function sleep(ms) {
         return new Promise((resolve)=>setTimeout(resolve, ms));
     }
-    function createBrowserLaunchPrompt(authUrl) {
-        if (!process.stdin.isTTY || !process.stdout.isTTY) return {
-            waitForOpen: Promise.resolve(false),
-            close: ()=>{}
-        };
-        const rl = external_readline_namespaceObject.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        let closed = false;
-        let resolveWait = null;
-        const close = (opened = false)=>{
-            if (closed) return;
-            closed = true;
-            rl.close();
-            resolveWait?.(opened);
-            resolveWait = null;
-        };
-        const waitForOpen = new Promise((resolve)=>{
-            resolveWait = resolve;
-            rl.on("SIGINT", ()=>{
-                close();
-                process.kill(process.pid, "SIGINT");
-            });
-            rl.question("", async ()=>{
-                try {
-                    await node_modules_open(authUrl);
-                    logger_logger.info(chalk_source.dim("Opened your browser to continue login."));
-                    close(true);
-                } catch  {
-                    logger_logger.warn("Could not open a browser automatically.");
-                    close(false);
-                }
-            });
-        });
-        return {
-            waitForOpen,
-            close
-        };
-    }
     async function parseOAuthError(response) {
         const contentType = response.headers.get("content-type") || "";
         if (contentType.includes("application/json")) {
@@ -46732,23 +46183,6 @@ var __webpack_exports__ = {};
             return text;
         }
     }
-    async function exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier) {
-        const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: new URLSearchParams({
-                grant_type: "authorization_code",
-                code,
-                redirect_uri: redirectUri,
-                client_id: CLIENT_ID,
-                code_verifier: codeVerifier
-            })
-        });
-        if (!tokenResponse.ok) throw new Error(`Failed to exchange authorization code for token. ${await parseOAuthError(tokenResponse)}`);
-        return await tokenResponse.json();
-    }
     async function requestDeviceAuthorization(anvilUrl) {
         const response = await fetch(`${anvilUrl}/oauth/device_authorization`, {
             method: "POST",
@@ -46796,131 +46230,6 @@ var __webpack_exports__ = {};
         }
         throw new Error("Device login expired before it was approved.");
     }
-    async function createPkceLoginFlow(anvilUrl) {
-        const codeVerifier = external_crypto_.randomBytes(48).toString("hex");
-        const codeChallenge = oauth_login_base64url(external_crypto_.createHash("sha256").update(codeVerifier, "ascii").digest());
-        const state = external_crypto_.randomBytes(16).toString("hex");
-        const server = external_http_.createServer();
-        await new Promise((resolve)=>server.listen(0, "127.0.0.1", resolve));
-        const address = server.address();
-        if (!address || "string" == typeof address) throw new Error("No address");
-        const port = address.port;
-        const redirectUri = `http://127.0.0.1:${port}/oauth-callback`;
-        const authUrl = new URL(`${anvilUrl}/oauth/authorize`);
-        authUrl.searchParams.set("response_type", "code");
-        authUrl.searchParams.set("client_id", CLIENT_ID);
-        authUrl.searchParams.set("redirect_uri", redirectUri);
-        authUrl.searchParams.set("scope", SCOPES);
-        authUrl.searchParams.set("state", state);
-        authUrl.searchParams.set("code_challenge", codeChallenge);
-        authUrl.searchParams.set("code_challenge_method", "S256");
-        const codePromise = new Promise((resolve, reject)=>{
-            server.on("request", (req, res)=>{
-                if (!req.url) return;
-                const url = new URL(req.url, `http://127.0.0.1:${port}`);
-                if ("/oauth-callback" !== url.pathname) return;
-                const code = url.searchParams.get("code") || void 0;
-                const error = url.searchParams.get("error") || void 0;
-                const recvState = url.searchParams.get("state");
-                if (!recvState || !code && !error) {
-                    res.statusCode = 400;
-                    res.end("Missing code, error or state");
-                    reject(new Error("Missing code/state/error"));
-                    server.close();
-                    return;
-                }
-                res.statusCode = 200;
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                if (code) res.end(successPage);
-                else res.end(errorPage(error || "unknown"));
-                resolve({
-                    code,
-                    error,
-                    recvState
-                });
-                server.closeAllConnections();
-                server.close();
-            });
-        });
-        let closed = false;
-        server.on("close", ()=>{
-            closed = true;
-        });
-        const close = async ()=>{
-            if (closed) return;
-            closed = true;
-            server.closeAllConnections();
-            if (!server.listening) return;
-            await new Promise((resolve)=>server.close(()=>resolve()));
-        };
-        return {
-            authUrl,
-            close,
-            waitForLogin: (async ()=>{
-                const { code, error, recvState } = await codePromise;
-                if (recvState !== state) throw new Error("Invalid state received from OAuth callback");
-                if (error) throw new Error(`Error received from OAuth callback: ${error}`);
-                const tokenData = await exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier);
-                return login(anvilUrl, {
-                    access_token: tokenData.access_token,
-                    refresh_token: tokenData.refresh_token,
-                    expires_in: tokenData.expires_in,
-                    scope: tokenData.scope
-                });
-            })()
-        };
-    }
-    function raceLoginAttempts(attempts) {
-        return new Promise((resolve, reject)=>{
-            let remaining = attempts.length;
-            let lastError = null;
-            for (const attempt of attempts)attempt.then(resolve).catch((error)=>{
-                if ("cancelled" === error.message) return;
-                remaining -= 1;
-                lastError = error;
-                if (0 === remaining && lastError) reject(lastError);
-            });
-        });
-    }
-    async function runInteractiveLoginFlow(anvilUrl) {
-        const pkceFlow = await createPkceLoginFlow(anvilUrl);
-        const deviceAuth = await requestDeviceAuthorization(anvilUrl);
-        const browserPrompt = createBrowserLaunchPrompt(pkceFlow.authUrl.toString());
-        let settled = false;
-        let spinnerStarted = false;
-        logger_logger.info(chalk_source.dim(`Logging in to ${anvilUrl}`));
-        console.log();
-        logger_logger.info(chalk_source.dim("Visit:"), `${deviceAuth.verification_uri_complete || deviceAuth.verification_uri}`);
-        logger_logger.info(chalk_source.dim("Device code:"), `${deviceAuth.user_code}`);
-        console.log();
-        logger_logger.info("OR Press ENTER to open a browser...");
-        browserPrompt.waitForOpen.then((opened)=>{
-            if (opened && !settled) {
-                spinnerStarted = true;
-                logger_logger.progress("login", "Waiting for login to complete...");
-            }
-        });
-        try {
-            const result = await raceLoginAttempts([
-                pkceFlow.waitForLogin,
-                pollDeviceAuthorization(anvilUrl, deviceAuth, {
-                    isCancelled: ()=>settled
-                }).then(async (tokenData)=>login(anvilUrl, {
-                        access_token: tokenData.access_token,
-                        refresh_token: tokenData.refresh_token,
-                        expires_in: tokenData.expires_in,
-                        scope: tokenData.scope
-                    }))
-            ]);
-            settled = true;
-            return result;
-        } finally{
-            settled = true;
-            browserPrompt.close();
-            if (spinnerStarted) logger_logger.progressEnd("login");
-            await pkceFlow.close();
-        }
-    }
     function getUrlConfigKey(appId) {
         return `anvil.auth.${appId}.url`;
     }
@@ -47034,539 +46343,6 @@ var __webpack_exports__ = {};
             cleanRemoteUrl
         };
     }
-    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}`));
-                });
-            });
-        }
-    };
-    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;
-            }
-            if ("\\" === ch) {
-                escaping = true;
-                continue;
-            }
-            if (quote) {
-                if (ch === quote) quote = null;
-                else current += ch;
-                continue;
-            }
-            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(" ");
-    }
-    function formatFallbackEditorLabel(preferredEditorCommand) {
-        const trimmed = preferredEditorCommand.trim();
-        if (!trimmed) return "your editor";
-        return trimmed;
-    }
-    async function path_open_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 ${formatFallbackEditorLabel(preferredEditorCommand)} automatically: ${errors_getErrorMessage(error)}.`);
-        }
-        else logger_logger.info(`Open ${formatFallbackEditorLabel(preferredEditorCommand)} to edit your app.`);
-        await deps.openSystem(targetPath);
-    }
-    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 parseNonNegativeMs(raw) {
-        if (null == raw) return null;
-        const parsed = Number(raw);
-        if (!Number.isFinite(parsed) || parsed < 0) return null;
-        return parsed;
-    }
-    function getCheckoutPickerDelayMs() {
-        const fromEnv = parseNonNegativeMs(process.env.ANVIL_CHECKOUT_PICKER_DELAY_MS);
-        if (null != fromEnv) return fromEnv;
-        return 0;
-    }
-    function getCheckoutPickerPaginationDelayMs() {
-        return getCheckoutPickerDelayMs();
-    }
-    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();
-        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
-        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();
-        const paginationDelayMs = getCheckoutPickerPaginationDelayMs();
-        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 isUpKey = (key, keybindings = [])=>'up' === key.name || keybindings.includes('vim') && 'k' === key.name || keybindings.includes('emacs') && key.ctrl && 'p' === key.name;
     const isDownKey = (key, keybindings = [])=>'down' === key.name || keybindings.includes('vim') && 'j' === key.name || keybindings.includes('emacs') && key.ctrl && 'n' === key.name;
     const isSpaceKey = (key)=>'space' === key.name;
@@ -49976,7 +48752,7 @@ var __webpack_exports__ = {};
     }
     createPromptModule();
     resolveAnvilUrl();
-    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
+    function watch_decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
         if (explicitUrl) return {
             source: "explicit",
             url: config_normalizeAnvilUrl(explicitUrl)
@@ -50003,7 +48779,6 @@ var __webpack_exports__ = {};
         getValidAuthToken: auth_getValidAuthToken,
         validateAppId: anvil_api_validateAppId,
         listAppsForCheckout: listAppsForCheckout,
-        runInteractiveLoginFlow: runInteractiveLoginFlow,
         clone: async (repoUrl, destinationPath, options)=>{
             const cloneArgs = [];
             if (options?.branch) cloneArgs.push("--branch", options.branch);
@@ -50016,9 +48791,6 @@ 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.");
@@ -50060,29 +48832,12 @@ var __webpack_exports__ = {};
         }
         return appId;
     }
-    async function resolveCheckoutUrl(explicitUrl, parsedUrl) {
-        if (explicitUrl) {
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from --url: ") + chalk_source.bold(config_normalizeAnvilUrl(explicitUrl)));
-            return config_normalizeAnvilUrl(explicitUrl);
-        }
-        if (parsedUrl) {
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from checkout input: ") + chalk_source.bold(config_normalizeAnvilUrl(parsedUrl)));
-            return config_normalizeAnvilUrl(parsedUrl);
-        }
-        const decision = decideFallbackUrl(void 0);
-        if ("available-multiple" !== decision.source) {
-            if (decision.url) logger_logger.verbose(chalk_source.cyan("Using configured Anvil URL: ") + chalk_source.bold(decision.url));
-            return decision.url;
-        }
-        const choices = decision.urls.map((url)=>({
-                name: url,
-                value: url
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
+    function resolveCheckoutUrlForApi(explicitUrl, parsedUrl) {
+        if (explicitUrl) return config_normalizeAnvilUrl(explicitUrl);
+        if (parsedUrl) return config_normalizeAnvilUrl(parsedUrl);
+        const decision = watch_decideFallbackUrl(void 0);
+        if ("available-multiple" === decision.source) throw new Error(`Multiple logged-in Anvil URLs found: ${decision.urls.join(", ")}. Use --url <ANVIL_URL> to choose one.`);
+        return decision.url;
     }
     async function isPathInsideGitRepo(targetPath) {
         const resolved = external_path_default().resolve(targetPath);
@@ -50122,64 +48877,31 @@ var __webpack_exports__ = {};
             logger_logger.verbose(chalk_source.cyan("Checking auth token for: ") + chalk_source.bold(username ? `${username} @ ${anvilUrl}` : anvilUrl));
             return await deps.getValidAuthToken(anvilUrl, username);
         } catch (e) {
-            const interactive = process.stdin.isTTY && process.stdout.isTTY;
-            if (!interactive) throw createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
-            const shouldLogin = await logger_logger.confirm(`Not logged in to ${anvilUrl}. Log in now?`, true);
-            if (!shouldLogin) throw createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
-            await deps.runInteractiveLoginFlow(anvilUrl);
-            return deps.getValidAuthToken(anvilUrl, username);
+            throw createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
         }
     }
-    async function resolveCheckoutUsername(anvilUrl, explicitUsername, getAccounts = auth_getAccountsForUrl) {
+    function resolveCheckoutUsernameForApi(anvilUrl, explicitUsername) {
         if (explicitUsername) return explicitUsername;
-        const accounts = getAccounts(anvilUrl);
+        const accounts = auth_getAccountsForUrl(anvilUrl);
         if (0 === accounts.length) return;
-        if (1 === accounts.length) {
-            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(accounts[0]));
-            return accounts[0];
-        }
-        const interactive = process.stdin.isTTY && process.stdout.isTTY;
-        if (!interactive) throw new Error(`Multiple accounts found for ${anvilUrl}. Use --user <USERNAME> to choose one.`);
-        const choices = accounts.map((acct)=>({
-                name: acct,
-                value: acct
-            }));
-        choices.push({
-            name: "Cancel",
-            value: null
-        });
-        return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0]);
+        if (1 === accounts.length) return accounts[0];
+        throw new Error(`Multiple accounts found for ${anvilUrl}: ${accounts.join(", ")}. Use --user <USERNAME> to choose one.`);
     }
     async function executeCheckout(options, deps = defaultCheckoutDeps) {
         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;
-        }
+        if (!checkoutInput) throw new Error("Checkout input is required. Pass an app ID, editor URL, or /git URL explicitly.");
         logger_logger.verbose(chalk_source.cyan("Checkout input: ") + chalk_source.bold(checkoutInput));
         const parsed = parseCheckoutInput(checkoutInput);
         logger_logger.verbose(chalk_source.cyan("Resolved app ID: ") + chalk_source.bold(parsed.appId));
-        const anvilUrl = preselectedAnvilUrl || await resolveCheckoutUrl(options.url, parsed.detectedUrl);
-        if (!anvilUrl) return void logger_logger.info("Checkout cancelled.");
-        const resolvedUsername = preselectedUsername || await resolveCheckoutUsername(anvilUrl, options.user);
-        if (null === resolvedUsername) return void logger_logger.info("Checkout cancelled.");
+        const anvilUrl = resolveCheckoutUrlForApi(options.url, parsed.detectedUrl);
+        if (!anvilUrl) throw new Error("Anvil URL is required. Use --url <ANVIL_URL> or pass an input URL containing the host.");
+        const resolvedUsername = resolveCheckoutUsernameForApi(anvilUrl, options.user);
         if (resolvedUsername) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(resolvedUsername));
         else logger_logger.verbose(chalk_source.cyan("No account preselected; resolving after auth token lookup."));
         const authToken = await ensureCheckoutAuthToken(anvilUrl, resolvedUsername, deps);
         let checkoutUsername = resolvedUsername;
         if (!checkoutUsername) {
-            const inferredUsername = await resolveCheckoutUsername(anvilUrl, void 0);
-            if (null === inferredUsername) return void logger_logger.info("Checkout cancelled.");
+            const inferredUsername = resolveCheckoutUsernameForApi(anvilUrl, void 0);
             if (!inferredUsername) throw new Error(`Could not determine account for ${anvilUrl}. Use --user <USERNAME> so checkout can bind repository credentials.`);
             checkoutUsername = inferredUsername;
         }
@@ -50199,8 +48921,6 @@ var __webpack_exports__ = {};
         if (options.branch) logger_logger.verbose(chalk_source.cyan("Requested branch: ") + chalk_source.bold(options.branch));
         if ("number" == typeof options.depth) logger_logger.verbose(chalk_source.cyan("Clone depth: ") + chalk_source.bold(String(options.depth)));
         if (options.singleBranch) logger_logger.verbose(chalk_source.cyan("Single-branch clone enabled"));
-        logger_logger.progress("checkout", `Checking out app ${parsed.appId} from ${anvilUrl}`);
-        logger_logger.info(chalk_source.gray(`   Destination directory: ${destinationDisplay}`));
         await deps.clone(cloneUrl, destinationPath, {
             branch: options.branch,
             depth: options.depth,
@@ -50222,18 +48942,15 @@ var __webpack_exports__ = {};
         } catch (e) {
             throw new Error(`Checkout clone succeeded, but failed to configure repository credentials: ${errors_getErrorMessage(e)}. The repository exists at ${destinationDisplay}, but Git auth bridge setup is incomplete.`);
         }
-        logger_logger.progressEnd("checkout", `Checked out ${parsed.appId} into ${destinationDisplay}`);
-        const preferredEditor = String(config_getConfig("preferredEditor") || "").trim();
-        const preferredEditorCommand = preferredEditor ? config_getPreferredEditorCommand(preferredEditor) : "";
-        if (options.open) {
-            await checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand);
-            logger_logger.info(chalk_source.gray(`Opened ${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 checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps) {
-        await path_open_openPathInEditorOrDefault(destinationPath, preferredEditorCommand, deps);
+        return {
+            appId: parsed.appId,
+            appName: validation.app_name,
+            anvilUrl,
+            destinationPath,
+            destinationDisplay,
+            username: checkoutUsername,
+            remoteName
+        };
     }
     const api_DEFAULT_ANVIL_URL = resolveAnvilUrl();
     async function api_checkUncommittedChanges(repoPath) {
@@ -50256,7 +48973,8 @@ var __webpack_exports__ = {};
             throw errors_createGitError.commandFailed("status", e.message);
         }
     }
-    async function src_api_syncToLatest(repoPath, appId, anvilUrl, authToken, currentBranch, username) {
+    async function src_api_syncToLatest(repoPath, appId, options) {
+        const { anvilUrl, authToken, currentBranch, username } = options;
         try {
             const git = esm_default(repoPath);
             const commitId = (await git.revparse([
@@ -50280,7 +48998,8 @@ var __webpack_exports__ = {};
             throw errors_createGitError.commandFailed("sync", e instanceof Error ? e.message : String(e));
         }
     }
-    async function src_api_watch(repoPath, appId, anvilUrl = api_DEFAULT_ANVIL_URL, stagedOnly = false, username) {
+    async function src_api_watch(repoPath, appId, options = {}) {
+        const { anvilUrl = api_DEFAULT_ANVIL_URL, stagedOnly = false, username } = options;
         repoPath = external_path_default().resolve(repoPath);
         const authToken = await auth_getValidAuthToken(anvilUrl, username);
         await auth_verifyAuth(authToken, anvilUrl);
@@ -50307,7 +49026,11 @@ var __webpack_exports__ = {};
         }
         logger_logger.verbose(chalk_source.cyan("Current branch: ") + chalk_source.bold(currentBranch));
         logger_logger.verbose(chalk_source.cyan("Current commit ID: ") + chalk_source.gray(commitId));
-        const syncStatus = await validation_validateBranchSyncStatus(git, currentBranch, appId, anvilUrl, username);
+        const syncStatus = await validation_validateBranchSyncStatus(git, currentBranch, {
+            appId,
+            anvilUrl,
+            username
+        });
         let hasUncommittedChanges = false;
         try {
             const status = await git.status();
@@ -50352,6 +49075,7 @@ var __webpack_exports__ = {};
         return session;
     }
 })();
+exports.ANVIL_SYNC_CLIENT_ID = __webpack_exports__.ANVIL_SYNC_CLIENT_ID;
 exports.AnvilYamlValidationResult = __webpack_exports__.AnvilYamlValidationResult;
 exports.AppIdCandidate = __webpack_exports__.AppIdCandidate;
 exports.AppIdWithContext = __webpack_exports__.AppIdWithContext;
@@ -50360,6 +49084,7 @@ exports.CheckoutAppListItem = __webpack_exports__.CheckoutAppListItem;
 exports.CheckoutCloneOptions = __webpack_exports__.CheckoutCloneOptions;
 exports.CheckoutExecutionDeps = __webpack_exports__.CheckoutExecutionDeps;
 exports.CheckoutOptions = __webpack_exports__.CheckoutOptions;
+exports.CheckoutResult = __webpack_exports__.CheckoutResult;
 exports.DeviceAuthorizationResponse = __webpack_exports__.DeviceAuthorizationResponse;
 exports.FormTemplateValidationResult = __webpack_exports__.FormTemplateValidationResult;
 exports.LoginResult = __webpack_exports__.LoginResult;
@@ -50371,14 +49096,15 @@ exports.SettableConfigKey = __webpack_exports__.SettableConfigKey;
 exports.StoredTokens = __webpack_exports__.StoredTokens;
 exports.TokenData = __webpack_exports__.TokenData;
 exports.ValidateAppIdResponse = __webpack_exports__.ValidateAppIdResponse;
+exports.ValidateBranchSyncStatusOptions = __webpack_exports__.ValidateBranchSyncStatusOptions;
 exports.ValidatePathResult = __webpack_exports__.ValidatePathResult;
 exports.ValidationIssue = __webpack_exports__.ValidationIssue;
 exports.ValidationTarget = __webpack_exports__.ValidationTarget;
+exports.WatchSession = __webpack_exports__.WatchSession;
 exports.checkUncommittedChanges = __webpack_exports__.checkUncommittedChanges;
 exports.deleteConfig = __webpack_exports__.deleteConfig;
 exports.detectAppIdsByCommitLookup = __webpack_exports__.detectAppIdsByCommitLookup;
 exports.detectAppIdsFromAllRemotes = __webpack_exports__.detectAppIdsFromAllRemotes;
-exports.ensureCheckoutAuthToken = __webpack_exports__.ensureCheckoutAuthToken;
 exports.executeCheckout = __webpack_exports__.executeCheckout;
 exports.filterCandidates = __webpack_exports__.filterCandidates;
 exports.formatCandidateLabel = __webpack_exports__.formatCandidateLabel;
@@ -50407,7 +49133,6 @@ exports.logout = __webpack_exports__.logout;
 exports.lookupByCommit = __webpack_exports__.lookupByCommit;
 exports.lookupRemoteInfoForAppId = __webpack_exports__.lookupRemoteInfoForAppId;
 exports.normalizeAnvilUrl = __webpack_exports__.normalizeAnvilUrl;
-exports.openPathInEditorOrDefault = __webpack_exports__.openPathInEditorOrDefault;
 exports.parseCheckoutInput = __webpack_exports__.parseCheckoutInput;
 exports.parseConfigSetValue = __webpack_exports__.parseConfigSetValue;
 exports.pollDeviceAuthorization = __webpack_exports__.pollDeviceAuthorization;
@@ -50415,9 +49140,6 @@ exports.preferredEditors = __webpack_exports__.preferredEditors;
 exports.requestDeviceAuthorization = __webpack_exports__.requestDeviceAuthorization;
 exports.resetConfig = __webpack_exports__.resetConfig;
 exports.resolveAnvilUrl = __webpack_exports__.resolveAnvilUrl;
-exports.resolveCheckoutUrl = __webpack_exports__.resolveCheckoutUrl;
-exports.resolveCheckoutUsername = __webpack_exports__.resolveCheckoutUsername;
-exports.runInteractiveLoginFlow = __webpack_exports__.runInteractiveLoginFlow;
 exports.sanitizeDirectoryName = __webpack_exports__.sanitizeDirectoryName;
 exports.saveUpdates = __webpack_exports__.saveUpdates;
 exports.setAuthTokensForAccount = __webpack_exports__.setAuthTokensForAccount;
@@ -50433,6 +49155,7 @@ exports.validatePath = __webpack_exports__.validatePath;
 exports.verifyAuth = __webpack_exports__.verifyAuth;
 exports.watch = __webpack_exports__.watch;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ANVIL_SYNC_CLIENT_ID",
     "AnvilYamlValidationResult",
     "AppIdCandidate",
     "AppIdWithContext",
@@ -50441,6 +49164,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CheckoutCloneOptions",
     "CheckoutExecutionDeps",
     "CheckoutOptions",
+    "CheckoutResult",
     "DeviceAuthorizationResponse",
     "FormTemplateValidationResult",
     "LoginResult",
@@ -50452,14 +49176,15 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "StoredTokens",
     "TokenData",
     "ValidateAppIdResponse",
+    "ValidateBranchSyncStatusOptions",
     "ValidatePathResult",
     "ValidationIssue",
     "ValidationTarget",
+    "WatchSession",
     "checkUncommittedChanges",
     "deleteConfig",
     "detectAppIdsByCommitLookup",
     "detectAppIdsFromAllRemotes",
-    "ensureCheckoutAuthToken",
     "executeCheckout",
     "filterCandidates",
     "formatCandidateLabel",
@@ -50488,7 +49213,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "lookupByCommit",
     "lookupRemoteInfoForAppId",
     "normalizeAnvilUrl",
-    "openPathInEditorOrDefault",
     "parseCheckoutInput",
     "parseConfigSetValue",
     "pollDeviceAuthorization",
@@ -50496,9 +49220,6 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "requestDeviceAuthorization",
     "resetConfig",
     "resolveAnvilUrl",
-    "resolveCheckoutUrl",
-    "resolveCheckoutUsername",
-    "runInteractiveLoginFlow",
     "sanitizeDirectoryName",
     "saveUpdates",
     "setAuthTokensForAccount",