@anvil-works/anvil-cli 0.4.0 → 0.4.1

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;
@@ -49834,7 +49800,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -49863,27 +49830,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 +49859,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 +49897,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 +50342,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
+                        });
                     }
-                    anvilUrl = answer;
+                }
+                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);
+                    }
+                    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;
@@ -25459,7 +25456,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -25490,14 +25488,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 +25507,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.1",
   "description": "CLI tool for developing Anvil apps locally",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",