@anvil-works/anvil-cli 0.5.10 → 0.5.12

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

@@ -50998,6 +50998,16 @@ var __webpack_exports__ = {};
         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;
     }
+    const defaultConfigureWatchGitAuthDeps = {
+        configureCredentialHelperForUrl: configureCredentialHelperForUrl,
+        setAppAuthBinding: setAppAuthBinding
+    };
+    const defaultSyncStartDeps = {
+        pushToAnvil,
+        recreateSessionAndValidate,
+        recheckSyncStatus,
+        startWatchingWithEventHandlers
+    };
     function resolveWatchOpenPath(repoPath) {
         return external_path_default().resolve(repoPath);
     }
@@ -51007,6 +51017,17 @@ var __webpack_exports__ = {};
         await openPathInEditorOrDefault(targetPath, preferredEditorCommand, deps);
         logger_logger.info(chalk_source.gray(`Opened ${targetPath}`));
     }
+    async function configureWatchGitAuth(options, deps = defaultConfigureWatchGitAuthDeps) {
+        await deps.configureCredentialHelperForUrl(options.repoPath, options.anvilUrl);
+        await deps.setAppAuthBinding(options.repoPath, options.appId, {
+            url: options.anvilUrl,
+            username: options.username
+        });
+    }
+    function isStaleRemotePushError(message) {
+        const normalized = message.toLowerCase();
+        return normalized.includes("fetch first") || normalized.includes("non-fast-forward") || normalized.includes("failed to push some refs") || normalized.includes("remote contains work that you do") || normalized.includes("[rejected]");
+    }
     async function selectAppId(candidates) {
         if (0 === candidates.length) {
             logger_logger.warn("Could not auto-detect app ID from repository.");
@@ -51093,11 +51114,19 @@ var __webpack_exports__ = {};
             logger_logger.progress("push", "Pushing to Anvil...");
             await git.push(pushUrl, refSpec, options.force ?? false);
             logger_logger.progressEnd("push", "Pushed to Anvil");
-            return true;
+            return {
+                success: true,
+                staleRemote: false
+            };
         } catch (e) {
+            const errorMessage = errors_getErrorMessage(e);
             logger_logger.progressEnd("push", "Push failed");
-            logger_logger.error(`Failed to push: ${errors_getErrorMessage(e)}`);
-            return false;
+            logger_logger.error(`Failed to push: ${errorMessage}`);
+            return {
+                success: false,
+                staleRemote: isStaleRemotePushError(errorMessage),
+                errorMessage
+            };
         }
     }
     async function fetchAndRebaseFromAnvil(options) {
@@ -51223,7 +51252,7 @@ var __webpack_exports__ = {};
             return false;
         }
     }
-    async function checkSyncStatusAndStart(session, options) {
+    async function checkSyncStatusAndStart(session, options, deps = defaultSyncStartDeps) {
         const syncStatus = session.syncStatus;
         const branchName = session.getBranchName() || "master";
         const hasUncommitted = session.hasUncommittedChanges;
@@ -51236,8 +51265,8 @@ var __webpack_exports__ = {};
             else {
                 shouldPush = await logger_logger.confirm("Would you like to push this branch to Anvil?", true);
                 if (shouldPush) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldPush) {
@@ -51246,15 +51275,21 @@ var __webpack_exports__ = {};
                 return false;
             }
             session.cleanup();
-            const pushed = await pushToAnvil({
+            const pushed = await deps.pushToAnvil({
                 repoPath: options.repoPath,
                 appId: options.appId,
                 anvilUrl: options.anvilUrl,
                 branchName,
                 username: options.username
             });
-            if (!pushed) return false;
-            return await recreateSessionAndValidate(options);
+            if (!pushed.success) {
+                if (pushed.staleRemote) {
+                    logger_logger.warn("Branch appeared on Anvil while pushing. Re-checking sync status...");
+                    return await deps.recreateSessionAndValidate(options);
+                }
+                return false;
+            }
+            return await deps.recreateSessionAndValidate(options);
         }
         if (syncStatus?.behind || syncStatus?.ahead) if (syncStatus.ahead && !syncStatus.behind) {
             logger_logger.warn(`Your local repository is ${syncStatus.ahead} commit(s) ahead of Anvil.`);
@@ -51274,8 +51309,8 @@ var __webpack_exports__ = {};
                 ], "push");
                 shouldPush = "push" === action;
                 if (shouldPush) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldPush) {
@@ -51284,15 +51319,15 @@ var __webpack_exports__ = {};
                 return false;
             }
             session.cleanup();
-            const pushed = await pushToAnvil({
+            const pushed = await deps.pushToAnvil({
                 repoPath: options.repoPath,
                 appId: options.appId,
                 anvilUrl: options.anvilUrl,
                 branchName,
                 username: options.username
             });
-            if (!pushed) return false;
-            return await recreateSessionAndValidate(options);
+            if (!pushed.success) return false;
+            return await deps.recreateSessionAndValidate(options);
         } else if (syncStatus.diverged) {
             logger_logger.warn("Your local repository has diverged from Anvil.");
             logger_logger.info(chalk_source.gray(`   You are ${syncStatus.ahead} commit(s) ahead and ${syncStatus.behind} commit(s) behind.`));
@@ -51315,7 +51350,7 @@ var __webpack_exports__ = {};
                     return false;
                 }
                 if (!result.success) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             const action = await logger_logger.select("How would you like to resolve this?", [
                 {
@@ -51339,8 +51374,8 @@ var __webpack_exports__ = {};
                 logger_logger.warn("Watch cancelled.");
                 return false;
             }
-            const changed = await recheckSyncStatus(stateCategory, branchName, options);
-            if (changed) return await checkSyncStatusAndStart(changed, options);
+            const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+            if (changed) return await checkSyncStatusAndStart(changed, options, deps);
             if ("rebase" === action) {
                 const result = await fetchAndRebaseFromAnvil({
                     repoPath: options.repoPath,
@@ -51357,7 +51392,7 @@ var __webpack_exports__ = {};
                     return false;
                 }
                 if (!result.success) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             if ("reset" === action) {
                 const resetWarning = hasUncommitted ? `This will discard ${syncStatus.ahead} local commit(s) and your uncommitted changes. Are you sure?` : `This will discard ${syncStatus.ahead} local commit(s). Are you sure?`;
@@ -51374,7 +51409,7 @@ var __webpack_exports__ = {};
                     username: options.username
                 });
                 if (!reset) return false;
-                return await recreateSessionAndValidate(options);
+                return await deps.recreateSessionAndValidate(options);
             }
             if ("push" === action) {
                 const confirmed = await logger_logger.confirm("This will overwrite Anvil's version. Are you sure?", false);
@@ -51382,7 +51417,7 @@ var __webpack_exports__ = {};
                     logger_logger.warn("Watch cancelled.");
                     return false;
                 }
-                const pushed = await pushToAnvil({
+                const pushed = await deps.pushToAnvil({
                     repoPath: options.repoPath,
                     appId: options.appId,
                     anvilUrl: options.anvilUrl,
@@ -51390,8 +51425,8 @@ var __webpack_exports__ = {};
                     username: options.username,
                     force: true
                 });
-                if (!pushed) return false;
-                return await recreateSessionAndValidate(options);
+                if (!pushed.success) return false;
+                return await deps.recreateSessionAndValidate(options);
             }
         } else {
             logger_logger.warn(`Your local repository is ${syncStatus.behind} commit(s) behind Anvil.`);
@@ -51402,8 +51437,8 @@ var __webpack_exports__ = {};
             else {
                 shouldSync = await logger_logger.confirm("Would you like to sync to the latest version from Anvil now?", true);
                 if (shouldSync) {
-                    const changed = await recheckSyncStatus(stateCategory, branchName, options);
-                    if (changed) return await checkSyncStatusAndStart(changed, options);
+                    const changed = await deps.recheckSyncStatus(stateCategory, branchName, options);
+                    if (changed) return await checkSyncStatusAndStart(changed, options, deps);
                 }
             }
             if (!shouldSync) {
@@ -51428,9 +51463,9 @@ var __webpack_exports__ = {};
                 logger_logger.error(`Failed to sync: ${errors_getErrorMessage(e)}`);
                 process.exit(1);
             }
-            return await recreateSessionAndValidate(options);
+            return await deps.recreateSessionAndValidate(options);
         }
-        await startWatchingWithEventHandlers(session, options);
+        await deps.startWatchingWithEventHandlers(session, options);
         return true;
     }
     async function startWatchingWithEventHandlers(session, options) {
@@ -51639,6 +51674,12 @@ var __webpack_exports__ = {};
                 process.exit(1);
             }
             logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
+            await configureWatchGitAuth({
+                repoPath,
+                appId: finalAppId,
+                anvilUrl,
+                username
+            });
             logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
             const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
             logger_logger.progressEnd("validate");
@@ -51849,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");
@@ -51886,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);
@@ -51923,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) {
@@ -52706,10 +52893,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);
@@ -52719,7 +52907,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.10",
+  "version": "0.5.12",
   "description": "CLI tool for developing Anvil apps locally",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",