@anvil-works/anvil-cli 0.3.12 → 0.4.1

package/dist/index.js

@@ -90,6 +90,704 @@ var __webpack_modules__ = {
         exports1.deferred = deferred;
         exports1.createDeferred = deferred;
     },
+    "./node_modules/.pnpm/@napi-rs+keyring@1.2.0/node_modules/@napi-rs/keyring/index.js" (module, __unused_rspack_exports, __webpack_require__) {
+        var require1;
+        const { createRequire } = __webpack_require__("node:module");
+        require1 = createRequire(__filename);
+        const { readFileSync } = __webpack_require__("node:fs");
+        let nativeBinding = null;
+        const loadErrors = [];
+        const isMusl = ()=>{
+            let musl = false;
+            if ('linux' === process.platform) {
+                musl = isMuslFromFilesystem();
+                if (null === musl) musl = isMuslFromReport();
+                if (null === musl) musl = isMuslFromChildProcess();
+            }
+            return musl;
+        };
+        const isFileMusl = (f)=>f.includes('libc.musl-') || f.includes('ld-musl-');
+        const isMuslFromFilesystem = ()=>{
+            try {
+                return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl');
+            } catch  {
+                return null;
+            }
+        };
+        const isMuslFromReport = ()=>{
+            let report = null;
+            if ('function' == typeof process.report?.getReport) {
+                process.report.excludeNetwork = true;
+                report = process.report.getReport();
+            }
+            if (!report) return null;
+            if (report.header && report.header.glibcVersionRuntime) return false;
+            if (Array.isArray(report.sharedObjects)) {
+                if (report.sharedObjects.some(isFileMusl)) return true;
+            }
+            return false;
+        };
+        const isMuslFromChildProcess = ()=>{
+            try {
+                return __webpack_require__("child_process").execSync('ldd --version', {
+                    encoding: 'utf8'
+                }).includes('musl');
+            } catch (e) {
+                return false;
+            }
+        };
+        function requireNative() {
+            if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) try {
+                nativeBinding = require1(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+            } catch (err) {
+                loadErrors.push(err);
+            }
+            else if ('android' === process.platform) if ('arm64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.android-arm64.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-android-arm64'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-android-arm64/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('arm' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.android-arm-eabi.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-android-arm-eabi'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-android-arm-eabi/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+            else if ('win32' === process.platform) if ('x64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.win32-x64-msvc.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-x64-msvc'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-x64-msvc/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('ia32' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.win32-ia32-msvc.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-ia32-msvc'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-ia32-msvc/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('arm64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.win32-arm64-msvc.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-arm64-msvc'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-win32-arm64-msvc/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+            else if ('darwin' === process.platform) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.darwin-universal.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-darwin-universal'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-darwin-universal/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                if ('x64' === process.arch) {
+                    try {
+                        return __webpack_require__(Object(function() {
+                            var e = new Error("Cannot find module './keyring.darwin-x64.node'");
+                            e.code = 'MODULE_NOT_FOUND';
+                            throw e;
+                        }()));
+                    } catch (e) {
+                        loadErrors.push(e);
+                    }
+                    try {
+                        const binding = __webpack_require__(Object(function() {
+                            var e = new Error("Cannot find module '@napi-rs/keyring-darwin-x64'");
+                            e.code = 'MODULE_NOT_FOUND';
+                            throw e;
+                        }()));
+                        const bindingPackageVersion = __webpack_require__(Object(function() {
+                            var e = new Error("Cannot find module '@napi-rs/keyring-darwin-x64/package.json'");
+                            e.code = 'MODULE_NOT_FOUND';
+                            throw e;
+                        }()));
+                        if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                        return binding;
+                    } catch (e) {
+                        loadErrors.push(e);
+                    }
+                } else if ('arm64' === process.arch) {
+                    try {
+                        return __webpack_require__(Object(function() {
+                            var e = new Error("Cannot find module './keyring.darwin-arm64.node'");
+                            e.code = 'MODULE_NOT_FOUND';
+                            throw e;
+                        }()));
+                    } catch (e) {
+                        loadErrors.push(e);
+                    }
+                    try {
+                        const binding = __webpack_require__("./node_modules/.pnpm/@napi-rs+keyring-darwin-arm64@1.2.0/node_modules/@napi-rs/keyring-darwin-arm64/keyring.darwin-arm64.node");
+                        const bindingPackageVersion = __webpack_require__("./node_modules/.pnpm/@napi-rs+keyring-darwin-arm64@1.2.0/node_modules/@napi-rs/keyring-darwin-arm64/package.json").rE;
+                        if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                        return binding;
+                    } catch (e) {
+                        loadErrors.push(e);
+                    }
+                } else loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+            } else if ('freebsd' === process.platform) if ('x64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.freebsd-x64.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-freebsd-x64'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-freebsd-x64/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('arm64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.freebsd-arm64.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-freebsd-arm64'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-freebsd-arm64/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+            else if ('linux' === process.platform) if ('x64' === process.arch) if (isMusl()) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-x64-musl.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-x64-musl'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-x64-musl/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-x64-gnu.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-x64-gnu'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-x64-gnu/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            }
+            else if ('arm64' === process.arch) if (isMusl()) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-arm64-musl.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm64-musl'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm64-musl/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-arm64-gnu.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm64-gnu'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm64-gnu/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            }
+            else if ('arm' === process.arch) if (isMusl()) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-arm-musleabihf.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm-musleabihf'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm-musleabihf/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-arm-gnueabihf.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm-gnueabihf'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-arm-gnueabihf/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            }
+            else if ('riscv64' === process.arch) if (isMusl()) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-riscv64-musl.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-riscv64-musl'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-riscv64-musl/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-riscv64-gnu.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-riscv64-gnu'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-riscv64-gnu/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            }
+            else if ('ppc64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-ppc64-gnu.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-ppc64-gnu'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-ppc64-gnu/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('s390x' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.linux-s390x-gnu.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-s390x-gnu'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-linux-s390x-gnu/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+            else if ('openharmony' === process.platform) if ('arm64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.openharmony-arm64.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-arm64'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-arm64/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('x64' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.openharmony-x64.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-x64'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-x64/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else if ('arm' === process.arch) {
+                try {
+                    return __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module './keyring.openharmony-arm.node'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+                try {
+                    const binding = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-arm'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    const bindingPackageVersion = __webpack_require__(Object(function() {
+                        var e = new Error("Cannot find module '@napi-rs/keyring-openharmony-arm/package.json'");
+                        e.code = 'MODULE_NOT_FOUND';
+                        throw e;
+                    }()));
+                    if ('1.2.0' !== bindingPackageVersion && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && '0' !== process.env.NAPI_RS_ENFORCE_VERSION_CHECK) throw new Error(`Native binding package version mismatch, expected 1.2.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`);
+                    return binding;
+                } catch (e) {
+                    loadErrors.push(e);
+                }
+            } else loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+            else loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+        }
+        nativeBinding = requireNative();
+        if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+            try {
+                nativeBinding = __webpack_require__(Object(function() {
+                    var e = new Error("Cannot find module './keyring.wasi.cjs'");
+                    e.code = 'MODULE_NOT_FOUND';
+                    throw e;
+                }()));
+            } catch (err) {
+                if (process.env.NAPI_RS_FORCE_WASI) loadErrors.push(err);
+            }
+            if (!nativeBinding) try {
+                nativeBinding = __webpack_require__(Object(function() {
+                    var e = new Error("Cannot find module '@napi-rs/keyring-wasm32-wasi'");
+                    e.code = 'MODULE_NOT_FOUND';
+                    throw e;
+                }()));
+            } catch (err) {
+                if (process.env.NAPI_RS_FORCE_WASI) loadErrors.push(err);
+            }
+        }
+        if (!nativeBinding) {
+            if (loadErrors.length > 0) throw new Error("Cannot find native binding. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try `npm i` again after removing both package-lock.json and node_modules directory.", {
+                cause: loadErrors
+            });
+            throw new Error("Failed to load native binding");
+        }
+        module.exports = nativeBinding;
+        module.exports.AsyncEntry = nativeBinding.AsyncEntry;
+        module.exports.Entry = nativeBinding.Entry;
+        module.exports.findCredentials = nativeBinding.findCredentials;
+        module.exports.findCredentialsAsync = nativeBinding.findCredentialsAsync;
+    },
+    "./node_modules/.pnpm/@napi-rs+keyring-darwin-arm64@1.2.0/node_modules/@napi-rs/keyring-darwin-arm64/keyring.darwin-arm64.node" (module, __unused_rspack_exports, __webpack_require__) {
+        module = __webpack_require__.nmd(module);
+        try {
+            const path = __webpack_require__("node:path");
+            process.dlopen(module, path.join(__dirname, "keyring.darwin-arm64.node"));
+        } catch (error) {
+            throw new Error('Failed to load Node.js addon: "keyring.darwin-arm64.node"', {
+                cause: error
+            });
+        }
+    },
     "./node_modules/.pnpm/ajv-formats@3.0.1_ajv@8.17.1/node_modules/ajv-formats/dist/formats.js" (__unused_rspack_module, exports1) {
         "use strict";
         Object.defineProperty(exports1, "__esModule", {
@@ -10547,6 +11245,10 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("buffer");
     },
+    child_process (module) {
+        "use strict";
+        module.exports = require("child_process");
+    },
     crypto (module) {
         "use strict";
         module.exports = require("crypto");
@@ -10571,6 +11273,18 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = require("net");
     },
+    "node:fs" (module) {
+        "use strict";
+        module.exports = require("node:fs");
+    },
+    "node:module" (module) {
+        "use strict";
+        module.exports = require("node:module");
+    },
+    "node:path" (module) {
+        "use strict";
+        module.exports = require("node:path");
+    },
     os (module) {
         "use strict";
         module.exports = require("os");
@@ -11164,6 +11878,12 @@ var __webpack_modules__ = {
             stringArrayToHexStripped
         };
     },
+    "./node_modules/.pnpm/@napi-rs+keyring-darwin-arm64@1.2.0/node_modules/@napi-rs/keyring-darwin-arm64/package.json" (module) {
+        "use strict";
+        module.exports = {
+            rE: "1.2.0"
+        };
+    },
     "./node_modules/.pnpm/ajv@8.17.1/node_modules/ajv/dist/refs/data.json" (module) {
         "use strict";
         module.exports = JSON.parse('{"$id":"https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#","description":"Meta-schema for $data reference (JSON AnySchema extension proposal)","type":"object","required":["$data"],"properties":{"$data":{"type":"string","anyOf":[{"format":"relative-json-pointer"},{"format":"json-pointer"}]}},"additionalProperties":false}');
@@ -11210,9 +11930,12 @@ function __webpack_require__(moduleId) {
     var cachedModule = __webpack_module_cache__[moduleId];
     if (void 0 !== cachedModule) return cachedModule.exports;
     var module = __webpack_module_cache__[moduleId] = {
+        id: moduleId,
+        loaded: false,
         exports: {}
     };
     __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    module.loaded = true;
     return module.exports;
 }
 (()=>{
@@ -11245,33 +11968,47 @@ function __webpack_require__(moduleId) {
         });
     };
 })();
+(()=>{
+    __webpack_require__.nmd = (module)=>{
+        module.paths = [];
+        if (!module.children) module.children = [];
+        return module;
+    };
+})();
 var __webpack_exports__ = {};
 (()=>{
     "use strict";
     __webpack_require__.r(__webpack_exports__);
     __webpack_require__.d(__webpack_exports__, {
-        syncToLatest: ()=>syncToLatest,
-        validateAnvilApp: ()=>validateAnvilApp,
-        validateBranchSyncStatus: ()=>validateBranchSyncStatus,
         verifyAuth: ()=>verifyAuth,
-        watch: ()=>api_watch,
-        detectAppIds: ()=>detectAppIds,
-        hasTokensForUrl: ()=>hasTokensForUrl,
+        lookupRemoteInfoForAppId: ()=>lookupRemoteInfoForAppId,
+        validateBranchSyncStatus: ()=>validateBranchSyncStatus,
+        AppIdWithContext: ()=>anvil_api_namespaceObject.AppIdWithContext,
         checkUncommittedChanges: ()=>checkUncommittedChanges,
-        getValidAuthToken: ()=>auth_getValidAuthToken,
-        login: ()=>login,
+        hasTokensForUrl: ()=>hasTokensForUrl,
+        validateAnvilApp: ()=>validateAnvilApp,
         logout: ()=>logout,
         detectAppIdsFromAllRemotes: ()=>detectAppIdsFromAllRemotes,
+        BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus,
+        formatCandidateLabel: ()=>formatCandidateLabel,
+        syncToLatest: ()=>syncToLatest,
+        filterCandidates: ()=>filterCandidates,
+        getValidAuthToken: ()=>auth_getValidAuthToken,
+        login: ()=>login,
+        watch: ()=>api_watch,
         AppIdCandidate: ()=>anvil_api_namespaceObject.AppIdCandidate,
-        BranchSyncStatus: ()=>validation_namespaceObject.BranchSyncStatus
+        detectAppIdsByCommitLookup: ()=>detectAppIdsByCommitLookup
     });
     var anvil_api_namespaceObject = {};
     __webpack_require__.r(anvil_api_namespaceObject);
     __webpack_require__.d(anvil_api_namespaceObject, {
-        PH: ()=>detectAppIds,
+        lx: ()=>detectAppIdsByCommitLookup,
         NZ: ()=>detectAppIdsFromAllRemotes,
+        rZ: ()=>filterCandidates,
+        T_: ()=>formatCandidateLabel,
         OI: ()=>getGitFetchUrl,
-        $0: ()=>getWebSocketUrl
+        $0: ()=>getWebSocketUrl,
+        Wj: ()=>lookupRemoteInfoForAppId
     });
     var validation_namespaceObject = {};
     __webpack_require__.r(validation_namespaceObject);
@@ -11846,9 +12583,9 @@ var __webpack_exports__ = {};
     const external_node_buffer_namespaceObject = require("node:buffer");
     var dist = __webpack_require__("./node_modules/.pnpm/@kwsites+file-exists@1.1.1/node_modules/@kwsites/file-exists/dist/index.js");
     var src = __webpack_require__("./node_modules/.pnpm/debug@4.4.3_supports-color@5.5.0/node_modules/debug/src/index.js");
-    const external_child_process_namespaceObject = require("child_process");
+    var external_child_process_ = __webpack_require__("child_process");
     var promise_deferred_dist = __webpack_require__("./node_modules/.pnpm/@kwsites+promise-deferred@1.1.1/node_modules/@kwsites/promise-deferred/dist/index.js");
-    const external_node_path_namespaceObject = require("node:path");
+    var external_node_path_ = __webpack_require__("node:path");
     const external_node_events_namespaceObject = require("node:events");
     var __defProp = Object.defineProperty;
     var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -13084,7 +13821,7 @@ var __webpack_exports__ = {};
                                 rejection = reason || rejection;
                             }
                         });
-                        const spawned = (0, external_child_process_namespaceObject.spawn)(command, args, spawnOptions);
+                        const spawned = (0, external_child_process_.spawn)(command, args, spawnOptions);
                         spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
                         spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
                         spawned.on("error", onErrorReceived(stdErr, logger));
@@ -14767,7 +15504,7 @@ var __webpack_exports__ = {};
     });
     function esm_toPath(input) {
         const path = input.trim().replace(/^["']|["']$/g, "");
-        return path && (0, external_node_path_namespaceObject.normalize)(path);
+        return path && (0, external_node_path_.normalize)(path);
     }
     var parseCheckIgnore;
     var init_CheckIgnore = __esm({
@@ -18035,7 +18772,7 @@ var __webpack_exports__ = {};
         }
     }
     const external_node_util_namespaceObject = require("node:util");
-    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_ = __webpack_require__("node:fs");
     const external_node_crypto_namespaceObject = require("node:crypto");
     const external_node_assert_namespaceObject = require("node:assert");
     const dot_prop_isObject = (value)=>{
@@ -18222,34 +18959,34 @@ var __webpack_exports__ = {};
     const tmpdir = external_node_os_namespaceObject.tmpdir();
     const { env: env_paths_env } = external_node_process_namespaceObject;
     const macos = (name)=>{
-        const library = external_node_path_namespaceObject.join(homedir, 'Library');
+        const library = external_node_path_.join(homedir, 'Library');
         return {
-            data: external_node_path_namespaceObject.join(library, 'Application Support', name),
-            config: external_node_path_namespaceObject.join(library, 'Preferences', name),
-            cache: external_node_path_namespaceObject.join(library, 'Caches', name),
-            log: external_node_path_namespaceObject.join(library, 'Logs', name),
-            temp: external_node_path_namespaceObject.join(tmpdir, name)
+            data: external_node_path_.join(library, 'Application Support', name),
+            config: external_node_path_.join(library, 'Preferences', name),
+            cache: external_node_path_.join(library, 'Caches', name),
+            log: external_node_path_.join(library, 'Logs', name),
+            temp: external_node_path_.join(tmpdir, name)
         };
     };
     const windows = (name)=>{
-        const appData = env_paths_env.APPDATA || external_node_path_namespaceObject.join(homedir, 'AppData', 'Roaming');
-        const localAppData = env_paths_env.LOCALAPPDATA || external_node_path_namespaceObject.join(homedir, 'AppData', 'Local');
+        const appData = env_paths_env.APPDATA || external_node_path_.join(homedir, 'AppData', 'Roaming');
+        const localAppData = env_paths_env.LOCALAPPDATA || external_node_path_.join(homedir, 'AppData', 'Local');
         return {
-            data: external_node_path_namespaceObject.join(localAppData, name, 'Data'),
-            config: external_node_path_namespaceObject.join(appData, name, 'Config'),
-            cache: external_node_path_namespaceObject.join(localAppData, name, 'Cache'),
-            log: external_node_path_namespaceObject.join(localAppData, name, 'Log'),
-            temp: external_node_path_namespaceObject.join(tmpdir, name)
+            data: external_node_path_.join(localAppData, name, 'Data'),
+            config: external_node_path_.join(appData, name, 'Config'),
+            cache: external_node_path_.join(localAppData, name, 'Cache'),
+            log: external_node_path_.join(localAppData, name, 'Log'),
+            temp: external_node_path_.join(tmpdir, name)
         };
     };
     const linux = (name)=>{
-        const username = external_node_path_namespaceObject.basename(homedir);
+        const username = external_node_path_.basename(homedir);
         return {
-            data: external_node_path_namespaceObject.join(env_paths_env.XDG_DATA_HOME || external_node_path_namespaceObject.join(homedir, '.local', 'share'), name),
-            config: external_node_path_namespaceObject.join(env_paths_env.XDG_CONFIG_HOME || external_node_path_namespaceObject.join(homedir, '.config'), name),
-            cache: external_node_path_namespaceObject.join(env_paths_env.XDG_CACHE_HOME || external_node_path_namespaceObject.join(homedir, '.cache'), name),
-            log: external_node_path_namespaceObject.join(env_paths_env.XDG_STATE_HOME || external_node_path_namespaceObject.join(homedir, '.local', 'state'), name),
-            temp: external_node_path_namespaceObject.join(tmpdir, username, name)
+            data: external_node_path_.join(env_paths_env.XDG_DATA_HOME || external_node_path_.join(homedir, '.local', 'share'), name),
+            config: external_node_path_.join(env_paths_env.XDG_CONFIG_HOME || external_node_path_.join(homedir, '.config'), name),
+            cache: external_node_path_.join(env_paths_env.XDG_CACHE_HOME || external_node_path_.join(homedir, '.cache'), name),
+            log: external_node_path_.join(env_paths_env.XDG_STATE_HOME || external_node_path_.join(homedir, '.local', 'state'), name),
+            temp: external_node_path_.join(tmpdir, username, name)
         };
     };
     function envPaths(name, { suffix = 'nodejs' } = {}) {
@@ -18350,41 +19087,41 @@ var __webpack_exports__ = {};
     };
     const FS = {
         attempt: {
-            chmod: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-            chown: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-            close: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.close), ATTEMPTIFY_NOOP_OPTIONS),
-            fsync: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.fsync), ATTEMPTIFY_NOOP_OPTIONS),
-            mkdir: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
-            realpath: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.realpath), ATTEMPTIFY_NOOP_OPTIONS),
-            stat: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.stat), ATTEMPTIFY_NOOP_OPTIONS),
-            unlink: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.unlink), ATTEMPTIFY_NOOP_OPTIONS),
-            chmodSync: attemptify_sync(external_node_fs_namespaceObject.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-            chownSync: attemptify_sync(external_node_fs_namespaceObject.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
-            closeSync: attemptify_sync(external_node_fs_namespaceObject.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
-            existsSync: attemptify_sync(external_node_fs_namespaceObject.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
-            fsyncSync: attemptify_sync(external_node_fs_namespaceObject.fsync, ATTEMPTIFY_NOOP_OPTIONS),
-            mkdirSync: attemptify_sync(external_node_fs_namespaceObject.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
-            realpathSync: attemptify_sync(external_node_fs_namespaceObject.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
-            statSync: attemptify_sync(external_node_fs_namespaceObject.statSync, ATTEMPTIFY_NOOP_OPTIONS),
-            unlinkSync: attemptify_sync(external_node_fs_namespaceObject.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
+            chmod: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.chmod), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+            chown: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.chown), ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+            close: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.close), ATTEMPTIFY_NOOP_OPTIONS),
+            fsync: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.fsync), ATTEMPTIFY_NOOP_OPTIONS),
+            mkdir: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.mkdir), ATTEMPTIFY_NOOP_OPTIONS),
+            realpath: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.realpath), ATTEMPTIFY_NOOP_OPTIONS),
+            stat: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.stat), ATTEMPTIFY_NOOP_OPTIONS),
+            unlink: attemptify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.unlink), ATTEMPTIFY_NOOP_OPTIONS),
+            chmodSync: attemptify_sync(external_node_fs_.chmodSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+            chownSync: attemptify_sync(external_node_fs_.chownSync, ATTEMPTIFY_CHANGE_ERROR_OPTIONS),
+            closeSync: attemptify_sync(external_node_fs_.closeSync, ATTEMPTIFY_NOOP_OPTIONS),
+            existsSync: attemptify_sync(external_node_fs_.existsSync, ATTEMPTIFY_NOOP_OPTIONS),
+            fsyncSync: attemptify_sync(external_node_fs_.fsync, ATTEMPTIFY_NOOP_OPTIONS),
+            mkdirSync: attemptify_sync(external_node_fs_.mkdirSync, ATTEMPTIFY_NOOP_OPTIONS),
+            realpathSync: attemptify_sync(external_node_fs_.realpathSync, ATTEMPTIFY_NOOP_OPTIONS),
+            statSync: attemptify_sync(external_node_fs_.statSync, ATTEMPTIFY_NOOP_OPTIONS),
+            unlinkSync: attemptify_sync(external_node_fs_.unlinkSync, ATTEMPTIFY_NOOP_OPTIONS)
         },
         retry: {
-            close: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.close), RETRYIFY_OPTIONS),
-            fsync: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.fsync), RETRYIFY_OPTIONS),
-            open: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.open), RETRYIFY_OPTIONS),
-            readFile: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.readFile), RETRYIFY_OPTIONS),
-            rename: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.rename), RETRYIFY_OPTIONS),
-            stat: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.stat), RETRYIFY_OPTIONS),
-            write: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.write), RETRYIFY_OPTIONS),
-            writeFile: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_namespaceObject.writeFile), RETRYIFY_OPTIONS),
-            closeSync: retryify_sync(external_node_fs_namespaceObject.closeSync, RETRYIFY_OPTIONS),
-            fsyncSync: retryify_sync(external_node_fs_namespaceObject.fsyncSync, RETRYIFY_OPTIONS),
-            openSync: retryify_sync(external_node_fs_namespaceObject.openSync, RETRYIFY_OPTIONS),
-            readFileSync: retryify_sync(external_node_fs_namespaceObject.readFileSync, RETRYIFY_OPTIONS),
-            renameSync: retryify_sync(external_node_fs_namespaceObject.renameSync, RETRYIFY_OPTIONS),
-            statSync: retryify_sync(external_node_fs_namespaceObject.statSync, RETRYIFY_OPTIONS),
-            writeSync: retryify_sync(external_node_fs_namespaceObject.writeSync, RETRYIFY_OPTIONS),
-            writeFileSync: retryify_sync(external_node_fs_namespaceObject.writeFileSync, RETRYIFY_OPTIONS)
+            close: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.close), RETRYIFY_OPTIONS),
+            fsync: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.fsync), RETRYIFY_OPTIONS),
+            open: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.open), RETRYIFY_OPTIONS),
+            readFile: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.readFile), RETRYIFY_OPTIONS),
+            rename: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.rename), RETRYIFY_OPTIONS),
+            stat: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.stat), RETRYIFY_OPTIONS),
+            write: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.write), RETRYIFY_OPTIONS),
+            writeFile: retryify_async((0, external_node_util_namespaceObject.promisify)(external_node_fs_.writeFile), RETRYIFY_OPTIONS),
+            closeSync: retryify_sync(external_node_fs_.closeSync, RETRYIFY_OPTIONS),
+            fsyncSync: retryify_sync(external_node_fs_.fsyncSync, RETRYIFY_OPTIONS),
+            openSync: retryify_sync(external_node_fs_.openSync, RETRYIFY_OPTIONS),
+            readFileSync: retryify_sync(external_node_fs_.readFileSync, RETRYIFY_OPTIONS),
+            renameSync: retryify_sync(external_node_fs_.renameSync, RETRYIFY_OPTIONS),
+            statSync: retryify_sync(external_node_fs_.statSync, RETRYIFY_OPTIONS),
+            writeSync: retryify_sync(external_node_fs_.writeSync, RETRYIFY_OPTIONS),
+            writeFileSync: retryify_sync(external_node_fs_.writeFileSync, RETRYIFY_OPTIONS)
         }
     };
     const stubborn_fs_dist = FS;
@@ -18474,7 +19211,7 @@ var __webpack_exports__ = {};
             for(const filePath in temp_Temp.store)temp_Temp.purgeSync(filePath);
         },
         truncate: (filePath)=>{
-            const basename = external_node_path_namespaceObject.basename(filePath);
+            const basename = external_node_path_.basename(filePath);
             if (basename.length <= LIMIT_BASENAME_LENGTH) return filePath;
             const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
             if (!truncable) return filePath;
@@ -18516,7 +19253,7 @@ var __webpack_exports__ = {};
                 }
             }
             if (!filePathExists) {
-                const parentPath = external_node_path_namespaceObject.dirname(filePath);
+                const parentPath = external_node_path_.dirname(filePath);
                 stubborn_fs_dist.attempt.mkdirSync(parentPath, {
                     mode: constants_DEFAULT_FOLDER_MODE,
                     recursive: true
@@ -18795,7 +19532,7 @@ var __webpack_exports__ = {};
         }
         get store() {
             try {
-                const data = external_node_fs_namespaceObject.readFileSync(this.path, this.#encryptionKey ? null : 'utf8');
+                const data = external_node_fs_.readFileSync(this.path, this.#encryptionKey ? null : 'utf8');
                 const dataString = this._decryptData(data);
                 const deserializedData = this._deserialize(dataString);
                 if (!this.#isInMigration) this._validate(deserializedData);
@@ -18816,7 +19553,7 @@ var __webpack_exports__ = {};
         set store(value) {
             this._ensureDirectory();
             if (!hasProperty(value, INTERNAL_KEY)) try {
-                const data = external_node_fs_namespaceObject.readFileSync(this.path, this.#encryptionKey ? null : 'utf8');
+                const data = external_node_fs_.readFileSync(this.path, this.#encryptionKey ? null : 'utf8');
                 const dataString = this._decryptData(data);
                 const currentStore = this._deserialize(dataString);
                 if (hasProperty(currentStore, INTERNAL_KEY)) dot_prop_setProperty(value, INTERNAL_KEY, getProperty(currentStore, INTERNAL_KEY));
@@ -18837,7 +19574,7 @@ var __webpack_exports__ = {};
                 this.#watcher = void 0;
             }
             if (this.#watchFile) {
-                external_node_fs_namespaceObject.unwatchFile(this.path);
+                external_node_fs_.unwatchFile(this.path);
                 this.#watchFile = false;
             }
             this.#debouncedChangeHandler = void 0;
@@ -18907,7 +19644,7 @@ var __webpack_exports__ = {};
             throw new Error('Config schema violation: ' + errors.join('; '));
         }
         _ensureDirectory() {
-            external_node_fs_namespaceObject.mkdirSync(external_node_path_namespaceObject.dirname(this.path), {
+            external_node_fs_.mkdirSync(external_node_path_.dirname(this.path), {
                 recursive: true
             });
         }
@@ -18924,7 +19661,7 @@ var __webpack_exports__ = {};
                     cipher.final()
                 ]);
             }
-            if (external_node_process_namespaceObject.env.SNAP) external_node_fs_namespaceObject.writeFileSync(this.path, data, {
+            if (external_node_process_namespaceObject.env.SNAP) external_node_fs_.writeFileSync(this.path, data, {
                 mode: this.#options.configFileMode
             });
             else try {
@@ -18932,7 +19669,7 @@ var __webpack_exports__ = {};
                     mode: this.#options.configFileMode
                 });
             } catch (error) {
-                if (error?.code === 'EXDEV') return void external_node_fs_namespaceObject.writeFileSync(this.path, data, {
+                if (error?.code === 'EXDEV') return void external_node_fs_.writeFileSync(this.path, data, {
                     mode: this.#options.configFileMode
                 });
                 throw error;
@@ -18940,16 +19677,16 @@ var __webpack_exports__ = {};
         }
         _watch() {
             this._ensureDirectory();
-            if (!external_node_fs_namespaceObject.existsSync(this.path)) this._write(createPlainObject());
+            if (!external_node_fs_.existsSync(this.path)) this._write(createPlainObject());
             if ('win32' === external_node_process_namespaceObject.platform || 'darwin' === external_node_process_namespaceObject.platform) {
                 this.#debouncedChangeHandler ??= debounce_fn(()=>{
                     this.events.dispatchEvent(new Event('change'));
                 }, {
                     wait: 100
                 });
-                const directory = external_node_path_namespaceObject.dirname(this.path);
-                const basename = external_node_path_namespaceObject.basename(this.path);
-                this.#watcher = external_node_fs_namespaceObject.watch(directory, {
+                const directory = external_node_path_.dirname(this.path);
+                const basename = external_node_path_.basename(this.path);
+                this.#watcher = external_node_fs_.watch(directory, {
                     persistent: false,
                     encoding: 'utf8'
                 }, (_eventType, filename)=>{
@@ -18962,7 +19699,7 @@ var __webpack_exports__ = {};
                 }, {
                     wait: 1000
                 });
-                external_node_fs_namespaceObject.watchFile(this.path, {
+                external_node_fs_.watchFile(this.path, {
                     persistent: false
                 }, (_current, _previous)=>{
                     if ('function' == typeof this.#debouncedChangeHandler) this.#debouncedChangeHandler();
@@ -19088,7 +19825,7 @@ var __webpack_exports__ = {};
         #resolvePath(options) {
             const normalizedFileExtension = 'string' == typeof options.fileExtension ? options.fileExtension : void 0;
             const fileExtension = normalizedFileExtension ? `.${normalizedFileExtension}` : '';
-            return external_node_path_namespaceObject.resolve(options.cwd, `${options.configName ?? 'config'}${fileExtension}`);
+            return external_node_path_.resolve(options.cwd, `${options.configName ?? 'config'}${fileExtension}`);
         }
         #initializeStore(options) {
             if (options.migrations) {
@@ -19124,6 +19861,57 @@ var __webpack_exports__ = {};
             }
         }
     }
+    let Entry = null;
+    let loadAttempted = false;
+    function loadKeyring() {
+        if (loadAttempted) return Entry;
+        loadAttempted = true;
+        try {
+            const mod = __webpack_require__("./node_modules/.pnpm/@napi-rs+keyring@1.2.0/node_modules/@napi-rs/keyring/index.js");
+            Entry = mod.Entry;
+        } catch  {}
+        return Entry;
+    }
+    function getServiceName(url) {
+        return `anvil-cli:${url}`;
+    }
+    function keychain_keychainGet(url, username) {
+        if (isTestMode()) return null;
+        const Ctor = loadKeyring();
+        if (!Ctor) return null;
+        try {
+            const entry = new Ctor(getServiceName(url), username);
+            const raw = entry.getPassword();
+            const parsed = JSON.parse(raw);
+            return {
+                authToken: parsed.authToken ?? null,
+                refreshToken: parsed.refreshToken ?? null
+            };
+        } catch  {
+            return null;
+        }
+    }
+    function keychainSet(url, username, secrets) {
+        if (isTestMode()) return false;
+        const Ctor = loadKeyring();
+        if (!Ctor) return false;
+        try {
+            const entry = new Ctor(getServiceName(url), username);
+            entry.setPassword(JSON.stringify(secrets));
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    function keychainDelete(url, username) {
+        if (isTestMode()) return;
+        const Ctor = loadKeyring();
+        if (!Ctor) return;
+        try {
+            const entry = new Ctor(getServiceName(url), username);
+            entry.deletePassword();
+        } catch  {}
+    }
     const EMPTY_TOKENS = {
         authToken: null,
         refreshToken: null,
@@ -19157,17 +19945,30 @@ var __webpack_exports__ = {};
         const normalized = config_normalizeAnvilUrl(url);
         return store[normalized];
     }
+    function token_store_getAccountTokens(url, username) {
+        const urlTokens = getUrlTokens(url);
+        if (!urlTokens || !urlTokens[username]) return {
+            ...EMPTY_TOKENS
+        };
+        const configTokens = urlTokens[username];
+        if (!configTokens.authToken && !configTokens.refreshToken) {
+            const secrets = keychain_keychainGet(config_normalizeAnvilUrl(url), username);
+            if (secrets) return {
+                ...configTokens,
+                ...secrets
+            };
+        }
+        return configTokens;
+    }
     function token_store_getTokensAutoSelect(url, username) {
         const normalized = config_normalizeAnvilUrl(url);
+        if (username) return token_store_getAccountTokens(normalized, username);
         const urlTokens = getUrlTokens(normalized);
         if (!urlTokens) return {
             ...EMPTY_TOKENS
         };
-        if (username) return urlTokens[username] ?? {
-            ...EMPTY_TOKENS
-        };
         const accounts = Object.keys(urlTokens);
-        if (1 === accounts.length) return urlTokens[accounts[0]];
+        if (1 === accounts.length) return token_store_getAccountTokens(normalized, accounts[0]);
         return {
             ...EMPTY_TOKENS
         };
@@ -19176,11 +19977,21 @@ var __webpack_exports__ = {};
         const normalized = config_normalizeAnvilUrl(url);
         const store = getTokenStore();
         if (!store[normalized]) store[normalized] = {};
-        store[normalized][username] = tokens;
+        const keychainOk = keychainSet(normalized, username, {
+            authToken: tokens.authToken,
+            refreshToken: tokens.refreshToken
+        });
+        if (keychainOk) store[normalized][username] = {
+            authToken: null,
+            refreshToken: null,
+            authTokenExpiresAt: tokens.authTokenExpiresAt
+        };
+        else store[normalized][username] = tokens;
         setTokenStore(store);
     }
     function deleteAccountTokens(url, username) {
         const normalized = config_normalizeAnvilUrl(url);
+        keychainDelete(normalized, username);
         const store = getTokenStore();
         if (!store[normalized] || !store[normalized][username]) return false;
         delete store[normalized][username];
@@ -19192,14 +20003,22 @@ var __webpack_exports__ = {};
         const normalized = config_normalizeAnvilUrl(url);
         const store = getTokenStore();
         if (!store[normalized]) return false;
+        for (const username of Object.keys(store[normalized]))keychainDelete(normalized, username);
         delete store[normalized];
         setTokenStore(store);
         return true;
     }
     function findAccountByRefreshToken(url, refreshToken) {
-        const urlTokens = getUrlTokens(url);
+        const normalized = config_normalizeAnvilUrl(url);
+        const urlTokens = getUrlTokens(normalized);
         if (!urlTokens) return;
-        for (const [username, tokens] of Object.entries(urlTokens))if (tokens.refreshToken === refreshToken) return username;
+        for (const [username, tokens] of Object.entries(urlTokens)){
+            if (tokens.refreshToken === refreshToken) return username;
+            if (!tokens.refreshToken) {
+                const secrets = keychain_keychainGet(normalized, username);
+                if (secrets?.refreshToken === refreshToken) return username;
+            }
+        }
     }
     function token_store_hasTokens(url, username) {
         const normalized = config_normalizeAnvilUrl(url);
@@ -19207,11 +20026,18 @@ var __webpack_exports__ = {};
         if (!urlTokens) return false;
         if (username) {
             const tokens = urlTokens[username];
-            return !!(tokens && (tokens.authToken || tokens.refreshToken));
+            if (!tokens) return false;
+            if (tokens.authToken || tokens.refreshToken) return true;
+            return null !== keychain_keychainGet(normalized, username);
         }
-        return Object.values(urlTokens).some((tokens)=>tokens.authToken || tokens.refreshToken);
+        return Object.entries(urlTokens).some(([uname, tokens])=>{
+            if (tokens.authToken || tokens.refreshToken) return true;
+            return null !== keychain_keychainGet(normalized, uname);
+        });
     }
     function clearAllTokens() {
+        const store = getTokenStore();
+        for (const [url, urlTokens] of Object.entries(store))for (const username of Object.keys(urlTokens))keychainDelete(url, username);
         setTokenStore({});
     }
     const configDefaults = {
@@ -20081,7 +20907,7 @@ var __webpack_exports__ = {};
             this._wantsDir = type ? DIR_TYPES.has(type) : false;
             this._wantsFile = type ? FILE_TYPES.has(type) : false;
             this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
-            this._root = (0, external_node_path_namespaceObject.resolve)(root);
+            this._root = (0, external_node_path_.resolve)(root);
             this._isDirent = !opts.alwaysStat;
             this._statsProp = this._isDirent ? 'dirent' : 'stats';
             this._rdOptions = {
@@ -20155,9 +20981,9 @@ var __webpack_exports__ = {};
             let entry;
             const basename = this._isDirent ? dirent.name : dirent;
             try {
-                const fullPath = (0, external_node_path_namespaceObject.resolve)((0, external_node_path_namespaceObject.join)(path, basename));
+                const fullPath = (0, external_node_path_.resolve)((0, external_node_path_.join)(path, basename));
                 entry = {
-                    path: (0, external_node_path_namespaceObject.relative)(this._root, fullPath),
+                    path: (0, external_node_path_.relative)(this._root, fullPath),
                     fullPath,
                     basename
                 };
@@ -20185,7 +21011,7 @@ var __webpack_exports__ = {};
                     if (entryRealPathStats.isFile()) return 'file';
                     if (entryRealPathStats.isDirectory()) {
                         const len = entryRealPath.length;
-                        if (full.startsWith(entryRealPath) && full.substr(len, 1) === external_node_path_namespaceObject.sep) {
+                        if (full.startsWith(entryRealPath) && full.substr(len, 1) === external_node_path_.sep) {
                             const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
                             recursiveError.code = RECURSIVE_ERROR_CODE;
                             return this._onError(recursiveError);
@@ -21697,38 +22523,36 @@ var __webpack_exports__ = {};
     function getWebSocketUrl(appId, authToken, anvilUrl = anvil_api_getDefaultAnvilUrl()) {
         return anvilUrl.replace(/^http/, "ws") + `/ide/api/_/apps/${appId}/ws?access_token=${authToken}`;
     }
-    async function detectAppIdsFromRemotes(repoPath, anvilUrl) {
-        const git = esm_default(repoPath);
-        const out = [];
-        try {
-            const remotes = await git.getRemotes(true);
-            const url = new URL(anvilUrl);
-            const expectedHost = url.hostname;
-            for (const remote of remotes){
-                const httpMatch = remote.refs.fetch?.match(/(?:http|https):\/\/(?:[^@]+@)?([^:\/]+)(?::\d+)?\/git\/([A-Z0-9]+)\.git/);
-                if (httpMatch) {
-                    const [, host, detectedAppId] = httpMatch;
-                    if (host === expectedHost) {
-                        out.push({
-                            appId: detectedAppId,
-                            source: "remote",
-                            description: `Git remote '${remote.name}'`
-                        });
-                        continue;
-                    }
-                }
-                const sshMatch = remote.refs.fetch?.match(/ssh:\/\/(?:[^@]+@)?([^:\/]+):(\d+)\/([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const [, host, , detectedAppId] = sshMatch;
-                    if (host === expectedHost) out.push({
-                        appId: detectedAppId,
-                        source: "remote",
-                        description: `Git remote '${remote.name}' (SSH)`
-                    });
-                }
-            }
-        } catch (_e) {}
-        return out;
+    function filterCandidates(candidates, explicitUrl, explicitUsername) {
+        let filtered = candidates;
+        if (explicitUrl) {
+            const normalizedExplicit = config_normalizeAnvilUrl(explicitUrl);
+            filtered = filtered.filter((c)=>c.detectedUrl && config_normalizeAnvilUrl(c.detectedUrl) === normalizedExplicit);
+        }
+        if (explicitUsername) filtered = filtered.filter((c)=>!c.detectedUsername || c.detectedUsername === explicitUsername);
+        return filtered;
+    }
+    function formatCandidateLabel(candidate) {
+        const parts = [
+            candidate.appId
+        ];
+        if (candidate.detectedUrl) if (candidate.detectedUsername) parts.push(`(${candidate.detectedUsername} on ${candidate.detectedUrl})`);
+        else parts.push(`(${candidate.detectedUrl})`);
+        parts.push(`- ${candidate.description}`);
+        return parts.join(" ");
+    }
+    function lookupRemoteInfoForAppId(appId, detectedRemotes) {
+        const matches = detectedRemotes.filter((c)=>c.appId === appId);
+        if (0 === matches.length) return {};
+        const withUsername = matches.find((c)=>c.detectedUsername);
+        if (withUsername) return {
+            detectedUrl: withUsername.detectedUrl,
+            detectedUsername: withUsername.detectedUsername
+        };
+        return {
+            detectedUrl: matches[0].detectedUrl,
+            detectedUsername: matches[0].detectedUsername
+        };
     }
     async function detectAppIdsFromAllRemotes(repoPath) {
         const git = esm_default(repoPath);
@@ -21764,11 +22588,13 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIdsByCommitLookup(repoPath, anvilUrl) {
+    async function detectAppIdsByCommitLookup(repoPath, options) {
+        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
+        const username = options.username;
         const git = esm_default(repoPath);
         const out = [];
         try {
-            const authToken = await auth_getValidAuthToken(anvilUrl);
+            const authToken = await auth_getValidAuthToken(anvilUrl, username);
             const branchRef = await git.revparse([
                 "--abbrev-ref",
                 "HEAD"
@@ -21807,16 +22633,6 @@ var __webpack_exports__ = {};
         } catch (_e) {}
         return out;
     }
-    async function detectAppIds(repoPath, options = {}) {
-        const anvilUrl = options.anvilUrl || resolveAnvilUrl();
-        const results = [];
-        const includeReverseLookup = options.includeReverseLookup ?? true;
-        results.push(...await detectAppIdsFromRemotes(repoPath, anvilUrl));
-        if (0 === results.length && includeReverseLookup) results.push(...await detectAppIdsByCommitLookup(repoPath, anvilUrl));
-        const seen = new Set();
-        const unique = results.filter((c)=>seen.has(c.appId) ? false : (seen.add(c.appId), true));
-        return unique;
-    }
     class WebSocketClient extends Emitter {
         ws = null;
         appId;
@@ -21876,8 +22692,8 @@ var __webpack_exports__ = {};
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Closed: code=${code}, reason=${reason.toString()}`);
                 this.ws = null;
                 if (1008 === code || reason.toString().includes("unauthenticated")) {
-                    logger_logger.warn(chalk_source.yellow(" WebSocket authentication failed - real-time sync disabled"));
-                    logger_logger.verbose(chalk_source.gray("   File watching will continue, but remote changes won't be detected until you save"));
+                    logger_logger.warn(chalk_source.yellow(" WebSocket authentication failed - changes from the Anvil Editor won't be detected"));
+                    logger_logger.verbose(chalk_source.gray("   Local changes will still sync to Anvil, but editor changes won't appear locally"));
                     this.emit("auth-failed", void 0);
                     return;
                 }
@@ -21895,7 +22711,7 @@ var __webpack_exports__ = {};
                             });
                         });
                     }, this.RECONNECT_DELAY);
-                } else logger_logger.warn(chalk_source.yellow(` WebSocket reconnection failed after ${this.MAX_RECONNECT_ATTEMPTS} attempts. Real-time sync disabled.`));
+                } else logger_logger.warn(chalk_source.yellow(` WebSocket reconnection failed after ${this.MAX_RECONNECT_ATTEMPTS} attempts - changes from the Anvil Editor won't be detected`));
             });
             this.ws.on("error", (error)=>{
                 logger_logger.debug(`[WebSocket ${this.sessionId}]`, `Error: ${error.message}`);
@@ -24219,8 +25035,8 @@ var __webpack_exports__ = {};
             try {
                 await this.connectWebSocket();
             } catch (error) {
-                logger_logger.warn(chalk_source.yellow(" WebSocket connection unavailable - real-time sync disabled"));
-                logger_logger.verbose(chalk_source.gray("   (Server may need to support token-based WebSocket auth)"));
+                logger_logger.warn(chalk_source.yellow(" WebSocket connection unavailable - changes from the Anvil Editor won't be detected"));
+                logger_logger.verbose(chalk_source.gray("   Local changes will still sync to Anvil, but editor changes won't appear locally"));
                 logger_logger.debug("WebSocket init error:", error.message);
             }
         }
@@ -24640,7 +25456,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -24671,14 +25488,18 @@ var __webpack_exports__ = {};
     }
 })();
 exports.AppIdCandidate = __webpack_exports__.AppIdCandidate;
+exports.AppIdWithContext = __webpack_exports__.AppIdWithContext;
 exports.BranchSyncStatus = __webpack_exports__.BranchSyncStatus;
 exports.checkUncommittedChanges = __webpack_exports__.checkUncommittedChanges;
-exports.detectAppIds = __webpack_exports__.detectAppIds;
+exports.detectAppIdsByCommitLookup = __webpack_exports__.detectAppIdsByCommitLookup;
 exports.detectAppIdsFromAllRemotes = __webpack_exports__.detectAppIdsFromAllRemotes;
+exports.filterCandidates = __webpack_exports__.filterCandidates;
+exports.formatCandidateLabel = __webpack_exports__.formatCandidateLabel;
 exports.getValidAuthToken = __webpack_exports__.getValidAuthToken;
 exports.hasTokensForUrl = __webpack_exports__.hasTokensForUrl;
 exports.login = __webpack_exports__.login;
 exports.logout = __webpack_exports__.logout;
+exports.lookupRemoteInfoForAppId = __webpack_exports__.lookupRemoteInfoForAppId;
 exports.syncToLatest = __webpack_exports__.syncToLatest;
 exports.validateAnvilApp = __webpack_exports__.validateAnvilApp;
 exports.validateBranchSyncStatus = __webpack_exports__.validateBranchSyncStatus;
@@ -24686,14 +25507,18 @@ exports.verifyAuth = __webpack_exports__.verifyAuth;
 exports.watch = __webpack_exports__.watch;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AppIdCandidate",
+    "AppIdWithContext",
     "BranchSyncStatus",
     "checkUncommittedChanges",
-    "detectAppIds",
+    "detectAppIdsByCommitLookup",
     "detectAppIdsFromAllRemotes",
+    "filterCandidates",
+    "formatCandidateLabel",
     "getValidAuthToken",
     "hasTokensForUrl",
     "login",
     "logout",
+    "lookupRemoteInfoForAppId",
     "syncToLatest",
     "validateAnvilApp",
     "validateBranchSyncStatus",