@anvil-works/anvil-cli 0.8.0-canary.8 → 0.8.0-dev.0

package/dist/index.js

@@ -7376,15 +7376,15 @@ var __webpack_exports__ = {};
         validateCheckoutDestination: ()=>validateCheckoutDestination,
         DeviceAuthorizationResponse: ()=>oauth_login_namespaceObject.DeviceAuthorizationResponse,
         OAuthTokenResponse: ()=>oauth_login_namespaceObject.OAuthTokenResponse,
+        REFRESH_REQUEST_TIMEOUT_MS: ()=>REFRESH_REQUEST_TIMEOUT_MS,
         WatchSession: ()=>WatchSession_WatchSession,
         parseConfigSetValue: ()=>parseConfigSetValue,
-        requestDeviceAuthorization: ()=>requestDeviceAuthorization,
         getGitPushUrl: ()=>anvil_api_getGitPushUrl,
+        requestDeviceAuthorization: ()=>requestDeviceAuthorization,
         requireEnvironmentBranch: ()=>requireEnvironmentBranch,
         setAuthTokensForAccount: ()=>setAccountTokens,
-        validateAnvilApp: ()=>validation_validateAnvilApp,
         ValidateAppIdResponse: ()=>anvil_api_namespaceObject.ValidateAppIdResponse,
-        verifyAndStoreTokens: ()=>auth_verifyAndStoreTokens,
+        getModelToken: ()=>getModelToken,
         formatValidationPath: ()=>formatValidationPath,
         resolveAnvilUrl: ()=>resolveAnvilUrl,
         createCheckoutPickerSource: ()=>createCheckoutPickerSource,
@@ -7392,12 +7392,13 @@ var __webpack_exports__ = {};
         parseCheckoutInput: ()=>parseCheckoutInput,
         formatGitAuthDoctorReport: ()=>formatGitAuthDoctorReport,
         resetConfig: ()=>resetConfig,
+        MODEL_TOKEN_HELPER_FILENAME: ()=>MODEL_TOKEN_HELPER_FILENAME,
         FormTemplateValidationResult: ()=>validators_namespaceObject.FormTemplateValidationResult,
         createWatchDiagnostic: ()=>createWatchDiagnostic,
         ValidationTarget: ()=>validators_namespaceObject.ValidationTarget,
         detectAppIdsByCommitLookup: ()=>anvil_api_detectAppIdsByCommitLookup,
         sanitizeDirectoryName: ()=>sanitizeDirectoryName,
-        validatePath: ()=>validatePath,
+        validateAnvilApp: ()=>validation_validateAnvilApp,
         LoginResult: ()=>auth_namespaceObject.LoginResult,
         listAppsForCheckout: ()=>listAppsForCheckout,
         getInstalledPreferredEditors: ()=>getInstalledPreferredEditors,
@@ -7406,8 +7407,11 @@ var __webpack_exports__ = {};
         CheckoutExecutionDeps: ()=>checkout_namespaceObject.CheckoutExecutionDeps,
         validateFormTemplateHtml: ()=>validateFormTemplateHtml,
         ValidateBranchSyncStatusOptions: ()=>validation_namespaceObject.ValidateBranchSyncStatusOptions,
+        validatePath: ()=>validatePath,
+        withRepoAuthFileLock: ()=>withRepoAuthFileLock,
         BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus,
         getLatestVersion: ()=>getLatestVersion,
+        getModelTokenHelperScript: ()=>getModelTokenHelperScript,
         isDirectoryNonEmpty: ()=>isDirectoryNonEmpty,
         syncToLatest: ()=>src_api_syncToLatest,
         filterCandidates: ()=>anvil_api_filterCandidates,
@@ -7416,7 +7420,7 @@ var __webpack_exports__ = {};
         isPathInsideGitRepo: ()=>isPathInsideGitRepo,
         normalizeAnvilUrl: ()=>config_normalizeAnvilUrl,
         ValidationIssue: ()=>validators_namespaceObject.ValidationIssue,
-        writeEnvironmentPid: ()=>writeEnvironmentPid,
+        verifyAndStoreTokens: ()=>auth_verifyAndStoreTokens,
         readEnvironmentPid: ()=>environment_readEnvironmentPid,
         validateFormTemplate: ()=>validateFormTemplate,
         preferredEditors: ()=>preferredEditors,
@@ -7428,12 +7432,14 @@ var __webpack_exports__ = {};
         validateBranchSyncStatus: ()=>validation_validateBranchSyncStatus,
         checkUncommittedChanges: ()=>api_checkUncommittedChanges,
         hasTokensForUrl: ()=>auth_hasTokensForUrl,
+        writeEnvironmentPid: ()=>writeEnvironmentPid,
         AnvilYamlValidationResult: ()=>validators_namespaceObject.AnvilYamlValidationResult,
         ValidatePathResult: ()=>validators_namespaceObject.ValidatePathResult,
         getSettableConfigKeys: ()=>getSettableConfigKeys,
         logout: ()=>logout,
         TokenData: ()=>auth_namespaceObject.TokenData,
         detectAppIdsFromAllRemotes: ()=>anvil_api_detectAppIdsFromAllRemotes,
+        executeModelTokenOperation: ()=>executeModelTokenOperation,
         getWebSocketUrl: ()=>getWebSocketUrl,
         getAllConfig: ()=>getAllConfig,
         isCommandAvailable: ()=>config_isCommandAvailable,
@@ -7443,6 +7449,7 @@ var __webpack_exports__ = {};
         getValidAuthToken: ()=>auth_getValidAuthToken,
         watch: ()=>src_api_watch,
         deleteConfig: ()=>deleteConfig,
+        installModelTokenHelperScript: ()=>installModelTokenHelperScript,
         getGitFetchUrl: ()=>anvil_api_getGitFetchUrl,
         PreferredEditor: ()=>config_namespaceObject.PreferredEditor,
         getAvailableAnvilUrls: ()=>getAvailableAnvilUrls,
@@ -7455,8 +7462,11 @@ var __webpack_exports__ = {};
         CheckoutResult: ()=>checkout_namespaceObject.CheckoutResult,
         ParsedCheckoutInput: ()=>checkout_namespaceObject.ParsedCheckoutInput,
         parseCredentialHelperCommand: ()=>parseCredentialHelperCommand,
+        MODEL_TOKEN_LOCK_TIMEOUT_MS: ()=>MODEL_TOKEN_LOCK_TIMEOUT_MS,
+        GetValidAuthTokenOptions: ()=>auth_namespaceObject.GetValidAuthTokenOptions,
         clearInMemoryTokens: ()=>clearInMemoryTokens,
         getDefaultDestinationDirectory: ()=>getDefaultDestinationDirectory,
+        AUTH_FILE_LOCK_DEFAULTS: ()=>AUTH_FILE_LOCK_DEFAULTS,
         lookupByCommit: ()=>lookupByCommit,
         AppIdCandidate: ()=>anvil_api_namespaceObject.AppIdCandidate,
         verifyAuth: ()=>auth_verifyAuth
@@ -7485,12 +7495,14 @@ var __webpack_exports__ = {};
     __webpack_require__.r(auth_namespaceObject);
     __webpack_require__.d(auth_namespaceObject, {
         fg: ()=>ANVIL_SYNC_CLIENT_ID,
+        ru: ()=>REFRESH_REQUEST_TIMEOUT_MS,
         Ou: ()=>clearInMemoryTokens,
         Fr: ()=>auth_getAccountsForUrl,
         u5: ()=>getAvailableAnvilUrls,
         _p: ()=>auth_getValidAuthToken,
         Fi: ()=>auth_hasTokensForUrl,
         ri: ()=>logout,
+        UE: ()=>auth_resolveAuthAnvilUrl,
         f5: ()=>setInMemoryTokens,
         iT: ()=>auth_setRepoContext,
         CQ: ()=>auth_verifyAndStoreTokens,
@@ -13365,9 +13377,10 @@ var __webpack_exports__ = {};
                 type: "auth_invalid",
                 message
             }),
-        refreshFailed: (message)=>({
+        refreshFailed: (message, status)=>({
                 type: "token_refresh_failed",
-                message
+                message,
+                status
             })
     };
     const createAppError = {
@@ -13584,6 +13597,7 @@ var __webpack_exports__ = {};
     const external_module_namespaceObject = require("module");
     const requireFromHere = (0, external_module_namespaceObject.createRequire)(__filename);
     const GIT_CREDENTIAL_HELPER_FILENAME = "anvil-credential-helper.cjs";
+    const MODEL_TOKEN_HELPER_FILENAME = "anvil-model-token-helper.cjs";
     const GIT_CREDENTIAL_HELPER_LOCATOR = `$(git rev-parse --git-common-dir)/${GIT_CREDENTIAL_HELPER_FILENAME}`;
     function getUrlConfigKey(appId) {
         return `anvil.auth.${appId}.url`;
@@ -13674,6 +13688,38 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
 });
 `;
     }
+    function getModelTokenHelperScript(modulePath) {
+        return `#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("child_process");
+const { executeModelTokenOperation } = require(${JSON.stringify(modulePath)});
+
+function resolveRepoPath() {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+        cwd: process.cwd(),
+        encoding: "utf8",
+    }).trim();
+}
+
+Promise.resolve()
+    .then(() => executeModelTokenOperation({ repoPath: resolveRepoPath() }))
+    .catch((e) => {
+        process.stderr.write("anvil model token helper failed: " + ((e && e.message) || e) + "\\n");
+        process.exit(1);
+    });
+`;
+    }
+    async function installModelTokenHelperScript(helperPath, options) {
+        await external_fs_.promises.mkdir(external_path_default().dirname(helperPath), {
+            recursive: true
+        });
+        await external_fs_.promises.writeFile(helperPath, getModelTokenHelperScript(options?.modulePath ?? getCredentialHelperModulePath()), {
+            mode: 448
+        });
+        await external_fs_.promises.chmod(helperPath, 448);
+        return helperPath;
+    }
     function findPackageRoot(startPath) {
         let dir = external_fs_default().existsSync(startPath) && external_fs_default().statSync(startPath).isDirectory() ? startPath : external_path_default().dirname(startPath);
         while(true){
@@ -13801,6 +13847,76 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     function getAuthFilePath(gitDir) {
         return external_path_default().join(gitDir, "anvil-auth.json");
     }
+    const AUTH_FILE_LOCK_DEFAULTS = {
+        staleMs: 30000,
+        timeoutMs: 60000,
+        retryDelayMs: 100,
+        heartbeatMs: 5000
+    };
+    function git_auth_delay(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    async function acquireAuthFileLock(lockPath, options) {
+        const deadline = Date.now() + options.timeoutMs;
+        while(true){
+            try {
+                const handle = await external_fs_.promises.open(lockPath, "wx", 384);
+                try {
+                    await handle.writeFile(JSON.stringify({
+                        pid: process.pid,
+                        acquiredAt: new Date().toISOString()
+                    }));
+                } finally{
+                    await handle.close();
+                }
+                return;
+            } catch (e) {
+                if ("EEXIST" !== e.code) throw e;
+            }
+            try {
+                const lockStat = await external_fs_.promises.stat(lockPath);
+                if (Date.now() - lockStat.mtimeMs > options.staleMs) {
+                    await external_fs_.promises.rm(lockPath, {
+                        force: true
+                    });
+                    continue;
+                }
+            } catch  {
+                continue;
+            }
+            if (Date.now() >= deadline) throw new Error(`Timed out waiting for the Anvil auth file lock at ${lockPath}`);
+            await git_auth_delay(options.retryDelayMs);
+        }
+    }
+    async function withRepoAuthFileLock(repoPath, fn, options) {
+        const gitDir = await getRepositoryGitDir(repoPath);
+        const lockPath = `${getAuthFilePath(gitDir)}.lock`;
+        const lockOptions = {
+            ...AUTH_FILE_LOCK_DEFAULTS,
+            ...options
+        };
+        await external_fs_.promises.mkdir(external_path_default().dirname(lockPath), {
+            recursive: true
+        });
+        await acquireAuthFileLock(lockPath, lockOptions);
+        const heartbeat = startAuthFileLockHeartbeat(lockPath, lockOptions.heartbeatMs);
+        try {
+            return await fn();
+        } finally{
+            clearInterval(heartbeat);
+            await external_fs_.promises.rm(lockPath, {
+                force: true
+            });
+        }
+    }
+    function startAuthFileLockHeartbeat(lockPath, heartbeatMs) {
+        const heartbeat = setInterval(()=>{
+            const now = new Date();
+            external_fs_.promises.utimes(lockPath, now, now).catch(()=>{});
+        }, heartbeatMs);
+        heartbeat.unref();
+        return heartbeat;
+    }
     function decodeKey(b64key) {
         const key = Buffer.from(b64key, "base64");
         if (32 !== key.length) throw new Error("Encryption key must be a base64-encoded 32-byte key");
@@ -13845,10 +13961,19 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             recursive: true
         });
         const authJson = JSON.stringify(auth, null, 2);
-        await external_fs_.promises.writeFile(authFilePath, encrypt(authJson, encryptionKey), {
-            mode: 384
-        });
-        await external_fs_.promises.chmod(authFilePath, 448);
+        const tempFilePath = `${authFilePath}.tmp-${external_node_crypto_default().randomBytes(6).toString("hex")}`;
+        try {
+            await external_fs_.promises.writeFile(tempFilePath, encrypt(authJson, encryptionKey), {
+                mode: 384
+            });
+            await external_fs_.promises.chmod(tempFilePath, 448);
+            await external_fs_.promises.rename(tempFilePath, authFilePath);
+        } catch (e) {
+            await external_fs_.promises.rm(tempFilePath, {
+                force: true
+            });
+            throw e;
+        }
         await git.raw([
             "config",
             "--local",
@@ -13859,6 +13984,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     }
     const readAuthFromRepo = async (repoPath)=>{
         const git = esm_default(repoPath);
+        if (!await git.checkIsRepo()) return;
         const gitDir = await getRepositoryGitDir(repoPath, git);
         const authFilePath = getAuthFilePath(gitDir);
         if (!external_fs_default().existsSync(authFilePath)) return;
@@ -13870,6 +13996,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
         return resolveAnvilUrl();
     }
     const ANVIL_SYNC_CLIENT_ID = "anvil-sync";
+    const REFRESH_REQUEST_TIMEOUT_MS = 12000;
     let inMemoryAuth = null;
     function setInMemoryTokens(anvilUrl, username, tokens) {
         inMemoryAuth = {
@@ -13888,6 +14015,11 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     function auth_setRepoContext(repoPath) {
         repoContext = repoPath;
     }
+    async function auth_resolveAuthAnvilUrl() {
+        if (inMemoryAuth) return inMemoryAuth.anvilUrl;
+        const repoAuth = repoContext ? await readAuthFromRepo(repoContext) : void 0;
+        return repoAuth?.anvilUrl ?? resolveAnvilUrl();
+    }
     const inFlightRefreshes = new Map();
     async function auth_verifyAuth(authToken, anvilUrl = getDefaultAnvilUrl()) {
         try {
@@ -13908,7 +14040,7 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             throw createAuthError.invalid(`Network error: ${e.message}`);
         }
     }
-    async function refreshAccessToken(refreshToken, anvilUrl = getDefaultAnvilUrl(), clientId = ANVIL_SYNC_CLIENT_ID) {
+    async function refreshAccessToken(refreshToken, anvilUrl = getDefaultAnvilUrl(), clientId = ANVIL_SYNC_CLIENT_ID, options) {
         try {
             const tokenResponse = await fetch(`${anvilUrl}/oauth/token`, {
                 method: "POST",
@@ -13919,11 +14051,12 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                     grant_type: "refresh_token",
                     refresh_token: refreshToken,
                     client_id: clientId
-                })
+                }),
+                signal: AbortSignal.timeout(options?.timeoutMs ?? REFRESH_REQUEST_TIMEOUT_MS)
             });
             if (!tokenResponse.ok) {
                 const errorText = await tokenResponse.text();
-                throw createAuthError.refreshFailed(`Failed to refresh token: ${tokenResponse.status} ${errorText}`);
+                throw createAuthError.refreshFailed(`Failed to refresh token: ${tokenResponse.status} ${errorText}`, tokenResponse.status);
             }
             const tokenData = await tokenResponse.json();
             return tokenData;
@@ -13940,17 +14073,16 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             return hasTokens(anvilUrl, username);
         }
     }
-    async function auth_getValidAuthToken(anvilUrl = getDefaultAnvilUrl(), username) {
+    async function auth_getValidAuthToken(anvilUrl = getDefaultAnvilUrl(), username, options) {
         const normalized = config_normalizeAnvilUrl(anvilUrl);
         const source = await resolveTokenSource(normalized, username);
         const tokens = getSourceTokens(source);
         if (!tokens.authToken && !tokens.refreshToken) throw createAuthError.required("Not logged in. Please log in first.");
-        const isExpired = null !== tokens.authTokenExpiresAt && tokens.authTokenExpiresAt <= Math.floor(Date.now() / 1000) + 60;
-        if (tokens.refreshToken && isExpired) {
+        if (tokens.refreshToken && isAccessTokenExpired(tokens)) {
             const refreshKey = getRefreshKey(normalized, username, source, tokens.refreshToken);
             const existingRefresh = inFlightRefreshes.get(refreshKey);
             if (existingRefresh) return existingRefresh;
-            const refreshPromise = refreshAndStoreAccessToken(normalized, username, source, tokens.refreshToken).finally(()=>{
+            const refreshPromise = refreshAndStoreAccessToken(normalized, username, source, tokens.refreshToken, options).finally(()=>{
                 inFlightRefreshes.delete(refreshKey);
             });
             inFlightRefreshes.set(refreshKey, refreshPromise);
@@ -13980,6 +14112,9 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
     function getSourceTokens(source) {
         return "store" === source.type ? source.tokens : source.auth.tokens;
     }
+    function isAccessTokenExpired(tokens) {
+        return null !== tokens.authTokenExpiresAt && tokens.authTokenExpiresAt <= Math.floor(Date.now() / 1000) + 60;
+    }
     function getStoreAccountUsername(normalizedUrl, username, refreshToken) {
         if (username) return username;
         const urlTokens = getUrlTokens(normalizedUrl);
@@ -13998,11 +14133,43 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
                 return `store:${normalizedUrl}:${source.accountUsername ?? username ?? refreshToken}`;
         }
     }
-    async function refreshAndStoreAccessToken(normalizedUrl, username, source, refreshToken) {
+    async function refreshAndStoreAccessToken(normalizedUrl, username, source, refreshToken, options) {
+        if ("repo" === source.type) return refreshRepoAuthTokens(source.repoPath, {
+            anvilUrl: normalizedUrl,
+            username,
+            auth: source.auth,
+            refreshToken,
+            lock: options?.lock,
+            requestTimeoutMs: options?.requestTimeoutMs
+        });
+        return performTokenRefresh(normalizedUrl, username, source, refreshToken, options?.requestTimeoutMs);
+    }
+    async function refreshRepoAuthTokens(repoPath, options) {
+        const normalizedUrl = config_normalizeAnvilUrl(options.anvilUrl);
+        return withRepoAuthFileLock(repoPath, async ()=>{
+            let auth = options.auth;
+            let refreshToken = options.refreshToken;
+            const current = await readAuthFromRepo(repoPath);
+            if (current && authMatches(current, normalizedUrl, options.username)) {
+                if (current.tokens.authToken && !isAccessTokenExpired(current.tokens)) return current.tokens.authToken;
+                auth = current;
+                refreshToken = current.tokens.refreshToken ?? refreshToken;
+            }
+            if (!auth || !refreshToken) throw createAuthError.required("No repo auth tokens available to refresh.");
+            return performTokenRefresh(normalizedUrl, options.username, {
+                type: "repo",
+                auth,
+                repoPath
+            }, refreshToken, options.requestTimeoutMs);
+        }, options.lock);
+    }
+    async function performTokenRefresh(normalizedUrl, username, source, refreshToken, requestTimeoutMs) {
         try {
             const tokens = getSourceTokens(source);
             const clientId = tokens.clientId ?? ANVIL_SYNC_CLIENT_ID;
-            const tokenData = await refreshAccessToken(refreshToken, normalizedUrl, clientId);
+            const tokenData = await refreshAccessToken(refreshToken, normalizedUrl, clientId, {
+                timeoutMs: requestTimeoutMs
+            });
             const newTokens = {
                 authToken: tokenData.access_token,
                 refreshToken: tokenData.refresh_token,
@@ -14024,10 +14191,26 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             }
             return tokenData.access_token;
         } catch (e) {
+            if ("repo" === source.type && isRefreshTokenRejection(e)) await clearRepoAuthTokens(source.repoPath, source.auth).catch(()=>{});
             await clearTokensForAccount(normalizedUrl, username, refreshToken);
             throw e;
         }
     }
+    function isRefreshTokenRejection(e) {
+        const error = e;
+        return error?.type === "token_refresh_failed" && (400 === error.status || 401 === error.status);
+    }
+    async function clearRepoAuthTokens(repoPath, auth) {
+        const encryptionKey = process.env["ANVIL_AUTH_FILE_ENCRYPTION_KEY"];
+        if (!encryptionKey) return;
+        auth.tokens = {
+            authToken: null,
+            refreshToken: null,
+            authTokenExpiresAt: null,
+            clientId: auth.tokens.clientId
+        };
+        await writeAuthToFile(repoPath, auth, encryptionKey);
+    }
     async function clearTokensForAccount(url, username, refreshToken) {
         if (inMemoryAuth || repoContext && await readAuthFromRepo(repoContext)) return;
         {
@@ -14109,1042 +14292,1074 @@ Promise.resolve(executeGitCredentialOperation(process.argv[2] || "get", {
             return getAvailableUrls();
         }
     }
-    function anvil_api_getDefaultAnvilUrl() {
-        return resolveAnvilUrl();
+    const promises_namespaceObject = require("timers/promises");
+    const WANT_NOT_VALID_RE = /\bwant\s+[0-9a-f]{7,40}\s+not valid\b/i;
+    const FETCH_RETRY_DELAY_MS = 200;
+    function isWantNotValidError(error) {
+        return WANT_NOT_VALID_RE.test(error.message || "");
     }
-    async function anvil_api_validateAppId(appId, anvilUrl = anvil_api_getDefaultAnvilUrl(), username) {
-        const authToken = await auth_getValidAuthToken(anvilUrl, username);
-        try {
-            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/validate-app-id`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                    app_id: appId
-                })
-            });
-            const data = await resp.json();
-            if (resp.ok) return {
-                valid: data.valid ?? false,
-                app_name: data.app_name
-            };
-            if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
-            if (403 === resp.status) throw createAppError.accessDenied(appId);
-            if (404 === resp.status) throw createAppError.notFound(appId);
-            logger_logger.debug(`validate-app-id failed: ${resp.status} ${resp.statusText}`);
-            return {
-                valid: false,
-                error: data.error || `Server error: ${resp.status}`
-            };
-        } catch (error) {
-            if (error.type) throw error;
-            throw createNetworkError.network(error.message);
+    class git_GitService extends Emitter {
+        git;
+        repoPath;
+        static INDEX_LOCK_RETRY_DELAYS_MS = [
+            25,
+            50,
+            100,
+            200
+        ];
+        constructor(repoPath){
+            super();
+            this.repoPath = external_path_default().resolve(repoPath);
+            this.git = esm_default(this.repoPath);
         }
-    }
-    async function lookupByCommit(commitId, branchName, anvilUrl = anvil_api_getDefaultAnvilUrl(), username) {
-        const authToken = await auth_getValidAuthToken(anvilUrl, username);
-        try {
-            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/lookup-by-commit`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                    commit_id: commitId,
-                    branch_name: branchName
-                })
-            });
-            if (!resp.ok) {
-                if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
-                throw createNetworkError.server(resp.status, resp.statusText);
+        getGit() {
+            return this.git;
+        }
+        getRepoPath() {
+            return this.repoPath;
+        }
+        async getGitDir() {
+            try {
+                const gitDir = (await this.git.revparse([
+                    "--git-dir"
+                ])).trim();
+                if (!external_path_default().isAbsolute(gitDir)) return external_path_default().resolve(this.repoPath, gitDir);
+                return gitDir;
+            } catch (e) {
+                throw errors_createGitError.commandFailed("rev-parse --git-dir", e.message);
             }
-            const data = await resp.json();
-            return data;
-        } catch (error) {
-            if (error.type) throw error;
-            throw createNetworkError.network(error.message);
         }
-    }
-    async function listAppsForCheckout(options = {}) {
-        const anvilUrl = options.anvilUrl ?? anvil_api_getDefaultAnvilUrl();
-        const authToken = await auth_getValidAuthToken(anvilUrl, options.username);
-        const params = new URLSearchParams();
-        if ("number" == typeof options.limit) params.set("limit", String(options.limit));
-        if (options.cursor) params.set("cursor", options.cursor);
-        if (options.q && options.q.trim()) params.set("q", options.q.trim());
-        const query = params.toString();
-        const url = `${anvilUrl}/ide/api/_/apps${query ? `?${query}` : ""}`;
-        try {
-            const resp = await fetch(url, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${authToken}`
-                },
-                signal: options.signal
-            });
-            if (!resp.ok) {
-                if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
-                throw createNetworkError.server(resp.status, resp.statusText);
+        async getCurrentBranch() {
+            try {
+                const branchRef = await this.git.revparse([
+                    "--abbrev-ref",
+                    "HEAD"
+                ]);
+                if ("HEAD" === branchRef) throw createSyncError.detachedHead();
+                return branchRef;
+            } catch (e) {
+                if ("detached_head" === e.type) throw e;
+                throw createSyncError.detachedHead();
             }
-            const data = await resp.json();
-            return {
-                apps: Array.isArray(data.apps) ? data.apps : [],
-                next_cursor: "string" == typeof data.next_cursor ? data.next_cursor : null
-            };
-        } catch (error) {
-            if (error.type) throw error;
-            throw createNetworkError.network(error.message);
         }
-    }
-    async function saveUpdates(appId, branchName, payload, anvilUrl = anvil_api_getDefaultAnvilUrl(), authToken) {
-        try {
-            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/update?make_fresh_version=false&branch=${branchName}`, {
-                method: "PUT",
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify(payload)
-            });
-            const data = await resp.json();
-            if (401 === resp.status) throw createAuthError.invalid(`Authentication failed (401): ${data.error || "unauthorized"}`);
-            if (403 === resp.status) throw createAuthError.invalid(`Authentication failed (403): ${data.error || "unauthorized"}\n   This may indicate:\n   - The OAuth token doesn't have permission to write to app ${appId}\n   - The app belongs to a different user or organization\n   - The OAuth token is missing required scopes (apps:write)`);
-            return {
-                version: data.version,
-                overtaken: data.overtaken,
-                latest_version: data.latest_version,
-                error: 200 !== resp.status ? data.error || `Status ${resp.status}` : void 0
-            };
-        } catch (error) {
-            if (error.type) throw error;
-            throw createNetworkError.network(error.message);
+        async getCommitId() {
+            try {
+                const commitId = (await this.git.revparse([
+                    "HEAD"
+                ])).trim();
+                return commitId;
+            } catch (e) {
+                throw errors_createGitError.commandFailed("revparse", e.message);
+            }
         }
-    }
-    function anvil_api_getGitFetchUrl(appId, authToken, gitUrl = anvil_api_getDefaultAnvilUrl()) {
-        const url = new URL(gitUrl);
-        const encodedToken = encodeURIComponent(authToken);
-        return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git?no_freeze=true&q=`;
-    }
-    function anvil_api_getGitPushUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
-        const url = new URL(anvilUrl);
-        const encodedToken = encodeURIComponent(authToken);
-        return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git`;
-    }
-    function getWebSocketUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
-        return anvilUrl.replace(/^http/, "ws") + `/ide/api/_/apps/${appId}/ws?access_token=${authToken}`;
-    }
-    async function getLatestVersion() {
-        try {
-            const response = await fetch("https://registry.npmjs.org/@anvil-works/anvil-cli/latest");
-            if (!response.ok) return null;
-            const data = await response.json();
-            return data.version;
-        } catch (e) {
-            return null;
-        }
-    }
-    function anvil_api_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 anvil_api_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 anvil_api_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 anvil_api_detectAppIdsFromAllRemotes(repoPath) {
-        const git = esm_default(repoPath);
-        const out = [];
-        try {
-            const remotes = await git.getRemotes(true);
-            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;
-                    out.push({
-                        appId: detectedAppId,
-                        source: "remote",
-                        description: `Git remote '${remote.name}'`,
-                        detectedUrl: config_normalizeAnvilUrl(host)
-                    });
-                    continue;
-                }
-                const sshMatch = remote.refs.fetch?.match(/ssh:\/\/([^@]+)@([^:]+):(\d+)\/(?:git\/)?([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const [, usernamePart, host, , detectedAppId] = sshMatch;
-                    const detectedUsername = usernamePart.includes("%") ? decodeURIComponent(usernamePart) : usernamePart;
-                    const finalUsername = "git" !== detectedUsername ? detectedUsername : void 0;
-                    out.push({
-                        appId: detectedAppId,
-                        source: "remote",
-                        description: `Git remote '${remote.name}' (SSH)`,
-                        detectedUrl: config_normalizeAnvilUrl(host),
-                        detectedUsername: finalUsername
-                    });
-                }
-            }
-        } catch (_e) {}
-        return out;
-    }
-    async function anvil_api_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, username);
-            const branchRef = await git.revparse([
-                "--abbrev-ref",
-                "HEAD"
-            ]);
-            const currentBranch = "HEAD" === branchRef ? "master" : branchRef;
-            const commitId = (await git.revparse([
-                "HEAD"
-            ]))?.trim();
-            if (!commitId) return out;
-            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/lookup-by-commit`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify({
-                    commit_id: commitId,
-                    branch_name: currentBranch
-                })
-            });
-            logger_logger.debug(`Reverse lookup by commit ${commitId} on branch ${currentBranch} returned ${resp.status}`);
-            if (!resp.ok) {
-                const errorBody = await resp.text();
-                logger_logger.debug(`lookup-by-commit error: ${errorBody}`);
-            }
-            if (resp.ok) {
-                const data = await resp.json();
-                logger_logger.debug(`data ${JSON.stringify(data)}`);
-                const apps = data?.apps ?? [];
-                for (const app of apps)if (app?.app_id) out.push({
-                    appId: app.app_id,
-                    source: "remote",
-                    description: `Reverse lookup by commit${app.branch ? ` on branch '${app.branch}'` : ""}`
-                });
+        async getCommitInfo() {
+            try {
+                const hash = (await this.git.revparse([
+                    "HEAD"
+                ])).trim();
+                const message = (await this.git.raw([
+                    "log",
+                    "-1",
+                    "--format=%s"
+                ])).trim();
+                return {
+                    hash,
+                    shortHash: hash.substring(0, 8),
+                    message
+                };
+            } catch (e) {
+                throw errors_createGitError.commandFailed("log", e.message);
             }
-        } catch (_e) {}
-        return out;
-    }
-    const promises_namespaceObject = require("fs/promises");
-    var promises_default = /*#__PURE__*/ __webpack_require__.n(promises_namespaceObject);
-    function normalizeLineEndings(content) {
-        return content.replace(/\r\n/g, "\n");
-    }
-    function pythonifyName(name) {
-        return name.replace(/[^A-z0-9]/g, "_").replace(/^[0-9]/, "_$&");
-    }
-    function extractPythonName(relativePath, skipParts = 1) {
-        const parts = relativePath.slice(0, -3).split("/");
-        const isPackage = relativePath.endsWith("__init__.py");
-        const relevantParts = isPackage ? parts.slice(skipParts, -1) : parts.slice(skipParts);
-        return relevantParts.map(pythonifyName).join(".");
-    }
-    function deepEqual(a, b) {
-        if (a === b) return true;
-        if (null == a || null == b) return false;
-        if (typeof a !== typeof b) return false;
-        if ("object" != typeof a) return a === b;
-        if (Array.isArray(a) !== Array.isArray(b)) return false;
-        if (Array.isArray(a)) {
-            if (a.length !== b.length) return false;
-            return a.every((item, index)=>deepEqual(item, b[index]));
-        }
-        const keysA = Object.keys(a);
-        const keysB = Object.keys(b);
-        if (keysA.length !== keysB.length) return false;
-        return keysA.every((key)=>deepEqual(a[key], b[key]));
-    }
-    function parseHtmlWithFrontmatter(htmlContent) {
-        const frontmatterPattern = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
-        const match = htmlContent.match(frontmatterPattern);
-        if (match) {
-            const yamlStr = match[1];
-            const html = match[2];
-            const frontmatter = yamlStr ? external_js_yaml_default().load(yamlStr) ?? {} : {};
-            return {
-                frontmatter,
-                html
-            };
         }
-        return {
-            frontmatter: {},
-            html: htmlContent
-        };
-    }
-    const ANVIL_GITIGNORE_ENTRY = "/.anvil/";
-    async function ensureProjectGitignoreIgnoresAnvilDir(projectRoot) {
-        const rootGitignorePath = external_path_default().join(projectRoot, ".gitignore");
-        try {
-            const existing = await external_fs_.promises.readFile(rootGitignorePath, "utf8");
-            if (existing.includes(ANVIL_GITIGNORE_ENTRY)) return false;
-            const prefix = existing.endsWith("\n") || 0 === existing.length ? "" : "\n";
-            await external_fs_.promises.writeFile(rootGitignorePath, `${existing}${prefix}${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
-            return true;
-        } catch (error) {
-            if ("ENOENT" !== error.code) throw error;
-            await external_fs_.promises.writeFile(rootGitignorePath, `${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
-            return true;
-        }
-    }
-    const ANVIL_DEPS_DIR = ".anvil/deps";
-    const ANVIL_DEPS_MANIFEST = "manifest.json";
-    const DEPS_MANIFEST_VERSION = 2;
-    function formatFetchError(prefix, status, errorBody) {
-        if (!errorBody) return `${prefix}: ${status}`;
-        try {
-            const parsed = JSON.parse(errorBody);
-            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
-        } catch  {}
-        return `${prefix}: ${status} ${errorBody}`;
-    }
-    async function fetchAllDependencies(appId, anvilUrl = resolveAnvilUrl(), options = {}) {
-        const { commit, includeDocs = true, knownDependencies = [] } = options;
-        const token = await auth_getValidAuthToken(anvilUrl);
-        const body = {
-            include_docs: includeDocs,
-            known_dependencies: knownDependencies
-        };
-        if (commit) body.commit = commit;
-        const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/resolved-dependencies`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(body)
-        });
-        if (!resp.ok) {
-            const errorBody = await resp.text();
-            throw new Error(formatFetchError("Failed to fetch dependencies", resp.status, errorBody));
-        }
-        return await resp.json();
-    }
-    async function refreshDependencyCache(projectRoot, appId, anvilUrl = resolveAnvilUrl(), options = {}) {
-        const includeDocs = options.includeDocs ?? true;
-        const knownDependencies = await getKnownDependenciesForCache(projectRoot, includeDocs);
-        const response = await fetchAllDependencies(appId, anvilUrl, {
-            commit: options.commit,
-            includeDocs,
-            knownDependencies
-        });
-        if (!response.resolved_dependencies.length) {
-            await clearDepsCache(projectRoot);
-            return {
-                response,
-                addedGitignoreEntry: false
-            };
-        }
-        const addedGitignoreEntry = await ensureProjectGitignoreIgnoresAnvilDir(projectRoot);
-        await writeAllDepsToCache(projectRoot, response, {
-            includeDocs
-        });
-        return {
-            response,
-            addedGitignoreEntry
-        };
-    }
-    function depsDir(projectRoot) {
-        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
-    }
-    function depsManifestPath(projectRoot) {
-        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
-    }
-    function isResolvedDependencyManifestEntry(value) {
-        if (!value || "object" != typeof value) return false;
-        const entry = value;
-        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
-    }
-    function isCachedDependencyManifestEntry(value) {
-        if (!isResolvedDependencyManifestEntry(value)) return false;
-        const entry = value;
-        return "string" == typeof entry.package_name && entry.package_name.length > 0;
-    }
-    function isDepsCacheManifest(value) {
-        if (!value || "object" != typeof value) return false;
-        const manifest = value;
-        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && Array.isArray(manifest.source_dependencies) && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
-    }
-    async function readDepsCacheManifest(projectRoot) {
-        try {
-            const raw = await promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
-            const parsed = JSON.parse(raw);
-            return isDepsCacheManifest(parsed) ? parsed : void 0;
-        } catch  {
-            return;
+        async getStatus() {
+            try {
+                const status = await this.git.status();
+                const staged = status.files.filter((file)=>{
+                    const indexStatus = file.index.trim();
+                    return indexStatus.length > 0 && "?" !== indexStatus;
+                }).map((file)=>file.path);
+                return {
+                    isClean: status.isClean(),
+                    modified: status.modified,
+                    notAdded: status.not_added,
+                    created: status.created,
+                    deleted: status.deleted,
+                    staged,
+                    renamed: status.renamed || []
+                };
+            } catch (e) {
+                throw errors_createGitError.commandFailed("status", e.message);
+            }
         }
-    }
-    async function getKnownDependenciesForCache(projectRoot, includeDocs) {
-        const manifest = await readDepsCacheManifest(projectRoot);
-        if (!manifest || manifest.includeDocs !== includeDocs) return [];
-        return manifest.resolved_dependencies.map(({ app_id, commit_id })=>({
-                app_id,
-                commit_id
-            }));
-    }
-    function getDependencyWatchSubscriptionsFromManifest(manifest) {
-        if (!manifest) return [];
-        const cachedByAppId = new Map(manifest.cached_dependencies.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        return manifest.resolved_dependencies.flatMap((dep)=>{
-            if (!dep.branch) return [];
-            return [
-                {
-                    appId: dep.app_id,
-                    branch: dep.branch,
-                    packageName: cachedByAppId.get(dep.app_id)?.package_name
-                }
-            ];
-        });
-    }
-    function normalizeAnvilYamlDependenciesFromContent(content) {
-        const parsed = external_js_yaml_default().load(content);
-        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
-        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
-    }
-    function normalizeAnvilYamlDependenciesValue(value) {
-        if (!Array.isArray(value)) return [];
-        return value.map(normalizeForComparison);
-    }
-    async function readAnvilYamlDependencies(projectRoot) {
-        try {
-            const content = await promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
-            return normalizeAnvilYamlDependenciesFromContent(content);
-        } catch  {
-            return [];
+        async discardModeOnlyChanges(paths) {
+            const discarded = [];
+            for (const relativePath of paths)try {
+                const headMode = await this.getHeadFileMode(relativePath);
+                if ("100644" !== headMode && "100755" !== headMode) continue;
+                const contentUnchanged = await this.hasSameContentAsHead(relativePath);
+                if (!contentUnchanged) continue;
+                await this.restoreExecutableBit(relativePath, "100755" === headMode);
+                discarded.push(relativePath);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("discard mode-only changes", e.message);
+            }
+            return discarded;
         }
-    }
-    function anvilYamlDependenciesEqual(left, right) {
-        return deepEqual(left, right);
-    }
-    function normalizeForComparison(value) {
-        if (Array.isArray(value)) return value.map(normalizeForComparison);
-        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
-                key,
-                normalizeForComparison(entryValue)
-            ]));
-        return value;
-    }
-    function cachedManifestEntry(dep, packageName) {
-        return {
-            app_id: dep.app_id,
-            commit_id: dep.commit_id,
-            ...dep.branch ? {
-                branch: dep.branch
-            } : {},
-            package_name: packageName
-        };
-    }
-    function safeDependencyPath(filePath, kind) {
-        const normalizedPath = external_path_default().normalize(filePath);
-        if (external_path_default().isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) throw new Error(`Invalid dependency ${kind} path: ${filePath}`);
-        return normalizedPath;
-    }
-    function dependencyPythonPath(name, kind) {
-        const parts = name.split(".");
-        if (0 === parts.length || parts.some((part)=>!part || "." === part || ".." === part || part.includes("/") || part.includes("\\"))) throw new Error(`Invalid dependency ${kind} name: ${name}`);
-        return external_path_default().join(...parts);
-    }
-    async function writeDepToCache(projectRoot, dep) {
-        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
-        await promises_default().rm(depDir, {
-            recursive: true,
-            force: true
-        });
-        await promises_default().mkdir(external_path_default().join(depDir, "client_code"), {
-            recursive: true
-        });
-        await promises_default().mkdir(external_path_default().join(depDir, "server_code"), {
-            recursive: true
-        });
-        await promises_default().writeFile(external_path_default().join(depDir, "anvil.yaml"), external_js_yaml_default().dump({
-            package_name: dep.package_name
-        }));
-        for (const mod of dep.modules ?? []){
-            const modulePath = external_path_default().join(depDir, "client_code", dependencyPythonPath(mod.name, "module"));
-            if (mod.is_package) {
-                await promises_default().mkdir(modulePath, {
-                    recursive: true
-                });
-                await promises_default().writeFile(external_path_default().join(modulePath, "__init__.py"), mod.code);
-            } else {
-                const moduleFile = `${modulePath}.py`;
-                await promises_default().mkdir(external_path_default().dirname(moduleFile), {
-                    recursive: true
-                });
-                await promises_default().writeFile(moduleFile, mod.code);
+        async discardStagedModeOnlyChanges(paths) {
+            const discarded = [];
+            for (const relativePath of paths)try {
+                const headMode = await this.getHeadFileMode(relativePath);
+                if ("100644" !== headMode && "100755" !== headMode) continue;
+                const indexContentUnchanged = await this.hasSameIndexContentAsHead(relativePath);
+                if (!indexContentUnchanged) continue;
+                await this.git.raw([
+                    "reset",
+                    "-q",
+                    "HEAD",
+                    "--",
+                    relativePath
+                ]);
+                await this.restoreExecutableBit(relativePath, "100755" === headMode);
+                discarded.push(relativePath);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("discard staged mode-only changes", e.message);
             }
+            return discarded;
         }
-        for (const form of dep.forms ?? []){
-            const { code, class_name, is_package, ...formTemplate } = form;
-            const formPath = external_path_default().join(depDir, "client_code", dependencyPythonPath(class_name, "form"));
-            if (is_package) {
-                await promises_default().mkdir(formPath, {
-                    recursive: true
+        async getHeadFileMode(relativePath) {
+            const output = await this.git.raw([
+                "ls-tree",
+                "HEAD",
+                "--",
+                relativePath
+            ]);
+            const match = output.match(/^(\d{6})\s/);
+            return match?.[1] ?? null;
+        }
+        async hasSameContentAsHead(relativePath) {
+            const headHash = (await this.git.revparse([
+                `HEAD:${relativePath}`
+            ])).trim();
+            const worktreeHash = (await this.git.raw([
+                "hash-object",
+                "--",
+                relativePath
+            ])).trim();
+            return headHash === worktreeHash;
+        }
+        async hasSameIndexContentAsHead(relativePath) {
+            const headHash = (await this.git.revparse([
+                `HEAD:${relativePath}`
+            ])).trim();
+            const indexHash = (await this.git.revparse([
+                `:${relativePath}`
+            ])).trim();
+            return headHash === indexHash;
+        }
+        async restoreExecutableBit(relativePath, executable) {
+            const filePath = external_path_default().join(this.repoPath, relativePath);
+            const stat = await external_fs_.promises.stat(filePath);
+            const mode = executable ? 73 | stat.mode : -74 & stat.mode;
+            if ((511 & stat.mode) !== (511 & mode)) await external_fs_.promises.chmod(filePath, mode);
+        }
+        async hasUncommittedChanges() {
+            const status = await this.getStatus();
+            return !status.isClean;
+        }
+        async fetch(url, refSpec) {
+            let attempt = 0;
+            while(true)try {
+                await this.git.fetch([
+                    url,
+                    refSpec
+                ]);
+                if (attempt > 0) this.emit("fetch-retry-resolved", {
+                    attempts: attempt,
+                    outcome: "succeeded"
                 });
-                await promises_default().writeFile(external_path_default().join(formPath, "__init__.py"), code);
-                await promises_default().writeFile(external_path_default().join(formPath, "form_template.yaml"), external_js_yaml_default().dump(formTemplate));
-            } else {
-                const formCodeFile = `${formPath}.py`;
-                await promises_default().mkdir(external_path_default().dirname(formCodeFile), {
-                    recursive: true
+                return;
+            } catch (e) {
+                const err = e;
+                if (!isWantNotValidError(err)) {
+                    if (attempt > 0) this.emit("fetch-retry-resolved", {
+                        attempts: attempt,
+                        outcome: "failed"
+                    });
+                    throw errors_createGitError.fetchFailed(err.message);
+                }
+                attempt++;
+                this.emit("fetch-retry", {
+                    attempt,
+                    delayMs: FETCH_RETRY_DELAY_MS,
+                    error: err.message
                 });
-                await promises_default().writeFile(formCodeFile, code);
-                await promises_default().writeFile(`${formPath}.yaml`, external_js_yaml_default().dump(formTemplate));
+                logger_logger.verbose(`git fetch race (attempt ${attempt}, sleeping ${FETCH_RETRY_DELAY_MS}ms): ${err.message}`);
+                await (0, promises_namespaceObject.setTimeout)(FETCH_RETRY_DELAY_MS);
             }
         }
-        for (const mod of dep.server_modules ?? []){
-            const modulePath = external_path_default().join(depDir, "server_code", dependencyPythonPath(mod.name, "server module"));
-            if (mod.is_package) {
-                await promises_default().mkdir(modulePath, {
-                    recursive: true
-                });
-                await promises_default().writeFile(external_path_default().join(modulePath, "__init__.py"), mod.code);
-            } else {
-                const moduleFile = `${modulePath}.py`;
-                await promises_default().mkdir(external_path_default().dirname(moduleFile), {
-                    recursive: true
-                });
-                await promises_default().writeFile(moduleFile, mod.code);
+        async reset(ref, mode = "mixed") {
+            await this.runGitCommandWithIndexLockRetry("reset", ()=>this.git.reset([
+                    `--${mode}`,
+                    ref
+                ]));
+        }
+        async checkout(paths) {
+            await this.runGitCommandWithIndexLockRetry("checkout", ()=>this.git.checkout(paths));
+        }
+        async runGitCommandWithIndexLockRetry(command, operation) {
+            let lastError;
+            for(let attempt = 0; attempt <= git_GitService.INDEX_LOCK_RETRY_DELAYS_MS.length; attempt += 1)try {
+                await operation();
+                return;
+            } catch (e) {
+                lastError = e;
+                if (!this.isIndexLockError(e) || attempt === git_GitService.INDEX_LOCK_RETRY_DELAYS_MS.length) throw errors_createGitError.commandFailed(command, e.message);
+                await (0, promises_namespaceObject.setTimeout)(git_GitService.INDEX_LOCK_RETRY_DELAYS_MS[attempt]);
             }
+            throw errors_createGitError.commandFailed(command, lastError.message);
         }
-        for (const asset of dep.assets ?? []){
-            const targetPath = external_path_default().join(depDir, "theme", "assets", safeDependencyPath(asset.name, "asset"));
-            await promises_default().mkdir(external_path_default().dirname(targetPath), {
-                recursive: true
-            });
-            await promises_default().writeFile(targetPath, Buffer.from(asset.content, "base64"));
+        isIndexLockError(error) {
+            const message = error.message ?? "";
+            return message.includes("Unable to create") && message.includes("index.lock") && message.includes("File exists");
         }
-        for (const doc of dep.docs ?? []){
-            const targetPath = external_path_default().join(depDir, safeDependencyPath(doc.path, "doc"));
-            await promises_default().mkdir(external_path_default().dirname(targetPath), {
-                recursive: true
-            });
-            await promises_default().writeFile(targetPath, doc.content);
+        async stash(message) {
+            try {
+                const args = [
+                    "stash",
+                    "push",
+                    "--include-untracked"
+                ];
+                if (message) args.push("-m", message);
+                const result = await this.git.raw(args);
+                return !result.includes("No local changes to save");
+            } catch (e) {
+                throw errors_createGitError.commandFailed("stash", e.message);
+            }
         }
-    }
-    async function writeAllDepsToCache(projectRoot, response, options = {}) {
-        const includeDocs = options.includeDocs ?? true;
-        const manifest = await readDepsCacheManifest(projectRoot);
-        const canReuseExistingCache = manifest?.includeDocs === includeDocs;
-        if (!canReuseExistingCache) await clearDepsCache(projectRoot);
-        const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
-        const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
-        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
-            recursive: true,
-            force: true
-        });
-        for (const dep of response.dependencies)await writeDepToCache(projectRoot, dep);
-        const returnedByAppId = new Map(response.dependencies.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        const previousByAppId = new Map(previousCached.map((dep)=>[
-                dep.app_id,
-                dep
-            ]));
-        const cachedDependencies = response.resolved_dependencies.map((dep)=>{
-            const returned = returnedByAppId.get(dep.app_id);
-            if (returned) return cachedManifestEntry(returned, returned.package_name);
-            const previous = previousByAppId.get(dep.app_id);
-            if (!previous) return;
-            return cachedManifestEntry(dep, previous.package_name);
-        }).filter((dep)=>void 0 !== dep);
-        const newManifest = {
-            version: DEPS_MANIFEST_VERSION,
-            includeDocs,
-            source_dependencies: await readAnvilYamlDependencies(projectRoot),
-            resolved_dependencies: response.resolved_dependencies,
-            cached_dependencies: cachedDependencies
-        };
-        await promises_default().mkdir(depsDir(projectRoot), {
-            recursive: true
-        });
-        await promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
-    }
-    async function clearDepsCache(projectRoot) {
-        await promises_default().rm(depsDir(projectRoot), {
-            recursive: true,
-            force: true
-        });
-    }
-    const external_timers_promises_namespaceObject = require("timers/promises");
-    const WANT_NOT_VALID_RE = /\bwant\s+[0-9a-f]{7,40}\s+not valid\b/i;
-    const FETCH_RETRY_DELAY_MS = 200;
-    function isWantNotValidError(error) {
-        return WANT_NOT_VALID_RE.test(error.message || "");
-    }
-    class git_GitService extends Emitter {
-        git;
-        repoPath;
-        static INDEX_LOCK_RETRY_DELAYS_MS = [
-            25,
-            50,
-            100,
-            200
-        ];
-        constructor(repoPath){
-            super();
-            this.repoPath = external_path_default().resolve(repoPath);
-            this.git = esm_default(this.repoPath);
+        async stashPop() {
+            try {
+                await this.git.raw([
+                    "stash",
+                    "pop"
+                ]);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("stash pop", e.message);
+            }
         }
-        getGit() {
-            return this.git;
+        async clean(files) {
+            try {
+                await this.git.clean(CleanOptions.FORCE, files);
+            } catch (e) {
+                throw errors_createGitError.commandFailed("clean", e.message);
+            }
         }
-        getRepoPath() {
-            return this.repoPath;
+        async diffNames(fromCommit, toCommit) {
+            try {
+                const diffResult = await this.git.diff([
+                    fromCommit,
+                    toCommit,
+                    "--name-only"
+                ]);
+                const files = diffResult.split("\n").filter((f)=>f.trim());
+                return files;
+            } catch (e) {
+                throw errors_createGitError.commandFailed("diff", e.message);
+            }
         }
-        async getGitDir() {
+        async getAheadBehind(localRef, remoteRef) {
             try {
-                const gitDir = (await this.git.revparse([
-                    "--git-dir"
-                ])).trim();
-                if (!external_path_default().isAbsolute(gitDir)) return external_path_default().resolve(this.repoPath, gitDir);
-                return gitDir;
+                const result = await this.git.raw([
+                    "rev-list",
+                    "--left-right",
+                    "--count",
+                    `${remoteRef}...${localRef}`
+                ]);
+                const [behind, ahead] = result.trim().split("\t").map(Number);
+                return {
+                    ahead,
+                    behind
+                };
+            } catch (e) {
+                throw errors_createGitError.commandFailed("rev-list", e.message);
+            }
+        }
+        async show(refPath) {
+            try {
+                const content = await this.git.show([
+                    refPath
+                ]);
+                return content;
+            } catch (e) {
+                throw errors_createGitError.commandFailed("show", e.message);
+            }
+        }
+        async push(url, refSpec, force = false) {
+            try {
+                const args = force ? [
+                    "push",
+                    "--force",
+                    url,
+                    refSpec
+                ] : [
+                    "push",
+                    url,
+                    refSpec
+                ];
+                await this.git.raw(args);
             } catch (e) {
-                throw errors_createGitError.commandFailed("rev-parse --git-dir", e.message);
+                throw errors_createGitError.commandFailed("push", e.message);
             }
         }
-        async getCurrentBranch() {
+        async rebase(onto) {
             try {
-                const branchRef = await this.git.revparse([
-                    "--abbrev-ref",
-                    "HEAD"
+                await this.git.raw([
+                    "rebase",
+                    onto
                 ]);
-                if ("HEAD" === branchRef) throw createSyncError.detachedHead();
-                return branchRef;
             } catch (e) {
-                if ("detached_head" === e.type) throw e;
-                throw createSyncError.detachedHead();
+                throw errors_createGitError.commandFailed("rebase", e.message);
             }
         }
-        async getCommitId() {
+        async rebaseAbort() {
             try {
-                const commitId = (await this.git.revparse([
-                    "HEAD"
-                ])).trim();
-                return commitId;
+                await this.git.raw([
+                    "rebase",
+                    "--abort"
+                ]);
             } catch (e) {
-                throw errors_createGitError.commandFailed("revparse", e.message);
+                throw errors_createGitError.commandFailed("rebase --abort", e.message);
             }
         }
-        async getCommitInfo() {
+        async isAncestor(ancestorRef, descendantRef) {
             try {
-                const hash = (await this.git.revparse([
-                    "HEAD"
+                const mergeBase = (await this.git.raw([
+                    "merge-base",
+                    ancestorRef,
+                    descendantRef
                 ])).trim();
-                const message = (await this.git.raw([
-                    "log",
-                    "-1",
-                    "--format=%s"
+                const ancestorCommit = (await this.git.revparse([
+                    ancestorRef
                 ])).trim();
-                return {
-                    hash,
-                    shortHash: hash.substring(0, 8),
-                    message
-                };
-            } catch (e) {
-                throw errors_createGitError.commandFailed("log", e.message);
+                return mergeBase === ancestorCommit;
+            } catch  {
+                return false;
             }
         }
-        async getStatus() {
+        async mergeFastForward(ref) {
+            await this.runGitCommandWithIndexLockRetry("merge --ff-only", ()=>this.git.raw([
+                    "merge",
+                    "--ff-only",
+                    ref
+                ]));
+        }
+        async deleteRef(ref) {
             try {
-                const status = await this.git.status();
-                const staged = status.files.filter((file)=>{
-                    const indexStatus = file.index.trim();
-                    return indexStatus.length > 0 && "?" !== indexStatus;
-                }).map((file)=>file.path);
-                return {
-                    isClean: status.isClean(),
-                    modified: status.modified,
-                    notAdded: status.not_added,
-                    created: status.created,
-                    deleted: status.deleted,
-                    staged,
-                    renamed: status.renamed || []
-                };
+                await this.git.raw([
+                    "update-ref",
+                    "-d",
+                    ref
+                ]);
+            } catch (e) {}
+        }
+        async getRemotes() {
+            try {
+                const remotes = await this.git.getRemotes(true);
+                return remotes.map((r)=>({
+                        name: r.name,
+                        fetchUrl: r.refs.fetch
+                    }));
             } catch (e) {
-                throw errors_createGitError.commandFailed("status", e.message);
+                throw errors_createGitError.commandFailed("remote", e.message);
             }
         }
-        async discardModeOnlyChanges(paths) {
-            const discarded = [];
-            for (const relativePath of paths)try {
-                const headMode = await this.getHeadFileMode(relativePath);
-                if ("100644" !== headMode && "100755" !== headMode) continue;
-                const contentUnchanged = await this.hasSameContentAsHead(relativePath);
-                if (!contentUnchanged) continue;
-                await this.restoreExecutableBit(relativePath, "100755" === headMode);
-                discarded.push(relativePath);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("discard mode-only changes", e.message);
+        async isGitInitialized() {
+            const gitPath = external_path_default().join(this.repoPath, ".git");
+            return external_fs_.existsSync(gitPath);
+        }
+        async removeEmptyDirectories(removedFiles) {
+            const directoriesToCheck = new Set();
+            for (const file of removedFiles){
+                let dir = external_path_default().dirname(file);
+                while(dir && "." !== dir){
+                    directoriesToCheck.add(dir);
+                    const parentDir = external_path_default().dirname(dir);
+                    if (parentDir === dir) break;
+                    dir = parentDir;
+                }
             }
-            return discarded;
+            const sortedDirs = Array.from(directoriesToCheck).sort((a, b)=>b.split("/").length - a.split("/").length);
+            for (const dir of sortedDirs)try {
+                const dirPath = external_path_default().join(this.repoPath, dir);
+                if (!external_fs_.existsSync(dirPath)) continue;
+                const entries = await external_fs_.promises.readdir(dirPath);
+                if (0 === entries.length) await external_fs_.promises.rmdir(dirPath);
+            } catch (error) {}
         }
-        async discardStagedModeOnlyChanges(paths) {
-            const discarded = [];
-            for (const relativePath of paths)try {
-                const headMode = await this.getHeadFileMode(relativePath);
-                if ("100644" !== headMode && "100755" !== headMode) continue;
-                const indexContentUnchanged = await this.hasSameIndexContentAsHead(relativePath);
-                if (!indexContentUnchanged) continue;
-                await this.git.raw([
-                    "reset",
-                    "-q",
-                    "HEAD",
-                    "--",
-                    relativePath
-                ]);
-                await this.restoreExecutableBit(relativePath, "100755" === headMode);
-                discarded.push(relativePath);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("discard staged mode-only changes", e.message);
+    }
+    async function getStagedFileChanges(git, gitService) {
+        try {
+            const status = await git.status();
+            const renames = status.renamed || [];
+            const stagedFiles = status.files.filter((f)=>" " !== f.index && "?" !== f.index);
+            const stagedModeOnlyPaths = new Set(gitService ? await gitService.discardStagedModeOnlyChanges(stagedFiles.filter((f)=>"R" !== f.index && "D" !== f.index).map((f)=>f.path)) : []);
+            const stagedRenames = [];
+            for (const f of stagedFiles)if ("R" === f.index) {
+                const rename = renames.find((r)=>r.to === f.path);
+                if (rename) stagedRenames.push({
+                    path: rename.to,
+                    type: "rename",
+                    from: rename.from
+                });
             }
-            return discarded;
+            const stagedRenamedFromPaths = new Set(stagedRenames.map((r)=>r.from));
+            const stagedRenamedToPaths = new Set(stagedRenames.map((r)=>r.path));
+            const changes = [];
+            for (const f of stagedFiles){
+                if ("R" !== f.index) {
+                    if (!stagedModeOnlyPaths.has(f.path)) {
+                        if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
+                            path: f.path,
+                            type: "unlink"
+                        });
+                        else if ("A" === f.index || "?" === f.index) changes.push({
+                            path: f.path,
+                            type: "add"
+                        });
+                        else changes.push({
+                            path: f.path,
+                            type: "change"
+                        });
+                    }
+                }
+            }
+            changes.push(...stagedRenames);
+            return changes;
+        } catch (e) {
+            throw errors_createGitError.commandFailed("status", e.message);
         }
-        async getHeadFileMode(relativePath) {
-            const output = await this.git.raw([
-                "ls-tree",
-                "HEAD",
-                "--",
-                relativePath
-            ]);
-            const match = output.match(/^(\d{6})\s/);
-            return match?.[1] ?? null;
+    }
+    async function git_getCurrentOrFallbackBranchName(git) {
+        const branchRef = (await git.revparse([
+            "--abbrev-ref",
+            "HEAD"
+        ])).trim();
+        if ("HEAD" !== branchRef) return branchRef;
+        const [localBranches, remoteBranches] = await Promise.all([
+            git.raw([
+                "branch",
+                "--format=%(refname:short)",
+                "--contains",
+                "HEAD"
+            ]),
+            git.raw([
+                "branch",
+                "-r",
+                "--format=%(refname:short)",
+                "--contains",
+                "HEAD"
+            ])
+        ]);
+        const branchNames = [
+            ...parseBranchList(localBranches),
+            ...parseBranchList(remoteBranches).filter((branchName)=>!branchName.endsWith("/HEAD")).map((branchName)=>branchName.replace(/^[^/]+\//, ""))
+        ];
+        const branchSet = new Set(branchNames);
+        if (branchSet.has("master")) return "master";
+        if (branchSet.has("main")) return "main";
+        return "master";
+    }
+    function parseBranchList(output) {
+        return output.split(/\r?\n/).map((line)=>line.trim()).filter(Boolean);
+    }
+    function anvil_api_getDefaultAnvilUrl() {
+        return resolveAnvilUrl();
+    }
+    async function anvil_api_validateAppId(appId, anvilUrl = anvil_api_getDefaultAnvilUrl(), username) {
+        const authToken = await auth_getValidAuthToken(anvilUrl, username);
+        try {
+            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/validate-app-id`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    app_id: appId
+                })
+            });
+            const data = await resp.json();
+            if (resp.ok) return {
+                valid: data.valid ?? false,
+                app_name: data.app_name
+            };
+            if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
+            if (403 === resp.status) throw createAppError.accessDenied(appId);
+            if (404 === resp.status) throw createAppError.notFound(appId);
+            logger_logger.debug(`validate-app-id failed: ${resp.status} ${resp.statusText}`);
+            return {
+                valid: false,
+                error: data.error || `Server error: ${resp.status}`
+            };
+        } catch (error) {
+            if (error.type) throw error;
+            throw createNetworkError.network(error.message);
+        }
+    }
+    async function lookupByCommit(commitId, branchName, anvilUrl = anvil_api_getDefaultAnvilUrl(), username) {
+        const authToken = await auth_getValidAuthToken(anvilUrl, username);
+        try {
+            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/lookup-by-commit`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    commit_id: commitId,
+                    branch_name: branchName
+                })
+            });
+            if (!resp.ok) {
+                if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
+                throw createNetworkError.server(resp.status, resp.statusText);
+            }
+            const data = await resp.json();
+            return data;
+        } catch (error) {
+            if (error.type) throw error;
+            throw createNetworkError.network(error.message);
         }
-        async hasSameContentAsHead(relativePath) {
-            const headHash = (await this.git.revparse([
-                `HEAD:${relativePath}`
-            ])).trim();
-            const worktreeHash = (await this.git.raw([
-                "hash-object",
-                "--",
-                relativePath
-            ])).trim();
-            return headHash === worktreeHash;
+    }
+    async function listAppsForCheckout(options = {}) {
+        const anvilUrl = options.anvilUrl ?? anvil_api_getDefaultAnvilUrl();
+        const authToken = await auth_getValidAuthToken(anvilUrl, options.username);
+        const params = new URLSearchParams();
+        if ("number" == typeof options.limit) params.set("limit", String(options.limit));
+        if (options.cursor) params.set("cursor", options.cursor);
+        if (options.q && options.q.trim()) params.set("q", options.q.trim());
+        const query = params.toString();
+        const url = `${anvilUrl}/ide/api/_/apps${query ? `?${query}` : ""}`;
+        try {
+            const resp = await fetch(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${authToken}`
+                },
+                signal: options.signal
+            });
+            if (!resp.ok) {
+                if (401 === resp.status) throw createAuthError.invalid("Authentication failed");
+                throw createNetworkError.server(resp.status, resp.statusText);
+            }
+            const data = await resp.json();
+            return {
+                apps: Array.isArray(data.apps) ? data.apps : [],
+                next_cursor: "string" == typeof data.next_cursor ? data.next_cursor : null
+            };
+        } catch (error) {
+            if (error.type) throw error;
+            throw createNetworkError.network(error.message);
         }
-        async hasSameIndexContentAsHead(relativePath) {
-            const headHash = (await this.git.revparse([
-                `HEAD:${relativePath}`
-            ])).trim();
-            const indexHash = (await this.git.revparse([
-                `:${relativePath}`
-            ])).trim();
-            return headHash === indexHash;
+    }
+    async function saveUpdates(appId, branchName, payload, anvilUrl = anvil_api_getDefaultAnvilUrl(), authToken) {
+        try {
+            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/update?make_fresh_version=false&branch=${branchName}`, {
+                method: "PUT",
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(payload)
+            });
+            const data = await resp.json();
+            if (401 === resp.status) throw createAuthError.invalid(`Authentication failed (401): ${data.error || "unauthorized"}`);
+            if (403 === resp.status) throw createAuthError.invalid(`Authentication failed (403): ${data.error || "unauthorized"}\n   This may indicate:\n   - The OAuth token doesn't have permission to write to app ${appId}\n   - The app belongs to a different user or organization\n   - The OAuth token is missing required scopes (apps:write)`);
+            return {
+                version: data.version,
+                overtaken: data.overtaken,
+                latest_version: data.latest_version,
+                error: 200 !== resp.status ? data.error || `Status ${resp.status}` : void 0
+            };
+        } catch (error) {
+            if (error.type) throw error;
+            throw createNetworkError.network(error.message);
         }
-        async restoreExecutableBit(relativePath, executable) {
-            const filePath = external_path_default().join(this.repoPath, relativePath);
-            const stat = await external_fs_.promises.stat(filePath);
-            const mode = executable ? 73 | stat.mode : -74 & stat.mode;
-            if ((511 & stat.mode) !== (511 & mode)) await external_fs_.promises.chmod(filePath, mode);
+    }
+    function anvil_api_getGitFetchUrl(appId, authToken, gitUrl = anvil_api_getDefaultAnvilUrl()) {
+        const url = new URL(gitUrl);
+        const encodedToken = encodeURIComponent(authToken);
+        return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git?no_freeze=true&q=`;
+    }
+    function anvil_api_getGitPushUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
+        const url = new URL(anvilUrl);
+        const encodedToken = encodeURIComponent(authToken);
+        return `${url.protocol}//git:${encodedToken}@${url.hostname}${url.port ? ":" + url.port : ""}/git/${appId}.git`;
+    }
+    function getWebSocketUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
+        return anvilUrl.replace(/^http/, "ws") + `/ide/api/_/apps/${appId}/ws?access_token=${authToken}`;
+    }
+    async function getLatestVersion() {
+        try {
+            const response = await fetch("https://registry.npmjs.org/@anvil-works/anvil-cli/latest");
+            if (!response.ok) return null;
+            const data = await response.json();
+            return data.version;
+        } catch (e) {
+            return null;
         }
-        async hasUncommittedChanges() {
-            const status = await this.getStatus();
-            return !status.isClean;
+    }
+    function anvil_api_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);
         }
-        async fetch(url, refSpec) {
-            let attempt = 0;
-            while(true)try {
-                await this.git.fetch([
-                    url,
-                    refSpec
-                ]);
-                if (attempt > 0) this.emit("fetch-retry-resolved", {
-                    attempts: attempt,
-                    outcome: "succeeded"
-                });
-                return;
-            } catch (e) {
-                const err = e;
-                if (!isWantNotValidError(err)) {
-                    if (attempt > 0) this.emit("fetch-retry-resolved", {
-                        attempts: attempt,
-                        outcome: "failed"
+        if (explicitUsername) filtered = filtered.filter((c)=>!c.detectedUsername || c.detectedUsername === explicitUsername);
+        return filtered;
+    }
+    function anvil_api_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 anvil_api_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 anvil_api_detectAppIdsFromAllRemotes(repoPath) {
+        const git = esm_default(repoPath);
+        const out = [];
+        try {
+            const remotes = await git.getRemotes(true);
+            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;
+                    out.push({
+                        appId: detectedAppId,
+                        source: "remote",
+                        description: `Git remote '${remote.name}'`,
+                        detectedUrl: config_normalizeAnvilUrl(host)
+                    });
+                    continue;
+                }
+                const sshMatch = remote.refs.fetch?.match(/ssh:\/\/([^@]+)@([^:]+):(\d+)\/(?:git\/)?([A-Z0-9]+)\.git/);
+                if (sshMatch) {
+                    const [, usernamePart, host, , detectedAppId] = sshMatch;
+                    const detectedUsername = usernamePart.includes("%") ? decodeURIComponent(usernamePart) : usernamePart;
+                    const finalUsername = "git" !== detectedUsername ? detectedUsername : void 0;
+                    out.push({
+                        appId: detectedAppId,
+                        source: "remote",
+                        description: `Git remote '${remote.name}' (SSH)`,
+                        detectedUrl: config_normalizeAnvilUrl(host),
+                        detectedUsername: finalUsername
                     });
-                    throw errors_createGitError.fetchFailed(err.message);
                 }
-                attempt++;
-                this.emit("fetch-retry", {
-                    attempt,
-                    delayMs: FETCH_RETRY_DELAY_MS,
-                    error: err.message
-                });
-                logger_logger.verbose(`git fetch race (attempt ${attempt}, sleeping ${FETCH_RETRY_DELAY_MS}ms): ${err.message}`);
-                await (0, external_timers_promises_namespaceObject.setTimeout)(FETCH_RETRY_DELAY_MS);
-            }
-        }
-        async reset(ref, mode = "mixed") {
-            await this.runGitCommandWithIndexLockRetry("reset", ()=>this.git.reset([
-                    `--${mode}`,
-                    ref
-                ]));
-        }
-        async checkout(paths) {
-            await this.runGitCommandWithIndexLockRetry("checkout", ()=>this.git.checkout(paths));
-        }
-        async runGitCommandWithIndexLockRetry(command, operation) {
-            let lastError;
-            for(let attempt = 0; attempt <= git_GitService.INDEX_LOCK_RETRY_DELAYS_MS.length; attempt += 1)try {
-                await operation();
-                return;
-            } catch (e) {
-                lastError = e;
-                if (!this.isIndexLockError(e) || attempt === git_GitService.INDEX_LOCK_RETRY_DELAYS_MS.length) throw errors_createGitError.commandFailed(command, e.message);
-                await (0, external_timers_promises_namespaceObject.setTimeout)(git_GitService.INDEX_LOCK_RETRY_DELAYS_MS[attempt]);
             }
-            throw errors_createGitError.commandFailed(command, lastError.message);
-        }
-        isIndexLockError(error) {
-            const message = error.message ?? "";
-            return message.includes("Unable to create") && message.includes("index.lock") && message.includes("File exists");
-        }
-        async stash(message) {
-            try {
-                const args = [
-                    "stash",
-                    "push",
-                    "--include-untracked"
-                ];
-                if (message) args.push("-m", message);
-                const result = await this.git.raw(args);
-                return !result.includes("No local changes to save");
-            } catch (e) {
-                throw errors_createGitError.commandFailed("stash", e.message);
+        } catch (_e) {}
+        return out;
+    }
+    async function anvil_api_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, username);
+            const commitId = (await git.revparse([
+                "HEAD"
+            ]))?.trim();
+            if (!commitId) return out;
+            const branchName = await git_getCurrentOrFallbackBranchName(git);
+            const resp = await fetch(`${anvilUrl}/ide/api/_/apps/lookup-by-commit`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    commit_id: commitId,
+                    branch_name: branchName
+                })
+            });
+            logger_logger.debug(`Reverse lookup by commit ${commitId} on branch ${branchName} returned ${resp.status}`);
+            if (!resp.ok) {
+                const errorBody = await resp.text();
+                logger_logger.debug(`lookup-by-commit error: ${errorBody}`);
             }
-        }
-        async stashPop() {
-            try {
-                await this.git.raw([
-                    "stash",
-                    "pop"
-                ]);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("stash pop", e.message);
+            if (resp.ok) {
+                const data = await resp.json();
+                logger_logger.debug(`data ${JSON.stringify(data)}`);
+                const apps = data?.apps ?? [];
+                for (const app of apps)if (app?.app_id) out.push({
+                    appId: app.app_id,
+                    source: "remote",
+                    description: `Reverse lookup by commit${app.branch ? ` on branch '${app.branch}'` : ""}`
+                });
             }
+        } catch (_e) {}
+        return out;
+    }
+    const external_fs_promises_namespaceObject = require("fs/promises");
+    var external_fs_promises_default = /*#__PURE__*/ __webpack_require__.n(external_fs_promises_namespaceObject);
+    function normalizeLineEndings(content) {
+        return content.replace(/\r\n/g, "\n");
+    }
+    function pythonifyName(name) {
+        return name.replace(/[^A-z0-9]/g, "_").replace(/^[0-9]/, "_$&");
+    }
+    function extractPythonName(relativePath, skipParts = 1) {
+        const parts = relativePath.slice(0, -3).split("/");
+        const isPackage = relativePath.endsWith("__init__.py");
+        const relevantParts = isPackage ? parts.slice(skipParts, -1) : parts.slice(skipParts);
+        return relevantParts.map(pythonifyName).join(".");
+    }
+    function deepEqual(a, b) {
+        if (a === b) return true;
+        if (null == a || null == b) return false;
+        if (typeof a !== typeof b) return false;
+        if ("object" != typeof a) return a === b;
+        if (Array.isArray(a) !== Array.isArray(b)) return false;
+        if (Array.isArray(a)) {
+            if (a.length !== b.length) return false;
+            return a.every((item, index)=>deepEqual(item, b[index]));
         }
-        async clean(files) {
-            try {
-                await this.git.clean(CleanOptions.FORCE, files);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("clean", e.message);
-            }
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length) return false;
+        return keysA.every((key)=>deepEqual(a[key], b[key]));
+    }
+    function parseHtmlWithFrontmatter(htmlContent) {
+        const frontmatterPattern = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+        const match = htmlContent.match(frontmatterPattern);
+        if (match) {
+            const yamlStr = match[1];
+            const html = match[2];
+            const frontmatter = yamlStr ? external_js_yaml_default().load(yamlStr) ?? {} : {};
+            return {
+                frontmatter,
+                html
+            };
         }
-        async diffNames(fromCommit, toCommit) {
-            try {
-                const diffResult = await this.git.diff([
-                    fromCommit,
-                    toCommit,
-                    "--name-only"
-                ]);
-                const files = diffResult.split("\n").filter((f)=>f.trim());
-                return files;
-            } catch (e) {
-                throw errors_createGitError.commandFailed("diff", e.message);
-            }
+        return {
+            frontmatter: {},
+            html: htmlContent
+        };
+    }
+    function formatHttpError(prefix, status, body) {
+        if (!body) return `${prefix}: ${status}`;
+        try {
+            const parsed = JSON.parse(body);
+            if ("string" == typeof parsed.error && parsed.error.trim()) return `${prefix}: ${parsed.error} (${status})`;
+        } catch  {}
+        return `${prefix}: ${status} ${body}`;
+    }
+    const ANVIL_GITIGNORE_ENTRY = "/.anvil/";
+    async function ensureProjectGitignoreIgnoresAnvilDir(projectRoot) {
+        const rootGitignorePath = external_path_default().join(projectRoot, ".gitignore");
+        try {
+            const existing = await external_fs_.promises.readFile(rootGitignorePath, "utf8");
+            if (existing.includes(ANVIL_GITIGNORE_ENTRY)) return false;
+            const prefix = existing.endsWith("\n") || 0 === existing.length ? "" : "\n";
+            await external_fs_.promises.writeFile(rootGitignorePath, `${existing}${prefix}${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
+        } catch (error) {
+            if ("ENOENT" !== error.code) throw error;
+            await external_fs_.promises.writeFile(rootGitignorePath, `${ANVIL_GITIGNORE_ENTRY}\n`, "utf8");
+            return true;
         }
-        async getAheadBehind(localRef, remoteRef) {
-            try {
-                const result = await this.git.raw([
-                    "rev-list",
-                    "--left-right",
-                    "--count",
-                    `${remoteRef}...${localRef}`
-                ]);
-                const [behind, ahead] = result.trim().split("\t").map(Number);
-                return {
-                    ahead,
-                    behind
-                };
-            } catch (e) {
-                throw errors_createGitError.commandFailed("rev-list", e.message);
-            }
+    }
+    const ANVIL_DEPS_DIR = ".anvil/deps";
+    const ANVIL_DEPS_MANIFEST = "manifest.json";
+    const DEPS_MANIFEST_VERSION = 2;
+    async function fetchAllDependencies(appId, anvilUrl, options = {}) {
+        const { commit, includeDocs = true, knownDependencies = [] } = options;
+        anvilUrl ??= await auth_resolveAuthAnvilUrl();
+        const token = await auth_getValidAuthToken(anvilUrl);
+        const body = {
+            include_docs: includeDocs,
+            known_dependencies: knownDependencies
+        };
+        if (commit) body.commit = commit;
+        const resp = await fetch(`${anvilUrl}/ide/api/_/apps/${appId}/resolved-dependencies`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(body)
+        });
+        if (!resp.ok) {
+            const errorBody = await resp.text();
+            throw new Error(formatHttpError("Failed to fetch dependencies", resp.status, errorBody));
         }
-        async show(refPath) {
-            try {
-                const content = await this.git.show([
-                    refPath
-                ]);
-                return content;
-            } catch (e) {
-                throw errors_createGitError.commandFailed("show", e.message);
-            }
+        return await resp.json();
+    }
+    async function refreshDependencyCache(projectRoot, appId, anvilUrl, options = {}) {
+        auth_setRepoContext(projectRoot);
+        anvilUrl ??= await auth_resolveAuthAnvilUrl();
+        const includeDocs = options.includeDocs ?? true;
+        const knownDependencies = await getKnownDependenciesForCache(projectRoot, includeDocs);
+        const response = await fetchAllDependencies(appId, anvilUrl, {
+            commit: options.commit,
+            includeDocs,
+            knownDependencies
+        });
+        if (!response.resolved_dependencies.length) {
+            await clearDepsCache(projectRoot);
+            return {
+                response,
+                addedGitignoreEntry: false
+            };
         }
-        async push(url, refSpec, force = false) {
-            try {
-                const args = force ? [
-                    "push",
-                    "--force",
-                    url,
-                    refSpec
-                ] : [
-                    "push",
-                    url,
-                    refSpec
-                ];
-                await this.git.raw(args);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("push", e.message);
-            }
+        const addedGitignoreEntry = await ensureProjectGitignoreIgnoresAnvilDir(projectRoot);
+        await writeAllDepsToCache(projectRoot, response, {
+            includeDocs
+        });
+        return {
+            response,
+            addedGitignoreEntry
+        };
+    }
+    function depsDir(projectRoot) {
+        return external_path_default().join(projectRoot, ANVIL_DEPS_DIR);
+    }
+    function depsManifestPath(projectRoot) {
+        return external_path_default().join(depsDir(projectRoot), ANVIL_DEPS_MANIFEST);
+    }
+    function isResolvedDependencyManifestEntry(value) {
+        if (!value || "object" != typeof value) return false;
+        const entry = value;
+        return "string" == typeof entry.app_id && entry.app_id.length > 0 && "string" == typeof entry.commit_id && entry.commit_id.length > 0 && (void 0 === entry.branch || "string" == typeof entry.branch);
+    }
+    function isCachedDependencyManifestEntry(value) {
+        if (!isResolvedDependencyManifestEntry(value)) return false;
+        const entry = value;
+        return "string" == typeof entry.package_name && entry.package_name.length > 0;
+    }
+    function isDepsCacheManifest(value) {
+        if (!value || "object" != typeof value) return false;
+        const manifest = value;
+        return manifest.version === DEPS_MANIFEST_VERSION && "boolean" == typeof manifest.includeDocs && Array.isArray(manifest.source_dependencies) && Array.isArray(manifest.resolved_dependencies) && manifest.resolved_dependencies.every(isResolvedDependencyManifestEntry) && Array.isArray(manifest.cached_dependencies) && manifest.cached_dependencies.every(isCachedDependencyManifestEntry);
+    }
+    async function readDepsCacheManifest(projectRoot) {
+        try {
+            const raw = await external_fs_promises_default().readFile(depsManifestPath(projectRoot), "utf-8");
+            const parsed = JSON.parse(raw);
+            return isDepsCacheManifest(parsed) ? parsed : void 0;
+        } catch  {
+            return;
         }
-        async rebase(onto) {
-            try {
-                await this.git.raw([
-                    "rebase",
-                    onto
-                ]);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("rebase", e.message);
-            }
+    }
+    async function getKnownDependenciesForCache(projectRoot, includeDocs) {
+        const manifest = await readDepsCacheManifest(projectRoot);
+        if (!manifest || manifest.includeDocs !== includeDocs) return [];
+        return manifest.resolved_dependencies.map(({ app_id, commit_id })=>({
+                app_id,
+                commit_id
+            }));
+    }
+    function getDependencyWatchSubscriptionsFromManifest(manifest) {
+        if (!manifest) return [];
+        const cachedByAppId = new Map(manifest.cached_dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        return manifest.resolved_dependencies.flatMap((dep)=>{
+            if (!dep.branch) return [];
+            return [
+                {
+                    appId: dep.app_id,
+                    branch: dep.branch,
+                    packageName: cachedByAppId.get(dep.app_id)?.package_name
+                }
+            ];
+        });
+    }
+    function normalizeAnvilYamlDependenciesFromContent(content) {
+        const parsed = external_js_yaml_default().load(content);
+        if (!parsed || "object" != typeof parsed || !Array.isArray(parsed.dependencies)) return [];
+        return normalizeAnvilYamlDependenciesValue(parsed.dependencies);
+    }
+    function normalizeAnvilYamlDependenciesValue(value) {
+        if (!Array.isArray(value)) return [];
+        return value.map(normalizeForComparison);
+    }
+    async function readAnvilYamlDependencies(projectRoot) {
+        try {
+            const content = await external_fs_promises_default().readFile(external_path_default().join(projectRoot, "anvil.yaml"), "utf-8");
+            return normalizeAnvilYamlDependenciesFromContent(content);
+        } catch  {
+            return [];
         }
-        async rebaseAbort() {
-            try {
-                await this.git.raw([
-                    "rebase",
-                    "--abort"
-                ]);
-            } catch (e) {
-                throw errors_createGitError.commandFailed("rebase --abort", e.message);
+    }
+    function anvilYamlDependenciesEqual(left, right) {
+        return deepEqual(left, right);
+    }
+    function normalizeForComparison(value) {
+        if (Array.isArray(value)) return value.map(normalizeForComparison);
+        if (value && "object" == typeof value) return Object.fromEntries(Object.entries(value).sort(([left], [right])=>left.localeCompare(right)).map(([key, entryValue])=>[
+                key,
+                normalizeForComparison(entryValue)
+            ]));
+        return value;
+    }
+    function cachedManifestEntry(dep, packageName) {
+        return {
+            app_id: dep.app_id,
+            commit_id: dep.commit_id,
+            ...dep.branch ? {
+                branch: dep.branch
+            } : {},
+            package_name: packageName
+        };
+    }
+    function safeDependencyPath(filePath, kind) {
+        const normalizedPath = external_path_default().normalize(filePath);
+        if (external_path_default().isAbsolute(normalizedPath) || normalizedPath.startsWith("..")) throw new Error(`Invalid dependency ${kind} path: ${filePath}`);
+        return normalizedPath;
+    }
+    function dependencyPythonPath(name, kind) {
+        const parts = name.split(".");
+        if (0 === parts.length || parts.some((part)=>!part || "." === part || ".." === part || part.includes("/") || part.includes("\\"))) throw new Error(`Invalid dependency ${kind} name: ${name}`);
+        return external_path_default().join(...parts);
+    }
+    async function writeDepToCache(projectRoot, dep) {
+        const depDir = external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name);
+        await external_fs_promises_default().rm(depDir, {
+            recursive: true,
+            force: true
+        });
+        await external_fs_promises_default().mkdir(external_path_default().join(depDir, "client_code"), {
+            recursive: true
+        });
+        await external_fs_promises_default().mkdir(external_path_default().join(depDir, "server_code"), {
+            recursive: true
+        });
+        await external_fs_promises_default().writeFile(external_path_default().join(depDir, "anvil.yaml"), external_js_yaml_default().dump({
+            package_name: dep.package_name
+        }));
+        for (const mod of dep.modules ?? []){
+            const modulePath = external_path_default().join(depDir, "client_code", dependencyPythonPath(mod.name, "module"));
+            if (mod.is_package) {
+                await external_fs_promises_default().mkdir(modulePath, {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(external_path_default().join(modulePath, "__init__.py"), mod.code);
+            } else {
+                const moduleFile = `${modulePath}.py`;
+                await external_fs_promises_default().mkdir(external_path_default().dirname(moduleFile), {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(moduleFile, mod.code);
             }
         }
-        async isAncestor(ancestorRef, descendantRef) {
-            try {
-                const mergeBase = (await this.git.raw([
-                    "merge-base",
-                    ancestorRef,
-                    descendantRef
-                ])).trim();
-                const ancestorCommit = (await this.git.revparse([
-                    ancestorRef
-                ])).trim();
-                return mergeBase === ancestorCommit;
-            } catch  {
-                return false;
+        for (const form of dep.forms ?? []){
+            const { code, class_name, is_package, ...formTemplate } = form;
+            const formPath = external_path_default().join(depDir, "client_code", dependencyPythonPath(class_name, "form"));
+            if (is_package) {
+                await external_fs_promises_default().mkdir(formPath, {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(external_path_default().join(formPath, "__init__.py"), code);
+                await external_fs_promises_default().writeFile(external_path_default().join(formPath, "form_template.yaml"), external_js_yaml_default().dump(formTemplate));
+            } else {
+                const formCodeFile = `${formPath}.py`;
+                await external_fs_promises_default().mkdir(external_path_default().dirname(formCodeFile), {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(formCodeFile, code);
+                await external_fs_promises_default().writeFile(`${formPath}.yaml`, external_js_yaml_default().dump(formTemplate));
             }
         }
-        async mergeFastForward(ref) {
-            await this.runGitCommandWithIndexLockRetry("merge --ff-only", ()=>this.git.raw([
-                    "merge",
-                    "--ff-only",
-                    ref
-                ]));
-        }
-        async deleteRef(ref) {
-            try {
-                await this.git.raw([
-                    "update-ref",
-                    "-d",
-                    ref
-                ]);
-            } catch (e) {}
-        }
-        async getRemotes() {
-            try {
-                const remotes = await this.git.getRemotes(true);
-                return remotes.map((r)=>({
-                        name: r.name,
-                        fetchUrl: r.refs.fetch
-                    }));
-            } catch (e) {
-                throw errors_createGitError.commandFailed("remote", e.message);
+        for (const mod of dep.server_modules ?? []){
+            const modulePath = external_path_default().join(depDir, "server_code", dependencyPythonPath(mod.name, "server module"));
+            if (mod.is_package) {
+                await external_fs_promises_default().mkdir(modulePath, {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(external_path_default().join(modulePath, "__init__.py"), mod.code);
+            } else {
+                const moduleFile = `${modulePath}.py`;
+                await external_fs_promises_default().mkdir(external_path_default().dirname(moduleFile), {
+                    recursive: true
+                });
+                await external_fs_promises_default().writeFile(moduleFile, mod.code);
             }
         }
-        async isGitInitialized() {
-            const gitPath = external_path_default().join(this.repoPath, ".git");
-            return external_fs_.existsSync(gitPath);
+        for (const asset of dep.assets ?? []){
+            const targetPath = external_path_default().join(depDir, "theme", "assets", safeDependencyPath(asset.name, "asset"));
+            await external_fs_promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await external_fs_promises_default().writeFile(targetPath, Buffer.from(asset.content, "base64"));
         }
-        async removeEmptyDirectories(removedFiles) {
-            const directoriesToCheck = new Set();
-            for (const file of removedFiles){
-                let dir = external_path_default().dirname(file);
-                while(dir && "." !== dir){
-                    directoriesToCheck.add(dir);
-                    const parentDir = external_path_default().dirname(dir);
-                    if (parentDir === dir) break;
-                    dir = parentDir;
-                }
-            }
-            const sortedDirs = Array.from(directoriesToCheck).sort((a, b)=>b.split("/").length - a.split("/").length);
-            for (const dir of sortedDirs)try {
-                const dirPath = external_path_default().join(this.repoPath, dir);
-                if (!external_fs_.existsSync(dirPath)) continue;
-                const entries = await external_fs_.promises.readdir(dirPath);
-                if (0 === entries.length) await external_fs_.promises.rmdir(dirPath);
-            } catch (error) {}
+        for (const doc of dep.docs ?? []){
+            const targetPath = external_path_default().join(depDir, safeDependencyPath(doc.path, "doc"));
+            await external_fs_promises_default().mkdir(external_path_default().dirname(targetPath), {
+                recursive: true
+            });
+            await external_fs_promises_default().writeFile(targetPath, doc.content);
         }
     }
-    async function getStagedFileChanges(git, gitService) {
-        try {
-            const status = await git.status();
-            const renames = status.renamed || [];
-            const stagedFiles = status.files.filter((f)=>" " !== f.index && "?" !== f.index);
-            const stagedModeOnlyPaths = new Set(gitService ? await gitService.discardStagedModeOnlyChanges(stagedFiles.filter((f)=>"R" !== f.index && "D" !== f.index).map((f)=>f.path)) : []);
-            const stagedRenames = [];
-            for (const f of stagedFiles)if ("R" === f.index) {
-                const rename = renames.find((r)=>r.to === f.path);
-                if (rename) stagedRenames.push({
-                    path: rename.to,
-                    type: "rename",
-                    from: rename.from
-                });
-            }
-            const stagedRenamedFromPaths = new Set(stagedRenames.map((r)=>r.from));
-            const stagedRenamedToPaths = new Set(stagedRenames.map((r)=>r.path));
-            const changes = [];
-            for (const f of stagedFiles){
-                if ("R" !== f.index) {
-                    if (!stagedModeOnlyPaths.has(f.path)) {
-                        if (!(stagedRenamedFromPaths.has(f.path) || stagedRenamedToPaths.has(f.path))) if ("D" === f.index) changes.push({
-                            path: f.path,
-                            type: "unlink"
-                        });
-                        else if ("A" === f.index || "?" === f.index) changes.push({
-                            path: f.path,
-                            type: "add"
-                        });
-                        else changes.push({
-                            path: f.path,
-                            type: "change"
-                        });
-                    }
-                }
-            }
-            changes.push(...stagedRenames);
-            return changes;
-        } catch (e) {
-            throw errors_createGitError.commandFailed("status", e.message);
-        }
+    async function writeAllDepsToCache(projectRoot, response, options = {}) {
+        const includeDocs = options.includeDocs ?? true;
+        const manifest = await readDepsCacheManifest(projectRoot);
+        const canReuseExistingCache = manifest?.includeDocs === includeDocs;
+        if (!canReuseExistingCache) await clearDepsCache(projectRoot);
+        const previousCached = canReuseExistingCache ? manifest.cached_dependencies : [];
+        const resolvedAppIds = new Set(response.resolved_dependencies.map((dep)=>dep.app_id));
+        for (const dep of previousCached)if (!resolvedAppIds.has(dep.app_id)) await external_fs_promises_default().rm(external_path_default().join(projectRoot, ANVIL_DEPS_DIR, dep.package_name), {
+            recursive: true,
+            force: true
+        });
+        for (const dep of response.dependencies)await writeDepToCache(projectRoot, dep);
+        const returnedByAppId = new Map(response.dependencies.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const previousByAppId = new Map(previousCached.map((dep)=>[
+                dep.app_id,
+                dep
+            ]));
+        const cachedDependencies = response.resolved_dependencies.map((dep)=>{
+            const returned = returnedByAppId.get(dep.app_id);
+            if (returned) return cachedManifestEntry(returned, returned.package_name);
+            const previous = previousByAppId.get(dep.app_id);
+            if (!previous) return;
+            return cachedManifestEntry(dep, previous.package_name);
+        }).filter((dep)=>void 0 !== dep);
+        const newManifest = {
+            version: DEPS_MANIFEST_VERSION,
+            includeDocs,
+            source_dependencies: await readAnvilYamlDependencies(projectRoot),
+            resolved_dependencies: response.resolved_dependencies,
+            cached_dependencies: cachedDependencies
+        };
+        await external_fs_promises_default().mkdir(depsDir(projectRoot), {
+            recursive: true
+        });
+        await external_fs_promises_default().writeFile(depsManifestPath(projectRoot), `${JSON.stringify(newManifest, null, 2)}\n`);
+    }
+    async function clearDepsCache(projectRoot) {
+        await external_fs_promises_default().rm(depsDir(projectRoot), {
+            recursive: true,
+            force: true
+        });
     }
     const external_chokidar_namespaceObject = require("chokidar");
     var external_chokidar_default = /*#__PURE__*/ __webpack_require__.n(external_chokidar_namespaceObject);
@@ -16912,7 +17127,7 @@ print(json.dumps({"issues": issues}))
     }
     function validateScheduledTasks(value, path) {
         const issues = [];
-        if (void 0 === value) return issues;
+        if (null == value) return issues;
         if (!Array.isArray(value)) {
             validators_pushIssue(issues, path, "must be an array");
             return issues;
@@ -18411,6 +18626,15 @@ print(json.dumps({"issues": issues}))
             this.hasPendingChanges = true;
             await this.processSaveBatchWithEvents();
         }
+        async flush() {
+            const requireReady = ()=>{
+                if (this.config.isPaused() || this.config.isCleanedUp() || !this.config.isSettlePeriodOver()) throw new Error("Cannot flush saves while watching is paused, closed, or changing branch");
+            };
+            requireReady();
+            await this.forceSave();
+            requireReady();
+            if (this.hasPendingChanges) throw new Error("Saves remain pending");
+        }
         cleanup() {
             if (this.hasPendingChanges) {
                 logger_logger.progressEnd("sync");
@@ -18507,10 +18731,7 @@ print(json.dumps({"issues": issues}))
                 status = await this.config.gitService.getStatus();
             } catch (e) {
                 logger_logger.error(external_chalk_default().red(`Error reading git status: ${errors_getErrorMessage(e)}`));
-                return {
-                    skipped: true,
-                    reason: "Git status error"
-                };
+                throw e;
             }
             let allChanges;
             if (this.config.stagedOnly) {
@@ -19667,6 +19888,12 @@ print(json.dumps({"issues": issues}))
             if (!this.saveProcessor) return;
             return this.saveProcessor.forceSave();
         }
+        async flushSaves() {
+            if (!this.saveProcessor || this.isSwitchingForEnvironment) throw new Error("App synchronization is not ready");
+            const branch = this.currentBranch;
+            await this.saveProcessor.flush();
+            if (this.isSwitchingForEnvironment || this.currentBranch !== branch || await this.gitService.getCurrentBranch() !== branch) throw new Error("App branch changed while flushing saves");
+        }
         async getSuccessMessage() {
             try {
                 const info = await this.gitService.getCommitInfo();
@@ -20537,7 +20764,29 @@ print(json.dumps({"issues": issues}))
         const response = await buildGitCredentialResponse(operation, request, options);
         writeGitCredentialResponse(response);
     }
-    resolveAnvilUrl();
+    const MODEL_TOKEN_LOCK_TIMEOUT_MS = 12000;
+    const modelToken_defaultDeps = {
+        getValidAuthToken: auth_getValidAuthToken,
+        readAuthFromRepo: readAuthFromRepo,
+        cwd: ()=>process.cwd()
+    };
+    async function getModelToken(options = {}) {
+        const deps = options.deps ?? modelToken_defaultDeps;
+        const repoPath = options.repoPath ?? deps.cwd();
+        auth_setRepoContext(repoPath);
+        if (!process.env["ANVIL_AUTH_FILE_ENCRYPTION_KEY"]) throw new Error("ANVIL_AUTH_FILE_ENCRYPTION_KEY is not set; cannot read repo auth tokens.");
+        const auth = await deps.readAuthFromRepo(repoPath);
+        if (!auth) throw new Error(`No Anvil auth tokens found for the repository at ${repoPath}.`);
+        return deps.getValidAuthToken(auth.anvilUrl, auth.username, {
+            lock: {
+                timeoutMs: options.lockTimeoutMs ?? MODEL_TOKEN_LOCK_TIMEOUT_MS
+            }
+        });
+    }
+    async function executeModelTokenOperation(options = {}) {
+        const token = await getModelToken(options);
+        process.stdout.write(`${token}\n`);
+    }
     async function watch_decideFallbackUrl(explicitUrl, availableUrls) {
         if (explicitUrl) return {
             source: "explicit",
@@ -20748,7 +20997,6 @@ print(json.dumps({"issues": issues}))
             remoteName
         };
     }
-    const api_DEFAULT_ANVIL_URL = resolveAnvilUrl();
     async function api_checkUncommittedChanges(repoPath) {
         try {
             const git = esm_default(repoPath);
@@ -20797,9 +21045,10 @@ print(json.dumps({"issues": issues}))
         }
     }
     async function src_api_watch(repoPath, appId, options = {}) {
-        const { anvilUrl = api_DEFAULT_ANVIL_URL, gitUrl = anvilUrl, stagedOnly = false, username } = options;
         repoPath = external_path_default().resolve(repoPath);
         auth_setRepoContext(repoPath);
+        const anvilUrl = options.anvilUrl ?? await auth_resolveAuthAnvilUrl();
+        const { gitUrl = anvilUrl, stagedOnly = false, username } = options;
         const storedEnvPid = options.environment?.envPid ? void 0 : await environment_readEnvironmentPid(repoPath);
         const environment = options.environment ?? (storedEnvPid ? {
             envPid: storedEnvPid
@@ -20914,6 +21163,7 @@ print(json.dumps({"issues": issues}))
     }
 })();
 exports.ANVIL_SYNC_CLIENT_ID = __webpack_exports__.ANVIL_SYNC_CLIENT_ID;
+exports.AUTH_FILE_LOCK_DEFAULTS = __webpack_exports__.AUTH_FILE_LOCK_DEFAULTS;
 exports.AnvilYamlValidationResult = __webpack_exports__.AnvilYamlValidationResult;
 exports.AppIdCandidate = __webpack_exports__.AppIdCandidate;
 exports.AppIdWithContext = __webpack_exports__.AppIdWithContext;
@@ -20925,11 +21175,15 @@ exports.CheckoutOptions = __webpack_exports__.CheckoutOptions;
 exports.CheckoutResult = __webpack_exports__.CheckoutResult;
 exports.DeviceAuthorizationResponse = __webpack_exports__.DeviceAuthorizationResponse;
 exports.FormTemplateValidationResult = __webpack_exports__.FormTemplateValidationResult;
+exports.GetValidAuthTokenOptions = __webpack_exports__.GetValidAuthTokenOptions;
 exports.LoginResult = __webpack_exports__.LoginResult;
 exports.LogoutResult = __webpack_exports__.LogoutResult;
+exports.MODEL_TOKEN_HELPER_FILENAME = __webpack_exports__.MODEL_TOKEN_HELPER_FILENAME;
+exports.MODEL_TOKEN_LOCK_TIMEOUT_MS = __webpack_exports__.MODEL_TOKEN_LOCK_TIMEOUT_MS;
 exports.OAuthTokenResponse = __webpack_exports__.OAuthTokenResponse;
 exports.ParsedCheckoutInput = __webpack_exports__.ParsedCheckoutInput;
 exports.PreferredEditor = __webpack_exports__.PreferredEditor;
+exports.REFRESH_REQUEST_TIMEOUT_MS = __webpack_exports__.REFRESH_REQUEST_TIMEOUT_MS;
 exports.SettableConfigKey = __webpack_exports__.SettableConfigKey;
 exports.TokenData = __webpack_exports__.TokenData;
 exports.ValidateAppIdResponse = __webpack_exports__.ValidateAppIdResponse;
@@ -20950,6 +21204,7 @@ exports.detectAppIdsByCommitLookup = __webpack_exports__.detectAppIdsByCommitLoo
 exports.detectAppIdsFromAllRemotes = __webpack_exports__.detectAppIdsFromAllRemotes;
 exports.executeCheckout = __webpack_exports__.executeCheckout;
 exports.executeGitCredentialOperation = __webpack_exports__.executeGitCredentialOperation;
+exports.executeModelTokenOperation = __webpack_exports__.executeModelTokenOperation;
 exports.filterCandidates = __webpack_exports__.filterCandidates;
 exports.formatCandidateLabel = __webpack_exports__.formatCandidateLabel;
 exports.formatGitAuthDoctorReport = __webpack_exports__.formatGitAuthDoctorReport;
@@ -20963,12 +21218,15 @@ exports.getGitFetchUrl = __webpack_exports__.getGitFetchUrl;
 exports.getGitPushUrl = __webpack_exports__.getGitPushUrl;
 exports.getInstalledPreferredEditors = __webpack_exports__.getInstalledPreferredEditors;
 exports.getLatestVersion = __webpack_exports__.getLatestVersion;
+exports.getModelToken = __webpack_exports__.getModelToken;
+exports.getModelTokenHelperScript = __webpack_exports__.getModelTokenHelperScript;
 exports.getPreferredEditorCommand = __webpack_exports__.getPreferredEditorCommand;
 exports.getSettableConfigKeys = __webpack_exports__.getSettableConfigKeys;
 exports.getValidAuthToken = __webpack_exports__.getValidAuthToken;
 exports.getWebSocketUrl = __webpack_exports__.getWebSocketUrl;
 exports.hasTokensForUrl = __webpack_exports__.hasTokensForUrl;
 exports.inspectCredentialHelperCommand = __webpack_exports__.inspectCredentialHelperCommand;
+exports.installModelTokenHelperScript = __webpack_exports__.installModelTokenHelperScript;
 exports.isCommandAvailable = __webpack_exports__.isCommandAvailable;
 exports.isDirectoryNonEmpty = __webpack_exports__.isDirectoryNonEmpty;
 exports.isPathInsideGitRepo = __webpack_exports__.isPathInsideGitRepo;
@@ -21004,9 +21262,11 @@ exports.validatePath = __webpack_exports__.validatePath;
 exports.verifyAndStoreTokens = __webpack_exports__.verifyAndStoreTokens;
 exports.verifyAuth = __webpack_exports__.verifyAuth;
 exports.watch = __webpack_exports__.watch;
+exports.withRepoAuthFileLock = __webpack_exports__.withRepoAuthFileLock;
 exports.writeEnvironmentPid = __webpack_exports__.writeEnvironmentPid;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "ANVIL_SYNC_CLIENT_ID",
+    "AUTH_FILE_LOCK_DEFAULTS",
     "AnvilYamlValidationResult",
     "AppIdCandidate",
     "AppIdWithContext",
@@ -21018,11 +21278,15 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CheckoutResult",
     "DeviceAuthorizationResponse",
     "FormTemplateValidationResult",
+    "GetValidAuthTokenOptions",
     "LoginResult",
     "LogoutResult",
+    "MODEL_TOKEN_HELPER_FILENAME",
+    "MODEL_TOKEN_LOCK_TIMEOUT_MS",
     "OAuthTokenResponse",
     "ParsedCheckoutInput",
     "PreferredEditor",
+    "REFRESH_REQUEST_TIMEOUT_MS",
     "SettableConfigKey",
     "TokenData",
     "ValidateAppIdResponse",
@@ -21043,6 +21307,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "detectAppIdsFromAllRemotes",
     "executeCheckout",
     "executeGitCredentialOperation",
+    "executeModelTokenOperation",
     "filterCandidates",
     "formatCandidateLabel",
     "formatGitAuthDoctorReport",
@@ -21056,12 +21321,15 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getGitPushUrl",
     "getInstalledPreferredEditors",
     "getLatestVersion",
+    "getModelToken",
+    "getModelTokenHelperScript",
     "getPreferredEditorCommand",
     "getSettableConfigKeys",
     "getValidAuthToken",
     "getWebSocketUrl",
     "hasTokensForUrl",
     "inspectCredentialHelperCommand",
+    "installModelTokenHelperScript",
     "isCommandAvailable",
     "isDirectoryNonEmpty",
     "isPathInsideGitRepo",
@@ -21097,6 +21365,7 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "verifyAndStoreTokens",
     "verifyAuth",
     "watch",
+    "withRepoAuthFileLock",
     "writeEnvironmentPid"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {