@anvil-works/anvil-cli 0.3.9 → 0.3.11

package/dist/cli.js

@@ -44259,7 +44259,10 @@ var __webpack_exports__ = {};
             const handlers = this.listeners.get(event);
             if (handlers) handlers.forEach((handler)=>{
                 try {
-                    handler(data);
+                    const result = handler(data);
+                    if (result && "function" == typeof result.catch) result.catch((error)=>{
+                        this.onError(String(event), error);
+                    });
                 } catch (error) {
                     this.onError(String(event), error);
                 }
@@ -44334,7 +44337,7 @@ var __webpack_exports__ = {};
                 files
             })
     };
-    const createGitError = {
+    const errors_createGitError = {
         notInitialized: (path)=>({
                 type: "git_not_initialized",
                 path
@@ -44520,7 +44523,7 @@ var __webpack_exports__ = {};
                 if (!external_path_default().isAbsolute(gitDir)) return external_path_default().resolve(this.repoPath, gitDir);
                 return gitDir;
             } catch (e) {
-                throw createGitError.commandFailed("rev-parse --git-dir", e.message);
+                throw errors_createGitError.commandFailed("rev-parse --git-dir", e.message);
             }
         }
         async getCurrentBranch() {
@@ -44543,7 +44546,7 @@ var __webpack_exports__ = {};
                 ])).trim();
                 return commitId;
             } catch (e) {
-                throw createGitError.commandFailed("revparse", e.message);
+                throw errors_createGitError.commandFailed("revparse", e.message);
             }
         }
         async getCommitInfo() {
@@ -44562,7 +44565,7 @@ var __webpack_exports__ = {};
                     message
                 };
             } catch (e) {
-                throw createGitError.commandFailed("log", e.message);
+                throw errors_createGitError.commandFailed("log", e.message);
             }
         }
         async getStatus() {
@@ -44582,7 +44585,7 @@ var __webpack_exports__ = {};
                     renamed: status.renamed || []
                 };
             } catch (e) {
-                throw createGitError.commandFailed("status", e.message);
+                throw errors_createGitError.commandFailed("status", e.message);
             }
         }
         async hasUncommittedChanges() {
@@ -44596,7 +44599,7 @@ var __webpack_exports__ = {};
                     refSpec
                 ]);
             } catch (e) {
-                throw createGitError.fetchFailed(e.message);
+                throw errors_createGitError.fetchFailed(e.message);
             }
         }
         async reset(ref, mode = "mixed") {
@@ -44606,21 +44609,45 @@ var __webpack_exports__ = {};
                     ref
                 ]);
             } catch (e) {
-                throw createGitError.commandFailed("reset", e.message);
+                throw errors_createGitError.commandFailed("reset", e.message);
             }
         }
         async checkout(paths) {
             try {
                 await this.git.checkout(paths);
             } catch (e) {
-                throw createGitError.commandFailed("checkout", e.message);
+                throw errors_createGitError.commandFailed("checkout", e.message);
+            }
+        }
+        async stash(message) {
+            try {
+                const args = [
+                    "stash",
+                    "push",
+                    "--include-untracked"
+                ];
+                if (message) args.push("-m", message);
+                const result = await this.git.raw(args);
+                return !result.includes("No local changes to save");
+            } catch (e) {
+                throw errors_createGitError.commandFailed("stash", e.message);
+            }
+        }
+        async stashPop() {
+            try {
+                await this.git.raw([
+                    "stash",
+                    "pop"
+                ]);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("stash pop", e.message);
             }
         }
         async clean(files) {
             try {
                 await this.git.clean(CleanOptions.FORCE, files);
             } catch (e) {
-                throw createGitError.commandFailed("clean", e.message);
+                throw errors_createGitError.commandFailed("clean", e.message);
             }
         }
         async diffNames(fromCommit, toCommit) {
@@ -44633,7 +44660,7 @@ var __webpack_exports__ = {};
                 const files = diffResult.split("\n").filter((f)=>f.trim());
                 return files;
             } catch (e) {
-                throw createGitError.commandFailed("diff", e.message);
+                throw errors_createGitError.commandFailed("diff", e.message);
             }
         }
         async getAheadBehind(localRef, remoteRef) {
@@ -44650,7 +44677,7 @@ var __webpack_exports__ = {};
                     behind
                 };
             } catch (e) {
-                throw createGitError.commandFailed("rev-list", e.message);
+                throw errors_createGitError.commandFailed("rev-list", e.message);
             }
         }
         async show(refPath) {
@@ -44660,7 +44687,44 @@ var __webpack_exports__ = {};
                 ]);
                 return content;
             } catch (e) {
-                throw createGitError.commandFailed("show", e.message);
+                throw errors_createGitError.commandFailed("show", e.message);
+            }
+        }
+        async push(url, refSpec, force = false) {
+            try {
+                const args = force ? [
+                    "push",
+                    "--force",
+                    url,
+                    refSpec
+                ] : [
+                    "push",
+                    url,
+                    refSpec
+                ];
+                await this.git.raw(args);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("push", e.message);
+            }
+        }
+        async rebase(onto) {
+            try {
+                await this.git.raw([
+                    "rebase",
+                    onto
+                ]);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("rebase", e.message);
+            }
+        }
+        async rebaseAbort() {
+            try {
+                await this.git.raw([
+                    "rebase",
+                    "--abort"
+                ]);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("rebase --abort", e.message);
             }
         }
         async deleteRef(ref) {
@@ -44680,7 +44744,7 @@ var __webpack_exports__ = {};
                         fetchUrl: r.refs.fetch
                     }));
             } catch (e) {
-                throw createGitError.commandFailed("remote", e.message);
+                throw errors_createGitError.commandFailed("remote", e.message);
             }
         }
         async isGitInitialized() {
@@ -44741,7 +44805,7 @@ var __webpack_exports__ = {};
             changes.push(...stagedRenames);
             return changes;
         } catch (e) {
-            throw createGitError.commandFailed("status", e.message);
+            throw errors_createGitError.commandFailed("status", e.message);
         }
     }
     function normalizeLineEndings(content) {
@@ -46521,6 +46585,11 @@ var __webpack_exports__ = {};
         const encodedToken = encodeURIComponent(authToken);
         return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git?no_freeze=true&q=`;
     }
+    function getGitPushUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
+        const url = new URL(anvilUrl);
+        const encodedToken = encodeURIComponent(authToken);
+        return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git`;
+    }
     function getWebSocketUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
         return anvilUrl.replace(/^http/, "ws") + `/ide/api/_/apps/${appId}/ws?access_token=${authToken}`;
     }
@@ -46725,7 +46794,13 @@ var __webpack_exports__ = {};
                 if (this.reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS) {
                     this.reconnectAttempts++;
                     logger_logger.verbose(chalk_source.gray(`WebSocket disconnected, reconnecting in ${this.RECONNECT_DELAY / 1000}s (attempt ${this.reconnectAttempts}/${this.MAX_RECONNECT_ATTEMPTS})...`));
-                    this.reconnectTimer = setTimeout(()=>this.connect(), this.RECONNECT_DELAY);
+                    this.reconnectTimer = setTimeout(()=>{
+                        this.connect().catch((error)=>{
+                            this.emit("error", {
+                                error: error instanceof Error ? error : new Error(String(error))
+                            });
+                        });
+                    }, this.RECONNECT_DELAY);
                 } else logger_logger.warn(chalk_source.yellow(` WebSocket reconnection failed after ${this.MAX_RECONNECT_ATTEMPTS} attempts. Real-time sync disabled.`));
             });
             this.ws.on("error", (error)=>{
@@ -47897,7 +47972,11 @@ var __webpack_exports__ = {};
             this.hasPendingChanges = true;
             if (this.debounceTimer) clearTimeout(this.debounceTimer);
             if (isFirstChange) logger_logger.progress("sync", "Change detected");
-            this.debounceTimer = setTimeout(()=>this.processSaveBatchWithEvents(), this.SAVE_DEBOUNCE_MS);
+            this.debounceTimer = setTimeout(()=>{
+                this.processSaveBatchWithEvents().catch((error)=>{
+                    logger_logger.error(`Save failed: ${errors_getErrorMessage(error)}`);
+                });
+            }, this.SAVE_DEBOUNCE_MS);
         }
         async forceSave() {
             if (this.debounceTimer) {
@@ -48264,8 +48343,11 @@ var __webpack_exports__ = {};
         }
         async handleConflict(json_resp, originalFilePaths, retryCount) {
             if (retryCount >= this.MAX_RETRIES) {
-                logger_logger.error(`Save failed after ${this.MAX_RETRIES} retries - version conflict`);
-                logger_logger.warn("Please resolve conflicts manually or restart anvil sync");
+                logger_logger.error(`Save failed after ${this.MAX_RETRIES} retries due to version conflicts.`);
+                logger_logger.warn("This usually means someone else is editing the app at the same time.");
+                this.emit("max-retries-exceeded", {
+                    retries: this.MAX_RETRIES
+                });
                 throw createSaveError.maxRetriesExceeded(this.MAX_RETRIES);
             }
             let conflictReason = "Unknown conflict";
@@ -48600,6 +48682,7 @@ var __webpack_exports__ = {};
             this.saveProcessor.on("save-complete", (data)=>this.emit("save-complete", data));
             this.saveProcessor.on("validation-failed", (data)=>this.emit("validation-failed", data));
             this.saveProcessor.on("sync-conflict", (data)=>this.emit("sync-conflict", data));
+            this.saveProcessor.on("max-retries-exceeded", (data)=>this.emit("max-retries-exceeded", data));
         }
         async connectWebSocket() {
             this.wsClient = new WebSocketClient({
@@ -48672,7 +48755,11 @@ var __webpack_exports__ = {};
                 this.saveProcessor?.queueSave();
             });
             this.fileWatcher.on("file-change", async ({ event, path: filePath, relativePath })=>{
-                await this.handleFileChange(event, filePath, relativePath);
+                try {
+                    await this.handleFileChange(event, filePath, relativePath);
+                } catch (error) {
+                    logger_logger.error(`Error handling file change for ${relativePath}: ${error.message}`);
+                }
             });
             await this.fileWatcher.start(this.currentBranch);
             await new Promise(()=>{});
@@ -48826,7 +48913,7 @@ var __webpack_exports__ = {};
             logger_logger.verbose(chalk_source.green(`✔ Branch '${branchName}' is up-to-date with Anvil.`));
             return null;
         } catch (e) {
-            throw createGitError.fetchFailed(e.message);
+            throw errors_createGitError.fetchFailed(e.message);
         }
     }
     async function validateViaAnvilServer(git, branchName, appId, anvilUrl, username) {
@@ -48838,7 +48925,7 @@ var __webpack_exports__ = {};
                 "HEAD"
             ])).trim();
         } catch (e) {
-            throw createGitError.commandFailed("revparse", e.message);
+            throw errors_createGitError.commandFailed("revparse", e.message);
         }
         try {
             const resp = await fetch(`${anvilUrl}/ide/api/_/apps/lookup-by-commit`, {
@@ -48862,7 +48949,12 @@ var __webpack_exports__ = {};
             }
             const allBranches = data.apps?.flatMap((app)=>app.branches || []) || [];
             const branchExistsOnAnvil = allBranches.some((b)=>b === branchName);
-            if (!branchExistsOnAnvil) throw createValidationError.invalidApp(branchName, `Branch '${branchName}' doesn't exist on Anvil yet. Push to Anvil first: git push anvil ${branchName}`);
+            if (!branchExistsOnAnvil) return {
+                behind: 0,
+                ahead: 0,
+                diverged: false,
+                branchMissing: true
+            };
             throw createValidationError.invalidApp(appId, `Anvil server doesn't recognize commit ${commitId.substring(0, 8)} on branch '${branchName}'. Please pull the latest changes from Anvil before starting sync.`);
         } catch (e) {
             if (e.type) throw e;
@@ -48870,26 +48962,6 @@ var __webpack_exports__ = {};
         }
     }
     const DEFAULT_ANVIL_URL = resolveAnvilUrl();
-    async function checkUncommittedChanges(repoPath) {
-        try {
-            const git = esm_default(repoPath);
-            const status = await git.status();
-            const staged = status.files.filter((file)=>{
-                const indexStatus = file.index.trim();
-                return indexStatus.length > 0 && "?" !== indexStatus;
-            }).map((file)=>file.path);
-            return {
-                hasChanges: !status.isClean(),
-                modified: status.modified,
-                notAdded: status.not_added,
-                created: status.created,
-                deleted: status.deleted,
-                staged
-            };
-        } catch (e) {
-            throw createGitError.commandFailed("status", e.message);
-        }
-    }
     async function syncToLatest(repoPath, appId, anvilUrl, authToken, currentBranch, username) {
         try {
             const git = esm_default(repoPath);
@@ -48911,7 +48983,7 @@ var __webpack_exports__ = {};
             return newCommitId;
         } catch (e) {
             if (isAnvilError(e)) throw e;
-            throw createGitError.commandFailed("sync", e instanceof Error ? e.message : String(e));
+            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) {
@@ -48925,11 +48997,11 @@ var __webpack_exports__ = {};
                 "--abbrev-ref",
                 "HEAD"
             ]);
-            if ("HEAD" === branchRef) throw createGitError.commandFailed("revparse", "Cannot sync from detached HEAD state. Please checkout a branch first.");
+            if ("HEAD" === branchRef) throw errors_createGitError.commandFailed("revparse", "Cannot sync from detached HEAD state. Please checkout a branch first.");
             currentBranch = branchRef;
         } catch (e) {
             if ("git_command_failed" === e.type) throw e;
-            throw createGitError.commandFailed("revparse", e.message);
+            throw errors_createGitError.commandFailed("revparse", e.message);
         }
         let commitId;
         try {
@@ -48937,7 +49009,7 @@ var __webpack_exports__ = {};
                 "HEAD"
             ])).trim();
         } catch (e) {
-            throw createGitError.commandFailed("revparse", e.message);
+            throw errors_createGitError.commandFailed("revparse", e.message);
         }
         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));
@@ -48947,7 +49019,7 @@ var __webpack_exports__ = {};
             const status = await git.status();
             hasUncommittedChanges = status.files.length > 0;
         } catch (e) {
-            throw createGitError.commandFailed("status", e.message);
+            throw errors_createGitError.commandFailed("status", e.message);
         }
         logger_logger.verbose(chalk_source.blue("Has uncommitted changes: ") + chalk_source.bold(hasUncommittedChanges));
         const session = new WatchSession(repoPath, appId, {
@@ -48978,7 +49050,7 @@ var __webpack_exports__ = {};
         try {
             await session.initialize();
         } catch (e) {
-            throw createGitError.commandFailed("initialize", e.message);
+            throw errors_createGitError.commandFailed("initialize", e.message);
         }
         if (null !== syncStatus) session.syncStatus = syncStatus;
         session.hasUncommittedChanges = hasUncommittedChanges;
@@ -49074,30 +49146,328 @@ var __webpack_exports__ = {};
             return null;
         }
     }
+    async function pushToAnvil(options) {
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            const git = new GitService(options.repoPath);
+            const refSpec = `${options.branchName}:${options.branchName}`;
+            logger_logger.progress("push", "Pushing to Anvil...");
+            await git.push(pushUrl, refSpec, options.force ?? false);
+            logger_logger.progressEnd("push", "Pushed to Anvil");
+            return true;
+        } catch (e) {
+            logger_logger.progressEnd("push", "Push failed");
+            logger_logger.error(`Failed to push: ${errors_getErrorMessage(e)}`);
+            return false;
+        }
+    }
+    async function fetchAndRebaseFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-rebase-temp-${Date.now()}`;
+        let didStash = false;
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            const hasChanges = await git.hasUncommittedChanges();
+            if (hasChanges) {
+                logger_logger.progress("rebase", "Stashing uncommitted changes...");
+                didStash = await git.stash("anvil-sync: stash before rebase");
+            }
+            logger_logger.progressUpdate("rebase", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("rebase", "Rebasing...");
+            await git.rebase(tempRef);
+            logger_logger.progressUpdate("rebase", "Pushing rebased changes...");
+            const pushUrl = getGitPushUrl(options.appId, authToken, options.anvilUrl);
+            await git.push(pushUrl, `${options.branchName}:${options.branchName}`, true);
+            logger_logger.progressEnd("rebase", "Rebased and pushed to Anvil");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+                logger_logger.verbose(chalk_source.green("Restored uncommitted changes"));
+            } catch (e) {
+                logger_logger.warn("Uncommitted changes were stashed but could not be restored automatically.");
+                logger_logger.info(chalk_source.gray("   Run: git stash pop"));
+            }
+            return {
+                success: true,
+                conflicted: false
+            };
+        } catch (e) {
+            const msg = errors_getErrorMessage(e);
+            if (msg.includes("rebase") && (msg.includes("conflict") || msg.includes("CONFLICT") || msg.includes("could not apply"))) {
+                try {
+                    await git.rebaseAbort();
+                } catch  {}
+                await git.deleteRef(`refs/heads/${tempRef}`);
+                if (didStash) try {
+                    await git.stashPop();
+                } catch  {
+                    logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
+                }
+                logger_logger.progressEnd("rebase", "Rebase failed - conflicts");
+                return {
+                    success: false,
+                    conflicted: true
+                };
+            }
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            if (didStash) try {
+                await git.stashPop();
+            } catch  {
+                logger_logger.warn("Your uncommitted changes are in the stash. Run: git stash pop");
+            }
+            logger_logger.progressEnd("rebase", "Rebase failed");
+            logger_logger.error(`Failed to rebase: ${msg}`);
+            return {
+                success: false,
+                conflicted: false
+            };
+        }
+    }
+    async function fetchAndHardResetFromAnvil(options) {
+        const git = new GitService(options.repoPath);
+        const tempRef = `anvil-reset-temp-${Date.now()}`;
+        try {
+            const authToken = await auth_getValidAuthToken(options.anvilUrl, options.username);
+            const fetchUrl = getGitFetchUrl(options.appId, authToken, options.anvilUrl);
+            logger_logger.progress("reset", "Fetching from Anvil...");
+            await git.fetch(fetchUrl, `+${options.branchName}:${tempRef}`);
+            logger_logger.progressUpdate("reset", "Resetting to Anvil's version...");
+            await git.reset(tempRef, "hard");
+            logger_logger.progressEnd("reset", "Reset to Anvil's version");
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            return true;
+        } catch (e) {
+            await git.deleteRef(`refs/heads/${tempRef}`);
+            logger_logger.progressEnd("reset", "Reset failed");
+            logger_logger.error(`Failed to reset: ${errors_getErrorMessage(e)}`);
+            return false;
+        }
+    }
+    function getSyncStateCategory(syncStatus) {
+        if (syncStatus?.branchMissing) return "branch-missing";
+        if (syncStatus?.diverged) return "diverged";
+        if (syncStatus?.ahead && !syncStatus?.behind) return "ahead";
+        if (syncStatus?.behind && !syncStatus?.ahead) return "behind";
+        if (syncStatus?.ahead && syncStatus?.behind) return "diverged";
+        return "in-sync";
+    }
+    async function recheckSyncStatus(previousCategory, previousBranch, options) {
+        try {
+            logger_logger.progress("verify", "Verifying repository status...");
+            const freshSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("verify");
+            const currentCategory = getSyncStateCategory(freshSession.syncStatus);
+            const currentBranch = freshSession.getBranchName() || "master";
+            if (currentCategory !== previousCategory || currentBranch !== previousBranch) {
+                logger_logger.warn("Repository status has changed. Re-evaluating...");
+                return freshSession;
+            }
+            freshSession.cleanup();
+            return null;
+        } catch (e) {
+            logger_logger.progressEnd("verify");
+            logger_logger.verbose(chalk_source.gray(`Could not re-verify status: ${errors_getErrorMessage(e)}`));
+            return null;
+        }
+    }
+    async function recreateSessionAndValidate(options) {
+        logger_logger.progress("init", "Restarting watch session...");
+        try {
+            const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
+            logger_logger.progressEnd("init");
+            return await checkSyncStatusAndStart(newSession, options);
+        } catch (e) {
+            logger_logger.progressEnd("init", "Failed");
+            logger_logger.error(`Failed to restart: ${errors_getErrorMessage(e)}`);
+            return false;
+        }
+    }
     async function checkSyncStatusAndStart(session, options) {
         const syncStatus = session.syncStatus;
+        const branchName = session.getBranchName() || "master";
+        const hasUncommitted = session.hasUncommittedChanges;
+        const stateCategory = getSyncStateCategory(syncStatus);
+        if (syncStatus?.branchMissing) {
+            logger_logger.warn(`Branch '${branchName}' doesn't exist on Anvil yet.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing new branch to Anvil..."));
+            else {
+                shouldPush = await logger_logger.confirm("Would you like to push this branch to Anvil?", true);
+                if (shouldPush) {
+                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled. Push your branch to Anvil, then try again.");
+                session.cleanup();
+                return false;
+            }
+            session.cleanup();
+            const pushed = await pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed) return false;
+            return await recreateSessionAndValidate(options);
+        }
         if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
-            logger_logger.error(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
-            logger_logger.verbose(chalk_source.gray("   You have local commits that haven't been pushed to Anvil yet."));
-            logger_logger.warn("Please push your changes to Anvil before continuing:");
-            logger_logger.verbose(chalk_source.gray("   git push anvil <branch-name>"));
+            logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
+            let shouldPush = options.autoMode;
+            if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-pushing to Anvil..."));
+            else {
+                const action = await logger_logger.select("What would you like to do?", [
+                    {
+                        name: "Push your changes to Anvil (recommended)",
+                        value: "push"
+                    },
+                    {
+                        name: "Exit and handle manually",
+                        value: "exit"
+                    }
+                ], "push");
+                shouldPush = "push" === action;
+                if (shouldPush) {
+                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                }
+            }
+            if (!shouldPush) {
+                logger_logger.warn("Watch cancelled.");
+                session.cleanup();
+                return false;
+            }
             session.cleanup();
-            return false;
+            const pushed = await pushToAnvil({
+                repoPath: options.repoPath,
+                appId: options.appId,
+                anvilUrl: options.anvilUrl,
+                branchName,
+                username: options.username
+            });
+            if (!pushed) return false;
+            return await recreateSessionAndValidate(options);
         } else if (syncStatus.diverged) {
-            logger_logger.error("Your local repository has diverged from Anvil.");
-            logger_logger.verbose(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
-            logger_logger.warn("Please resolve the divergence before continuing:");
-            logger_logger.verbose(chalk_source.gray("   Option 1: Pull from Anvil and rebase your changes (git pull --rebase)"));
-            logger_logger.verbose(chalk_source.gray("   Option 2: Reset to Anvil's version (you'll lose local commits)"));
-            logger_logger.verbose(chalk_source.gray("   Option 3: Push your changes to Anvil (if you want to keep them)"));
+            logger_logger.warn("Your local repository has diverged from Anvil.");
+            logger_logger.info(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
             session.cleanup();
-            return false;
+            if (options.autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-rebasing onto Anvil's version..."));
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await recreateSessionAndValidate(options);
+            }
+            const action = await logger_logger.select("How would you like to resolve this?", [
+                {
+                    name: "Pull from Anvil and rebase your changes on top (recommended)",
+                    value: "rebase"
+                },
+                {
+                    name: "Discard your local commits and use Anvil's version",
+                    value: "reset"
+                },
+                {
+                    name: "Push your version to Anvil (overwrites remote)",
+                    value: "push"
+                },
+                {
+                    name: "Exit and handle manually",
+                    value: "exit"
+                }
+            ], "rebase");
+            if ("exit" === action) {
+                logger_logger.warn("Watch cancelled.");
+                return false;
+            }
+            const changed = await recheckSyncStatus(stateCategory, branchName, options);
+            if (changed) return await checkSyncStatusAndStart(changed, options);
+            if ("rebase" === action) {
+                const result = await fetchAndRebaseFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (result.conflicted) {
+                    logger_logger.error("Rebase failed due to conflicts. Please resolve manually:");
+                    logger_logger.info(chalk_source.gray("   1. Run: git fetch anvil && git rebase anvil/" + branchName));
+                    logger_logger.info(chalk_source.gray("   2. Resolve conflicts, then: git rebase --continue"));
+                    logger_logger.info(chalk_source.gray("   3. Push: git push anvil " + branchName));
+                    return false;
+                }
+                if (!result.success) return false;
+                return await recreateSessionAndValidate(options);
+            }
+            if ("reset" === action) {
+                const resetWarning = hasUncommitted ? `This will discard ${syncStatus.ahead} local commit(s) and your uncommitted changes. Are you sure?` : `This will discard ${syncStatus.ahead} local commit(s). Are you sure?`;
+                const confirmed = await logger_logger.confirm(resetWarning, false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const reset = await fetchAndHardResetFromAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username
+                });
+                if (!reset) return false;
+                return await recreateSessionAndValidate(options);
+            }
+            if ("push" === action) {
+                const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
+                if (!confirmed) {
+                    logger_logger.warn("Watch cancelled.");
+                    return false;
+                }
+                const pushed = await pushToAnvil({
+                    repoPath: options.repoPath,
+                    appId: options.appId,
+                    anvilUrl: options.anvilUrl,
+                    branchName,
+                    username: options.username,
+                    force: true
+                });
+                if (!pushed) return false;
+                return await recreateSessionAndValidate(options);
+            }
         } else {
             logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
             logger_logger.verbose(chalk_source.gray("   You need to sync to the latest version before watching."));
+            if (hasUncommitted) logger_logger.info(chalk_source.gray("   You also have uncommitted changes."));
             let shouldSync = options.autoMode;
             if (options.autoMode) logger_logger.info(chalk_source.cyan("→ Auto-syncing to latest version..."));
-            else shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
+            else {
+                shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
+                if (shouldSync) {
+                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                }
+            }
             if (!shouldSync) {
                 logger_logger.warn("Watch cancelled. Please sync manually before watching.");
                 session.cleanup();
@@ -49113,23 +49483,14 @@ 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, session.getBranchName() || "master", options.username);
+                const newCommitId = await syncToLatest(options.repoPath, options.appId, options.anvilUrl, authToken, branchName, options.username);
                 logger_logger.progressEnd("sync-latest", `Synced to latest version: ${newCommitId.substring(0, 8)}`);
             } catch (e) {
                 logger_logger.progressEnd("sync-latest", "Failed");
                 logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
                 process.exit(1);
             }
-            logger_logger.progress("init", "Starting watch...");
-            try {
-                const newSession = await api_watch(options.repoPath, options.appId, options.anvilUrl, options.stagedOnly, options.username);
-                logger_logger.progressEnd("init");
-                return await checkSyncStatusAndStart(newSession, options);
-            } catch (e) {
-                logger_logger.progressEnd("init", "Failed");
-                logger_logger.error(`Failed to start watch: ${errors_getErrorMessage(e)}`);
-                process.exit(1);
-            }
+            return await recreateSessionAndValidate(options);
         }
         await startWatchingWithEventHandlers(session, options);
         return true;
@@ -49137,64 +49498,30 @@ var __webpack_exports__ = {};
     async function startWatchingWithEventHandlers(session, options) {
         const { autoMode, repoPath, appId, anvilUrl, stagedOnly } = options;
         session.on("branch-changed", async ({ oldBranch, newBranch })=>{
-            session.cleanup();
-            logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
-            if (autoMode) {
-                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch on new branch..."));
+            try {
+                session.cleanup();
+                logger_logger.warn(`Branch changed: ${chalk_source.bold(oldBranch)} → ${chalk_source.bold(newBranch)}`);
+                logger_logger.info(chalk_source.cyan("→ Restarting watch on new branch..."));
                 const git = esm_default(repoPath);
                 const actualBranch = (await git.revparse([
                     "--abbrev-ref",
                     "HEAD"
                 ])).trim();
                 if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed again to ${chalk_source.bold(actualBranch)}, using that instead`));
-                logger_logger.verbose(chalk_source.blue(`Restarting watch on branch: ${chalk_source.bold(actualBranch)}`));
                 logger_logger.progress("init", "Initializing watch session...");
                 try {
                     const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
                     logger_logger.progressEnd("init");
                     const started = await checkSyncStatusAndStart(newSession, options);
-                    if (!started) process.exit(1);
+                    if (!started) process.exit(0);
                 } catch (e) {
                     logger_logger.progressEnd("init", "Failed");
                     logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
                     process.exit(1);
                 }
-            } else {
-                logger_logger.verbose(chalk_source.gray("   Watch session needs to be restarted to validate the new branch."));
-                const action = await logger_logger.select("What would you like to do?", [
-                    {
-                        name: "Restart watch on new branch (recommended)",
-                        value: "restart"
-                    },
-                    {
-                        name: "Exit",
-                        value: "exit"
-                    }
-                ], "restart");
-                if ("restart" === action) {
-                    logger_logger.info(chalk_source.cyan("→ Restarting watch..."));
-                    const git = esm_default(repoPath);
-                    const actualBranch = (await git.revparse([
-                        "--abbrev-ref",
-                        "HEAD"
-                    ])).trim();
-                    if (actualBranch !== newBranch) logger_logger.verbose(chalk_source.yellow(`Branch changed to ${chalk_source.bold(actualBranch)} while prompting`));
-                    logger_logger.verbose(chalk_source.blue(`Starting watch on branch: ${chalk_source.bold(actualBranch)}`));
-                    logger_logger.progress("init", "Initializing watch session...");
-                    try {
-                        const newSession = await api_watch(repoPath, appId, anvilUrl, stagedOnly, options.username);
-                        logger_logger.progressEnd("init");
-                        const started = await checkSyncStatusAndStart(newSession, options);
-                        if (!started) process.exit(1);
-                    } catch (e) {
-                        logger_logger.progressEnd("init", "Failed");
-                        logger_logger.error("Failed to restart watch: " + errors_getErrorMessage(e));
-                        process.exit(1);
-                    }
-                } else {
-                    logger_logger.info("Exiting...");
-                    process.exit(0);
-                }
+            } catch (error) {
+                logger_logger.error(`Error handling branch change: ${error.message}`);
+                process.exit(1);
             }
         });
         session.on("validation-failed", ({ reason, currentBranch })=>{
@@ -49204,8 +49531,31 @@ var __webpack_exports__ = {};
             session.cleanup();
             process.exit(1);
         });
+        session.on("max-retries-exceeded", async ()=>{
+            if (autoMode) {
+                logger_logger.info(chalk_source.cyan("→ Auto-restarting watch session..."));
+                session.cleanup();
+                const restarted = await recreateSessionAndValidate(options);
+                if (!restarted) process.exit(1);
+            } else {
+                const shouldRestart = await logger_logger.confirm("Would you like to restart the watch session?", true);
+                if (shouldRestart) {
+                    session.cleanup();
+                    const restarted = await recreateSessionAndValidate(options);
+                    if (!restarted) process.exit(1);
+                }
+            }
+        });
         if (session.hasUncommittedChanges) {
-            logger_logger.progress("save", "You have uncommitted changes. Saving to Anvil...");
+            if (!autoMode) {
+                const shouldContinue = await logger_logger.confirm("Continue? Your uncommitted changes will be synced to Anvil.", true);
+                if (!shouldContinue) {
+                    logger_logger.warn("Watch cancelled. Commit, stash, or discard your changes, then try again.");
+                    session.cleanup();
+                    process.exit(0);
+                }
+            }
+            logger_logger.progress("save", "Saving uncommitted changes to Anvil...");
             try {
                 await session.forceSave();
                 logger_logger.progressEnd("save");
@@ -49216,7 +49566,12 @@ var __webpack_exports__ = {};
         }
         await session.startWatching();
     }
-    async function handleSyncCommand(options) {
+    async function handleWatchCommand(options) {
+        const invoked = process.argv[2];
+        if ("sync" === invoked) {
+            logger_logger.error("'sync' has been renamed to 'watch'. Please use 'anvil watch' instead.");
+            process.exit(1);
+        }
         const { path: repoPath = process.cwd(), appid: explicitAppId, useFirst = false, stagedOnly = false, autoMode = false, url: explicitUrl, user: explicitUsername } = options;
         try {
             const validationResult = await validateAnvilApp(repoPath);
@@ -49281,7 +49636,7 @@ var __webpack_exports__ = {};
                 const detectedAppIds = detectedFromAllRemotes.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === detectedUrl).map((c)=>c.appId);
                 logger_logger.warn(chalk_source.yellow("Git remotes point to ") + chalk_source.bold(detectedUrl) + chalk_source.yellow(", but you specified: ") + chalk_source.bold(normalizedSelected));
                 if (detectedAppIds.length > 0) logger_logger.info(chalk_source.gray("   Detected app IDs on remote URL: ") + chalk_source.bold(detectedAppIds.join(", ")));
-                logger_logger.info(chalk_source.gray("   To use the remote URL instead, run: ") + chalk_source.cyan(`anvil sync --url ${detectedUrl}`));
+                logger_logger.info(chalk_source.gray("   To use the remote URL instead, run: ") + chalk_source.cyan(`anvil watch --url ${detectedUrl}`));
             }
             const candidatesForSelectedUrl = detectedFromAllRemotes.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === normalizedSelected);
             if (candidatesForSelectedUrl.length > 0) for (const candidate of candidatesForSelectedUrl){
@@ -49366,31 +49721,6 @@ var __webpack_exports__ = {};
             }
             logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
             if (appIdValidation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${appIdValidation.app_name}`));
-            const changeStatus = await checkUncommittedChanges(repoPath);
-            if (changeStatus.hasChanges) {
-                const skipPromptReasons = [];
-                if (autoMode) skipPromptReasons.push("Auto mode enabled - continuing without confirmation.");
-                if (stagedOnly && 0 === changeStatus.staged.length) skipPromptReasons.push("Staged-only mode with no staged changes - continuing without confirmation.");
-                logger_logger.warn("Repository has uncommitted changes");
-                if (changeStatus.modified.length > 0) logger_logger.verbose(chalk_source.gray(`   Modified: ${changeStatus.modified.join(", ")}`));
-                if (changeStatus.created.length > 0 || changeStatus.notAdded.length > 0) {
-                    const newFiles = [
-                        ...changeStatus.created,
-                        ...changeStatus.notAdded
-                    ];
-                    logger_logger.verbose(chalk_source.gray(`   New files: ${newFiles.join(", ")}`));
-                }
-                if (changeStatus.deleted.length > 0) logger_logger.verbose(chalk_source.gray(`   Deleted: ${changeStatus.deleted.join(", ")}`));
-                if (changeStatus.staged.length > 0) logger_logger.verbose(chalk_source.gray(`   Staged: ${changeStatus.staged.join(", ")}`));
-                if (skipPromptReasons.length > 0) skipPromptReasons.forEach((reason)=>logger_logger.verbose(chalk_source.gray(`   ${reason}`)));
-                else {
-                    const shouldContinue = await logger_logger.confirm("Do you want to continue watching anyway?", true);
-                    if (!shouldContinue) {
-                        logger_logger.warn("Watch cancelled. Please commit or stash your changes first.");
-                        process.exit(0);
-                    }
-                }
-            }
             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...");
@@ -49411,10 +49741,10 @@ var __webpack_exports__ = {};
             process.exit(1);
         }
     }
-    function registerSyncCommand(program) {
-        const syncCommand = program.command("sync [path]").description("Watch for file changes and sync to Anvil").alias("watch").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-V, --verbose", "Show detailed output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options)=>{
+    function registerWatchCommand(program) {
+        const watchCommand = program.command("watch [path]").description("Watch for file changes and sync to Anvil").alias("sync").alias("w").option("-A, --appid <APP_ID>", "Specify app ID directly").option("-f, --first", "Auto-select first detected app ID without confirmation").option("-s, --staged-only", "Only sync staged changes (use git add to stage files)").option("-a, --auto", "Auto mode: restart on branch changes and sync when behind").option("-V, --verbose", "Show detailed output").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL (e.g., anvil.works, localhost)").option("-U, --user <USERNAME>", "Specify which user account to use").action(async (path, options)=>{
             if (void 0 !== options.verbose && logger_logger instanceof CLILogger) logger_logger.setVerbose(options.verbose);
-            await handleSyncCommand({
+            await handleWatchCommand({
                 path,
                 appid: options.appid,
                 useFirst: options.first,
@@ -49425,7 +49755,7 @@ var __webpack_exports__ = {};
                 user: options.user
             });
         });
-        return syncCommand;
+        return watchCommand;
     }
     var external_http_ = __webpack_require__("http");
     const external_node_url_namespaceObject = require("node:url");
@@ -50177,83 +50507,88 @@ var __webpack_exports__ = {};
     }
     function registerLogoutCommand(program) {
         const logoutCommand = program.command("logout [anvil-server-url]").description("Logout from Anvil (optionally specify URL to logout from specific installation)").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL to logout from").option("-U, --user <USERNAME>", "Specify which user account to logout from").alias("lo").action(async (anvilUrl, options)=>{
-            const urlToLogout = options?.url || anvilUrl;
-            const usernameToLogout = options?.user;
-            if (urlToLogout) {
-                const normalized = normalizeAnvilUrl(urlToLogout);
-                const result = await logout(normalized, usernameToLogout);
-                if (result.loggedOut) if (usernameToLogout) logger_logger.success(`Logged out from ${normalized} as ${usernameToLogout}`);
-                else logger_logger.success(`Logged out from ${normalized}`);
-                else logger_logger.info(result.message || `Not logged in to ${normalized}. No action needed.`);
-            } else {
-                const availableUrls = getAvailableAnvilUrls();
-                if (0 === availableUrls.length) logger_logger.warn("No logged-in accounts found.");
-                else if (1 === availableUrls.length) {
-                    const result = await logout();
-                    if (result.loggedOut) logger_logger.success("Logged out.");
+            try {
+                const urlToLogout = options?.url || anvilUrl;
+                const usernameToLogout = options?.user;
+                if (urlToLogout) {
+                    const normalized = normalizeAnvilUrl(urlToLogout);
+                    const result = await logout(normalized, usernameToLogout);
+                    if (result.loggedOut) if (usernameToLogout) logger_logger.success(`Logged out from ${normalized} as ${usernameToLogout}`);
+                    else logger_logger.success(`Logged out from ${normalized}`);
+                    else logger_logger.info(result.message || `Not logged in to ${normalized}. No action needed.`);
                 } else {
-                    const choices = [
-                        {
-                            name: "Logout from one account",
-                            value: "one"
-                        },
-                        {
-                            name: "Logout from all accounts",
-                            value: "all"
-                        },
-                        {
-                            name: "Cancel",
-                            value: "cancel"
-                        }
-                    ];
-                    const action = await logger_logger.select(`You have ${availableUrls.length} logged-in accounts. What would you like to do?`, choices, "one");
-                    if ("cancel" === action) return void logger_logger.info("Logout cancelled.");
-                    if ("all" === action) {
+                    const availableUrls = getAvailableAnvilUrls();
+                    if (0 === availableUrls.length) logger_logger.warn("No logged-in accounts found.");
+                    else if (1 === availableUrls.length) {
                         const result = await logout();
-                        if (result.loggedOut) logger_logger.success("Logged out from all accounts.");
+                        if (result.loggedOut) logger_logger.success("Logged out.");
                     } else {
-                        const urlChoices = availableUrls.map((url)=>({
-                                name: url,
-                                value: url
-                            }));
-                        urlChoices.push({
-                            name: "Cancel",
-                            value: null
-                        });
-                        const selectedUrl = await logger_logger.select("Which URL would you like to logout from?", urlChoices, availableUrls[0]);
-                        if (null === selectedUrl) return void logger_logger.info("Logout cancelled.");
-                        const accounts = auth_getAccountsForUrl(selectedUrl);
-                        if (accounts.length > 1) {
-                            const accountChoices = accounts.map((acc)=>({
-                                    name: acc,
-                                    value: acc
-                                }));
-                            accountChoices.push({
-                                name: "All accounts for this URL",
+                        const choices = [
+                            {
+                                name: "Logout from one account",
+                                value: "one"
+                            },
+                            {
+                                name: "Logout from all accounts",
                                 value: "all"
-                            });
-                            accountChoices.push({
+                            },
+                            {
+                                name: "Cancel",
+                                value: "cancel"
+                            }
+                        ];
+                        const action = await logger_logger.select(`You have ${availableUrls.length} logged-in accounts. What would you like to do?`, choices, "one");
+                        if ("cancel" === action) return void logger_logger.info("Logout cancelled.");
+                        if ("all" === action) {
+                            const result = await logout();
+                            if (result.loggedOut) logger_logger.success("Logged out from all accounts.");
+                        } else {
+                            const urlChoices = availableUrls.map((url)=>({
+                                    name: url,
+                                    value: url
+                                }));
+                            urlChoices.push({
                                 name: "Cancel",
                                 value: null
                             });
-                            const selectedAccount = await logger_logger.select(`Which account would you like to logout from ${selectedUrl}?`, accountChoices, accounts[0]);
-                            if (null === selectedAccount) return void logger_logger.info("Logout cancelled.");
-                            if ("all" === selectedAccount) {
+                            const selectedUrl = await logger_logger.select("Which URL would you like to logout from?", urlChoices, availableUrls[0]);
+                            if (null === selectedUrl) return void logger_logger.info("Logout cancelled.");
+                            const accounts = auth_getAccountsForUrl(selectedUrl);
+                            if (accounts.length > 1) {
+                                const accountChoices = accounts.map((acc)=>({
+                                        name: acc,
+                                        value: acc
+                                    }));
+                                accountChoices.push({
+                                    name: "All accounts for this URL",
+                                    value: "all"
+                                });
+                                accountChoices.push({
+                                    name: "Cancel",
+                                    value: null
+                                });
+                                const selectedAccount = await logger_logger.select(`Which account would you like to logout from ${selectedUrl}?`, accountChoices, accounts[0]);
+                                if (null === selectedAccount) return void logger_logger.info("Logout cancelled.");
+                                if ("all" === selectedAccount) {
+                                    const result = await logout(selectedUrl);
+                                    if (result.loggedOut) logger_logger.success(`Logged out from all accounts on ${selectedUrl}.`);
+                                    else logger_logger.info(result.message || `Not logged in to ${selectedUrl}. No action needed.`);
+                                } else {
+                                    const result = await logout(selectedUrl, selectedAccount);
+                                    if (result.loggedOut) logger_logger.success(`Logged out from ${selectedUrl} as ${selectedAccount}.`);
+                                    else logger_logger.info(result.message || `Not logged in to ${selectedUrl} as ${selectedAccount}. No action needed.`);
+                                }
+                            } else {
                                 const result = await logout(selectedUrl);
-                                if (result.loggedOut) logger_logger.success(`Logged out from all accounts on ${selectedUrl}.`);
+                                if (result.loggedOut) logger_logger.success(`Logged out from ${selectedUrl}.`);
                                 else logger_logger.info(result.message || `Not logged in to ${selectedUrl}. No action needed.`);
-                            } else {
-                                const result = await logout(selectedUrl, selectedAccount);
-                                if (result.loggedOut) logger_logger.success(`Logged out from ${selectedUrl} as ${selectedAccount}.`);
-                                else logger_logger.info(result.message || `Not logged in to ${selectedUrl} as ${selectedAccount}. No action needed.`);
                             }
-                        } else {
-                            const result = await logout(selectedUrl);
-                            if (result.loggedOut) logger_logger.success(`Logged out from ${selectedUrl}.`);
-                            else logger_logger.info(result.message || `Not logged in to ${selectedUrl}. No action needed.`);
                         }
                     }
                 }
+            } catch (error) {
+                logger_logger.error(`Logout failed: ${error.message}`);
+                process.exit(1);
             }
         });
         logoutCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + "\n  anvil logout                    Logout from all accounts (or prompt if multiple)\n  anvil logout anvil.works        Logout from anvil.works\n  anvil logout -u anvil.works     Logout from anvil.works (using option)\n  anvil logout -u anvil.works -U user@example.com  Logout specific user\n");
@@ -50354,6 +50689,10 @@ var __webpack_exports__ = {};
     setLogger(new CLILogger({
         verbose: false
     }));
+    process.on("unhandledRejection", (reason)=>{
+        logger_logger.error(`Unexpected error: ${reason}`);
+        process.exit(1);
+    });
     function showBetaBanner() {
         console.log();
         console.log(chalk_source.yellow("┌────────────────────────────────────────────────────────┐"));
@@ -50420,7 +50759,7 @@ var __webpack_exports__ = {};
             if ("update" !== commandName) checkVersionAndWarn();
         }
     });
-    const cli_syncCommand = registerSyncCommand(cli_program);
+    const cli_watchCommand = registerWatchCommand(cli_program);
     registerLoginCommand(cli_program);
     registerLogoutCommand(cli_program);
     registerConfigCommand(cli_program);
@@ -50428,13 +50767,13 @@ var __webpack_exports__ = {};
     cli_program.command("update").description("Update anvil to the latest version").alias("u").action(async ()=>{
         await handleUpdateCommand();
     });
-    if (cli_syncCommand) {
-        const syncOptions = cli_syncCommand.options.map((opt)=>{
+    if (cli_watchCommand) {
+        const watchOptions = cli_watchCommand.options.map((opt)=>{
             const flags = opt.flags;
             const description = opt.description || "";
             return `  ${flags.padEnd(30)} ${description}`;
         }).join("\n");
-        if (syncOptions) cli_program.addHelpText("after", "\n" + chalk_source.bold("Sync Command Options:") + "\n" + chalk_source.gray("  (These options apply to the 'sync' command)") + "\n" + syncOptions + "\n");
+        if (watchOptions) cli_program.addHelpText("after", "\n" + chalk_source.bold("Watch Command Options:") + "\n" + chalk_source.gray("  (These options apply to the 'watch' command)") + "\n" + watchOptions + "\n");
     }
     cli_program.parse();
 })();