@anvil-works/anvil-cli 0.5.11 → 0.5.13

package/README.md

@@ -172,6 +172,7 @@ Useful options:
 
 ```bash
 anvil login
+anvil login anvil.company.com
 anvil logout
 anvil config list
 anvil config get <key>
@@ -260,6 +261,19 @@ If you want to change the default server permanently:
 anvil config set anvilUrl https://anvil.company.com
 ```
 
+When you run `anvil login`, the CLI now supports both local and headless flows:
+
+- press `Enter` to open the default browser
+- or copy the printed device-login URL and code to continue in a browser of your choice
+
+For `anvil login`, prefer the positional server argument in docs and examples:
+
+```bash
+anvil login anvil.company.com
+```
+
+`--url` is also supported if needed.
+
 ## Troubleshooting
 
 ### `anvil` command not found

package/dist/cli.js

@@ -51890,34 +51890,134 @@ var __webpack_exports__ = {};
     </body>
   </html>`;
     }
+    const CLIENT_ID = "anvil-sync";
+    const SCOPES = "apps:read apps:write user:read";
     function oauth_login_base64url(buf) {
         return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
     }
-    async function waitForOAuthWithPrompt(authUrl, oauthPromise) {
+    function sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    function createBrowserLaunchPrompt(authUrl) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) return {
+            waitForOpen: Promise.resolve(false),
+            close: ()=>{}
+        };
         const rl = external_readline_namespaceObject.createInterface({
             input: process.stdin,
             output: process.stdout
         });
-        const enterPromise = new Promise((resolve)=>{
-            rl.question(chalk_source.gray("Press Enter to open browser (or visit URL manually)... "), ()=>resolve("enter"));
-        });
-        const result = await Promise.race([
-            enterPromise,
-            oauthPromise.then((r)=>({
-                    oauth: r
-                }))
-        ]);
-        if ("enter" === result) {
+        let closed = false;
+        let resolveWait = null;
+        const close = (opened = false)=>{
+            if (closed) return;
+            closed = true;
             rl.close();
-            await node_modules_open(authUrl.toString());
-            logger_logger.info(chalk_source.cyan("Waiting for login to complete in browser...\n"));
-            return await oauthPromise;
+            resolveWait?.(opened);
+            resolveWait = null;
+        };
+        const waitForOpen = new Promise((resolve)=>{
+            resolveWait = resolve;
+            rl.on("SIGINT", ()=>{
+                close();
+                process.kill(process.pid, "SIGINT");
+            });
+            rl.question("", async ()=>{
+                try {
+                    await node_modules_open(authUrl);
+                    logger_logger.info(chalk_source.dim("Opened your browser to continue login."));
+                    close(true);
+                } catch  {
+                    logger_logger.warn("Could not open a browser automatically.");
+                    close(false);
+                }
+            });
+        });
+        return {
+            waitForOpen,
+            close
+        };
+    }
+    async function parseOAuthError(response) {
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+            const data = await response.json();
+            return data.error || `HTTP ${response.status}`;
+        }
+        const text = (await response.text()).trim();
+        if (!text) return `HTTP ${response.status}`;
+        try {
+            const parsed = JSON.parse(text);
+            return parsed.error || text;
+        } catch  {
+            return text;
         }
-        rl.close();
-        process.stdout.write("\r" + " ".repeat(60) + "\r");
-        return result.oauth;
     }
-    async function runInteractiveLoginFlow(anvilUrl) {
+    async function exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier) {
+        const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code,
+                redirect_uri: redirectUri,
+                client_id: CLIENT_ID,
+                code_verifier: codeVerifier
+            })
+        });
+        if (!tokenResponse.ok) throw new Error(`Failed to exchange authorization code for token. ${await parseOAuthError(tokenResponse)}`);
+        return await tokenResponse.json();
+    }
+    async function requestDeviceAuthorization(anvilUrl) {
+        const response = await fetch(`${anvilUrl}/oauth/device_authorization`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams({
+                client_id: CLIENT_ID,
+                scope: SCOPES
+            })
+        });
+        if (!response.ok) throw new Error(`Failed to start device login. ${await parseOAuthError(response)}`);
+        return await response.json();
+    }
+    async function pollDeviceAuthorization(anvilUrl, deviceAuth, options) {
+        const expiresAt = Date.now() + 1000 * deviceAuth.expires_in;
+        let intervalMs = 1000 * Math.max(deviceAuth.interval ?? 5, 1);
+        while(Date.now() < expiresAt){
+            if (options?.isCancelled?.()) throw new Error("cancelled");
+            const response = await fetch(`${anvilUrl}/oauth/token`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded"
+                },
+                body: new URLSearchParams({
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                    device_code: deviceAuth.device_code,
+                    client_id: CLIENT_ID
+                })
+            });
+            if (response.ok) return await response.json();
+            const error = await parseOAuthError(response);
+            if ("authorization_pending" === error) {
+                await sleep(intervalMs);
+                continue;
+            }
+            if ("slow_down" === error) {
+                intervalMs += 1000;
+                await sleep(intervalMs);
+                continue;
+            }
+            if ("access_denied" === error) throw new Error("Device login was denied.");
+            if ("expired_token" === error || "invalid_grant" === error) break;
+            throw new Error(`Device login failed. ${error}`);
+        }
+        throw new Error("Device login expired before it was approved.");
+    }
+    async function createPkceLoginFlow(anvilUrl) {
         const codeVerifier = external_crypto_.randomBytes(48).toString("hex");
         const codeChallenge = oauth_login_base64url(external_crypto_.createHash("sha256").update(codeVerifier, "ascii").digest());
         const state = external_crypto_.randomBytes(16).toString("hex");
@@ -51927,10 +52027,9 @@ var __webpack_exports__ = {};
         if (!address || "string" == typeof address) throw new Error("No address");
         const port = address.port;
         const redirectUri = `http://127.0.0.1:${port}/oauth-callback`;
-        const SCOPES = "apps:read apps:write user:read";
         const authUrl = new URL(`${anvilUrl}/oauth/authorize`);
         authUrl.searchParams.set("response_type", "code");
-        authUrl.searchParams.set("client_id", "anvil-sync");
+        authUrl.searchParams.set("client_id", CLIENT_ID);
         authUrl.searchParams.set("redirect_uri", redirectUri);
         authUrl.searchParams.set("scope", SCOPES);
         authUrl.searchParams.set("state", state);
@@ -51964,37 +52063,84 @@ var __webpack_exports__ = {};
                 server.close();
             });
         });
-        logger_logger.info(chalk_source.blue("Link to your Anvil account to continue."));
+        let closed = false;
+        server.on("close", ()=>{
+            closed = true;
+        });
+        const close = async ()=>{
+            if (closed) return;
+            closed = true;
+            server.closeAllConnections();
+            if (!server.listening) return;
+            await new Promise((resolve)=>server.close(()=>resolve()));
+        };
+        return {
+            authUrl,
+            close,
+            waitForLogin: (async ()=>{
+                const { code, error, recvState } = await codePromise;
+                if (recvState !== state) throw new Error("Invalid state received from OAuth callback");
+                if (error) throw new Error(`Error received from OAuth callback: ${error}`);
+                const tokenData = await exchangeAuthorizationCodeForTokens(anvilUrl, redirectUri, code, codeVerifier);
+                return login(anvilUrl, {
+                    access_token: tokenData.access_token,
+                    refresh_token: tokenData.refresh_token,
+                    expires_in: tokenData.expires_in,
+                    scope: tokenData.scope
+                });
+            })()
+        };
+    }
+    function raceLoginAttempts(attempts) {
+        return new Promise((resolve, reject)=>{
+            let remaining = attempts.length;
+            let lastError = null;
+            for (const attempt of attempts)attempt.then(resolve).catch((error)=>{
+                if ("cancelled" === error.message) return;
+                remaining -= 1;
+                lastError = error;
+                if (0 === remaining && lastError) reject(lastError);
+            });
+        });
+    }
+    async function runInteractiveLoginFlow(anvilUrl) {
+        const pkceFlow = await createPkceLoginFlow(anvilUrl);
+        const deviceAuth = await requestDeviceAuthorization(anvilUrl);
+        const browserPrompt = createBrowserLaunchPrompt(pkceFlow.authUrl.toString());
+        let settled = false;
+        let spinnerStarted = false;
+        logger_logger.info(chalk_source.dim(`Logging in to ${anvilUrl}`));
         console.log();
-        logger_logger.info(chalk_source.gray(`   ${authUrl}`));
+        logger_logger.info(chalk_source.dim("Visit:"), `${deviceAuth.verification_uri_complete || deviceAuth.verification_uri}`);
+        logger_logger.info(chalk_source.dim("Device code:"), `${deviceAuth.user_code}`);
         console.log();
-        const { code, error, recvState } = await waitForOAuthWithPrompt(authUrl, codePromise);
-        if (recvState !== state) throw new Error("Invalid state received from OAuth callback");
-        if (error) throw new Error(`Error received from OAuth callback: ${error}`);
-        const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: new URLSearchParams({
-                grant_type: "authorization_code",
-                code: code,
-                redirect_uri: redirectUri,
-                client_id: "anvil-sync",
-                code_verifier: codeVerifier
-            })
+        logger_logger.info("OR Press ENTER to open a browser...");
+        browserPrompt.waitForOpen.then((opened)=>{
+            if (opened && !settled) {
+                spinnerStarted = true;
+                logger_logger.progress("login", "Waiting for login to complete...");
+            }
         });
-        if (!tokenResponse.ok) {
-            const errorText = await tokenResponse.text();
-            throw new Error(`Failed to exchange authorization code for token. ${errorText}`);
+        try {
+            const result = await raceLoginAttempts([
+                pkceFlow.waitForLogin,
+                pollDeviceAuthorization(anvilUrl, deviceAuth, {
+                    isCancelled: ()=>settled
+                }).then(async (tokenData)=>login(anvilUrl, {
+                        access_token: tokenData.access_token,
+                        refresh_token: tokenData.refresh_token,
+                        expires_in: tokenData.expires_in,
+                        scope: tokenData.scope
+                    }))
+            ]);
+            settled = true;
+            return result;
+        } finally{
+            settled = true;
+            browserPrompt.close();
+            if (spinnerStarted) logger_logger.progressEnd("login");
+            await pkceFlow.close();
         }
-        const tokenData = await tokenResponse.json();
-        return login(anvilUrl, {
-            access_token: tokenData.access_token,
-            refresh_token: tokenData.refresh_token,
-            expires_in: tokenData.expires_in,
-            scope: tokenData.scope
-        });
     }
     const CHECKOUT_ERROR_VALUE = "__ERROR__";
     function isAbortLikeError(error) {
@@ -52501,10 +52647,19 @@ var __webpack_exports__ = {};
         return appId;
     }
     async function resolveCheckoutUrl(explicitUrl, parsedUrl) {
-        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
-        if (parsedUrl) return normalizeAnvilUrl(parsedUrl);
+        if (explicitUrl) {
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from --url: ") + chalk_source.bold(normalizeAnvilUrl(explicitUrl)));
+            return normalizeAnvilUrl(explicitUrl);
+        }
+        if (parsedUrl) {
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL from checkout input: ") + chalk_source.bold(normalizeAnvilUrl(parsedUrl)));
+            return normalizeAnvilUrl(parsedUrl);
+        }
         const decision = decideFallbackUrl(void 0);
-        if ("available-multiple" !== decision.source) return decision.url;
+        if ("available-multiple" !== decision.source) {
+            if (decision.url) logger_logger.verbose(chalk_source.cyan("Using configured Anvil URL: ") + chalk_source.bold(decision.url));
+            return decision.url;
+        }
         const choices = decision.urls.map((url)=>({
                 name: url,
                 value: url
@@ -52550,6 +52705,7 @@ var __webpack_exports__ = {};
     }
     async function ensureCheckoutAuthToken(anvilUrl, username, deps = defaultCheckoutDeps) {
         try {
+            logger_logger.verbose(chalk_source.cyan("Checking auth token for: ") + chalk_source.bold(username ? `${username} @ ${anvilUrl}` : anvilUrl));
             return await deps.getValidAuthToken(anvilUrl, username);
         } catch (e) {
             const interactive = process.stdin.isTTY && process.stdout.isTTY;
@@ -52596,11 +52752,15 @@ var __webpack_exports__ = {};
             if (!selectedInput) return void logger_logger.info("Checkout cancelled.");
             checkoutInput = selectedInput;
         }
+        logger_logger.verbose(chalk_source.cyan("Checkout input: ") + chalk_source.bold(checkoutInput));
         const parsed = parseCheckoutInput(checkoutInput);
+        logger_logger.verbose(chalk_source.cyan("Resolved app ID: ") + chalk_source.bold(parsed.appId));
         const anvilUrl = preselectedAnvilUrl || await resolveCheckoutUrl(options.url, parsed.detectedUrl);
         if (!anvilUrl) return void logger_logger.info("Checkout cancelled.");
         const resolvedUsername = preselectedUsername || await resolveCheckoutUsername(anvilUrl, options.user);
         if (null === resolvedUsername) return void logger_logger.info("Checkout cancelled.");
+        if (resolvedUsername) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(resolvedUsername));
+        else logger_logger.verbose(chalk_source.cyan("No account preselected; resolving after auth token lookup."));
         const authToken = await ensureCheckoutAuthToken(anvilUrl, resolvedUsername, deps);
         let checkoutUsername = resolvedUsername;
         if (!checkoutUsername) {
@@ -52609,13 +52769,22 @@ var __webpack_exports__ = {};
             if (!inferredUsername) throw new Error(`Could not determine account for ${anvilUrl}. Use --user <USERNAME> so checkout can bind repository credentials.`);
             checkoutUsername = inferredUsername;
         }
+        logger_logger.verbose(chalk_source.cyan("Checkout account: ") + chalk_source.bold(checkoutUsername));
+        logger_logger.verbose(chalk_source.blue(`Validating app ID ${parsed.appId} with Anvil server...`));
         const validation = await deps.validateAppId(parsed.appId, anvilUrl, checkoutUsername);
         if (!validation.valid) throw new Error(validation.error || `App '${parsed.appId}' is not accessible on ${anvilUrl}.`);
+        logger_logger.verbose(chalk_source.green(`✔ App ID validated successfully`));
+        if (validation.app_name) logger_logger.verbose(chalk_source.gray(`   App name: ${validation.app_name}`));
         const destinationDir = options.directory || getDefaultDestinationDirectory(parsed.appId, validation.app_name);
         const destinationPath = external_path_default().resolve(process.cwd(), destinationDir);
         const destinationDisplay = formatPathForDisplay(destinationPath);
+        logger_logger.verbose(chalk_source.cyan("Resolved destination: ") + chalk_source.bold(destinationDisplay));
         await validateCheckoutDestination(destinationPath, options.force);
         const cloneUrl = getGitPushUrl(parsed.appId, authToken, anvilUrl);
+        logger_logger.verbose(chalk_source.cyan("Clone source: ") + chalk_source.bold(`${anvilUrl}/git/${parsed.appId}.git`));
+        if (options.branch) logger_logger.verbose(chalk_source.cyan("Requested branch: ") + chalk_source.bold(options.branch));
+        if ("number" == typeof options.depth) logger_logger.verbose(chalk_source.cyan("Clone depth: ") + chalk_source.bold(String(options.depth)));
+        if (options.singleBranch) logger_logger.verbose(chalk_source.cyan("Single-branch clone enabled"));
         logger_logger.progress("checkout", `Checking out app ${parsed.appId} from ${anvilUrl}`);
         logger_logger.info(chalk_source.gray(`   Destination directory: ${destinationDisplay}`));
         await deps.clone(cloneUrl, destinationPath, {
@@ -52635,6 +52804,7 @@ var __webpack_exports__ = {};
                 username: checkoutUsername,
                 remoteName
             });
+            logger_logger.verbose(chalk_source.cyan("Configured Git auth bridge for remote: ") + chalk_source.bold(remoteName));
         } catch (e) {
             throw new Error(`Checkout clone succeeded, but failed to configure repository credentials: ${errors_getErrorMessage(e)}. The repository exists at ${destinationDisplay}, but Git auth bridge setup is incomplete.`);
         }
@@ -52747,10 +52917,11 @@ var __webpack_exports__ = {};
         });
     }
     function registerLoginCommand(program) {
-        const loginCommand = program.command("login [anvil-server-url]").description("Log in to Anvil using OAuth").alias("l").action(async (anvilUrl)=>{
+        const loginCommand = program.command("login [anvil-server-url]").description("Log in to Anvil using OAuth").alias("l").option("-u, --url <ANVIL_URL>", "Specify Anvil server URL").action(async (anvilUrl, options)=>{
             try {
-                if (anvilUrl) {
-                    anvilUrl = normalizeAnvilUrl(anvilUrl.trim());
+                const requestedUrl = anvilUrl || options.url;
+                if (requestedUrl) {
+                    anvilUrl = normalizeAnvilUrl(requestedUrl.trim());
                     setConfig("anvilUrl", anvilUrl);
                 } else anvilUrl = resolveAnvilUrl();
                 const result = await runInteractiveLoginFlow(anvilUrl);
@@ -52760,7 +52931,7 @@ var __webpack_exports__ = {};
                 process.exit(1);
             }
         });
-        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");
+        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 --url localhost    Log in to localhost\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);

package/package.json

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