@anvil-works/anvil-cli 0.6.3 → 0.7.0-canary.1

package/dist/cli.js

@@ -42250,12 +42250,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;
@@ -42319,7 +42320,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);
@@ -42600,6 +42602,10 @@ var __webpack_exports__ = {};
     function getGlobalOutputConfig() {
         return globalOutputConfig;
     }
+    function 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 verboseTimestamp = ()=>{
         const now = new Date();
@@ -42706,14 +42712,32 @@ var __webpack_exports__ = {};
         resume() {
             this.paused = false;
         }
-        async prompt(questions) {
+        async prompt(questions, options) {
+            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();
@@ -42854,7 +42878,8 @@ var __webpack_exports__ = {};
         setVerbose(value) {
             this.sessionVerbose = value;
         }
-        async prompt(questions) {
+        async prompt(questions, options) {
+            assertCanPrompt(options?.action ?? "Prompt", options?.nonInteractiveHint);
             this.pause();
             try {
                 return await inquirer_dist_esm.prompt(questions);
@@ -42862,7 +42887,7 @@ var __webpack_exports__ = {};
                 this.resume();
             }
         }
-        async confirm(message, defaultValue = true) {
+        async confirm(message, defaultValue = true, options) {
             const answer = await this.prompt([
                 {
                     type: "confirm",
@@ -42870,10 +42895,10 @@ var __webpack_exports__ = {};
                     message,
                     default: defaultValue
                 }
-            ]);
+            ], options);
             return answer.value;
         }
-        async select(message, choices, defaultValue) {
+        async select(message, choices, defaultValue, options) {
             const answer = await this.prompt([
                 {
                     type: "list",
@@ -42883,7 +42908,7 @@ var __webpack_exports__ = {};
                     default: defaultValue,
                     loop: false
                 }
-            ]);
+            ], options);
             return answer.value;
         }
     }
@@ -47243,6 +47268,7 @@ var __webpack_exports__ = {};
     function getDefaultAnvilUrl() {
         return resolveAnvilUrl();
     }
+    const ANVIL_SYNC_CLIENT_ID = "anvil-sync";
     async function verifyAuth(authToken, anvilUrl = getDefaultAnvilUrl()) {
         try {
             const resp = await fetch(`${anvilUrl}/ide/api/_/user`, {
@@ -47262,7 +47288,7 @@ var __webpack_exports__ = {};
             throw errors_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",
@@ -47272,7 +47298,7 @@ var __webpack_exports__ = {};
                 body: new URLSearchParams({
                     grant_type: "refresh_token",
                     refresh_token: refreshToken,
-                    client_id: "anvil-sync"
+                    client_id: clientId
                 })
             });
             if (!tokenResponse.ok) {
@@ -47295,7 +47321,8 @@ var __webpack_exports__ = {};
         if (!tokens.authToken && !tokens.refreshToken) throw errors_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) {
@@ -47312,7 +47339,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) {
@@ -47337,7 +47365,8 @@ var __webpack_exports__ = {};
         setAccountTokens(normalized, username, {
             authToken: tokenData.access_token,
             refreshToken: tokenData.refresh_token,
-            authTokenExpiresAt: expiresAt
+            authTokenExpiresAt: expiresAt,
+            clientId: ANVIL_SYNC_CLIENT_ID
         });
         return {
             success: true,
@@ -48731,7 +48760,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) {
@@ -48819,7 +48850,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 {
@@ -48977,7 +49009,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",
@@ -48990,9 +49023,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");
@@ -49011,47 +49047,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 = [];
@@ -49060,10 +49109,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 = [
@@ -49075,10 +49124,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 = [
@@ -49092,10 +49141,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");
@@ -49113,10 +49162,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";
@@ -49125,7 +49174,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 = [
@@ -49173,7 +49225,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)"
@@ -49217,13 +49271,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 {
@@ -49235,7 +49291,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 = [
@@ -49248,7 +49306,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]);
@@ -49266,7 +49326,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;
@@ -49304,8 +49366,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);
@@ -49327,8 +49391,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");
@@ -49353,8 +49419,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({
@@ -49372,30 +49440,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",
@@ -49430,8 +49515,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: "",
@@ -49465,7 +49552,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",
@@ -49473,7 +49562,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({
@@ -49489,7 +49581,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");
@@ -49916,7 +50010,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
                 ];
@@ -50103,7 +50205,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
                 ];
@@ -50637,22 +50747,28 @@ var __webpack_exports__ = {};
             appName
         };
     }
-    async function validateBranchSyncStatus(git, branchName, appId, anvilUrl, username) {
+    async function 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`;
@@ -50713,7 +50829,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;
@@ -51378,7 +51495,7 @@ var __webpack_exports__ = {};
     </body>
   </html>`;
     }
-    const CLIENT_ID = "anvil-sync";
+    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(/=+$/, "");
@@ -51441,7 +51558,8 @@ var __webpack_exports__ = {};
             return text;
         }
     }
-    async function exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier) {
+    async function exchangeAuthorizationCodeForTokens(anvilUrl, options) {
+        const { redirectUri, code, codeVerifier } = options;
         const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
             method: "POST",
             headers: {
@@ -51569,7 +51687,11 @@ var __webpack_exports__ = {};
                 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);
+                const tokenData = await exchangeAuthorizationCodeForTokens(anvilUrl, {
+                    redirectUri,
+                    code: code,
+                    codeVerifier
+                });
                 return login(anvilUrl, {
                     access_token: tokenData.access_token,
                     refresh_token: tokenData.refresh_token,
@@ -52309,7 +52431,6 @@ var __webpack_exports__ = {};
         getValidAuthToken: auth_getValidAuthToken,
         validateAppId: validateAppId,
         listAppsForCheckout: listAppsForCheckout,
-        runInteractiveLoginFlow: runInteractiveLoginFlow,
         clone: async (repoUrl, destinationPath, options)=>{
             const cloneArgs = [];
             if (options?.branch) cloneArgs.push("--branch", options.branch);
@@ -52322,9 +52443,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.");
@@ -52388,7 +52506,17 @@ var __webpack_exports__ = {};
             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]);
+        return logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0], {
+            action: "`anvil checkout` URL selection",
+            nonInteractiveHint: `Use --url <ANVIL_URL>. Available URLs: ${decision.urls.join(", ")}.`
+        });
+    }
+    function resolveCheckoutUrlForApi(explicitUrl, parsedUrl) {
+        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
+        if (parsedUrl) return normalizeAnvilUrl(parsedUrl);
+        const decision = 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);
@@ -52428,11 +52556,17 @@ 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 errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
+            throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
+        }
+    }
+    async function ensureCheckoutAuthTokenInteractive(anvilUrl, username, deps = defaultCheckoutDeps) {
+        try {
+            return await ensureCheckoutAuthToken(anvilUrl, username, deps);
+        } catch (e) {
+            assertCanPrompt("`anvil checkout` login prompt", `Run 'anvil login ${anvilUrl}' before checkout.`);
             const shouldLogin = await logger_logger.confirm(`Not logged in to ${anvilUrl}. Log in now?`, true);
-            if (!shouldLogin) throw errors_createAuthError.required(`Not logged in to ${anvilUrl}. Run 'anvil login ${anvilUrl}' and retry.`);
-            await deps.runInteractiveLoginFlow(anvilUrl);
+            if (!shouldLogin) throw e;
+            await runInteractiveLoginFlow(anvilUrl);
             return deps.getValidAuthToken(anvilUrl, username);
         }
     }
@@ -52444,8 +52578,6 @@ var __webpack_exports__ = {};
             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
@@ -52454,38 +52586,33 @@ var __webpack_exports__ = {};
             name: "Cancel",
             value: null
         });
-        return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0]);
+        return logger_logger.select(`Multiple accounts found for ${anvilUrl}. Which account should be used for checkout?`, choices, accounts[0], {
+            action: "`anvil checkout` account selection",
+            nonInteractiveHint: `Use --user <USERNAME>. Available accounts: ${accounts.join(", ")}.`
+        });
+    }
+    function resolveCheckoutUsernameForApi(anvilUrl, explicitUsername) {
+        if (explicitUsername) return explicitUsername;
+        const accounts = auth_getAccountsForUrl(anvilUrl);
+        if (0 === accounts.length) return;
+        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;
         }
@@ -52505,8 +52632,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,
@@ -52528,14 +52653,57 @@ 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}`);
+        return {
+            appId: parsed.appId,
+            appName: validation.app_name,
+            anvilUrl,
+            destinationPath,
+            destinationDisplay,
+            username: checkoutUsername,
+            remoteName
+        };
+    }
+    async function executeCheckoutInteractive(options, deps = defaultCheckoutDeps) {
+        let checkoutInput = options.input?.trim();
+        let preselectedAnvilUrl;
+        let preselectedUsername;
+        if (!checkoutInput) {
+            assertCanPrompt("`anvil checkout` without arguments", "Pass an app ID, editor URL, or /git URL. Use --url <ANVIL_URL> and --user <USERNAME> if needed.");
+            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;
+        }
+        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.");
+        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."));
+        await ensureCheckoutAuthTokenInteractive(anvilUrl, resolvedUsername, deps);
+        logger_logger.progress("checkout", `Checking out app ${parsed.appId} from ${anvilUrl}`);
+        const result = await executeCheckout({
+            ...options,
+            input: checkoutInput,
+            url: anvilUrl,
+            user: resolvedUsername || options.user
+        }, deps);
+        logger_logger.progressEnd("checkout", `Checked out ${result.appId} into ${result.destinationDisplay}`);
         const preferredEditor = String(getConfig("preferredEditor") || "").trim();
         const preferredEditorCommand = preferredEditor ? getPreferredEditorCommand(preferredEditor) : "";
         if (options.open) {
-            await checkout_openPathInEditorOrDefault(destinationPath, preferredEditorCommand);
-            logger_logger.info(chalk_source.gray(`Opened ${destinationDisplay}`));
+            await checkout_openPathInEditorOrDefault(result.destinationPath, preferredEditorCommand);
+            logger_logger.info(chalk_source.gray(`Opened ${result.destinationDisplay}`));
         }
-        if (preferredEditorCommand && !options.open) if (isCommandAvailable(preferredEditorCommand)) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${destinationDisplay}`));
+        if (preferredEditorCommand && !options.open) if (isCommandAvailable(preferredEditorCommand)) logger_logger.info(chalk_source.cyan(`Next: ${preferredEditorCommand} ${result.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) {
@@ -52546,7 +52714,7 @@ var __webpack_exports__ = {};
             try {
                 const globalOptions = command?.optsWithGlobals() || options || {};
                 if ("number" == typeof options?.depth && (!Number.isFinite(options.depth) || options.depth <= 0)) throw new Error("--depth must be a positive integer");
-                await executeCheckout({
+                await executeCheckoutInteractive({
                     input,
                     directory,
                     open: options?.open,
@@ -52569,7 +52737,8 @@ var __webpack_exports__ = {};
         checkoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + '\n  anvil checkout http://localhost:3000/build/apps/APPID/code/assets/theme.css\n  anvil checkout https://anvil.works/git/APPID.git\n  anvil checkout APPID --url anvil.works\n  anvil checkout APPID --branch master --depth 1 --single-branch\n  anvil checkout APPID -O  # open editor/file browser after checkout\n  anvil checkout APPID my-local-folder --force\n  anvil checkout  # interactive search/select app list\n  anvil checkout -Q "dashboard"  # preseed picker search\n');
     }
     const DEFAULT_ANVIL_URL = resolveAnvilUrl();
-    async function syncToLatest(repoPath, appId, anvilUrl, authToken, currentBranch, username) {
+    async function syncToLatest(repoPath, appId, options) {
+        const { anvilUrl, authToken, currentBranch, username } = options;
         try {
             const git = esm_default(repoPath);
             const commitId = (await git.revparse([
@@ -52593,7 +52762,8 @@ var __webpack_exports__ = {};
             throw errors_createGitError.commandFailed("sync", e instanceof Error ? e.message : String(e));
         }
     }
-    async function api_watch(repoPath, appId, anvilUrl = DEFAULT_ANVIL_URL, stagedOnly = false, username) {
+    async function api_watch(repoPath, appId, options = {}) {
+        const { anvilUrl = DEFAULT_ANVIL_URL, stagedOnly = false, username } = options;
         repoPath = external_path_default().resolve(repoPath);
         const authToken = await auth_getValidAuthToken(anvilUrl, username);
         await verifyAuth(authToken, anvilUrl);
@@ -52620,7 +52790,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 validateBranchSyncStatus(git, currentBranch, appId, anvilUrl, username);
+        const syncStatus = await validateBranchSyncStatus(git, currentBranch, {
+            appId,
+            anvilUrl,
+            username
+        });
         let hasUncommittedChanges = false;
         try {
             const status = await git.status();
@@ -52969,7 +53143,11 @@ var __webpack_exports__ = {};
     async function recheckSyncStatus(previousCategory, previousBranch, options) {
         try {
             logger_logger.progress("verify", "Verifying repository status...");
-            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            const freshSession = await api_watch(options.repoPath, options.appId, {
+                anvilUrl: options.anvilUrl,
+                stagedOnly: options.stagedOnly,
+                username: options.username
+            });
             logger_logger.progressEnd("verify");
             const currentCategory = getSyncStateCategory(freshSession.syncStatus);
             const currentBranch = freshSession.getBranchName() || "master";
@@ -52988,7 +53166,11 @@ var __webpack_exports__ = {};
     async function recreateSessionAndValidate(options) {
         logger_logger.progress("init", "Restarting watch session...");
         try {
-            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            const newSession = await api_watch(options.repoPath, options.appId, {
+                anvilUrl: options.anvilUrl,
+                stagedOnly: options.stagedOnly,
+                username: options.username
+            });
             logger_logger.progressEnd("init");
             return await checkSyncStatusAndStart(newSession, options);
         } catch (e) {
@@ -53201,7 +53383,12 @@ var __webpack_exports__ = {};
             }
             logger_logger.progress("sync-latest", "Syncing to latest version from Anvil...");
             try {
-                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
+                const newCommitId = await syncToLatest(options.repoPath, options.appId, {
+                    anvilUrl: options.anvilUrl,
+                    authToken,
+                    currentBranch: branchName,
+                    username: options.username
+                });
                 logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
             } catch (e) {
                 logger_logger.progressEnd("sync-latest", "Failed");
@@ -53228,7 +53415,11 @@ var __webpack_exports__ = {};
                 if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
                 logger_logger.progress("init", "Initializing watch session...");
                 try {
-                    const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
+                    const newSession = await api_watch(repoPath, appId, {
+                        anvilUrl,
+                        stagedOnly,
+                        username: options.username
+                    });
                     logger_logger.progressEnd("init");
                     const started = await checkSyncStatusAndStart(newSession, options);
                     if (!started) process.exit(0);
@@ -53441,7 +53632,11 @@ var __webpack_exports__ = {};
             if (stagedOnly) logger_logger.info(chalk_source.yellow("▸ Staged-only mode: Only staged changes will be synced"));
             if (autoMode) logger_logger.info(chalk_source.cyan("▸ Auto mode: Will automatically restart on branch changes and sync when behind"));
             logger_logger.progress("init", "Initializing watch session...");
-            const session = await api_watch(repoPath, finalAppId, anvilUrl, stagedOnly, username);
+            const session = await api_watch(repoPath, finalAppId, {
+                anvilUrl,
+                stagedOnly,
+                username
+            });
             logger_logger.progressEnd("init");
             if (openAfterValidation) await openWatchPath(resolveWatchOpenPath(repoPath));
             logger_logger.verbose(chalk_source.blue("Watching for file changes..."));
@@ -53897,11 +54092,8 @@ var __webpack_exports__ = {};
         if (1 === accounts.length) return accounts[0];
         return `${accounts.length} accounts`;
     }
-    function configure_isInteractiveSession() {
-        return !!(process.stdin.isTTY && process.stdout.isTTY);
-    }
     async function runConfigureFlow(version, deps = configure_defaultDeps) {
-        if (!configure_isInteractiveSession()) throw new Error("`anvil configure` is interactive and requires a TTY terminal.");
+        assertCanPrompt("`anvil configure`", "Use `anvil config set anvilUrl <URL>`, `anvil config set preferredEditor <COMMAND>`, `anvil config set verbose <true|false>`, and `anvil login <URL>` instead.");
         console.log();
         logger_logger.info(chalk_source.cyan.bold("Anvil Configuration"));
         console.log();