@anvil-works/anvil-cli 0.4.2 → 0.4.3

package/README.md

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

package/dist/cli.js

@@ -49956,13 +49956,84 @@ var __webpack_exports__ = {};
         session.hasUncommittedChanges = hasUncommittedChanges;
         return session;
     }
-    function resolveUrlForFallback(explicitUrl) {
-        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
-        const availableUrls = getAvailableAnvilUrls();
-        if (availableUrls.length > 0) return availableUrls[0];
+    function decideFallbackUrl(explicitUrl, availableUrls = getAvailableAnvilUrls()) {
+        if (explicitUrl) return {
+            source: "explicit",
+            url: normalizeAnvilUrl(explicitUrl)
+        };
+        if (availableUrls.length > 1) return {
+            source: "available-multiple",
+            urls: availableUrls
+        };
+        if (1 === availableUrls.length) return {
+            source: "available-single",
+            url: availableUrls[0]
+        };
         const fromConfig = getConfig("anvilUrl");
-        if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
-        return isDevMode() ? "http://localhost:3000" : "https://anvil.works";
+        if ("string" == typeof fromConfig && fromConfig.trim()) return {
+            source: "config",
+            url: normalizeAnvilUrl(fromConfig.trim())
+        };
+        return {
+            source: "default",
+            url: isDevMode() ? "http://localhost:3000" : "https://anvil.works"
+        };
+    }
+    function decideUsernameForUrl(accounts) {
+        if (0 === accounts.length) return {
+            source: "none"
+        };
+        if (1 === accounts.length) return {
+            source: "single",
+            username: accounts[0]
+        };
+        return {
+            source: "multiple",
+            usernames: [
+                ...accounts
+            ]
+        };
+    }
+    async function resolveUsernameForUrl(anvilUrl, explicitUsername, promptMessage = "Multiple accounts found. Which account owns this app?") {
+        if (explicitUsername) return explicitUsername;
+        const decision = decideUsernameForUrl(auth_getAccountsForUrl(anvilUrl));
+        if ("none" === decision.source) return;
+        if ("single" === decision.source) {
+            logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(decision.username));
+            return decision.username;
+        }
+        const choices = decision.usernames.map((acct)=>({
+                name: acct,
+                value: acct
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        return logger_logger.select(promptMessage, choices, decision.usernames[0]);
+    }
+    async function confirmReverseLookupWithResolvedUser(anvilUrl, username) {
+        const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username, `Multiple accounts found for ${anvilUrl}. Which account should be used for app lookup?`);
+        if (null === resolvedUsername) return null;
+        const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} ${resolvedUsername ? `for ${resolvedUsername}` : ""} for matching app IDs? (slower)`, true);
+        return {
+            username: resolvedUsername,
+            shouldContinue
+        };
+    }
+    async function resolveUrlForFallback(explicitUrl) {
+        const decision = decideFallbackUrl(explicitUrl);
+        if ("available-multiple" !== decision.source) return decision.url;
+        const choices = decision.urls.map((url)=>({
+                name: url,
+                value: url
+            }));
+        choices.push({
+            name: "Cancel",
+            value: null
+        });
+        const selectedUrl = await logger_logger.select("Multiple logged-in Anvil URLs found. Which one would you like to use?", choices, decision.urls[0]);
+        return selectedUrl;
     }
     async function selectAppId(candidates) {
         if (0 === candidates.length) {
@@ -50474,6 +50545,7 @@ var __webpack_exports__ = {};
             let finalAppId;
             let anvilUrl;
             let username = explicitUsername;
+            let fallbackUrl;
             if (explicitAppId) {
                 finalAppId = explicitAppId;
                 const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
@@ -50489,13 +50561,23 @@ var __webpack_exports__ = {};
                 logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
                 if (0 === filteredCandidates.length) {
                     logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
-                    const fallbackUrl = resolveUrlForFallback(explicitUrl);
-                    const shouldContinue = await logger_logger.confirm(`Search ${fallbackUrl} for matching app IDs? (slower)`, true);
-                    if (shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${explicitUsername ? `for ${explicitUsername}` : ''} for matching app IDs...`);
+                    const resolvedFallbackUrl = await resolveUrlForFallback(explicitUrl);
+                    if (null === resolvedFallbackUrl) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    fallbackUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+                    const lookupDecision = await confirmReverseLookupWithResolvedUser(fallbackUrl, username);
+                    if (null === lookupDecision) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
+                    }
+                    username = lookupDecision.username;
+                    if (lookupDecision.shouldContinue) {
+                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${username ? `for ${username}` : ""} for matching app IDs...`);
                         const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
                             anvilUrl: fallbackUrl,
-                            username: explicitUsername,
+                            username,
                             includeRemotes: false
                         });
                         logger_logger.progressEnd("detect");
@@ -50527,32 +50609,24 @@ var __webpack_exports__ = {};
                 }
             }
             if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
-            else if (!anvilUrl) anvilUrl = resolveUrlForFallback();
+            else if (!anvilUrl) if (fallbackUrl) anvilUrl = fallbackUrl;
+            else {
+                const resolvedFallbackUrl = await resolveUrlForFallback();
+                if (null === resolvedFallbackUrl) {
+                    logger_logger.warn("Operation cancelled.");
+                    process.exit(0);
+                }
+                anvilUrl = normalizeAnvilUrl(resolvedFallbackUrl);
+            }
             anvilUrl = normalizeAnvilUrl(anvilUrl);
             logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
             logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            if (!username) {
-                const accounts = auth_getAccountsForUrl(anvilUrl);
-                if (1 === accounts.length) {
-                    username = accounts[0];
-                    logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(username));
-                } else if (accounts.length > 1) {
-                    const choices = accounts.map((acct)=>({
-                            name: acct,
-                            value: acct
-                        }));
-                    choices.push({
-                        name: "Cancel",
-                        value: null
-                    });
-                    const selected = await logger_logger.select("Multiple accounts found. Which account owns this app?", choices, accounts[0]);
-                    if (null === selected) {
-                        logger_logger.warn("Operation cancelled.");
-                        process.exit(0);
-                    }
-                    username = selected;
-                }
+            const resolvedUsername = await resolveUsernameForUrl(anvilUrl, username);
+            if (null === resolvedUsername) {
+                logger_logger.warn("Operation cancelled.");
+                process.exit(0);
             }
+            username = resolvedUsername;
             if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
             if (!hasTokensForUrl(anvilUrl, username)) {
                 if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
@@ -51359,6 +51433,13 @@ var __webpack_exports__ = {};
         });
         loginCommand.addHelpText("after", "\n" + chalk_source.bold("Examples:") + "\n  anvil login                    Log in to default Anvil server\n  anvil login anvil.works        Log in to anvil.works\n  anvil login localhost          Log in to local Anvil server\n");
     }
+    function getTotalLoggedInAccounts(urls) {
+        return urls.reduce((total, url)=>total + auth_getAccountsForUrl(url).length, 0);
+    }
+    function formatMultiAccountLogoutPrompt(totalAccounts, urlCount) {
+        if (urlCount <= 1) return `You have ${totalAccounts} logged-in accounts. What would you like to do?`;
+        return `You have ${totalAccounts} logged-in accounts across ${urlCount} URLs. What would you like to do?`;
+    }
     function registerLogoutCommand(program) {
         const logoutCommand = program.command("logout [anvil-server-url]").description("Log out from Anvil (optionally specify URL to logout from specific installation)").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL to logout from").option("-U, --user <USERNAME>", "Specify which user account to logout from").alias("lo").action(async (anvilUrl, options)=>{
             try {
@@ -51372,8 +51453,9 @@ var __webpack_exports__ = {};
                     else logger_logger.info(result.message || `Not logged in to ${normalized}. No action needed.`);
                 } else {
                     const availableUrls = getAvailableAnvilUrls();
-                    if (0 === availableUrls.length) logger_logger.warn("No logged-in accounts found.");
-                    else if (1 === availableUrls.length) {
+                    const totalAccounts = getTotalLoggedInAccounts(availableUrls);
+                    if (0 === totalAccounts) logger_logger.warn("No logged-in accounts found.");
+                    else if (1 === totalAccounts) {
                         const result = await logout();
                         if (result.loggedOut) logger_logger.success("Logged out.");
                     } else {
@@ -51391,7 +51473,7 @@ var __webpack_exports__ = {};
                                 value: "cancel"
                             }
                         ];
-                        const action = await logger_logger.select(`You have ${availableUrls.length} logged-in accounts. What would you like to do?`, choices, "one");
+                        const action = await logger_logger.select(formatMultiAccountLogoutPrompt(totalAccounts, availableUrls.length), choices, "one");
                         if ("cancel" === action) return void logger_logger.info("Logout cancelled.");
                         if ("all" === action) {
                             const result = await logout();
@@ -51490,17 +51572,21 @@ var __webpack_exports__ = {};
                         let totalAccounts = 0;
                         for (const url of urls){
                             const urlData = authTokens[url];
-                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) totalAccounts += Object.keys(urlData).length;
+                            if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
+                                const usernames = Object.keys(urlData);
+                                totalAccounts += usernames.filter((username)=>hasTokensForUrl(url, username)).length;
+                            }
                         }
-                        console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${totalAccounts} account(s) across ${urls.length} URL(s)`)}`);
+                        console.log(chalk_source.cyan("authTokens") + ` = ${chalk_source.gray(`${totalAccounts} logged-in account(s) across ${urls.length} URL(s)`)}`);
                         for (const url of urls){
                             const urlData = authTokens[url];
                             if (urlData && "object" == typeof urlData && !Array.isArray(urlData)) {
                                 const usernames = Object.keys(urlData).sort();
                                 if (usernames.length > 0) for (const username of usernames){
                                     const accountData = urlData[username];
-                                    const hasToken = !!(accountData?.authToken || accountData?.refreshToken);
-                                    const status = hasToken ? chalk_source.green("✓ logged in") : chalk_source.gray("(no tokens)");
+                                    const hasConfigTokens = !!(accountData?.authToken || accountData?.refreshToken);
+                                    const hasAnyTokens = hasTokensForUrl(url, username);
+                                    const status = hasConfigTokens ? chalk_source.green("✓ logged in (config)") : hasAnyTokens ? chalk_source.green("✓ logged in (keychain)") : chalk_source.gray("(no tokens)");
                                     console.log(chalk_source.gray(`  ${url}: ${username} ${status}`));
                                 }
                             }

package/package.json

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