@anvil-works/anvil-cli 0.4.0 → 0.4.2

package/dist/cli.js

@@ -42545,30 +42545,6 @@ var __webpack_exports__ = {};
         if (/^https?:\/\//.test(url)) return url;
         return `https://${url}`;
     }
-    async function detectAnvilUrlFromRemotes(repoPath) {
-        try {
-            const git = esm_default(repoPath);
-            const remotes = await git.getRemotes(true);
-            for (const remote of remotes){
-                const fetchUrl = remote.refs.fetch;
-                if (!fetchUrl) continue;
-                const httpMatch = fetchUrl.match(/(https?:\/\/[^\/]+)\/git\/[A-Z0-9]+\.git/);
-                if (httpMatch) return {
-                    url: normalizeAnvilUrl(httpMatch[1])
-                };
-                const sshMatch = fetchUrl.match(/ssh:\/\/([^@]+)@([^:]+):(\d+)\/(?:git\/)?([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const username = decodeURIComponent(sshMatch[1]);
-                    const hostname = sshMatch[2];
-                    return {
-                        url: normalizeAnvilUrl(hostname),
-                        username
-                    };
-                }
-            }
-        } catch (_e) {}
-        return null;
-    }
     function resolveAnvilUrl() {
         const fromConfig = getConfig("anvilUrl");
         if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
@@ -47410,38 +47386,36 @@ var __webpack_exports__ = {};
             return null;
         }
     }
-    async function detectAppIdsFromRemotes(repoPath, anvilUrl) {
-        const git = esm_default(repoPath);
-        const out = [];
-        try {
-            const remotes = await git.getRemotes(true);
-            const url = new URL(anvilUrl);
-            const expectedHost = url.hostname;
-            for (const remote of remotes){
-                const httpMatch = remote.refs.fetch?.match(/(?:http|https):\/\/(?:[^@]+@)?([^:\/]+)(?::\d+)?\/git\/([A-Z0-9]+)\.git/);
-                if (httpMatch) {
-                    const [, host, detectedAppId] = httpMatch;
-                    if (host === expectedHost) {
-                        out.push({
-                            appId: detectedAppId,
-                            source: "remote",
-                            description: `Git remote '${remote.name}'`
-                        });
-                        continue;
-                    }
-                }
-                const sshMatch = remote.refs.fetch?.match(/ssh:\/\/(?:[^@]+@)?([^:\/]+):(\d+)\/([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const [, host, , detectedAppId] = sshMatch;
-                    if (host === expectedHost) out.push({
-                        appId: detectedAppId,
-                        source: "remote",
-                        description: `Git remote '${remote.name}' (SSH)`
-                    });
-                }
-            }
-        } catch (_e) {}
-        return out;
+    function filterCandidates(candidates, explicitUrl, explicitUsername) {
+        let filtered = candidates;
+        if (explicitUrl) {
+            const normalizedExplicit = normalizeAnvilUrl(explicitUrl);
+            filtered = filtered.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === normalizedExplicit);
+        }
+        if (explicitUsername) filtered = filtered.filter((c)=>!c.detectedUsername || c.detectedUsername === explicitUsername);
+        return filtered;
+    }
+    function formatCandidateLabel(candidate) {
+        const parts = [
+            candidate.appId
+        ];
+        if (candidate.detectedUrl) if (candidate.detectedUsername) parts.push(`(${candidate.detectedUsername} on ${candidate.detectedUrl})`);
+        else parts.push(`(${candidate.detectedUrl})`);
+        parts.push(`- ${candidate.description}`);
+        return parts.join(" ");
+    }
+    function lookupRemoteInfoForAppId(appId, detectedRemotes) {
+        const matches = detectedRemotes.filter((c)=>c.appId === appId);
+        if (0 === matches.length) return {};
+        const withUsername = matches.find((c)=>c.detectedUsername);
+        if (withUsername) return {
+            detectedUrl: withUsername.detectedUrl,
+            detectedUsername: withUsername.detectedUsername
+        };
+        return {
+            detectedUrl: matches[0].detectedUrl,
+            detectedUsername: matches[0].detectedUsername
+        };
     }
     async function detectAppIdsFromAllRemotes(repoPath) {
         const git = esm_default(repoPath);
@@ -47477,11 +47451,13 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIdsByCommitLookup(repoPath, anvilUrl) {
+    async function detectAppIdsByCommitLookup(repoPath, options) {
+        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
+        const username = options.username;
         const git = esm_default(repoPath);
         const out = [];
         try {
-            const authToken = await auth_getValidAuthToken(anvilUrl);
+            const authToken = await auth_getValidAuthToken(anvilUrl, username);
             const branchRef = await git.revparse([
                 "--abbrev-ref",
                 "HEAD"
@@ -47520,16 +47496,6 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIds(repoPath, options = {}) {
-        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
-        const results = [];
-        const includeReverseLookup = options.includeReverseLookup ?? true;
-        results.push(...await detectAppIdsFromRemotes(repoPath, anvilUrl));
-        if (0 === results.length && includeReverseLookup) results.push(...await detectAppIdsByCommitLookup(repoPath, anvilUrl));
-        const seen = new Set();
-        const unique = results.filter((c)=>seen.has(c.appId) ? false : (seen.add(c.appId), true));
-        return unique;
-    }
     class WebSocketClient extends Emitter_Emitter {
         ws = null;
         appId;
@@ -47540,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;
@@ -47552,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);
@@ -47567,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,
@@ -47577,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)}`);
@@ -47585,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"));
@@ -47594,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}`);
@@ -47653,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) {
@@ -49398,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();
@@ -49536,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() {
@@ -49569,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));
@@ -49834,7 +49926,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -49863,27 +49956,8 @@ var __webpack_exports__ = {};
         session.hasUncommittedChanges = hasUncommittedChanges;
         return session;
     }
-    async function resolveAnvilUrlWithPrompt(explicitUrl, repoPath, explicitUsername) {
-        let url;
-        let username = explicitUsername;
-        if (explicitUrl) url = normalizeAnvilUrl(explicitUrl);
-        else if (repoPath) {
-            const detected = await detectAnvilUrlFromRemotes(repoPath);
-            if (detected) {
-                url = detected.url;
-                if (!username && detected.username) username = detected.username;
-            } else url = resolveUrlFromAvailableOrConfig();
-        } else url = resolveUrlFromAvailableOrConfig();
-        if (!username) {
-            const accounts = auth_getAccountsForUrl(url);
-            if (1 === accounts.length) username = accounts[0];
-        }
-        return {
-            url,
-            username
-        };
-    }
-    function resolveUrlFromAvailableOrConfig() {
+    function resolveUrlForFallback(explicitUrl) {
+        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
         const availableUrls = getAvailableAnvilUrls();
         if (availableUrls.length > 0) return availableUrls[0];
         const fromConfig = getConfig("anvilUrl");
@@ -49911,11 +49985,16 @@ var __webpack_exports__ = {};
                     trimmed ? resolve(trimmed) : resolve(null);
                 });
             });
-            return manualAppId;
+            if (manualAppId) return {
+                appId: manualAppId,
+                source: "config",
+                description: "Manual entry"
+            };
+            return null;
         }
-        const choices = candidates.map((candidate)=>({
-                name: `${candidate.appId} (${candidate.description})`,
-                value: candidate.appId
+        const choices = candidates.map((candidate, index)=>({
+                name: formatCandidateLabel(candidate),
+                value: index
             }));
         choices.push({
             name: "Cancel",
@@ -49944,9 +50023,14 @@ var __webpack_exports__ = {};
                         trimmed ? resolve(trimmed) : resolve(null);
                     });
                 });
-                return manualAppId;
+                if (manualAppId) return {
+                    appId: manualAppId,
+                    source: "config",
+                    description: "Manual entry"
+                };
+                return null;
             }
-            return answer.appId;
+            return candidates[answer.appId];
         } catch (error) {
             const errorObj = error;
             if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
@@ -50384,137 +50468,100 @@ var __webpack_exports__ = {};
             const validationResult = await validateAnvilApp(repoPath);
             if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
             const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
-            const availableUrls = getAvailableAnvilUrls();
-            const resolved = await resolveAnvilUrlWithPrompt(explicitUrl, repoPath, explicitUsername);
-            let anvilUrl = resolved.url;
-            let username = resolved.username;
-            logger_logger.verbose(chalk_source.cyan("Resolved Anvil URL: ") + chalk_source.bold(anvilUrl));
-            if (username) logger_logger.verbose(chalk_source.cyan("Using username: ") + chalk_source.bold(username));
-            if (!explicitUrl) {
-                const detectedFromRemote = detectedFromAllRemotes.length > 0 && detectedFromAllRemotes[0].detectedUrl ? {
-                    url: normalizeAnvilUrl(detectedFromAllRemotes[0].detectedUrl),
-                    username: detectedFromAllRemotes[0].detectedUsername
-                } : null;
-                if (detectedFromRemote) {
-                    logger_logger.verbose(chalk_source.cyan("Detected Anvil URL from git remote: ") + chalk_source.bold(detectedFromRemote.url));
-                    if (!username && detectedFromRemote.username) {
-                        username = detectedFromRemote.username;
-                        logger_logger.verbose(chalk_source.cyan("Detected username from git remote: ") + chalk_source.bold(username));
-                    }
-                    anvilUrl = detectedFromRemote.url;
-                    if (hasTokensForUrl(detectedFromRemote.url, username)) logger_logger.verbose(chalk_source.green("✓ Using detected URL (has authentication tokens)"));
-                    else logger_logger.verbose(chalk_source.yellow("Using detected URL from remotes (auth will be checked)"));
-                } else if (1 === availableUrls.length) anvilUrl = normalizeAnvilUrl(availableUrls[0]);
-                else if (availableUrls.length > 1) {
-                    const choices = availableUrls.map((url)=>({
-                            name: url,
-                            value: url
-                        }));
-                    choices.push({
-                        name: "Cancel",
-                        value: null
-                    });
-                    const answer = await logger_logger.select("Multiple Anvil installations found. Which one would you like to use?", choices, availableUrls[0]);
-                    if (null === answer) {
-                        logger_logger.warn("Operation cancelled. To login to a new Anvil installation, run:");
-                        logger_logger.verbose(chalk_source.gray("   anvil login <anvil-url>"));
-                        process.exit(0);
+            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
+            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
+            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
+            let finalAppId;
+            let anvilUrl;
+            let username = explicitUsername;
+            if (explicitAppId) {
+                finalAppId = explicitAppId;
+                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
+                if (remoteInfo.detectedUrl && !explicitUrl) {
+                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
+                }
+                if (remoteInfo.detectedUsername && !explicitUsername) {
+                    username = remoteInfo.detectedUsername;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
+                }
+            } else {
+                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
+                if (0 === filteredCandidates.length) {
+                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
+                    const 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 reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
+                            anvilUrl: fallbackUrl,
+                            username: explicitUsername,
+                            includeRemotes: false
+                        });
+                        logger_logger.progressEnd("detect");
+                        for (const c of reverseLookupCandidates)filteredCandidates.push({
+                            ...c,
+                            detectedUrl: fallbackUrl
+                        });
+                    }
+                }
+                if (filteredCandidates.length > 0) {
+                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
+                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
+                }
+                if (useFirst && filteredCandidates.length > 0) {
+                    const selected = filteredCandidates[0];
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
+                } else {
+                    const selected = await selectAppId(filteredCandidates);
+                    if (!selected) {
+                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
+                        process.exit(1);
                     }
-                    anvilUrl = answer;
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
                 }
             }
+            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
+            else if (!anvilUrl) anvilUrl = resolveUrlForFallback();
+            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 username: ") + chalk_source.bold(username));
+                    logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(username));
                 } else if (accounts.length > 1) {
-                    logger_logger.error(`Multiple accounts found for ${anvilUrl}. Please specify which account to use with --user flag.`);
-                    logger_logger.verbose(chalk_source.gray(`Available accounts: ${accounts.join(", ")}`));
-                    process.exit(1);
-                }
-            }
-            anvilUrl = normalizeAnvilUrl(anvilUrl);
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            const detectedUrls = new Set(detectedFromAllRemotes.map((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl)).filter(Boolean));
-            const normalizedSelected = normalizeAnvilUrl(anvilUrl);
-            if (explicitUrl && detectedFromAllRemotes.length > 0 && !detectedUrls.has(normalizedSelected)) {
-                const detectedUrl = Array.from(detectedUrls)[0];
-                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 watch --url ${detectedUrl}`));
-            }
-            const candidatesForSelectedUrl = detectedFromAllRemotes.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === normalizedSelected);
-            if (candidatesForSelectedUrl.length > 0) for (const candidate of candidatesForSelectedUrl){
-                const isLoggedInAny = hasTokensForUrl(normalizedSelected);
-                const isLoggedInWithUsername = candidate.detectedUsername ? hasTokensForUrl(normalizedSelected, candidate.detectedUsername) : false;
-                const loggedInAccounts = auth_getAccountsForUrl(normalizedSelected);
-                if (isLoggedInAny) {
-                    if (candidate.detectedUsername && !isLoggedInWithUsername) {
-                        logger_logger.warn(chalk_source.yellow("Detected from git remote: ") + chalk_source.bold(`app ID ${candidate.appId}`) + chalk_source.yellow(" on ") + chalk_source.bold(normalizedSelected) + chalk_source.yellow(" with username ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.yellow(", but you're logged in as ") + chalk_source.bold(loggedInAccounts.join(", ")) + chalk_source.yellow("."));
-                        logger_logger.info(chalk_source.gray("   To log in, run: ") + chalk_source.cyan(`anvil login ${normalizedSelected}`));
-                        logger_logger.info(chalk_source.gray("   Make sure you're logged in as ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.gray(" in your browser."));
+                    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);
                     }
-                } else {
-                    logger_logger.warn(chalk_source.yellow("Detected from git remote: ") + chalk_source.bold(`app ID ${candidate.appId}`) + chalk_source.yellow(" on ") + chalk_source.bold(normalizedSelected) + chalk_source.yellow(", but you're not logged in to this URL."));
-                    logger_logger.info(chalk_source.gray("   To log in, run: ") + chalk_source.cyan(`anvil login ${normalizedSelected}`));
-                    if (candidate.detectedUsername) logger_logger.info(chalk_source.gray("   Make sure you're logged in as ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.gray(" in your browser."));
+                    username = selected;
                 }
             }
+            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
             if (!hasTokensForUrl(anvilUrl, username)) {
                 if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
                 else logger_logger.error(`Not logged in to ${anvilUrl}`);
                 logger_logger.verbose(chalk_source.yellow("Please log in first:"));
-                console.log(chalk_source.cyan(`   anvil login ${anvilUrl}`));
+                console.log(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
                 process.exit(1);
             }
-            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found for this URL"));
-            let finalAppId = explicitAppId;
-            if (!finalAppId) {
-                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
-                logger_logger.progress("detect", "Auto-detecting app ID...");
-                let candidates = await detectAppIds(repoPath, {
-                    includeReverseLookup: false,
-                    anvilUrl
-                });
-                logger_logger.progressEnd("detect");
-                if (0 === candidates.length) {
-                    logger_logger.verbose(chalk_source.gray("Fast lookup found no matching app IDs."));
-                    const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} for matching app IDs? (slower)`, true);
-                    if (shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${anvilUrl} for matching app IDs...`);
-                        candidates = await detectAppIds(repoPath, {
-                            anvilUrl
-                        });
-                        logger_logger.progressEnd("detect");
-                    }
-                }
-                if (candidates.length > 0) {
-                    logger_logger.verbose(chalk_source.gray("Checking git remotes:"));
-                    candidates.filter((c)=>"remote" === c.source).forEach((c)=>{
-                        logger_logger.verbose(chalk_source.gray(`   Found: ${c.description}`));
-                        logger_logger.verbose(chalk_source.green("Found app ID in remote: ") + chalk_source.bold(c.appId));
-                    });
-                    if (candidates.some((c)=>"config" === c.source)) candidates.filter((c)=>"config" === c.source).forEach((c)=>{
-                        logger_logger.verbose(chalk_source.gray(`Checking ${c.description.split("'")[1]} config...`));
-                        logger_logger.verbose(chalk_source.green("Found app ID in config: ") + chalk_source.bold(c.appId));
-                    });
-                    if (candidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${candidates.length} potential app IDs:`));
-                }
-                if (useFirst && candidates.length > 0) {
-                    finalAppId = candidates[0].appId;
-                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
-                } else {
-                    const selectedAppId = await selectAppId(candidates);
-                    if (!selectedAppId) {
-                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
-                        process.exit(1);
-                    }
-                    finalAppId = selectedAppId;
-                }
-            }
-            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
+            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
             logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
             const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
             logger_logger.progressEnd("validate");

package/dist/index.js

@@ -11980,28 +11980,35 @@ var __webpack_exports__ = {};
     "use strict";
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        syncToLatest: ()=>syncToLatest,
-        validateAnvilApp: ()=>validateAnvilApp,
-        validateBranchSyncStatus: ()=>validateBranchSyncStatus,
         verifyAuth: ()=>verifyAuth,
-        watch: ()=>api_watch,
-        detectAppIds: ()=>detectAppIds,
-        hasTokensForUrl: ()=>hasTokensForUrl,
+        lookupRemoteInfoForAppId: ()=>lookupRemoteInfoForAppId,
+        validateBranchSyncStatus: ()=>validateBranchSyncStatus,
+        AppIdWithContext: ()=>anvil_api_namespaceObject.AppIdWithContext,
         checkUncommittedChanges: ()=>checkUncommittedChanges,
-        getValidAuthToken: ()=>auth_getValidAuthToken,
-        login: ()=>login,
+        hasTokensForUrl: ()=>hasTokensForUrl,
+        validateAnvilApp: ()=>validateAnvilApp,
         logout: ()=>logout,
         detectAppIdsFromAllRemotes: ()=>detectAppIdsFromAllRemotes,
+        BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus,
+        formatCandidateLabel: ()=>formatCandidateLabel,
+        syncToLatest: ()=>syncToLatest,
+        filterCandidates: ()=>filterCandidates,
+        getValidAuthToken: ()=>auth_getValidAuthToken,
+        login: ()=>login,
+        watch: ()=>api_watch,
         AppIdCandidate: ()=>anvil_api_namespaceObject.AppIdCandidate,
-        BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus
+        detectAppIdsByCommitLookup: ()=>detectAppIdsByCommitLookup
     });
     var anvil_api_namespaceObject = {};
     __webpack_require__.r(anvil_api_namespaceObject);
     __webpack_require__.d(anvil_api_namespaceObject, {
-        PH: ()=>detectAppIds,
+        lx: ()=>detectAppIdsByCommitLookup,
         NZ: ()=>detectAppIdsFromAllRemotes,
+        rZ: ()=>filterCandidates,
+        T_: ()=>formatCandidateLabel,
         OI: ()=>getGitFetchUrl,
-        $0: ()=>getWebSocketUrl
+        $0: ()=>getWebSocketUrl,
+        Wj: ()=>lookupRemoteInfoForAppId
     });
     var validation_namespaceObject = {};
     __webpack_require__.r(validation_namespaceObject);
@@ -22516,38 +22523,36 @@ var __webpack_exports__ = {};
     function getWebSocketUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
         return anvilUrl.replace(/^http/, "ws") + `/ide/api/_/apps/${appId}/ws?access_token=${authToken}`;
     }
-    async function detectAppIdsFromRemotes(repoPath, anvilUrl) {
-        const git = esm_default(repoPath);
-        const out = [];
-        try {
-            const remotes = await git.getRemotes(true);
-            const url = new URL(anvilUrl);
-            const expectedHost = url.hostname;
-            for (const remote of remotes){
-                const httpMatch = remote.refs.fetch?.match(/(?:http|https):\/\/(?:[^@]+@)?([^:\/]+)(?::\d+)?\/git\/([A-Z0-9]+)\.git/);
-                if (httpMatch) {
-                    const [, host, detectedAppId] = httpMatch;
-                    if (host === expectedHost) {
-                        out.push({
-                            appId: detectedAppId,
-                            source: "remote",
-                            description: `Git remote '${remote.name}'`
-                        });
-                        continue;
-                    }
-                }
-                const sshMatch = remote.refs.fetch?.match(/ssh:\/\/(?:[^@]+@)?([^:\/]+):(\d+)\/([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const [, host, , detectedAppId] = sshMatch;
-                    if (host === expectedHost) out.push({
-                        appId: detectedAppId,
-                        source: "remote",
-                        description: `Git remote '${remote.name}' (SSH)`
-                    });
-                }
-            }
-        } catch (_e) {}
-        return out;
+    function filterCandidates(candidates, explicitUrl, explicitUsername) {
+        let filtered = candidates;
+        if (explicitUrl) {
+            const normalizedExplicit = config_normalizeAnvilUrl(explicitUrl);
+            filtered = filtered.filter((c)=>c.detectedUrl && config_normalizeAnvilUrl(c.detectedUrl) === normalizedExplicit);
+        }
+        if (explicitUsername) filtered = filtered.filter((c)=>!c.detectedUsername || c.detectedUsername === explicitUsername);
+        return filtered;
+    }
+    function formatCandidateLabel(candidate) {
+        const parts = [
+            candidate.appId
+        ];
+        if (candidate.detectedUrl) if (candidate.detectedUsername) parts.push(`(${candidate.detectedUsername} on ${candidate.detectedUrl})`);
+        else parts.push(`(${candidate.detectedUrl})`);
+        parts.push(`- ${candidate.description}`);
+        return parts.join(" ");
+    }
+    function lookupRemoteInfoForAppId(appId, detectedRemotes) {
+        const matches = detectedRemotes.filter((c)=>c.appId === appId);
+        if (0 === matches.length) return {};
+        const withUsername = matches.find((c)=>c.detectedUsername);
+        if (withUsername) return {
+            detectedUrl: withUsername.detectedUrl,
+            detectedUsername: withUsername.detectedUsername
+        };
+        return {
+            detectedUrl: matches[0].detectedUrl,
+            detectedUsername: matches[0].detectedUsername
+        };
     }
     async function detectAppIdsFromAllRemotes(repoPath) {
         const git = esm_default(repoPath);
@@ -22583,11 +22588,13 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIdsByCommitLookup(repoPath, anvilUrl) {
+    async function detectAppIdsByCommitLookup(repoPath, options) {
+        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
+        const username = options.username;
         const git = esm_default(repoPath);
         const out = [];
         try {
-            const authToken = await auth_getValidAuthToken(anvilUrl);
+            const authToken = await auth_getValidAuthToken(anvilUrl, username);
             const branchRef = await git.revparse([
                 "--abbrev-ref",
                 "HEAD"
@@ -22626,16 +22633,6 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIds(repoPath, options = {}) {
-        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
-        const results = [];
-        const includeReverseLookup = options.includeReverseLookup ?? true;
-        results.push(...await detectAppIdsFromRemotes(repoPath, anvilUrl));
-        if (0 === results.length && includeReverseLookup) results.push(...await detectAppIdsByCommitLookup(repoPath, anvilUrl));
-        const seen = new Set();
-        const unique = results.filter((c)=>seen.has(c.appId) ? false : (seen.add(c.appId), true));
-        return unique;
-    }
     class WebSocketClient extends Emitter {
         ws = null;
         appId;
@@ -22646,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;
@@ -22658,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);
@@ -22673,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,
@@ -22683,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)}`);
@@ -22691,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"));
@@ -22700,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}`);
@@ -22759,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) {
@@ -25003,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();
@@ -25141,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() {
@@ -25174,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));
@@ -25459,7 +25582,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -25490,14 +25614,18 @@ var __webpack_exports__ = {};
     }
 })();
 exports.AppIdCandidate = __webpack_exports__.AppIdCandidate;
+exports.AppIdWithContext = __webpack_exports__.AppIdWithContext;
 exports.BranchSyncStatus = __webpack_exports__.BranchSyncStatus;
 exports.checkUncommittedChanges = __webpack_exports__.checkUncommittedChanges;
-exports.detectAppIds = __webpack_exports__.detectAppIds;
+exports.detectAppIdsByCommitLookup = __webpack_exports__.detectAppIdsByCommitLookup;
 exports.detectAppIdsFromAllRemotes = __webpack_exports__.detectAppIdsFromAllRemotes;
+exports.filterCandidates = __webpack_exports__.filterCandidates;
+exports.formatCandidateLabel = __webpack_exports__.formatCandidateLabel;
 exports.getValidAuthToken = __webpack_exports__.getValidAuthToken;
 exports.hasTokensForUrl = __webpack_exports__.hasTokensForUrl;
 exports.login = __webpack_exports__.login;
 exports.logout = __webpack_exports__.logout;
+exports.lookupRemoteInfoForAppId = __webpack_exports__.lookupRemoteInfoForAppId;
 exports.syncToLatest = __webpack_exports__.syncToLatest;
 exports.validateAnvilApp = __webpack_exports__.validateAnvilApp;
 exports.validateBranchSyncStatus = __webpack_exports__.validateBranchSyncStatus;
@@ -25505,14 +25633,18 @@ exports.verifyAuth = __webpack_exports__.verifyAuth;
 exports.watch = __webpack_exports__.watch;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AppIdCandidate",
+    "AppIdWithContext",
     "BranchSyncStatus",
     "checkUncommittedChanges",
-    "detectAppIds",
+    "detectAppIdsByCommitLookup",
     "detectAppIdsFromAllRemotes",
+    "filterCandidates",
+    "formatCandidateLabel",
     "getValidAuthToken",
     "hasTokensForUrl",
     "login",
     "logout",
+    "lookupRemoteInfoForAppId",
     "syncToLatest",
     "validateAnvilApp",
     "validateBranchSyncStatus",

package/package.json

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