@anvil-works/anvil-cli 0.4.1 → 0.4.3

package/README.md

@@ -85,9 +85,7 @@ Or use the short form:
 anvil w
 ```
 
-> **Note:** `anvil sync` still works but is deprecated. Use `anvil watch` instead.
-
-You can specify the app ID explicitly:
+You can specify the app ID explicitly:
 
 ```bash
 anvil watch -A YOUR_APP_ID
@@ -126,7 +124,6 @@ The diagram shows bidirectional sync:
 | -------------------------------------- | -------------------------------------------------------------------- |
 | `anvil watch [path]`                   | Watch directory for changes and sync to Anvil                        |
 | `anvil watch -V` or `--verbose`        | Watch with verbose logging (detailed output)                         |
-| `anvil sync [path]`                    | Deprecated alias for `watch`                                         |
 | `anvil w [path]`                       | Short form for watch                                                 |
 | `anvil login [anvil-server-url]`       | Authenticate with Anvil using OAuth (supports smart URL handling)    |
 | `anvil l [anvil-server-url]`           | Short form for login                                                 |
@@ -153,13 +150,15 @@ anvil watch -A YOUR_APP_ID
 
 ### Anvil URL Detection
 
-anvil-cli automatically detects which Anvil server to use:
-
-1. **Explicit URL**: If you specify `--url` or `-u` flag
-2. **Git Remotes**: Automatically extracts URL from git remotes in your repository
-3. **User Prompt**: If multiple accounts are available, prompts you to select one
-4. **Global Config**: Falls back to `anvilUrl` in config file
-5. **Default**: Uses `https://anvil.works` (or `http://localhost:3000` in dev mode)
+anvil-cli automatically detects which Anvil server to use:
+
+1. **Explicit URL**: If you specify `--url` or `-u` flag
+2. **Git Remotes**: Automatically extracts URL from git remotes in your repository
+3. **Logged-in URLs**:
+    - If one logged-in URL is available, uses it automatically
+    - If multiple logged-in URLs are available, prompts you to select one
+4. **Global Config**: Falls back to `anvilUrl` in config file
+5. **Default**: Uses `https://anvil.works` (or `http://localhost:3000` in dev mode)
 
 **Examples:**
 
@@ -172,12 +171,12 @@ anvil watch --url anvil.works
 anvil watch --url localhost:3000
 anvil watch --url anvil.mycompany.com
 
-# If multiple accounts, you'll be prompted to select
-anvil watch
-# ? Multiple Anvil installations found. Which one would you like to use?
-# ❯ https://anvil.works
-#   https://anvil.company.com
-#   Cancel
+# If multiple logged-in URLs, you'll be prompted to select
+anvil watch
+# ? Multiple Anvil installations found. Which one would you like to use?
+# ❯ https://anvil.works
+#   https://anvil.company.com
+#   Cancel
 ```
 
 ## Configuration
@@ -269,18 +268,21 @@ anvil login anvil.works
 anvil login anvil.company-a.com
 anvil login anvil.company-b.com
 
-# When syncing, you'll be prompted to select which one to use
-# Or specify explicitly:
-anvil watch --url anvil.company-a.com
-```
+# If URL is not resolved from git remotes and multiple logged-in URLs exist,
+# you'll be prompted to select which one to use
+# Or specify explicitly:
+anvil watch --url anvil.company-a.com
+```
 
 **URL Resolution Priority:**
 
-1. Explicit `--url` flag
-2. Git remote detection (from current repository)
-3. User prompt (if multiple accounts available)
-4. `anvilUrl` in config file
-5. Default based on `NODE_ENV`:
+1. Explicit `--url` flag
+2. Git remote detection (from current repository)
+3. Logged-in URL selection:
+    - One URL: auto-select
+    - Multiple URLs: prompt to select
+4. `anvilUrl` in config file
+5. Default based on `NODE_ENV`:
     - Production: `https://anvil.works`
     - Development: `http://localhost:3000`
 
@@ -308,10 +310,13 @@ anvil logout anvil.mycompany.com
 anvil logout --url localhost:3000
 ```
 
-**Multiple accounts:** If you have multiple accounts and run `anvil logout` without specifying a URL, you'll be prompted to:
-
--   Logout from one account (then select which one)
--   Logout from all accounts
+**Without URL:** `anvil logout` uses total logged-in account count across all URLs:
+
+-   If you have **one account total**, it logs out immediately
+-   If you have **multiple accounts total**, you'll be prompted to:
+
+-   Logout from one account (then select which one)
+-   Logout from all accounts
 -   Cancel
 
 ## Troubleshooting

package/dist/cli.js

@@ -47506,9 +47506,15 @@ var __webpack_exports__ = {};
         username;
         reconnectAttempts = 0;
         reconnectTimer = null;
+        heartbeatTimer = null;
+        pongTimeoutTimer = null;
+        reconnectDelayMs;
+        isClosing = false;
         sessionId;
-        MAX_RECONNECT_ATTEMPTS = 5;
-        RECONNECT_DELAY = 5000;
+        RECONNECT_DELAY_BASE_MS = 5000;
+        RECONNECT_DELAY_MAX_MS = 60000;
+        HEARTBEAT_INTERVAL_MS = 30000;
+        HEARTBEAT_TIMEOUT_MS = 10000;
         constructor(options){
             super();
             this.appId = options.appId;
@@ -47518,12 +47524,14 @@ var __webpack_exports__ = {};
             this.editSession = options.editSession;
             this.username = options.username;
             this.sessionId = Math.random().toString(36).substring(2, 10);
+            this.reconnectDelayMs = this.RECONNECT_DELAY_BASE_MS;
         }
         async connect() {
+            this.isClosing = false;
             if (this.ws?.readyState === ws_wrapper.OPEN) return void logger_logger.debug(`[WebSocket ${this.sessionId}]`, "WebSocket already open, skipping connection");
             if (this.ws) {
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing existing WebSocket before reconnecting");
-                this.close();
+                this.teardownSocket();
             }
             this.authToken = await auth_getValidAuthToken(this.anvilUrl, this.username);
             const wsUrl = getWebSocketUrl(this.appId, this.authToken, this.anvilUrl);
@@ -47533,6 +47541,8 @@ var __webpack_exports__ = {};
                 logger_logger.verbose(chalk_source.green("🔌 Connected to Anvil WebSocket"));
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "WebSocket opened");
                 this.reconnectAttempts = 0;
+                this.reconnectDelayMs = this.RECONNECT_DELAY_BASE_MS;
+                this.startHeartbeat();
                 const subscribeMsg = {
                     cmd: "WATCH_APP",
                     app: this.appId,
@@ -47543,6 +47553,7 @@ var __webpack_exports__ = {};
                 this.emit("connected", void 0);
             });
             this.ws.on("message", (data)=>{
+                this.markSocketResponsive();
                 try {
                     const msg = JSON.parse(data.toString());
                     logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Message: ${JSON.stringify(msg)}`);
@@ -47551,8 +47562,12 @@ var __webpack_exports__ = {};
                     logger_logger.error(chalk_source.red(`Failed to parse WebSocket message: ${error.message}`));
                 }
             });
+            this.ws.on("pong", ()=>{
+                this.markSocketResponsive();
+            });
             this.ws.on("close", (code, reason)=>{
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Closed: code=${code}, reason=${reason.toString()}`);
+                this.stopHeartbeat();
                 this.ws = null;
                 if (1008 === code || reason.toString().includes("unauthenticated")) {
                     logger_logger.warn(chalk_source.yellow(" WebSocket authentication failed - changes from the Anvil Editor won't be detected"));
@@ -47560,21 +47575,12 @@ var __webpack_exports__ = {};
                     this.emit("auth-failed", void 0);
                     return;
                 }
+                if (this.isClosing) return;
                 this.emit("disconnected", {
                     code,
                     reason: reason.toString()
                 });
-                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().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 - changes from the Anvil Editor won't be detected`));
+                this.scheduleReconnect();
             });
             this.ws.on("error", (error)=>{
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Error: ${error.message}`);
@@ -47619,24 +47625,74 @@ var __webpack_exports__ = {};
             return this.editSession;
         }
         close() {
+            this.isClosing = true;
             if (this.reconnectTimer) {
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Clearing reconnect timer");
                 clearTimeout(this.reconnectTimer);
                 this.reconnectTimer = null;
             }
-            if (this.ws) {
+            this.teardownSocket();
+        }
+        isConnected() {
+            return this.ws?.readyState === ws_wrapper.OPEN;
+        }
+        scheduleReconnect() {
+            if (this.reconnectTimer || this.isClosing) return;
+            this.reconnectAttempts++;
+            const delayMs = this.reconnectDelayMs;
+            logger_logger.verbose(chalk_source.gray(`WebSocket disconnected, reconnecting in ${Math.round(delayMs / 1000)}s (attempt ${this.reconnectAttempts})...`));
+            this.reconnectTimer = setTimeout(()=>{
+                this.reconnectTimer = null;
+                this.connect().catch((error)=>{
+                    this.emit("error", {
+                        error: error instanceof Error ? error : new Error(String(error))
+                    });
+                });
+            }, delayMs);
+            this.reconnectDelayMs = Math.min(Math.round(1.5 * this.reconnectDelayMs), this.RECONNECT_DELAY_MAX_MS);
+        }
+        startHeartbeat() {
+            this.stopHeartbeat();
+            this.heartbeatTimer = setInterval(()=>{
+                const ws = this.ws;
+                if (!ws || ws.readyState !== ws_wrapper.OPEN) return;
                 try {
-                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing WebSocket");
-                    this.ws.removeAllListeners();
-                    if (this.ws.readyState === ws_wrapper.OPEN) this.ws.close();
-                } catch (e) {
-                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Error closing WebSocket (ignoring):", e);
+                    ws.ping();
+                } catch (error) {
+                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Failed to send ping: ${error.message}`);
+                    ws.terminate();
+                    return;
                 }
-                this.ws = null;
+                this.pongTimeoutTimer = setTimeout(()=>{
+                    logger_logger.warn(chalk_source.yellow(" WebSocket heartbeat timed out - reconnecting"));
+                    ws.terminate();
+                }, this.HEARTBEAT_TIMEOUT_MS);
+            }, this.HEARTBEAT_INTERVAL_MS);
+        }
+        markSocketResponsive() {
+            if (this.pongTimeoutTimer) {
+                clearTimeout(this.pongTimeoutTimer);
+                this.pongTimeoutTimer = null;
             }
         }
-        isConnected() {
-            return this.ws?.readyState === ws_wrapper.OPEN;
+        stopHeartbeat() {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            this.markSocketResponsive();
+        }
+        teardownSocket() {
+            this.stopHeartbeat();
+            if (!this.ws) return;
+            try {
+                logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing WebSocket");
+                this.ws.removeAllListeners();
+                if (this.ws.readyState === ws_wrapper.OPEN || this.ws.readyState === ws_wrapper.CONNECTING) this.ws.terminate();
+            } catch (e) {
+                logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Error closing WebSocket (ignoring):", e);
+            }
+            this.ws = null;
         }
     }
     async function detectRemoteChanges(gitService, oldCommitId, newCommitId) {
@@ -49364,7 +49420,11 @@ var __webpack_exports__ = {};
         wsClient = null;
         saveProcessor = null;
         syncManager = null;
+        localChangePollTimer = null;
+        isPollingLocalChanges = false;
+        lastLocalStatusFingerprint = null;
         BRANCH_CHANGE_SETTLE_MS = 2000;
+        LOCAL_CHANGE_POLL_MS = 2000;
         stagedOnly;
         constructor(repoPath, appId, options){
             super();
@@ -49502,6 +49562,10 @@ var __webpack_exports__ = {};
                 this.fileWatcher.cleanup();
                 this.fileWatcher = null;
             }
+            if (this.localChangePollTimer) {
+                clearInterval(this.localChangePollTimer);
+                this.localChangePollTimer = null;
+            }
             logger_logger.debug(`[Session ${this.sessionId}]`, "Cleanup complete");
         }
         async startWatching() {
@@ -49535,8 +49599,70 @@ var __webpack_exports__ = {};
                 }
             });
             await this.fileWatcher.start(this.currentBranch);
+            await this.initializeLocalChangeFingerprint();
+            this.startLocalChangeFallbackPolling();
             await new Promise(()=>{});
         }
+        async initializeLocalChangeFingerprint() {
+            if (this.stagedOnly) return;
+            try {
+                const status = await this.gitService.getStatus();
+                this.lastLocalStatusFingerprint = this.getLocalStatusFingerprint(status);
+            } catch (error) {
+                logger_logger.debug(`[Session ${this.sessionId}]`, `Failed to initialize local change fingerprint: ${error.message}`);
+            }
+        }
+        startLocalChangeFallbackPolling() {
+            if (this.stagedOnly || this.localChangePollTimer) return;
+            this.localChangePollTimer = setInterval(()=>{
+                this.pollForMissedLocalChanges();
+            }, this.LOCAL_CHANGE_POLL_MS);
+        }
+        async pollForMissedLocalChanges() {
+            if (this.isCleanedUp || this.isPausedForUserInput || this.isPollingLocalChanges) return;
+            this.isPollingLocalChanges = true;
+            try {
+                const status = await this.gitService.getStatus();
+                const fingerprint = this.getLocalStatusFingerprint(status);
+                if (null === this.lastLocalStatusFingerprint) {
+                    this.lastLocalStatusFingerprint = fingerprint;
+                    return;
+                }
+                if (fingerprint !== this.lastLocalStatusFingerprint) {
+                    this.lastLocalStatusFingerprint = fingerprint;
+                    if (fingerprint) {
+                        logger_logger.debug(`[Session ${this.sessionId}]`, "Detected local change via fallback status poll");
+                        this.saveProcessor?.queueSave();
+                    }
+                }
+            } catch (error) {
+                logger_logger.debug(`[Session ${this.sessionId}]`, `Fallback status poll failed: ${error.message}`);
+            } finally{
+                this.isPollingLocalChanges = false;
+            }
+        }
+        getLocalStatusFingerprint(status) {
+            const renamed = status.renamed.map((r)=>`${r.from}->${r.to}`).sort();
+            const modified = [
+                ...status.modified
+            ].sort();
+            const notAdded = [
+                ...status.notAdded
+            ].sort();
+            const created = [
+                ...status.created
+            ].sort();
+            const deleted = [
+                ...status.deleted
+            ].sort();
+            return [
+                ...renamed.map((r)=>`R:${r}`),
+                ...modified.map((m)=>`M:${m}`),
+                ...notAdded.map((n)=>`N:${n}`),
+                ...created.map((c)=>`C:${c}`),
+                ...deleted.map((d)=>`D:${d}`)
+            ].join("|");
+        }
         async handleFileChange(event, filePath, relativePath) {
             if (this.isCleanedUp || this.isPausedForUserInput) return;
             logger_logger.verbose(chalk_source.blue("File changed: ") + chalk_source.bold(relativePath));
@@ -49830,13 +49956,84 @@ var __webpack_exports__ = {};
         session.hasUncommittedChanges = hasUncommittedChanges;
         return session;
     }
-    function resolveUrlForFallback(explicitUrl) {
-        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
-        const availableUrls = getAvailableAnvilUrls();
-        if (availableUrls.length > 0) return availableUrls[0];
+    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
+        if (explicitUrl) return {
+            source: "explicit",
+            url: normalizeAnvilUrl(explicitUrl)
+        };
+        if (availableUrls.length > 1) return {
+            source: "available-multiple",
+            urls: availableUrls
+        };
+        if (1 === availableUrls.length) return {
+            source: "available-single",
+            url: availableUrls[0]
+        };
         const fromConfig = getConfig("anvilUrl");
-        if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
-        return isDevMode() ? "http://localhost:3000" : "https://anvil.works";
+        if ("string" == typeof fromConfig && fromConfig.trim()) return {
+            source: "config",
+            url: normalizeAnvilUrl(fromConfig.trim())
+        };
+        return {
+            source: "default",
+            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
+        };
+    }
+    function decideUsernameForUrl(accounts) {
+        if (0 === accounts.length) return {
+            source: "none"
+        };
+        if (1 === accounts.length) return {
+            source: "single",
+            username: accounts[0]
+        };
+        return {
+            source: "multiple",
+            usernames: [
+                ...accounts
+            ]
+        };
+    }
+    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
+        if (explicitUsername) return explicitUsername;
+        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
+        if ("none" === decision.source) return;
+        if ("single" === decision.source) {
+            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
+            return decision.username;
+        }
+        const choices = decision.usernames.map((acct)=>({
+                name: acct,
+                value: acct
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
+    }
+    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
+        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
+        if (null === resolvedUsername) return null;
+        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? (slower)`, true);
+        return {
+            username: resolvedUsername,
+            shouldContinue
+        };
+    }
+    async function resolveUrlForFallback(explicitUrl) {
+        const decision = decideFallbackUrl(explicitUrl);
+        if ("available-multiple" !== decision.source) return decision.url;
+        const choices = decision.urls.map((url)=>({
+                name: url,
+                value: url
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        const selectedUrl = await logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
+        return selectedUrl;
     }
     async function selectAppId(candidates) {
         if (0 === candidates.length) {
@@ -50348,6 +50545,7 @@ var __webpack_exports__ = {};
             let finalAppId;
             let anvilUrl;
             let username = explicitUsername;
+            let fallbackUrl;
             if (explicitAppId) {
                 finalAppId = explicitAppId;
                 const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
@@ -50363,13 +50561,23 @@ var __webpack_exports__ = {};
                 logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
                 if (0 === filteredCandidates.length) {
                     logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
-                    const fallbackUrl = resolveUrlForFallback(explicitUrl);
-                    const shouldContinue = await logger_logger.confirm(`Search ${fallbackUrl} for matching app IDs? (slower)`, true);
-                    if (shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${explicitUsername ? `for ${explicitUsername}` : ''} for matching app IDs...`);
+                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
+                    if (null === resolvedFallbackUrl) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
+                    if (null === lookupDecision) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    username = lookupDecision.username;
+                    if (lookupDecision.shouldContinue) {
+                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
                         const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
                             anvilUrl: fallbackUrl,
-                            username: explicitUsername,
+                            username,
                             includeRemotes: false
                         });
                         logger_logger.progressEnd("detect");
@@ -50401,32 +50609,24 @@ var __webpack_exports__ = {};
                 }
             }
             if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
-            else if (!anvilUrl) anvilUrl = resolveUrlForFallback();
+            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
+            else {
+                const resolvedFallbackUrl = await resolveUrlForFallback();
+                if (null === resolvedFallbackUrl) {
+                    logger_logger.warn("Operation cancelled.");
+                    process.exit(0);
+                }
+                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+            }
             anvilUrl = normalizeAnvilUrl(anvilUrl);
             logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
             logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            if (!username) {
-                const accounts = auth_getAccountsForUrl(anvilUrl);
-                if (1 === accounts.length) {
-                    username = accounts[0];
-                    logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(username));
-                } else if (accounts.length > 1) {
-                    const choices = accounts.map((acct)=>({
-                            name: acct,
-                            value: acct
-                        }));
-                    choices.push({
-                        name: "Cancel",
-                        value: null
-                    });
-                    const selected = await logger_logger.select("Multiple accounts found. Which account owns this app?", choices, accounts[0]);
-                    if (null === selected) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    username = selected;
-                }
+            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
+            if (null === resolvedUsername) {
+                logger_logger.warn("Operation cancelled.");
+                process.exit(0);
             }
+            username = resolvedUsername;
             if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
             if (!hasTokensForUrl(anvilUrl, username)) {
                 if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
@@ -51233,6 +51433,13 @@ var __webpack_exports__ = {};
         });
         loginCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + "\n  anvil login                    Log in to default Anvil server\n  anvil login anvil.works        Log in to anvil.works\n  anvil login localhost          Log in to local Anvil server\n");
     }
+    function getTotalLoggedInAccounts(urls) {
+        return urls.reduce((total, url)=>total + auth_getAccountsForUrl(url).length, 0);
+    }
+    function formatMultiAccountLogoutPrompt(totalAccounts, urlCount) {
+        if (urlCount <= 1) return `You have ${totalAccounts} logged-in accounts. What would you like to do?`;
+        return `You have ${totalAccounts} logged-in accounts across ${urlCount} URLs. What would you like to do?`;
+    }
     function registerLogoutCommand(program) {
         const logoutCommand = program.command("logout [anvil-server-url]").description("Log out 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)=>{
             try {
@@ -51246,8 +51453,9 @@ var __webpack_exports__ = {};
                     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 totalAccounts = getTotalLoggedInAccounts(availableUrls);
+                    if (0 === totalAccounts) logger_logger.warn("No logged-in accounts found.");
+                    else if (1 === totalAccounts) {
                         const result = await logout();
                         if (result.loggedOut) logger_logger.success("Logged out.");
                     } else {
@@ -51265,7 +51473,7 @@ var __webpack_exports__ = {};
                                 value: "cancel"
                             }
                         ];
-                        const action = await logger_logger.select(`You have ${availableUrls.length} logged-in accounts. What would you like to do?`, choices, "one");
+                        const action = await logger_logger.select(formatMultiAccountLogoutPrompt(totalAccounts, availableUrls.length), choices, "one");
                         if ("cancel" === action) return void logger_logger.info("Logout cancelled.");
                         if ("all" === action) {
                             const result = await logout();
@@ -51364,17 +51572,21 @@ var __webpack_exports__ = {};
                         let totalAccounts = 0;
                         for (const url of urls){
                             const urlData = authTokens[url];
-                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) totalAccounts += Object.keys(urlData).length;
+                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
+                                const usernames = Object.keys(urlData);
+                                totalAccounts += usernames.filter((username)=>hasTokensForUrl(url, username)).length;
+                            }
                         }
-                        console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${totalAccounts} account(s) across ${urls.length} URL(s)`)}`);
+                        console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${totalAccounts} logged-in account(s) across ${urls.length} URL(s)`)}`);
                         for (const url of urls){
                             const urlData = authTokens[url];
                             if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
                                 const usernames = Object.keys(urlData).sort();
                                 if (usernames.length > 0) for (const username of usernames){
                                     const accountData = urlData[username];
-                                    const hasToken = !!(accountData?.authToken || accountData?.refreshToken);
-                                    const status = hasToken ? chalk_source.green("✓ logged in") : chalk_source.gray("(no tokens)");
+                                    const hasConfigTokens = !!(accountData?.authToken || accountData?.refreshToken);
+                                    const hasAnyTokens = hasTokensForUrl(url, username);
+                                    const status = hasConfigTokens ? chalk_source.green("✓ logged in (config)") : hasAnyTokens ? chalk_source.green("✓ logged in (keychain)") : chalk_source.gray("(no tokens)");
                                     console.log(chalk_source.gray(`  ${url}: ${username} ${status}`));
                                 }
                             }

package/dist/index.js

@@ -22643,9 +22643,15 @@ var __webpack_exports__ = {};
         username;
         reconnectAttempts = 0;
         reconnectTimer = null;
+        heartbeatTimer = null;
+        pongTimeoutTimer = null;
+        reconnectDelayMs;
+        isClosing = false;
         sessionId;
-        MAX_RECONNECT_ATTEMPTS = 5;
-        RECONNECT_DELAY = 5000;
+        RECONNECT_DELAY_BASE_MS = 5000;
+        RECONNECT_DELAY_MAX_MS = 60000;
+        HEARTBEAT_INTERVAL_MS = 30000;
+        HEARTBEAT_TIMEOUT_MS = 10000;
         constructor(options){
             super();
             this.appId = options.appId;
@@ -22655,12 +22661,14 @@ var __webpack_exports__ = {};
             this.editSession = options.editSession;
             this.username = options.username;
             this.sessionId = Math.random().toString(36).substring(2, 10);
+            this.reconnectDelayMs = this.RECONNECT_DELAY_BASE_MS;
         }
         async connect() {
+            this.isClosing = false;
             if (this.ws?.readyState === ws_wrapper.OPEN) return void logger_logger.debug(`[WebSocket ${this.sessionId}]`, "WebSocket already open, skipping connection");
             if (this.ws) {
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing existing WebSocket before reconnecting");
-                this.close();
+                this.teardownSocket();
             }
             this.authToken = await auth_getValidAuthToken(this.anvilUrl, this.username);
             const wsUrl = getWebSocketUrl(this.appId, this.authToken, this.anvilUrl);
@@ -22670,6 +22678,8 @@ var __webpack_exports__ = {};
                 logger_logger.verbose(chalk_source.green("🔌 Connected to Anvil WebSocket"));
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "WebSocket opened");
                 this.reconnectAttempts = 0;
+                this.reconnectDelayMs = this.RECONNECT_DELAY_BASE_MS;
+                this.startHeartbeat();
                 const subscribeMsg = {
                     cmd: "WATCH_APP",
                     app: this.appId,
@@ -22680,6 +22690,7 @@ var __webpack_exports__ = {};
                 this.emit("connected", void 0);
             });
             this.ws.on("message", (data)=>{
+                this.markSocketResponsive();
                 try {
                     const msg = JSON.parse(data.toString());
                     logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Message: ${JSON.stringify(msg)}`);
@@ -22688,8 +22699,12 @@ var __webpack_exports__ = {};
                     logger_logger.error(chalk_source.red(`Failed to parse WebSocket message: ${error.message}`));
                 }
             });
+            this.ws.on("pong", ()=>{
+                this.markSocketResponsive();
+            });
             this.ws.on("close", (code, reason)=>{
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Closed: code=${code}, reason=${reason.toString()}`);
+                this.stopHeartbeat();
                 this.ws = null;
                 if (1008 === code || reason.toString().includes("unauthenticated")) {
                     logger_logger.warn(chalk_source.yellow(" WebSocket authentication failed - changes from the Anvil Editor won't be detected"));
@@ -22697,21 +22712,12 @@ var __webpack_exports__ = {};
                     this.emit("auth-failed", void 0);
                     return;
                 }
+                if (this.isClosing) return;
                 this.emit("disconnected", {
                     code,
                     reason: reason.toString()
                 });
-                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().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 - changes from the Anvil Editor won't be detected`));
+                this.scheduleReconnect();
             });
             this.ws.on("error", (error)=>{
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Error: ${error.message}`);
@@ -22756,24 +22762,74 @@ var __webpack_exports__ = {};
             return this.editSession;
         }
         close() {
+            this.isClosing = true;
             if (this.reconnectTimer) {
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Clearing reconnect timer");
                 clearTimeout(this.reconnectTimer);
                 this.reconnectTimer = null;
             }
-            if (this.ws) {
+            this.teardownSocket();
+        }
+        isConnected() {
+            return this.ws?.readyState === ws_wrapper.OPEN;
+        }
+        scheduleReconnect() {
+            if (this.reconnectTimer || this.isClosing) return;
+            this.reconnectAttempts++;
+            const delayMs = this.reconnectDelayMs;
+            logger_logger.verbose(chalk_source.gray(`WebSocket disconnected, reconnecting in ${Math.round(delayMs / 1000)}s (attempt ${this.reconnectAttempts})...`));
+            this.reconnectTimer = setTimeout(()=>{
+                this.reconnectTimer = null;
+                this.connect().catch((error)=>{
+                    this.emit("error", {
+                        error: error instanceof Error ? error : new Error(String(error))
+                    });
+                });
+            }, delayMs);
+            this.reconnectDelayMs = Math.min(Math.round(1.5 * this.reconnectDelayMs), this.RECONNECT_DELAY_MAX_MS);
+        }
+        startHeartbeat() {
+            this.stopHeartbeat();
+            this.heartbeatTimer = setInterval(()=>{
+                const ws = this.ws;
+                if (!ws || ws.readyState !== ws_wrapper.OPEN) return;
                 try {
-                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing WebSocket");
-                    this.ws.removeAllListeners();
-                    if (this.ws.readyState === ws_wrapper.OPEN) this.ws.close();
-                } catch (e) {
-                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Error closing WebSocket (ignoring):", e);
+                    ws.ping();
+                } catch (error) {
+                    logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Failed to send ping: ${error.message}`);
+                    ws.terminate();
+                    return;
                 }
-                this.ws = null;
+                this.pongTimeoutTimer = setTimeout(()=>{
+                    logger_logger.warn(chalk_source.yellow(" WebSocket heartbeat timed out - reconnecting"));
+                    ws.terminate();
+                }, this.HEARTBEAT_TIMEOUT_MS);
+            }, this.HEARTBEAT_INTERVAL_MS);
+        }
+        markSocketResponsive() {
+            if (this.pongTimeoutTimer) {
+                clearTimeout(this.pongTimeoutTimer);
+                this.pongTimeoutTimer = null;
             }
         }
-        isConnected() {
-            return this.ws?.readyState === ws_wrapper.OPEN;
+        stopHeartbeat() {
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            this.markSocketResponsive();
+        }
+        teardownSocket() {
+            this.stopHeartbeat();
+            if (!this.ws) return;
+            try {
+                logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Closing WebSocket");
+                this.ws.removeAllListeners();
+                if (this.ws.readyState === ws_wrapper.OPEN || this.ws.readyState === ws_wrapper.CONNECTING) this.ws.terminate();
+            } catch (e) {
+                logger_logger.debug(`[WebSocket ${this.sessionId}]`, "Error closing WebSocket (ignoring):", e);
+            }
+            this.ws = null;
         }
     }
     async function detectRemoteChanges(gitService, oldCommitId, newCommitId) {
@@ -25000,7 +25056,11 @@ var __webpack_exports__ = {};
         wsClient = null;
         saveProcessor = null;
         syncManager = null;
+        localChangePollTimer = null;
+        isPollingLocalChanges = false;
+        lastLocalStatusFingerprint = null;
         BRANCH_CHANGE_SETTLE_MS = 2000;
+        LOCAL_CHANGE_POLL_MS = 2000;
         stagedOnly;
         constructor(repoPath, appId, options){
             super();
@@ -25138,6 +25198,10 @@ var __webpack_exports__ = {};
                 this.fileWatcher.cleanup();
                 this.fileWatcher = null;
             }
+            if (this.localChangePollTimer) {
+                clearInterval(this.localChangePollTimer);
+                this.localChangePollTimer = null;
+            }
             logger_logger.debug(`[Session ${this.sessionId}]`, "Cleanup complete");
         }
         async startWatching() {
@@ -25171,8 +25235,70 @@ var __webpack_exports__ = {};
                 }
             });
             await this.fileWatcher.start(this.currentBranch);
+            await this.initializeLocalChangeFingerprint();
+            this.startLocalChangeFallbackPolling();
             await new Promise(()=>{});
         }
+        async initializeLocalChangeFingerprint() {
+            if (this.stagedOnly) return;
+            try {
+                const status = await this.gitService.getStatus();
+                this.lastLocalStatusFingerprint = this.getLocalStatusFingerprint(status);
+            } catch (error) {
+                logger_logger.debug(`[Session ${this.sessionId}]`, `Failed to initialize local change fingerprint: ${error.message}`);
+            }
+        }
+        startLocalChangeFallbackPolling() {
+            if (this.stagedOnly || this.localChangePollTimer) return;
+            this.localChangePollTimer = setInterval(()=>{
+                this.pollForMissedLocalChanges();
+            }, this.LOCAL_CHANGE_POLL_MS);
+        }
+        async pollForMissedLocalChanges() {
+            if (this.isCleanedUp || this.isPausedForUserInput || this.isPollingLocalChanges) return;
+            this.isPollingLocalChanges = true;
+            try {
+                const status = await this.gitService.getStatus();
+                const fingerprint = this.getLocalStatusFingerprint(status);
+                if (null === this.lastLocalStatusFingerprint) {
+                    this.lastLocalStatusFingerprint = fingerprint;
+                    return;
+                }
+                if (fingerprint !== this.lastLocalStatusFingerprint) {
+                    this.lastLocalStatusFingerprint = fingerprint;
+                    if (fingerprint) {
+                        logger_logger.debug(`[Session ${this.sessionId}]`, "Detected local change via fallback status poll");
+                        this.saveProcessor?.queueSave();
+                    }
+                }
+            } catch (error) {
+                logger_logger.debug(`[Session ${this.sessionId}]`, `Fallback status poll failed: ${error.message}`);
+            } finally{
+                this.isPollingLocalChanges = false;
+            }
+        }
+        getLocalStatusFingerprint(status) {
+            const renamed = status.renamed.map((r)=>`${r.from}->${r.to}`).sort();
+            const modified = [
+                ...status.modified
+            ].sort();
+            const notAdded = [
+                ...status.notAdded
+            ].sort();
+            const created = [
+                ...status.created
+            ].sort();
+            const deleted = [
+                ...status.deleted
+            ].sort();
+            return [
+                ...renamed.map((r)=>`R:${r}`),
+                ...modified.map((m)=>`M:${m}`),
+                ...notAdded.map((n)=>`N:${n}`),
+                ...created.map((c)=>`C:${c}`),
+                ...deleted.map((d)=>`D:${d}`)
+            ].join("|");
+        }
         async handleFileChange(event, filePath, relativePath) {
             if (this.isCleanedUp || this.isPausedForUserInput) return;
             logger_logger.verbose(chalk_source.blue("File changed: ") + chalk_source.bold(relativePath));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anvil-works/anvil-cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "CLI tool for developing Anvil apps locally",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",