@anvil-works/anvil-cli 0.3.12 → 0.4.1

package/dist/cli.js

@@ -94,6 +94,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", {
@@ -29804,6 +30502,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");
@@ -29840,6 +30542,10 @@ var __webpack_modules__ = {
         "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");
@@ -32314,6 +33020,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
         colors.bgWhiteBright = format(107, 49);
         module.exports = colors;
     },
+    "./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}');
@@ -34169,7 +34881,7 @@ var __webpack_exports__ = {};
         return `${lines}\u001b[?25l`;
     });
     var chardet_lib = __webpack_require__("./node_modules/.pnpm/chardet@2.1.1/node_modules/chardet/lib/index.js");
-    const external_child_process_namespaceObject = require("child_process");
+    var external_child_process_ = __webpack_require__("child_process");
     var external_node_path_ = __webpack_require__("node:path");
     const external_node_crypto_namespaceObject = require("node:crypto");
     var iconv_lite_lib = __webpack_require__("./node_modules/.pnpm/iconv-lite@0.7.2/node_modules/iconv-lite/lib/index.js");
@@ -34324,7 +35036,7 @@ var __webpack_exports__ = {};
         }
         launchEditor() {
             try {
-                const editorProcess = (0, external_child_process_namespaceObject.spawnSync)(this.editor.bin, this.editor.args.concat([
+                const editorProcess = (0, external_child_process_.spawnSync)(this.editor.bin, this.editor.args.concat([
                     this.tempFile
                 ]), {
                     stdio: 'inherit'
@@ -34336,7 +35048,7 @@ var __webpack_exports__ = {};
         }
         launchEditorAsync(callback) {
             try {
-                const editorProcess = (0, external_child_process_namespaceObject.spawn)(this.editor.bin, this.editor.args.concat([
+                const editorProcess = (0, external_child_process_.spawn)(this.editor.bin, this.editor.args.concat([
                     this.tempFile
                 ]), {
                     stdio: 'inherit'
@@ -38258,7 +38970,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));
@@ -41550,6 +42262,57 @@ var __webpack_exports__ = {};
             issues: dataset.issues
         };
     }
+    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 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,
@@ -41583,17 +42346,30 @@ var __webpack_exports__ = {};
         const normalized = 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 = keychainGet(normalizeAnvilUrl(url), username);
+            if (secrets) return {
+                ...configTokens,
+                ...secrets
+            };
+        }
+        return configTokens;
+    }
     function token_store_getTokensAutoSelect(url, username) {
         const normalized = 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
         };
@@ -41602,11 +42378,21 @@ var __webpack_exports__ = {};
         const normalized = 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 = normalizeAnvilUrl(url);
+        keychainDelete(normalized, username);
         const store = getTokenStore();
         if (!store[normalized] || !store[normalized][username]) return false;
         delete store[normalized][username];
@@ -41618,24 +42404,38 @@ var __webpack_exports__ = {};
         const normalized = 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 = 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 = keychainGet(normalized, username);
+                if (secrets?.refreshToken === refreshToken) return username;
+            }
+        }
     }
     function getAccountsForUrl(url) {
         const normalized = normalizeAnvilUrl(url);
         const urlTokens = getUrlTokens(normalized);
         if (!urlTokens) return [];
-        return Object.entries(urlTokens).filter(([_, tokens])=>tokens.authToken || tokens.refreshToken).map(([username])=>username).sort();
+        return Object.entries(urlTokens).filter(([username, tokens])=>{
+            if (tokens.authToken || tokens.refreshToken) return true;
+            return null !== keychainGet(normalized, username);
+        }).map(([username])=>username).sort();
     }
     function getAvailableUrls() {
         const store = getTokenStore();
-        return Object.entries(store).filter(([_, urlTokens])=>Object.values(urlTokens).some((tokens)=>tokens.authToken || tokens.refreshToken)).map(([url])=>url).sort();
+        return Object.entries(store).filter(([url, urlTokens])=>Object.entries(urlTokens).some(([username, tokens])=>{
+                if (tokens.authToken || tokens.refreshToken) return true;
+                return null !== keychainGet(url, username);
+            })).map(([url])=>url).sort();
     }
     function token_store_hasTokens(url, username) {
         const normalized = normalizeAnvilUrl(url);
@@ -41643,11 +42443,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 !== 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 !== 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 = {
@@ -41738,30 +42545,6 @@ var __webpack_exports__ = {};
         if (/^https?:\/\//.test(url)) return url;
         return `https://${url}`;
     }
-    async function detectAnvilUrlFromRemotes(repoPath) {
-        try {
-            const git = esm_default(repoPath);
-            const remotes = await git.getRemotes(true);
-            for (const remote of remotes){
-                const fetchUrl = remote.refs.fetch;
-                if (!fetchUrl) continue;
-                const httpMatch = fetchUrl.match(/(https?:\/\/[^\/]+)\/git\/[A-Z0-9]+\.git/);
-                if (httpMatch) return {
-                    url: normalizeAnvilUrl(httpMatch[1])
-                };
-                const sshMatch = fetchUrl.match(/ssh:\/\/([^@]+)@([^:]+):(\d+)\/(?:git\/)?([A-Z0-9]+)\.git/);
-                if (sshMatch) {
-                    const username = decodeURIComponent(sshMatch[1]);
-                    const hostname = sshMatch[2];
-                    return {
-                        url: normalizeAnvilUrl(hostname),
-                        username
-                    };
-                }
-            }
-        } catch (_e) {}
-        return null;
-    }
     function resolveAnvilUrl() {
         const fromConfig = getConfig("anvilUrl");
         if ("string" == typeof fromConfig && fromConfig.trim()) return fromConfig.trim();
@@ -46603,38 +47386,36 @@ var __webpack_exports__ = {};
             return null;
         }
     }
-    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 = normalizeAnvilUrl(explicitUrl);
+            filtered = filtered.filter((c)=>c.detectedUrl && 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);
@@ -46670,11 +47451,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"
@@ -46713,16 +47496,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_Emitter {
         ws = null;
         appId;
@@ -46782,8 +47555,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;
                 }
@@ -46801,7 +47574,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}`);
@@ -48626,8 +49399,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);
             }
         }
@@ -49027,7 +49800,8 @@ var __webpack_exports__ = {};
             authToken,
             currentBranch,
             commitId,
-            stagedOnly
+            stagedOnly,
+            username
         });
         session.on("branch-changed", (data)=>{
             logger_logger.debug("Event: branch-changed", data);
@@ -49056,27 +49830,8 @@ var __webpack_exports__ = {};
         session.hasUncommittedChanges = hasUncommittedChanges;
         return session;
     }
-    async function resolveAnvilUrlWithPrompt(explicitUrl, repoPath, explicitUsername) {
-        let url;
-        let username = explicitUsername;
-        if (explicitUrl) url = normalizeAnvilUrl(explicitUrl);
-        else if (repoPath) {
-            const detected = await detectAnvilUrlFromRemotes(repoPath);
-            if (detected) {
-                url = detected.url;
-                if (!username && detected.username) username = detected.username;
-            } else url = resolveUrlFromAvailableOrConfig();
-        } else url = resolveUrlFromAvailableOrConfig();
-        if (!username) {
-            const accounts = auth_getAccountsForUrl(url);
-            if (1 === accounts.length) username = accounts[0];
-        }
-        return {
-            url,
-            username
-        };
-    }
-    function resolveUrlFromAvailableOrConfig() {
+    function resolveUrlForFallback(explicitUrl) {
+        if (explicitUrl) return normalizeAnvilUrl(explicitUrl);
         const availableUrls = getAvailableAnvilUrls();
         if (availableUrls.length > 0) return availableUrls[0];
         const fromConfig = getConfig("anvilUrl");
@@ -49104,11 +49859,16 @@ var __webpack_exports__ = {};
                     trimmed ? resolve(trimmed) : resolve(null);
                 });
             });
-            return manualAppId;
+            if (manualAppId) return {
+                appId: manualAppId,
+                source: "config",
+                description: "Manual entry"
+            };
+            return null;
         }
-        const choices = candidates.map((candidate)=>({
-                name: `${candidate.appId} (${candidate.description})`,
-                value: candidate.appId
+        const choices = candidates.map((candidate, index)=>({
+                name: formatCandidateLabel(candidate),
+                value: index
             }));
         choices.push({
             name: "Cancel",
@@ -49137,9 +49897,14 @@ var __webpack_exports__ = {};
                         trimmed ? resolve(trimmed) : resolve(null);
                     });
                 });
-                return manualAppId;
+                if (manualAppId) return {
+                    appId: manualAppId,
+                    source: "config",
+                    description: "Manual entry"
+                };
+                return null;
             }
-            return answer.appId;
+            return candidates[answer.appId];
         } catch (error) {
             const errorObj = error;
             if ("ExitPromptError" === errorObj.name || errorObj.message.includes("User force closed")) logger_logger.warn("Operation cancelled by user.");
@@ -49577,137 +50342,100 @@ var __webpack_exports__ = {};
             const validationResult = await validateAnvilApp(repoPath);
             if (validationResult.appName) logger_logger.info(chalk_source.green("Anvil app: ") + chalk_source.bold(validationResult.appName));
             const detectedFromAllRemotes = await detectAppIdsFromAllRemotes(repoPath);
-            const availableUrls = getAvailableAnvilUrls();
-            const resolved = await resolveAnvilUrlWithPrompt(explicitUrl, repoPath, explicitUsername);
-            let anvilUrl = resolved.url;
-            let username = resolved.username;
-            logger_logger.verbose(chalk_source.cyan("Resolved Anvil URL: ") + chalk_source.bold(anvilUrl));
-            if (username) logger_logger.verbose(chalk_source.cyan("Using username: ") + chalk_source.bold(username));
-            if (!explicitUrl) {
-                const detectedFromRemote = detectedFromAllRemotes.length > 0 && detectedFromAllRemotes[0].detectedUrl ? {
-                    url: normalizeAnvilUrl(detectedFromAllRemotes[0].detectedUrl),
-                    username: detectedFromAllRemotes[0].detectedUsername
-                } : null;
-                if (detectedFromRemote) {
-                    logger_logger.verbose(chalk_source.cyan("Detected Anvil URL from git remote: ") + chalk_source.bold(detectedFromRemote.url));
-                    if (!username && detectedFromRemote.username) {
-                        username = detectedFromRemote.username;
-                        logger_logger.verbose(chalk_source.cyan("Detected username from git remote: ") + chalk_source.bold(username));
-                    }
-                    anvilUrl = detectedFromRemote.url;
-                    if (hasTokensForUrl(detectedFromRemote.url, username)) logger_logger.verbose(chalk_source.green("✓ Using detected URL (has authentication tokens)"));
-                    else logger_logger.verbose(chalk_source.yellow("Using detected URL from remotes (auth will be checked)"));
-                } else if (1 === availableUrls.length) anvilUrl = normalizeAnvilUrl(availableUrls[0]);
-                else if (availableUrls.length > 1) {
-                    const choices = availableUrls.map((url)=>({
-                            name: url,
-                            value: url
-                        }));
-                    choices.push({
-                        name: "Cancel",
-                        value: null
-                    });
-                    const answer = await logger_logger.select("Multiple Anvil installations found. Which one would you like to use?", choices, availableUrls[0]);
-                    if (null === answer) {
-                        logger_logger.warn("Operation cancelled. To login to a new Anvil installation, run:");
-                        logger_logger.verbose(chalk_source.gray("   anvil login <anvil-url>"));
-                        process.exit(0);
+            let filteredCandidates = filterCandidates(detectedFromAllRemotes, explicitUrl, explicitUsername);
+            logger_logger.verbose(chalk_source.cyan(`Detected ${detectedFromAllRemotes.length} app ID(s) from git remotes`));
+            if (filteredCandidates.length !== detectedFromAllRemotes.length) logger_logger.verbose(chalk_source.cyan(`After filtering: ${filteredCandidates.length} candidate(s)`));
+            let finalAppId;
+            let anvilUrl;
+            let username = explicitUsername;
+            if (explicitAppId) {
+                finalAppId = explicitAppId;
+                const remoteInfo = lookupRemoteInfoForAppId(explicitAppId, detectedFromAllRemotes);
+                if (remoteInfo.detectedUrl && !explicitUrl) {
+                    anvilUrl = normalizeAnvilUrl(remoteInfo.detectedUrl);
+                    logger_logger.verbose(chalk_source.cyan("Resolved URL from remote for app ID: ") + chalk_source.bold(anvilUrl));
+                }
+                if (remoteInfo.detectedUsername && !explicitUsername) {
+                    username = remoteInfo.detectedUsername;
+                    logger_logger.verbose(chalk_source.cyan("Resolved username from remote for app ID: ") + chalk_source.bold(username));
+                }
+            } else {
+                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
+                if (0 === filteredCandidates.length) {
+                    logger_logger.verbose(chalk_source.gray("No app IDs found in git remotes."));
+                    const fallbackUrl = resolveUrlForFallback(explicitUrl);
+                    const shouldContinue = await logger_logger.confirm(`Search ${fallbackUrl} for matching app IDs? (slower)`, true);
+                    if (shouldContinue) {
+                        logger_logger.progress("detect", `Searching ${fallbackUrl} ${explicitUsername ? `for ${explicitUsername}` : ''} for matching app IDs...`);
+                        const reverseLookupCandidates = await detectAppIdsByCommitLookup(repoPath, {
+                            anvilUrl: fallbackUrl,
+                            username: explicitUsername,
+                            includeRemotes: false
+                        });
+                        logger_logger.progressEnd("detect");
+                        for (const c of reverseLookupCandidates)filteredCandidates.push({
+                            ...c,
+                            detectedUrl: fallbackUrl
+                        });
                     }
-                    anvilUrl = answer;
+                }
+                if (filteredCandidates.length > 0) {
+                    for (const c of filteredCandidates)logger_logger.verbose(chalk_source.gray(`   Found: ${formatCandidateLabel(c)}`));
+                    if (filteredCandidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${filteredCandidates.length} potential app IDs`));
+                }
+                if (useFirst && filteredCandidates.length > 0) {
+                    const selected = filteredCandidates[0];
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
+                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
+                } else {
+                    const selected = await selectAppId(filteredCandidates);
+                    if (!selected) {
+                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
+                        process.exit(1);
+                    }
+                    finalAppId = selected.appId;
+                    if (selected.detectedUrl) anvilUrl = normalizeAnvilUrl(selected.detectedUrl);
+                    if (selected.detectedUsername && !username) username = selected.detectedUsername;
                 }
             }
+            if (explicitUrl) anvilUrl = normalizeAnvilUrl(explicitUrl);
+            else if (!anvilUrl) anvilUrl = resolveUrlForFallback();
+            anvilUrl = normalizeAnvilUrl(anvilUrl);
+            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
+            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
             if (!username) {
                 const accounts = auth_getAccountsForUrl(anvilUrl);
                 if (1 === accounts.length) {
                     username = accounts[0];
-                    logger_logger.verbose(chalk_source.cyan("Auto-selected username: ") + chalk_source.bold(username));
+                    logger_logger.verbose(chalk_source.cyan("Auto-selected account: ") + chalk_source.bold(username));
                 } else if (accounts.length > 1) {
-                    logger_logger.error(`Multiple accounts found for ${anvilUrl}. Please specify which account to use with --user flag.`);
-                    logger_logger.verbose(chalk_source.gray(`Available accounts: ${accounts.join(", ")}`));
-                    process.exit(1);
-                }
-            }
-            anvilUrl = normalizeAnvilUrl(anvilUrl);
-            logger_logger.verbose(chalk_source.cyan("Using Anvil URL: ") + chalk_source.bold(anvilUrl));
-            const detectedUrls = new Set(detectedFromAllRemotes.map((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl)).filter(Boolean));
-            const normalizedSelected = normalizeAnvilUrl(anvilUrl);
-            if (explicitUrl && detectedFromAllRemotes.length > 0 && !detectedUrls.has(normalizedSelected)) {
-                const detectedUrl = Array.from(detectedUrls)[0];
-                const detectedAppIds = detectedFromAllRemotes.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === detectedUrl).map((c)=>c.appId);
-                logger_logger.warn(chalk_source.yellow("Git remotes point to ") + chalk_source.bold(detectedUrl) + chalk_source.yellow(", but you specified: ") + chalk_source.bold(normalizedSelected));
-                if (detectedAppIds.length > 0) logger_logger.info(chalk_source.gray("   Detected app IDs on remote URL: ") + chalk_source.bold(detectedAppIds.join(", ")));
-                logger_logger.info(chalk_source.gray("   To use the remote URL instead, run: ") + chalk_source.cyan(`anvil watch --url ${detectedUrl}`));
-            }
-            const candidatesForSelectedUrl = detectedFromAllRemotes.filter((c)=>c.detectedUrl && normalizeAnvilUrl(c.detectedUrl) === normalizedSelected);
-            if (candidatesForSelectedUrl.length > 0) for (const candidate of candidatesForSelectedUrl){
-                const isLoggedInAny = hasTokensForUrl(normalizedSelected);
-                const isLoggedInWithUsername = candidate.detectedUsername ? hasTokensForUrl(normalizedSelected, candidate.detectedUsername) : false;
-                const loggedInAccounts = auth_getAccountsForUrl(normalizedSelected);
-                if (isLoggedInAny) {
-                    if (candidate.detectedUsername && !isLoggedInWithUsername) {
-                        logger_logger.warn(chalk_source.yellow("Detected from git remote: ") + chalk_source.bold(`app ID ${candidate.appId}`) + chalk_source.yellow(" on ") + chalk_source.bold(normalizedSelected) + chalk_source.yellow(" with username ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.yellow(", but you're logged in as ") + chalk_source.bold(loggedInAccounts.join(", ")) + chalk_source.yellow("."));
-                        logger_logger.info(chalk_source.gray("   To log in, run: ") + chalk_source.cyan(`anvil login ${normalizedSelected}`));
-                        logger_logger.info(chalk_source.gray("   Make sure you're logged in as ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.gray(" in your browser."));
+                    const choices = accounts.map((acct)=>({
+                            name: acct,
+                            value: acct
+                        }));
+                    choices.push({
+                        name: "Cancel",
+                        value: null
+                    });
+                    const selected = await logger_logger.select("Multiple accounts found. Which account owns this app?", choices, accounts[0]);
+                    if (null === selected) {
+                        logger_logger.warn("Operation cancelled.");
+                        process.exit(0);
                     }
-                } else {
-                    logger_logger.warn(chalk_source.yellow("Detected from git remote: ") + chalk_source.bold(`app ID ${candidate.appId}`) + chalk_source.yellow(" on ") + chalk_source.bold(normalizedSelected) + chalk_source.yellow(", but you're not logged in to this URL."));
-                    logger_logger.info(chalk_source.gray("   To log in, run: ") + chalk_source.cyan(`anvil login ${normalizedSelected}`));
-                    if (candidate.detectedUsername) logger_logger.info(chalk_source.gray("   Make sure you're logged in as ") + chalk_source.bold(candidate.detectedUsername) + chalk_source.gray(" in your browser."));
+                    username = selected;
                 }
             }
+            if (username) logger_logger.verbose(chalk_source.cyan("Using account: ") + chalk_source.bold(username));
             if (!hasTokensForUrl(anvilUrl, username)) {
                 if (username) logger_logger.error(`Not logged in to ${anvilUrl} as ${username}`);
                 else logger_logger.error(`Not logged in to ${anvilUrl}`);
                 logger_logger.verbose(chalk_source.yellow("Please log in first:"));
-                console.log(chalk_source.cyan(`   anvil login ${anvilUrl}`));
+                console.log(chalk_source.cyan(`   anvil login ${anvilUrl.replace(/^https?:\/\//, "")}`));
                 process.exit(1);
             }
-            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found for this URL"));
-            let finalAppId = explicitAppId;
-            if (!finalAppId) {
-                logger_logger.verbose(chalk_source.cyan("No app ID provided, attempting auto-detection..."));
-                logger_logger.progress("detect", "Auto-detecting app ID...");
-                let candidates = await detectAppIds(repoPath, {
-                    includeReverseLookup: false,
-                    anvilUrl
-                });
-                logger_logger.progressEnd("detect");
-                if (0 === candidates.length) {
-                    logger_logger.verbose(chalk_source.gray("Fast lookup found no matching app IDs."));
-                    const shouldContinue = await logger_logger.confirm(`Search ${anvilUrl} for matching app IDs? (slower)`, true);
-                    if (shouldContinue) {
-                        logger_logger.progress("detect", `Searching ${anvilUrl} for matching app IDs...`);
-                        candidates = await detectAppIds(repoPath, {
-                            anvilUrl
-                        });
-                        logger_logger.progressEnd("detect");
-                    }
-                }
-                if (candidates.length > 0) {
-                    logger_logger.verbose(chalk_source.gray("Checking git remotes:"));
-                    candidates.filter((c)=>"remote" === c.source).forEach((c)=>{
-                        logger_logger.verbose(chalk_source.gray(`   Found: ${c.description}`));
-                        logger_logger.verbose(chalk_source.green("Found app ID in remote: ") + chalk_source.bold(c.appId));
-                    });
-                    if (candidates.some((c)=>"config" === c.source)) candidates.filter((c)=>"config" === c.source).forEach((c)=>{
-                        logger_logger.verbose(chalk_source.gray(`Checking ${c.description.split("'")[1]} config...`));
-                        logger_logger.verbose(chalk_source.green("Found app ID in config: ") + chalk_source.bold(c.appId));
-                    });
-                    if (candidates.length > 1) logger_logger.verbose(chalk_source.yellow(`Found ${candidates.length} potential app IDs:`));
-                }
-                if (useFirst && candidates.length > 0) {
-                    finalAppId = candidates[0].appId;
-                    logger_logger.success("Auto-selected first app ID: " + chalk_source.bold(finalAppId));
-                } else {
-                    const selectedAppId = await selectAppId(candidates);
-                    if (!selectedAppId) {
-                        logger_logger.error("No app ID provided. Cannot continue without an app ID.");
-                        process.exit(1);
-                    }
-                    finalAppId = selectedAppId;
-                }
-            }
-            logger_logger.verbose(chalk_source.green("Using app ID: ") + chalk_source.bold(finalAppId));
+            logger_logger.verbose(chalk_source.green("✓ Authentication tokens found"));
             logger_logger.progress("validate", `Validating app ID: ${finalAppId}`);
             const appIdValidation = await validateAppId(finalAppId, anvilUrl, username);
             logger_logger.progressEnd("validate");