@dsh-sup/dsh-core-linux-x64 0.1.6-BETA.12 → 0.1.6-BETA.14

package/core.cjs

@@ -833,7 +833,11 @@ var require_config = __commonJS({
       // 不配置 = LAN 受 RFC1918 白名单约束，FRP 暴露仍强制 remoteToken。
       apiAccessKey: null,
       // 关闭窗口行为（系统级）：'hide' = 隐藏至托盘、服务常驻（默认）；'exit' = 退出管家并停全部服务链。
-      closeAction: "hide"
+      closeAction: "hide",
+      // 外部打开的浏览器偏好（系统级，本机配置）：存环境表单候选清单里的 id，null = 未选。
+      // 与「系统默认浏览器」分两个字段是刻意的：前者是用户在本产品里的选择，后者是操作系统的事实；
+      // 系统说不出默认时按候选次序分发并如实标注，用户可在这里定一次覆盖它（见 platform/os/environment.js）。
+      externalBrowser: null
     };
     function buildDefaults2(ext) {
       const pending = normalizeExtension(ext).defaults.slice();
@@ -947,7 +951,7 @@ var require_version = __commonJS({
     var fs2 = require("node:fs");
     var path2 = require("node:path");
     function guardVersion() {
-      if (true) return String("0.1.6-BETA.12");
+      if (true) return String("0.1.6-BETA.14");
       try {
         return JSON.parse(fs2.readFileSync(path2.join(__dirname, "..", "..", "package.json"), "utf8")).version || "unknown";
       } catch {
@@ -1080,6 +1084,7 @@ var require_fs = __commonJS({
   "src/platform/util/fs.js"(exports2, module2) {
     "use strict";
     var fs2 = require("node:fs");
+    var os2 = require("node:os");
     var path2 = require("node:path");
     function dirSizeBytes(root) {
       let total = 0;
@@ -1140,7 +1145,26 @@ var require_fs = __commonJS({
         throw e;
       }
     }
-    module2.exports = { dirSizeBytes, writeAtomic };
+    function removeTreeDeferred(dir, ms) {
+      if (!dir) return null;
+      const t = setTimeout(() => {
+        try {
+          fs2.rmSync(dir, { recursive: true, force: true });
+        } catch {
+        }
+      }, ms === void 0 ? 6e4 : ms);
+      if (t.unref) t.unref();
+      return t;
+    }
+    function allocTempDir(prefix) {
+      const dir = fs2.mkdtempSync(path2.join(os2.tmpdir(), prefix || "dsh-"));
+      try {
+        fs2.chmodSync(dir, 448);
+      } catch {
+      }
+      return dir;
+    }
+    module2.exports = { dirSizeBytes, writeAtomic, removeTreeDeferred, allocTempDir };
   }
 });
 
@@ -4639,23 +4663,66 @@ var require_desktop = __commonJS({
   "src/platform/os/desktop.js"(exports2, module2) {
     "use strict";
     var fs2 = require("node:fs");
+    var os2 = require("node:os");
+    var path2 = require("node:path");
     var PLATFORM = process.platform;
-    function hasX11Socket() {
+    var X11_DIR = "/tmp/.X11-unix";
+    function deps(o) {
+      const ov = o || {};
+      return {
+        env: ov.env || process.env,
+        readdir: ov.readdir || ((p) => fs2.readdirSync(p)),
+        exists: ov.exists || ((p) => fs2.existsSync(p)),
+        home: ov.home || os2.homedir(),
+        uid: typeof process.getuid === "function" ? process.getuid() : 0
+      };
+    }
+    function runtimeDir(env, uid) {
+      return env.XDG_RUNTIME_DIR || "/run/user/" + uid;
+    }
+    function x11Displays(o) {
+      const d = deps(o);
       try {
-        return fs2.readdirSync("/tmp/.X11-unix").some((f) => /^X\d+$/.test(f));
+        return d.readdir(X11_DIR).filter((f) => /^X\d+$/.test(f)).map((f) => Number(f.slice(1))).sort((a, b) => a - b);
       } catch {
-        return false;
+        return [];
       }
     }
-    function hasWaylandSocket() {
-      const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-      const rt = process.env.XDG_RUNTIME_DIR || "/run/user/" + uid;
+    function waylandSockets(o) {
+      const d = deps(o);
       try {
-        return fs2.readdirSync(rt).some((f) => /^wayland-\d+$/.test(f));
+        return d.readdir(runtimeDir(d.env, d.uid)).filter((f) => /^wayland-\d+$/.test(f)).sort();
       } catch {
-        return false;
+        return [];
       }
     }
+    function hasX11Socket(o) {
+      return x11Displays(o).length > 0;
+    }
+    function hasWaylandSocket(o) {
+      return waylandSockets(o).length > 0;
+    }
+    function sessionEnv(o) {
+      const d = deps(o);
+      const out = {};
+      if (PLATFORM !== "linux") return out;
+      if (!d.env.DISPLAY && !d.env.WAYLAND_DISPLAY) {
+        const xs = x11Displays(d);
+        if (xs.length) {
+          out.DISPLAY = ":" + xs[0];
+          const xauth = path2.join(d.home, ".Xauthority");
+          if (d.exists(xauth)) out.XAUTHORITY = xauth;
+        } else {
+          const wl = waylandSockets(d);
+          if (wl.length) out.WAYLAND_DISPLAY = wl[0];
+        }
+      }
+      if (!d.env.DBUS_SESSION_BUS_ADDRESS) {
+        const bus = path2.join(runtimeDir(d.env, d.uid), "bus");
+        if (d.exists(bus)) out.DBUS_SESSION_BUS_ADDRESS = "unix:path=" + bus;
+      }
+      return out;
+    }
     function sessionAvailable() {
       if (PLATFORM === "linux") {
         if (process.env.DISPLAY || process.env.WAYLAND_DISPLAY) return true;
@@ -4682,7 +4749,7 @@ var require_desktop = __commonJS({
         reason: "session-scoped-by-launcher"
       };
     }
-    module2.exports = { sessionAvailable, describe, PLATFORM };
+    module2.exports = { sessionAvailable, sessionEnv, describe, x11Displays, waylandSockets, PLATFORM };
   }
 });
 
@@ -4755,8 +4822,9 @@ var require_capability_profile = __commonJS({
       autostart: true,
       // 期望 schtasks（实测覆写）
       frpExpose: true,
-      // 可打开，但 win32 的两种启动形态（explorer.exe 调度器 / 裸 URL 直启解析到的浏览器）退出码都不携带
-      // 窗口是否出现的信息，故每次调用最多到 handedOff（见 browser.js#ownsItsWindow）。能力位只声明「能交出去」。
+      // 可打开，但 Windows 没有可信调度器（系统调度器只有 darwin 的 open 与 linux 的 xdg-open），
+      // 只能直启探测层解析出的浏览器本体；浏览器已在运行时本次进程只转交地址，退出码与窗口出现与否无关，
+      // 故该平台每次调用最多到 handedOff（判据见 browser.js#ownsItsWindow）。能力位只声明「能交出去」。
       openBrowser: true,
       hostService: "windows-service",
       guardAutostart: true,
@@ -4787,6 +4855,784 @@ var require_capability_profile = __commonJS({
   }
 });
 
+// src/platform/os/browser-inventory.js
+var require_browser_inventory = __commonJS({
+  "src/platform/os/browser-inventory.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require("node:fs");
+    var path2 = require("node:path");
+    var os2 = require("node:os");
+    var exec = require_exec();
+    var { isExecutableFile } = require_exec_path();
+    var PROBE_TIMEOUT_MS = 1500;
+    function engineOf(bin) {
+      const base = String(bin || "").toLowerCase().split(/[\\/]/).pop();
+      if (/(chrome|chromium|msedge|edge|brave|vivaldi|opera|thorium)/.test(base)) return "chromium";
+      if (/(firefox|librewolf|waterfox)/.test(base)) return "firefox";
+      return "other";
+    }
+    function tokenizeExec(line) {
+      const toks = [];
+      let cur = "";
+      let q = null;
+      let esc = false;
+      let has = false;
+      for (const ch of String(line)) {
+        if (esc) {
+          cur += ch;
+          esc = false;
+          continue;
+        }
+        if (ch === "\\") {
+          esc = true;
+          has = true;
+          continue;
+        }
+        if (q) {
+          if (ch === q) q = null;
+          else cur += ch;
+          continue;
+        }
+        if (ch === "'" || ch === '"') {
+          q = ch;
+          has = true;
+          continue;
+        }
+        if (/\s/.test(ch)) {
+          if (has) {
+            toks.push(cur);
+            cur = "";
+            has = false;
+          }
+          continue;
+        }
+        cur += ch;
+        has = true;
+      }
+      if (has) toks.push(cur);
+      return toks;
+    }
+    function parseExecLine(line) {
+      let toks = tokenizeExec(line).filter((t) => t !== "%%" && !/^%[a-zA-Z]$/.test(t));
+      if (toks[0] === "env") {
+        let i = 1;
+        while (i < toks.length && /=/.test(toks[i])) i++;
+        toks = toks.slice(i);
+      }
+      if (!toks.length) return null;
+      return { bin: toks[0], baseArgs: toks.slice(1) };
+    }
+    function regValueOf(out) {
+      const m = String(out || "").match(/REG_(?:EXPAND_SZ|SZ)\s+(.*)/);
+      if (!m) return null;
+      return m[1].trim() || null;
+    }
+    function expandEnvVars(value, env) {
+      const e = env || process.env;
+      return String(value).replace(/%([^%]+)%/g, (all, name) => e[name] === void 0 ? all : e[name]);
+    }
+    function exeFromCmdLine(cmdLine) {
+      const s = String(cmdLine || "");
+      let m = s.match(/^\s*"([^"]+\.exe)"/i);
+      if (m) return m[1];
+      m = s.match(/^\s*(.*?\.exe)/i);
+      return m ? m[1] : null;
+    }
+    function safeRegKeyPart(s) {
+      return typeof s === "string" && s.length > 0 && s.length <= 200 && /^[\x20-\x7e]+$/.test(s) && !/[;|&`$()<>^"'\r\n]/.test(s);
+    }
+    function regValue(runner, note, key, name) {
+      const args = name ? ["query", key, "/v", name] : ["query", key, "/ve"];
+      const out = runner("reg.exe", args);
+      const v = regValueOf(out);
+      note(name ? key + " /v " + name : key, v ? "ok" : "empty");
+      return v;
+    }
+    var REG_HIVE_ALIAS = { HKLM: "HKEY_LOCAL_MACHINE", HKCU: "HKEY_CURRENT_USER", HKCR: "HKEY_CLASSES_ROOT", HKU: "HKEY_USERS", HKCC: "HKEY_CURRENT_CONFIG" };
+    function regKeyFull(key) {
+      const s = String(key || "");
+      const i = s.indexOf("\\");
+      const root = i < 0 ? s : s.slice(0, i);
+      return (REG_HIVE_ALIAS[root.toUpperCase()] || root) + (i < 0 ? "" : s.slice(i));
+    }
+    function regSubkeys(runner, note, key) {
+      const out = runner("reg.exe", ["query", key]);
+      if (!out) {
+        note(key, "unreadable");
+        return [];
+      }
+      const prefix = regKeyFull(key) + "\\";
+      const names = [];
+      for (const line of String(out).split(/\r?\n/)) {
+        const l = line.trim();
+        if (!/^HKEY_/i.test(l) || l.length <= prefix.length) continue;
+        if (l.slice(0, prefix.length).toUpperCase() !== prefix.toUpperCase()) continue;
+        const rest = l.slice(prefix.length);
+        if (rest && !rest.includes("\\") && safeRegKeyPart(rest)) names.push(rest);
+      }
+      note(key, names.length ? names.length + " \u9879" : "\u65E0\u5B50\u952E");
+      return names;
+    }
+    var WIN_APP_PATHS = ["msedge.exe", "chrome.exe", "firefox.exe", "brave.exe", "opera.exe", "vivaldi.exe", "chromium.exe", "thorium.exe", "librewolf.exe"];
+    function winExeOfProgId(runner, note, progId, env) {
+      if (!safeRegKeyPart(progId)) return null;
+      for (const root of ["HKCU\\Software\\Classes", "HKLM\\Software\\Classes"]) {
+        const cmd2 = regValue(runner, note, root + "\\" + progId + "\\shell\\open\\command");
+        const exe = cmd2 ? exeFromCmdLine(expandEnvVars(cmd2, env)) : null;
+        if (exe) return exe;
+      }
+      return null;
+    }
+    function probeWin(d) {
+      const { runOut, env, canExec } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const found = /* @__PURE__ */ new Map();
+      const keyOf = (exe) => String(exe || "").toLowerCase().replace(/[\\/]/g, "\\");
+      const push = (exe, how) => {
+        const full = expandEnvVars(exe, env).trim();
+        if (!/\.exe$/i.test(full)) {
+          note(how, "\u6765\u6E90\u7ED9\u51FA\u7684\u4E0D\u662F exe \u8DEF\u5F84: " + full);
+          return null;
+        }
+        const k = keyOf(full);
+        const hit = found.get(k);
+        if (hit) {
+          if (!hit.sources.includes(how)) hit.sources.push(how);
+          return hit;
+        }
+        if (!canExec(full)) {
+          note(how, "\u6307\u5411\u7684\u6587\u4EF6\u4E0D\u53EF\u6267\u884C: " + full);
+          return null;
+        }
+        const item = { id: k, name: path2.basename(full).replace(/\.exe$/i, ""), engine: engineOf(full), bin: full, source: how, sources: [how] };
+        found.set(k, item);
+        note(how, item.name);
+        return item;
+      };
+      const progIds = /* @__PURE__ */ new Map();
+      const addProgId = (pid, how) => {
+        const s = String(pid || "").trim();
+        if (!safeRegKeyPart(s)) return;
+        if (progIds.get(s) === "userchoice") return;
+        progIds.set(s, how);
+      };
+      let defaultId = null;
+      let defaultSource = null;
+      const DEF_RANK = { userchoice: 1, "scheme-association": 2, "only-installed": 9 };
+      let defRank = 99;
+      const setDefault = (item, how) => {
+        const r = DEF_RANK[how] === void 0 ? 99 : DEF_RANK[how];
+        if (item && r < defRank) {
+          defRank = r;
+          defaultId = item.id;
+          defaultSource = how;
+        }
+      };
+      const cmdToExe = (raw) => raw ? exeFromCmdLine(expandEnvVars(raw, env)) : null;
+      const uc = regValue(runOut, note, "HKCU\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\https\\UserChoice", "ProgId");
+      if (uc) addProgId(uc, "userchoice");
+      for (const root of ["HKCU\\Software\\Classes", "HKLM\\Software\\Classes"]) {
+        const pid = regValue(runOut, note, root + "\\https");
+        if (pid) addProgId(pid, "scheme-association");
+        const exe = cmdToExe(regValue(runOut, note, root + "\\https\\shell\\open\\command"));
+        if (exe) setDefault(push(exe, "scheme-association"), "scheme-association");
+      }
+      for (const name of regSubkeys(runOut, note, "HKLM\\SOFTWARE\\Clients\\StartMenuInternet")) {
+        addProgId(name, "startmenu-catalog");
+        const exe = cmdToExe(regValue(runOut, note, "HKLM\\SOFTWARE\\Clients\\StartMenuInternet\\" + name + "\\shell\\open\\command")) || winExeOfProgId(runOut, note, name, env);
+        if (exe) push(exe, "startmenu-catalog");
+      }
+      for (const root of ["HKLM\\SOFTWARE", "HKCU\\SOFTWARE"]) {
+        for (const capPath of regValueTargets(runOut, note, root + "\\RegisteredApplications")) {
+          const https = regValue(runOut, note, capPath + "\\UrlAssociations\\https");
+          const sid = regValue(runOut, note, capPath, "StartMenuInternet");
+          const pid = https || sid;
+          if (pid) addProgId(pid, "registered-apps");
+        }
+      }
+      for (const exe of WIN_APP_PATHS) {
+        for (const root of ["HKCU", "HKLM"]) {
+          const v = regValue(runOut, note, root + "\\Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + exe);
+          if (v && push(v, "app-paths")) break;
+        }
+      }
+      for (const [pid, how] of progIds) {
+        const exe = winExeOfProgId(runOut, note, pid, env);
+        if (!exe) continue;
+        const item = push(exe, how);
+        if (how === "userchoice") setDefault(item, "userchoice");
+      }
+      if (found.size === 1) setDefault([...found.values()][0], "only-installed");
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    function regValueTargets(runOut, note, key) {
+      const out = runOut("reg.exe", ["query", key]);
+      if (!out) {
+        note(key, "unreadable");
+        return [];
+      }
+      const paths = [];
+      for (const line of String(out).split(/\r?\n/)) {
+        const m = line.trim().match(/REG_SZ\s+(.*)/);
+        if (!m) continue;
+        const rel = m[1].trim();
+        if (!safeRegKeyPart(rel)) continue;
+        const root = key.slice(0, key.indexOf("\\"));
+        paths.push(root + "\\" + rel);
+      }
+      note(key, paths.length ? paths.length + " \u4E2A\u80FD\u529B\u8DEF\u5F84" : "\u65E0\u503C");
+      return paths;
+    }
+    var MAC_JXA_LIST = [
+      "ObjC.import('Foundation');",
+      "var ws=$.NSWorkspace.sharedWorkspace;",
+      "var u=$.NSURL.URLWithString('https://dsh.local/probe');",
+      "var out=[];var def='';",
+      "try{var d=ws.URLForApplicationToOpenURL(u); if(!d.isNil()) def=ObjC.unwrap(d.path)||'';}catch(e){}",
+      "var list=null;",
+      "try{list=ws.urlsForApplicationsToOpenURL(u);}catch(e){}",
+      "if(list===null||typeof list.count!=='number'){if(def){out.push(def+'\\t\\t1');}}else{",
+      "var n=Number(list.count);",
+      "for(var i=0;i<n;i++){",
+      "var p=ObjC.unwrap(list.objectAtIndex(i).path)||''; if(!p) continue;",
+      "var exe='';var bid='';",
+      "var b=$.NSBundle.bundleWithPath(p);",
+      "if(!b.isNil()){exe=ObjC.unwrap(b.executablePath)||'';bid=ObjC.unwrap(b.bundleIdentifier)||'';}",
+      "out.push((exe||p)+'\\t'+bid+'\\t'+(p&&def&&p===def?1:0));}",
+      "}",
+      // 末句必须是裸表达式：osascript 取的是最后一条**语句**的值，if/else 语句不产结果，
+      //   写在分支里会让整段查询输出空字符串（表现为「系统未报任何可用应用」）。
+      "out.join('\\n');"
+    ].join("");
+    function probeMac(d) {
+      const { runOut, canExec } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const out = runOut("osascript", ["-l", "JavaScript", "-e", MAC_JXA_LIST]);
+      if (!out || !out.trim()) {
+        note("launchservices", "\u67E5\u8BE2\u65E0\u8F93\u51FA\uFF08\u65E7\u7CFB\u7EDF\u6216\u88AB\u6743\u9650\u62E6\u622A\uFF09");
+        return { browsers: [], defaultId: null, defaultSource: null, probed: notes };
+      }
+      const keyOf = (exe) => String(exe || "").toLowerCase();
+      const found = /* @__PURE__ */ new Map();
+      let defaultId = null;
+      let defaultSource = null;
+      for (const line of out.trim().split("\n")) {
+        const parts = line.split("	");
+        const bin = (parts[0] || "").trim();
+        if (!bin) continue;
+        if (!canExec(bin)) {
+          note("launchservices", "\u4E0D\u53EF\u6267\u884C: " + bin);
+          continue;
+        }
+        const k = keyOf(bin);
+        if (!found.has(k)) found.set(k, { id: k, name: path2.basename(bin), engine: engineOf(bin), bin, source: "launchservices", sources: ["launchservices"], isDefault: false });
+        if (parts[2] === "1") {
+          found.get(k).isDefault = true;
+          if (!defaultId) {
+            defaultId = k;
+            defaultSource = "launchservices";
+          }
+        }
+      }
+      note("launchservices", found.size ? found.size + " \u4E2A\u53EF\u6253\u5F00 https \u7684\u5E94\u7528" : "\u7CFB\u7EDF\u672A\u62A5\u4EFB\u4F55\u53EF\u7528\u5E94\u7528");
+      if (!defaultId && found.size === 1) {
+        defaultId = [...found.keys()][0];
+        defaultSource = "only-installed";
+      }
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    var PJ = path2.posix.join;
+    function desktopDirs(env, home) {
+      const dataHome = env.XDG_DATA_HOME || PJ(home, ".local", "share");
+      const dataDirs = String(env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":").filter(Boolean);
+      const dirs = [[dataHome, "xdg"], ...dataDirs.map((p) => [p, "xdg"])];
+      dirs.push([PJ(home, ".local", "share"), "xdg"]);
+      dirs.push(["/var/lib/flatpak/exports/share", "flatpak"]);
+      dirs.push([PJ(home, ".local", "share", "flatpak", "exports", "share"), "flatpak"]);
+      dirs.push(["/var/lib/snapd/desktop", "snap"]);
+      const seen = [];
+      return dirs.map(([root, kind]) => ({ dir: PJ(root, "applications"), kind })).filter((x) => {
+        if (seen.includes(x.dir)) return false;
+        seen.push(x.dir);
+        return true;
+      });
+    }
+    function browserFromDesktop(text, kind, file) {
+      let inMain = false;
+      const got = {};
+      for (const line of String(text).split(/\r?\n/)) {
+        if (/^\[Desktop Entry\]\s*$/.test(line)) {
+          inMain = true;
+          continue;
+        }
+        if (/^\[/.test(line)) break;
+        if (!inMain) continue;
+        const m = line.match(/^(Exec|Name|TryExec|Categories)=(.*)$/);
+        if (!m) continue;
+        if (m[1] === "Name" && got.Name) continue;
+        got[m[1]] = m[2].trim();
+      }
+      if (!got.Exec) return null;
+      const categories = String(got.Categories || "");
+      const parsed = parseExecLine(got.Exec);
+      if (!parsed) return null;
+      const engine = engineOf(parsed.bin);
+      const claimsBrowser = /(^|;)WebBrowser(;|$)/.test(categories);
+      if (!claimsBrowser && engine === "other") return null;
+      if (engine === "other") return null;
+      return {
+        // id 恒为归一后的可执行文件路径：defaultId 靠它在清单里定位条目，三平台同一契约
+        id: parsed.bin.toLowerCase(),
+        name: got.Name || path2.basename(file, ".desktop"),
+        engine,
+        bin: parsed.bin,
+        baseArgs: parsed.baseArgs,
+        source: kind,
+        desktopFile: file
+      };
+    }
+    function resolveLinuxBin(bin, canExec, env) {
+      const b = String(bin || "").trim();
+      if (!b) return null;
+      if (b.startsWith("/")) return canExec(b) ? b : null;
+      if (b.includes("/")) return null;
+      for (const dir of String(env.PATH || "").split(":")) {
+        if (!dir) continue;
+        const p = PJ(dir.replace(/\/+$/, ""), b);
+        if (canExec(p)) return p;
+      }
+      return null;
+    }
+    function probeLinux(d) {
+      const { runOut, readFile, exists, listDir, canExec, env, home } = d;
+      const notes = [];
+      const note = (source, detail) => {
+        notes.push({ source, detail });
+      };
+      const found = /* @__PURE__ */ new Map();
+      const usable = (item) => {
+        const resolved = resolveLinuxBin(item.bin, canExec, env);
+        if (!resolved) {
+          note(item.source, "\u4E0D\u53EF\u6267\u884C: " + item.bin);
+          return null;
+        }
+        const k = resolved.toLowerCase();
+        const hit = found.get(k);
+        if (hit) {
+          if (!hit.sources.includes(item.source)) hit.sources.push(item.source);
+          return hit;
+        }
+        const v = Object.assign({}, item, { id: k, bin: resolved, sources: [item.source] });
+        found.set(k, v);
+        return v;
+      };
+      for (const { dir, kind } of desktopDirs(env, home)) {
+        let names = [];
+        try {
+          names = listDir(dir).filter((f) => f.endsWith(".desktop"));
+        } catch {
+          continue;
+        }
+        for (const f of names) {
+          let text = null;
+          try {
+            text = readFile(PJ(dir, f));
+          } catch {
+            continue;
+          }
+          const item = browserFromDesktop(text, kind, f);
+          if (item) usable(item);
+        }
+      }
+      let defaultId = null;
+      let defaultSource = null;
+      const fromMime = linuxDefaultFromMimeApps(readFile, exists, env, home, note);
+      if (fromMime) {
+        const item = usable(fromMime);
+        if (item) {
+          defaultId = item.id;
+          defaultSource = "mimeapps";
+        }
+      }
+      const id = runOut("xdg-settings", ["get", "default-web-browser"]);
+      const desktopId = id && String(id).trim();
+      if (!defaultId && desktopId && /^[A-Za-z0-9._-]+\.desktop$/.test(desktopId)) {
+        for (const { dir } of desktopDirs(env, home)) {
+          const p = PJ(dir, desktopId);
+          let text = null;
+          try {
+            if (exists(p)) text = readFile(p);
+          } catch {
+            continue;
+          }
+          if (text === null) continue;
+          const item = browserFromDesktop(text, "xdg-settings", desktopId);
+          const used = item && usable(item);
+          if (used) {
+            defaultId = used.id;
+            defaultSource = "xdg-settings";
+            break;
+          }
+        }
+      }
+      if (!desktopId) note("xdg-settings", "\u65E0\u8F93\u51FA");
+      else if (defaultSource === "xdg-settings") note("xdg-settings", "\u9ED8\u8BA4=" + defaultId);
+      else note("xdg-settings", "\u62A5\u51FA " + desktopId + (defaultId ? "\uFF08\u9ED8\u8BA4\u5DF2\u7531 " + defaultSource + " \u5B9A\u51FA\uFF09" : " \u4F46\u4E0D\u53EF\u7528"));
+      if (!defaultId && found.size === 1) {
+        defaultId = [...found.keys()][0];
+        defaultSource = "only-installed";
+      }
+      return { browsers: [...found.values()], defaultId, defaultSource, probed: notes };
+    }
+    function linuxDefaultFromMimeApps(readFile, exists, env, home, note) {
+      const cfgHome = env.XDG_CONFIG_HOME || PJ(home, ".config");
+      const cfgDirs = String(env.XDG_CONFIG_DIRS || "/etc/xdg").split(":").filter(Boolean);
+      const dataDirs = String(env.XDG_DATA_DIRS || "/usr/local/share:/usr/share").split(":").filter(Boolean);
+      const files = [
+        PJ(cfgHome, "mimeapps.list"),
+        ...cfgDirs.map((d) => PJ(d, "mimeapps.list")),
+        ...dataDirs.map((d) => PJ(d, "applications", "mimeapps.list"))
+      ];
+      for (const f of files) {
+        if (!exists(f)) continue;
+        let text = null;
+        try {
+          text = readFile(f);
+        } catch {
+          continue;
+        }
+        const id = mimeAppsDefault(text);
+        if (!id) continue;
+        note("mimeapps", path2.basename(f) + " -> " + id);
+        for (const { dir, kind } of desktopDirs(env, home)) {
+          const p = PJ(dir, id);
+          if (!exists(p)) continue;
+          let dt = null;
+          try {
+            dt = readFile(p);
+          } catch {
+            continue;
+          }
+          const item = browserFromDesktop(dt, kind, id);
+          if (item) return item;
+        }
+        return null;
+      }
+      note("mimeapps", "\u65E0\u9ED8\u8BA4\u9879");
+      return null;
+    }
+    function mimeAppsDefault(text) {
+      let inDefault = false;
+      for (const line of String(text || "").split(/\r?\n/)) {
+        if (/^\s*\[/.test(line)) {
+          inDefault = /^\s*\[Default Applications\]\s*$/.test(line);
+          continue;
+        }
+        if (!inDefault) continue;
+        const m = line.match(/^\s*x-scheme-handler\/https?\s*=\s*(.*)$/i);
+        if (!m) continue;
+        const ids = m[1].split(";").map((s) => s.trim()).filter((s) => /^[A-Za-z0-9._-]+\.desktop$/.test(s));
+        if (ids.length) return ids[0];
+      }
+      return null;
+    }
+    function probe(platform, d) {
+      const pl = platform || process.platform;
+      const dd = Object.assign({}, d, { canExec: d.canExec || ((p) => isExecutableFile(p, pl)) });
+      if (pl === "win32") return probeWin(dd);
+      if (pl === "darwin") return probeMac(dd);
+      return probeLinux(dd);
+    }
+    var CACHE = /* @__PURE__ */ Object.create(null);
+    function inventory(platform, o) {
+      const ov = o || {};
+      const pl = platform || process.platform;
+      const now = ov.now || (() => Date.now());
+      const ttl = ov.ttlMs === void 0 ? 6e4 : ov.ttlMs;
+      const cached = CACHE[pl];
+      if (!ov.force && cached && now() - cached.at < ttl) return Object.assign({ cached: true }, cached.value);
+      const runOut = ov.runOut || ((bin, args) => exec.runOut(bin, args, { timeoutMs: PROBE_TIMEOUT_MS }));
+      const readFile = ov.readFile || ((p) => fs2.readFileSync(p, "utf8"));
+      const exists = ov.exists || ((p) => fs2.existsSync(p));
+      const listDir = ov.listDir || ((p) => fs2.readdirSync(p));
+      let value;
+      try {
+        value = probe(pl, { runOut, readFile, exists, listDir, canExec: ov.canExec, env: ov.env || process.env, home: ov.home || os2.homedir() });
+      } catch (e) {
+        value = { browsers: [], defaultId: null, defaultSource: null, probed: [{ source: "probe-error", detail: String(e && e.message || e) }] };
+      }
+      value.at = now();
+      value.platform = pl;
+      value.browsers.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+      CACHE[pl] = { at: now(), value };
+      return Object.assign({ cached: false }, value);
+    }
+    function invalidate(platform) {
+      if (platform) delete CACHE[platform];
+      else for (const k of Object.keys(CACHE)) delete CACHE[k];
+    }
+    module2.exports = {
+      inventory,
+      invalidate,
+      probe,
+      probeWin,
+      probeMac,
+      probeLinux,
+      engineOf,
+      tokenizeExec,
+      parseExecLine,
+      regValueOf,
+      expandEnvVars,
+      exeFromCmdLine,
+      regSubkeys,
+      regKeyFull,
+      regValueTargets,
+      safeRegKeyPart,
+      browserFromDesktop,
+      desktopDirs,
+      resolveLinuxBin,
+      mimeAppsDefault,
+      linuxDefaultFromMimeApps,
+      WIN_APP_PATHS,
+      PROBE_TIMEOUT_MS
+    };
+  }
+});
+
+// src/platform/os/environment.js
+var require_environment = __commonJS({
+  "src/platform/os/environment.js"(exports2, module2) {
+    "use strict";
+    var fs2 = require("node:fs");
+    var os2 = require("node:os");
+    var path2 = require("node:path");
+    var stateRoot2 = require_state_root();
+    var { writeAtomic } = require_fs();
+    var desktop = require_desktop();
+    var detector = require_browser_inventory();
+    var { engineOf } = detector;
+    var SCHEMA = 1;
+    var FILE_NAME = "environment.json";
+    var FORM_TTL_MS = 6e4;
+    var _sources = {};
+    function bind(sources) {
+      _sources = Object.assign({}, _sources, sources || {});
+      return _sources;
+    }
+    function preferenceId() {
+      const f = _sources.preference;
+      if (typeof f !== "function") return null;
+      const v = f();
+      return typeof v === "string" && v.trim() ? v.trim() : null;
+    }
+    function capabilities() {
+      const f = _sources.capabilities;
+      if (typeof f !== "function") return null;
+      return f() || null;
+    }
+    function identity() {
+      let user = null;
+      try {
+        user = os2.userInfo().username;
+      } catch {
+        user = process.env.USER || process.env.USERNAME || null;
+      }
+      return {
+        platform: process.platform,
+        arch: process.arch,
+        hostname: os2.hostname(),
+        user: user || null,
+        home: os2.homedir(),
+        node: process.version
+      };
+    }
+    function paths() {
+      return { root: stateRoot2.root(), supervisor: stateRoot2.supervisorDir(), shell: stateRoot2.shellDir() };
+    }
+    function normalizeInventory(inv, platform) {
+      const list = inv && Array.isArray(inv.browsers) ? inv.browsers : [];
+      const defaultId = inv && inv.defaultId ? inv.defaultId : null;
+      return {
+        platform: inv && inv.platform || platform || process.platform,
+        cached: !!(inv && inv.cached),
+        at: inv && inv.at !== void 0 ? inv.at : null,
+        defaultId,
+        defaultSource: inv && inv.defaultSource || null,
+        browsers: list.map((b) => ({
+          id: b.id,
+          name: b.name,
+          bin: b.bin,
+          engine: b.engine || engineOf(b.bin),
+          baseArgs: b.baseArgs || [],
+          sources: b.sources && b.sources.length ? b.sources : [b.source || "unknown"],
+          isDefault: !!defaultId && b.id === defaultId
+        })),
+        probed: inv && inv.probed || []
+      };
+    }
+    function browsers(o) {
+      const ov = o || {};
+      const pl = ov.platform || process.platform;
+      if (ov.inventory) return normalizeInventory(ov.inventory, pl);
+      const resolve = typeof ov.resolveInventory === "function" ? ov.resolveInventory : ((platform, deps) => detector.inventory(platform, deps));
+      return normalizeInventory(resolve(pl, ov.resolveDeps || {}), pl);
+    }
+    var ENGINE_RANK = { chromium: 0, firefox: 1, other: 2 };
+    function rankCandidates(list) {
+      const rankOf = (b) => {
+        const r = ENGINE_RANK[b && b.engine];
+        return r === void 0 ? ENGINE_RANK.other : r;
+      };
+      return (Array.isArray(list) ? list : []).slice().sort((a, b) => {
+        if (rankOf(a) !== rankOf(b)) return rankOf(a) - rankOf(b);
+        const ia = String(a && a.id || "");
+        const ib = String(b && b.id || "");
+        return ia < ib ? -1 : ia > ib ? 1 : 0;
+      });
+    }
+    function pickLauncher(platform, inv, preference) {
+      const list = inv && Array.isArray(inv.browsers) ? inv.browsers : [];
+      const byId = /* @__PURE__ */ new Map();
+      for (const b of list) byId.set(b.id, b);
+      const wanted = preference === void 0 ? preferenceId() : typeof preference === "string" && preference ? preference : null;
+      const stale = wanted !== null && !byId.has(wanted);
+      const out = (browser, how) => ({ browser, how, wanted, stale });
+      if (wanted !== null && byId.has(wanted)) return out(byId.get(wanted), "user-preference");
+      const sys = inv && inv.defaultId ? byId.get(inv.defaultId) : null;
+      if (sys) return out(sys, inv.defaultSource || "default");
+      if (list.length === 1) return out(list[0], "only-installed");
+      if (list.length > 1) return out(rankCandidates(list)[0], "candidate-rank");
+      return out(null, "none-found");
+    }
+    function snapshotPath() {
+      return path2.join(stateRoot2.supervisorDir(), FILE_NAME);
+    }
+    function readSnapshot() {
+      try {
+        const doc = JSON.parse(fs2.readFileSync(snapshotPath(), "utf8"));
+        return doc && doc.schema === SCHEMA ? doc : null;
+      } catch {
+        return null;
+      }
+    }
+    var _formCache = null;
+    function form(o) {
+      const ov = o || {};
+      const now = typeof ov.now === "function" ? ov.now : (() => Date.now());
+      const stamp = now();
+      const ttl = ov.ttlMs === void 0 ? FORM_TTL_MS : ov.ttlMs;
+      if (!ov.force && _formCache && stamp - _formCache.at < ttl) {
+        return Object.assign({}, _formCache.value, { cached: true });
+      }
+      const inv = browsers(ov);
+      const caps = capabilities();
+      const session = desktop.describe();
+      const prefId = preferenceId();
+      const prefEntry = prefId ? inv.browsers.find((b) => b.id === prefId) || null : null;
+      const preference = {
+        id: prefId,
+        configured: !!prefId,
+        matched: !!prefEntry,
+        browser: prefEntry ? { id: prefEntry.id, name: prefEntry.name, engine: prefEntry.engine } : null,
+        reason: !prefId ? "not-set" : prefEntry ? "matched" : "stale"
+      };
+      const pick = pickLauncher(inv.platform, inv, prefId);
+      const probed = inv.probed.map((p) => ({ section: "browsers", source: p.source, detail: p.detail }));
+      probed.push({ section: "session", source: "desktop", detail: session.reason + (session.available ? "\uFF08\u53EF\u7528\uFF09" : "\uFF08\u4E0D\u53EF\u7528\uFF09") });
+      probed.push({
+        section: "capabilities",
+        source: "profile",
+        detail: caps ? "openBrowser=" + (caps.openBrowser === true) : "\u672A\u7ED1\u5B9A\u80FD\u529B\u77E9\u9635\uFF08\u7531 platform/os/index.js \u88C5\u914D\u671F\u6CE8\u5165\uFF09"
+      });
+      probed.push({
+        section: "preference",
+        source: "config",
+        detail: preference.reason === "not-set" ? "\u672A\u8BBE\u7F6E\uFF0C\u6309\u7CFB\u7EDF\u9ED8\u8BA4\u6216\u5019\u9009\u6B21\u5E8F\u5206\u53D1" : preference.reason === "matched" ? "\u5DF2\u9009 " + preference.browser.name : "\u504F\u597D\u6240\u6307\u5DF2\u4E0D\u5728\u5019\u9009\u6E05\u5355: " + prefId
+      });
+      probed.push({
+        section: "pick",
+        source: "form",
+        detail: pick.how + (pick.browser ? "\uFF08" + pick.browser.name + "\uFF09" : "\uFF08\u65E0\u5019\u9009\uFF09") + (pick.stale ? "\uFF0C\u504F\u597D\u5DF2\u5931\u6548\u9700\u91CD\u9009" : "")
+      });
+      const value = {
+        schema: SCHEMA,
+        at: stamp,
+        platform: inv.platform,
+        identity: identity(),
+        paths: paths(),
+        session,
+        capabilities: caps,
+        preference,
+        default: inv.defaultId ? { id: inv.defaultId, source: inv.defaultSource } : null,
+        browsers: inv.browsers,
+        pick: { how: pick.how, id: pick.browser ? pick.browser.id : null, name: pick.browser ? pick.browser.name : null, wanted: pick.wanted, stale: pick.stale },
+        probed
+      };
+      const snapshot = { path: snapshotPath(), written: false, error: null };
+      if (ov.persist === true) {
+        try {
+          writeAtomic(snapshot.path, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+          snapshot.written = true;
+        } catch (e) {
+          snapshot.error = String(e && e.message || e);
+        }
+        probed.push({
+          section: "snapshot",
+          source: FILE_NAME,
+          detail: snapshot.written ? "\u5DF2\u843D\u76D8 " + snapshot.path : "\u843D\u76D8\u5931\u8D25: " + snapshot.error
+        });
+      }
+      value.snapshot = snapshot;
+      _formCache = { at: stamp, value };
+      return Object.assign({ cached: false }, value);
+    }
+    function invalidate(platform) {
+      _formCache = null;
+      return detector.invalidate(platform);
+    }
+    function checkPreference(value, form2) {
+      const candidates = (form2 && form2.browsers || []).map((b) => ({
+        id: b.id,
+        name: b.name,
+        engine: b.engine,
+        isDefault: b.isDefault === true
+      }));
+      const id = typeof value === "string" ? value.trim() : "";
+      if (!id) return { ok: true, id: null, browser: null, candidates };
+      const hit = candidates.find((c) => c.id === id);
+      if (!hit) {
+        return { ok: false, id: null, browser: null, candidates, error: "\u8BE5\u6D4F\u89C8\u5668\u4E0D\u5728\u672C\u673A\u5019\u9009\u6E05\u5355\u91CC\uFF08\u53EF\u80FD\u5DF2\u5378\u8F7D\u6216\u8DEF\u5F84\u5931\u6548\uFF09\uFF0C\u8BF7\u5148\u5237\u65B0\u73AF\u5883\u8868\u5355" };
+      }
+      return { ok: true, id: hit.id, browser: hit, candidates };
+    }
+    module2.exports = {
+      SCHEMA,
+      FILE_NAME,
+      FORM_TTL_MS,
+      bind,
+      preferenceId,
+      capabilities,
+      identity,
+      paths,
+      browsers,
+      normalizeInventory,
+      rankCandidates,
+      pickLauncher,
+      checkPreference,
+      form,
+      snapshotPath,
+      readSnapshot,
+      invalidate
+    };
+  }
+});
+
 // src/platform/os/process.js
 var require_process = __commonJS({
   "src/platform/os/process.js"(exports2, module2) {
@@ -5456,14 +6302,15 @@ var require_notify = __commonJS({
 var require_browser = __commonJS({
   "src/platform/os/browser.js"(exports2, module2) {
     "use strict";
-    var fs2 = require("node:fs");
     var path2 = require("node:path");
-    var os2 = require("node:os");
     var spawnOS = require_spawn();
     var desktop = require_desktop();
     var CAPABILITY_PROFILES = require_capability_profile();
     var { resolveExecutable, isExecutableFile } = require_exec_path();
-    var exec = require_exec();
+    var environment = require_environment();
+    var detector = require_browser_inventory();
+    var { engineOf } = detector;
+    var { allocTempDir, removeTreeDeferred } = require_fs();
     function isSafeHttpUrl(url) {
       try {
         const u = new URL(String(url));
@@ -5475,7 +6322,7 @@ var require_browser = __commonJS({
     function openCommand(platform, url) {
       const pl = platform || process.platform;
       if (pl === "darwin") return { cmd: "open", args: [url] };
-      if (pl === "win32") return { cmd: "explorer.exe", args: [url] };
+      if (pl === "win32") return null;
       return { cmd: "xdg-open", args: [url] };
     }
     var SUPPORTED_OPEN_PLATFORMS = Object.keys(CAPABILITY_PROFILES).filter((k) => CAPABILITY_PROFILES[k].openBrowser === true);
@@ -5499,7 +6346,7 @@ var require_browser = __commonJS({
     var HANDEDOFF_TEXT = "\u5DF2\u628A\u5730\u5740\u4EA4\u7ED9\u7CFB\u7EDF\uFF0C\u4F46\u8FD9\u6B21\u542F\u52A8\u62FF\u4E0D\u5230\u7A97\u53E3\u662F\u5426\u51FA\u73B0\u7684\u8BC1\u636E";
     var FAILURE_TEXT = {
       "unsafe-url": "\u5730\u5740\u4E0D\u662F http(s) \u7EDD\u5BF9 URL\uFF0C\u5DF2\u62D2\u7EDD\u4EA4\u7ED9\u6D4F\u89C8\u5668",
-      "no-launcher": "\u672A\u627E\u5230\u53EF\u7528\u7684\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740",
+      "no-launcher": "\u672C\u673A\u672A\u63A2\u5230\u53EF\u542F\u52A8\u7684\u6D4F\u89C8\u5668\uFF08\u6216\u6240\u9009\u6D4F\u89C8\u5668\u5DF2\u4E0D\u53EF\u6267\u884C\uFF09\uFF0C\u8BF7\u5728\u9762\u677F\u7684\u73AF\u5883\u8868\u5355\u91CC\u786E\u8BA4\uFF0C\u6216\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740",
       "spawn-failed": "\u6D4F\u89C8\u5668\u542F\u52A8\u5931\u8D25\uFF08\u7CFB\u7EDF\u62D2\u7EDD\u4E86\u8BE5\u547D\u4EE4\uFF09",
       "exit-nonzero": "\u7CFB\u7EDF\u62D2\u7EDD\u4E86\u8FD9\u4E2A\u5730\u5740\uFF08\u542F\u52A8\u547D\u4EE4\u975E 0 \u9000\u51FA\uFF09\uFF0C\u7A97\u53E3\u672A\u51FA\u73B0",
       "killed-by-signal": "\u6D4F\u89C8\u5668\u542F\u52A8\u547D\u4EE4\u88AB\u7CFB\u7EDF\u7EC8\u6B62\uFF0C\u7A97\u53E3\u672A\u51FA\u73B0",
@@ -5507,19 +6354,128 @@ var require_browser = __commonJS({
       "unsupported-platform": "\u5F53\u524D\u5E73\u53F0\u4E0D\u5728\u4EA7\u54C1\u652F\u6301\u7684\u684C\u9762\u5E73\u53F0\u5185\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u8BE5\u5730\u5740"
     };
     function ownsItsWindow(via, platform) {
+      if (via === "isolated") return true;
       if (via !== "dispatcher") return false;
       return platform !== "win32";
     }
+    function formOfBin(pl, b) {
+      const engine = b && b.bin ? engineOf(b.bin) : "other";
+      return { engine, direct: !!b && (engine !== "other" || pl === "win32") };
+    }
     function openPlan(platform, url, opts) {
       const o = opts || {};
       const pl = platform || process.platform;
-      const db = o.defaultBrowser;
-      const engine = db && db.bin ? engineOf(db.bin) : "other";
-      if (engine === "chromium" || engine === "firefox") {
-        return { bin: db.bin, engine, via: "browser", baseArgs: (db.baseArgs || []).concat([url]), exitIsEvidence: ownsItsWindow("browser", pl) };
+      const picked = o.pick || environment.pickLauncher(pl, o.inventory, o.preference);
+      const b = picked.browser;
+      const form = formOfBin(pl, b);
+      if (form.direct) {
+        return {
+          bin: b.bin,
+          args: (b.baseArgs || []).concat([url]),
+          engine: form.engine,
+          via: "browser",
+          isolated: false,
+          watch: false,
+          envKind: "sys",
+          pick: picked.how,
+          stale: picked.stale === true,
+          exitIsEvidence: ownsItsWindow("browser", pl)
+        };
+      }
+      const c = openCommand(pl, url);
+      if (!c) return {
+        bin: null,
+        args: [url],
+        engine: form.engine,
+        via: "none",
+        isolated: false,
+        watch: false,
+        envKind: "sys",
+        pick: picked.how,
+        stale: picked.stale === true,
+        exitIsEvidence: false
+      };
+      return {
+        bin: c.cmd,
+        args: c.args,
+        engine: "other",
+        via: "dispatcher",
+        isolated: false,
+        watch: false,
+        envKind: "sys",
+        pick: picked.how,
+        stale: picked.stale === true,
+        exitIsEvidence: ownsItsWindow("dispatcher", pl)
+      };
+    }
+    function isolatedPlan(platform, url, opts) {
+      const o = opts || {};
+      const pl = platform || process.platform;
+      const picked = o.pick || environment.pickLauncher(pl, o.inventory, o.preference);
+      const b = picked.browser;
+      const form = formOfBin(pl, b);
+      const baseArgs = b && b.baseArgs || [];
+      const common = { pick: picked.how, stale: picked.stale === true, engine: form.engine };
+      const plain = (bin, label) => Object.assign(common, {
+        bin,
+        args: baseArgs.concat([url]),
+        via: "browser",
+        isolated: false,
+        watch: false,
+        envKind: "sys",
+        label,
+        exitIsEvidence: ownsItsWindow("browser", pl)
+      });
+      if (form.direct && form.engine === "chromium" && o.profileDir) {
+        const args = ["--incognito", "--user-data-dir=" + o.profileDir];
+        if (Array.isArray(o.size) && o.size.length === 2) args.push("--window-size=" + o.size[0] + "," + o.size[1]);
+        if (o.lang) args.push("--lang=" + o.lang);
+        args.push("--no-first-run", "--no-default-browser-check", "--disable-session-crashed-bubble");
+        return Object.assign(common, {
+          bin: b.bin,
+          args: [...baseArgs, ...args, url],
+          via: "isolated",
+          isolated: true,
+          watch: true,
+          envKind: "anti",
+          label: "chromium",
+          exitIsEvidence: ownsItsWindow("isolated", pl)
+        });
       }
+      if (form.direct && form.engine === "firefox" && o.profileDir) {
+        return Object.assign(common, {
+          bin: b.bin,
+          args: [...baseArgs, "--no-remote", "--profile", o.profileDir, "-private-window", url],
+          via: "isolated",
+          isolated: true,
+          watch: true,
+          envKind: "anti",
+          label: "firefox",
+          exitIsEvidence: ownsItsWindow("isolated", pl)
+        });
+      }
+      if (form.direct) return plain(b.bin, path2.basename(b.bin));
       const c = openCommand(pl, url);
-      return { bin: c.cmd, engine: "other", via: "dispatcher", baseArgs: c.args, exitIsEvidence: ownsItsWindow("dispatcher", pl) };
+      if (!c) return Object.assign(common, {
+        bin: null,
+        args: [url],
+        via: "none",
+        isolated: false,
+        watch: false,
+        envKind: "sys",
+        label: null,
+        exitIsEvidence: false
+      });
+      return Object.assign(common, {
+        bin: c.cmd,
+        args: c.args,
+        via: "dispatcher",
+        isolated: false,
+        watch: false,
+        envKind: "sys",
+        label: c.cmd,
+        exitIsEvidence: ownsItsWindow("dispatcher", pl)
+      });
     }
     function observeSpawn(child, windowMs, setTimeoutFn) {
       return new Promise((resolve) => {
@@ -5531,63 +6487,40 @@ var require_browser = __commonJS({
           clearTimeout(timer);
           resolve(r);
         };
-        timer = (setTimeoutFn || setTimeout)(() => done({ stage: "alive" }), windowMs);
-        if (timer && timer.unref) timer.unref();
-        child.on("error", (e) => done({ stage: "error", code: e && e.code || String(e) }));
-        child.on("exit", (code, signal) => done({ stage: "exit", code, signal }));
-      });
-    }
-    var OPEN_OBSERVE_MS = 1500;
-    async function openBrowser(url, o) {
-      const opts = o || {};
-      const pl = opts.platform || process.platform;
-      if (!isSafeHttpUrl(url)) {
-        return outcome({ ok: false, reason: "unsafe-url", url: String(url || ""), evidence: null });
-      }
-      if (!SUPPORTED_OPEN_PLATFORMS.includes(pl)) {
-        return outcome({ ok: false, reason: "unsupported-platform", url, evidence: { platform: pl } });
-      }
-      const observeMs = opts.observeMs === void 0 ? OPEN_OBSERVE_MS : opts.observeMs;
-      const spawnWith = typeof opts.spawn === "function" ? opts.spawn : _spawnDetachedIgnored;
-      const avail = typeof opts.binAvailable === "function" ? opts.binAvailable : binAvailable;
-      const observe = typeof opts.observe === "function" ? opts.observe : observeSpawn;
-      let db;
-      if ("defaultBrowser" in opts) db = opts.defaultBrowser;
-      else if (typeof opts.resolveDefault === "function") db = opts.resolveDefault(pl, opts.resolveDeps || {});
-      else db = resolveDefaultBrowser(pl, opts.resolveDeps || {});
-      const plan = openPlan(pl, url, { defaultBrowser: db });
-      const evidence = { bin: plan.bin, engine: plan.engine, via: plan.via, ownsWindow: plan.exitIsEvidence === true, exitCode: null, exitSignal: null, error: null };
-      const desktopAvailable = typeof opts.desktopAvailable === "function" ? opts.desktopAvailable : desktop.sessionAvailable;
-      if (pl === "linux" && !desktopAvailable()) {
-        return outcome({ ok: false, reason: "no-desktop-session", url, evidence });
-      }
-      if (!avail(plan.bin)) {
-        return outcome({ ok: false, reason: "no-launcher", url, evidence });
-      }
-      let child;
-      try {
-        child = spawnWith(plan.bin, plan.baseArgs);
-      } catch (e) {
-        evidence.error = e && e.code || String(e);
-        return outcome({ ok: false, reason: "spawn-failed", url, evidence });
-      }
-      if (!child) return outcome({ ok: false, reason: "spawn-failed", url, evidence });
-      const seen = await observe(child, observeMs, opts.setTimeout);
-      evidence.error = seen.stage === "error" ? String(seen.code) : null;
-      evidence.exitCode = seen.code === void 0 ? null : seen.code;
-      evidence.exitSignal = seen.signal === void 0 ? null : seen.signal;
-      if (seen.stage === "error") return outcome({ ok: false, reason: "spawn-failed", url, evidence });
-      const exitDecides = seen.stage === "exit" && plan.exitIsEvidence === true;
-      if (exitDecides && (seen.code !== 0 || seen.signal)) {
-        return outcome({
-          ok: false,
-          reason: seen.signal ? "killed-by-signal" : "exit-nonzero",
-          url,
-          evidence,
-          error: FAILURE_TEXT[seen.signal ? "killed-by-signal" : "exit-nonzero"] + "\uFF08" + (seen.signal || seen.code) + "\uFF09"
-        });
-      }
-      return outcome({ ok: true, confirmed: exitDecides, handedOff: !exitDecides, url, evidence });
+        timer = (setTimeoutFn || setTimeout)(() => done({ stage: "alive" }), windowMs);
+        if (timer && timer.unref) timer.unref();
+        child.on("error", (e) => done({ stage: "error", code: e && e.code || String(e) }));
+        child.on("exit", (code, signal) => done({ stage: "exit", code, signal }));
+      });
+    }
+    var OPEN_OBSERVE_MS = 1500;
+    var LOGIN_TZ_POOL = ["Asia/Shanghai", "Asia/Seoul", "Asia/Tokyo", "Asia/Singapore", "Europe/Berlin", "Europe/London", "Europe/Paris", "America/New_York", "America/Los_Angeles", "Australia/Sydney"];
+    var LOGIN_LANG_POOL = ["zh-CN", "en-US", "en-GB", "ja-JP", "ko-KR", "de-DE", "fr-FR", "zh-TW"];
+    var LOGIN_SIZE_POOL = [[1280, 800], [1366, 768], [1440, 900], [1536, 864], [1600, 900], [1680, 1050], [1920, 1080], [1024, 768], [1152, 864], [1280, 720]];
+    function loginEnv(rand) {
+      const pick = (arr) => arr[Math.floor((typeof rand === "function" ? rand() : Math.random()) * arr.length)];
+      const size = pick(LOGIN_SIZE_POOL);
+      const lang = pick(LOGIN_LANG_POOL);
+      const tz = pick(LOGIN_TZ_POOL);
+      const sysEnv = Object.assign({}, process.env, desktop.sessionEnv());
+      return { size, lang, sysEnv, antiEnv: Object.assign({}, sysEnv, { TZ: tz, LANG: lang }) };
+    }
+    function launchDiagnostics(inv, plan, picked) {
+      const found = (inv && inv.browsers || []).map((b) => ({
+        name: b.name,
+        engine: b.engine || engineOf(b.bin),
+        via: (b.sources && b.sources.length ? b.sources : [b.source || "unknown"]).join("+")
+      }));
+      const pk = picked || {};
+      return {
+        platform: inv && inv.platform || null,
+        pick: pk.how || plan && plan.pick || "none",
+        bin: plan && plan.bin || null,
+        default: inv && inv.defaultId ? { id: inv.defaultId, source: inv.defaultSource || null } : null,
+        preference: pk.wanted ? { id: pk.wanted, matched: pk.stale !== true } : null,
+        found,
+        probed: inv && inv.probed || []
+      };
     }
     function _spawnDetachedIgnored(bin, args) {
       try {
@@ -5618,232 +6551,112 @@ var require_browser = __commonJS({
       child.unref();
       return child;
     }
-    function engineOf(bin) {
-      const base = String(bin || "").toLowerCase().split(/[\\/]/).pop();
-      if (/(chrome|chromium|msedge|edge|brave|vivaldi|opera|thorium)/.test(base)) return "chromium";
-      if (/(firefox|librewolf|waterfox)/.test(base)) return "firefox";
-      return "other";
-    }
-    function tokenizeExec(line) {
-      const toks = [];
-      let cur = "";
-      let q = null;
-      let esc = false;
-      let has = false;
-      for (const ch of String(line)) {
-        if (esc) {
-          cur += ch;
-          esc = false;
-          continue;
-        }
-        if (ch === "\\") {
-          esc = true;
-          has = true;
-          continue;
-        }
-        if (q) {
-          if (ch === q) q = null;
-          else cur += ch;
-          continue;
-        }
-        if (ch === "'" || ch === '"') {
-          q = ch;
-          has = true;
-          continue;
-        }
-        if (/\s/.test(ch)) {
-          if (has) {
-            toks.push(cur);
-            cur = "";
-            has = false;
-          }
-          continue;
-        }
-        cur += ch;
-        has = true;
-      }
-      if (has) toks.push(cur);
-      return toks;
-    }
-    function parseExecLine(line) {
-      let toks = tokenizeExec(line).filter((t) => t !== "%%" && !/^%[a-zA-Z]$/.test(t));
-      if (toks[0] === "env") {
-        let i = 1;
-        while (i < toks.length && /=/.test(toks[i])) i++;
-        toks = toks.slice(i);
-      }
-      if (!toks.length) return null;
-      return { bin: toks[0], baseArgs: toks.slice(1) };
-    }
-    function regValueOf(out) {
-      const m = String(out || "").match(/REG_SZ\s+(.*)/);
-      return m ? m[1].trim() : null;
-    }
-    function exeFromCmdLine(cmdLine) {
-      const s = String(cmdLine || "");
-      let m = s.match(/^\s*"([^"]+\.exe)"/i);
-      if (m) return m[1];
-      m = s.match(/^\s*(\S+\.exe)/i);
-      return m ? m[1] : null;
-    }
-    function resolveDefaultWin(runOut) {
-      const roots = ["HKCU\\Software\\Clients\\StartMenuInternet", "HKLM\\Software\\Clients\\StartMenuInternet"];
-      for (const root of roots) {
-        const progId = regValueOf(runOut("reg.exe", ["query", root, "/ve"]));
-        if (!progId || !/^[\x20-\x7e]+$/.test(progId)) continue;
-        for (const r2 of roots) {
-          const cmd2 = regValueOf(runOut("reg.exe", ["query", r2 + "\\" + progId + "\\shell\\open\\command", "/ve"]));
-          const bin = exeFromCmdLine(cmd2);
-          if (bin) return { bin, baseArgs: [] };
-        }
-      }
-      return null;
-    }
-    var MAC_JXA = [
-      "ObjC.import('CoreServices');ObjC.import('Foundation');",
-      "var b=ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme(null,'https'))||ObjC.unwrap($.LSCopyDefaultHandlerForURLScheme(null,'http'));",
-      "if(!b){'EMPTY';}else{",
-      "var u=$.NSWorkspace.workspace.URLForApplicationWithBundleIdentifier(b);",
-      "if(u.isNil()){'EMPTY';}else{",
-      "var e=ObjC.unwrap($.NSBundle.bundleWithURL(u).objectForInfoDictionaryKey('CFBundleExecutable'));",
-      "b+'\\t'+ObjC.unwrap(u.path)+'\\t'+e;}}"
-    ].join("");
-    function resolveDefaultMac(runOut) {
-      const out = runOut("osascript", ["-l", "JavaScript", "-e", MAC_JXA]);
-      if (!out) return null;
-      const parts = out.trim().split("	");
-      if (parts.length < 3 || parts[0] === "EMPTY" || !parts[2]) return null;
-      return { bin: path2.posix.join(parts[1], "Contents", "MacOS", parts[2]), baseArgs: [], bundleId: parts[0] };
-    }
-    function resolveDefaultLinux(runOut, readFile, exists, env, home) {
-      const id = runOut("xdg-settings", ["get", "default-web-browser"]);
-      const desktop2 = id && id.trim();
-      if (!desktop2 || !/^[A-Za-z0-9._-]+\.desktop$/.test(desktop2)) return null;
-      const dirs = [
-        env.XDG_DATA_HOME || path2.join(home, ".local", "share"),
-        "/usr/local/share",
-        "/usr/share",
-        "/var/lib/snapd/desktop"
-      ].map((d) => path2.join(d, "applications"));
-      for (const dir of dirs) {
-        const p = path2.join(dir, desktop2);
-        let text = null;
-        try {
-          if (exists(p)) text = readFile(p);
-        } catch {
-          continue;
-        }
-        if (text === null) continue;
-        let inMain = false;
-        for (const line of text.split(/\r?\n/)) {
-          if (/^\[Desktop Entry\]\s*$/.test(line)) {
-            inMain = true;
-            continue;
-          }
-          if (/^\[/.test(line)) break;
-          if (inMain) {
-            const m = line.match(/^Exec=(.+)/);
-            if (m) return parseExecLine(m[1]);
-          }
-        }
-      }
-      return null;
-    }
-    function resolveDefaultBrowser(platform, o) {
-      const ov = o || {};
-      const pl = platform || process.platform;
-      const runOut = ov.runOut || ((bin, args) => exec.runOut(bin, args, { timeoutMs: 5e3 }));
-      const readFile = ov.readFile || ((p) => fs2.readFileSync(p, "utf8"));
-      const exists = ov.exists || ((p) => fs2.existsSync(p));
-      const env = ov.env || process.env;
-      const home = ov.home || os2.homedir();
-      try {
-        if (pl === "win32") return resolveDefaultWin(runOut);
-        if (pl === "darwin") return resolveDefaultMac(runOut);
-        return resolveDefaultLinux(runOut, readFile, exists, env, home);
-      } catch {
-        return null;
-      }
-    }
-    function isolatedPlan(platform, url, opts) {
-      const o = opts || {};
-      const pl = platform || process.platform;
-      const db = o.defaultBrowser;
-      const engine = db && db.bin ? engineOf(db.bin) : "other";
-      const baseArgs = db && db.baseArgs || [];
-      if (engine === "chromium" && o.profileDir) {
-        const args = ["--incognito", "--user-data-dir=" + o.profileDir];
-        if (Array.isArray(o.size) && o.size.length === 2) args.push("--window-size=" + o.size[0] + "," + o.size[1]);
-        if (o.lang) args.push("--lang=" + o.lang);
-        args.push("--no-first-run", "--no-default-browser-check", "--disable-session-crashed-bubble");
-        return { bin: db.bin, args: [...baseArgs, ...args, url], isolated: true, watch: true, envKind: "anti", label: "chromium" };
-      }
-      if (engine === "firefox" && o.profileDir) {
-        return {
-          bin: db.bin,
-          args: [...baseArgs, "--no-remote", "--profile", o.profileDir, "-private-window", url],
-          isolated: true,
-          watch: true,
-          envKind: "anti",
-          label: "firefox"
-        };
-      }
-      const c = openCommand(pl, url);
-      return { bin: c.cmd, args: c.args, isolated: false, watch: false, envKind: "sys", label: c.cmd };
-    }
     function binAvailable(bin) {
       if (!bin) return false;
       if (bin.includes("/") || bin.includes("\\") || /^[A-Za-z]:[\\/]/.test(bin)) return isExecutableFile(bin);
       return resolveExecutable(bin) !== null;
     }
-    function launchIsolated(url, o) {
+    async function openBrowser(url, o) {
       const opts = o || {};
-      if (!isSafeHttpUrl(url)) return Object.assign(outcome({ ok: false, reason: "unsafe-url", url: String(url || "") }), { bin: null, isolated: false });
-      const antiEnv = opts.antiEnv || opts.sysEnv || process.env;
-      const sysEnv = opts.sysEnv || process.env;
-      const onExit = opts.onExit;
+      const pl = opts.platform || process.platform;
+      const intent = opts.intent === "isolated-login" ? "isolated-login" : "plain";
+      if (!isSafeHttpUrl(url)) {
+        return outcome({ ok: false, reason: "unsafe-url", url: String(url || ""), evidence: null });
+      }
+      if (!SUPPORTED_OPEN_PLATFORMS.includes(pl)) {
+        return outcome({ ok: false, reason: "unsupported-platform", url, evidence: { platform: pl } });
+      }
+      const observeMs = opts.observeMs === void 0 ? OPEN_OBSERVE_MS : opts.observeMs;
+      const spawnWith = typeof opts.spawn === "function" ? opts.spawn : intent === "isolated-login" ? _spawnDetached : _spawnDetachedIgnored;
       const avail = typeof opts.binAvailable === "function" ? opts.binAvailable : binAvailable;
-      const spawnWith = typeof opts.spawn === "function" ? opts.spawn : _spawnDetached;
-      const fail = (reason, extra) => Object.assign(outcome(Object.assign({ ok: false, reason, url }, extra)), { bin: null, isolated: false });
+      const observe = typeof opts.observe === "function" ? opts.observe : observeSpawn;
+      const resolveInv = typeof opts.resolveInventory === "function" ? opts.resolveInventory : ((platform, deps) => environment.browsers(Object.assign({ platform }, deps)));
+      const inv = "inventory" in opts ? opts.inventory : resolveInv(pl, opts.resolveDeps || {});
+      const pref = "preference" in opts ? opts.preference : void 0;
+      const login = intent === "isolated-login" ? loginEnv(opts.rand) : null;
+      const picked = opts.pick || environment.pickLauncher(pl, inv, pref);
+      const form = formOfBin(pl, picked.browser);
+      const canIsolate = intent === "isolated-login" && form.direct && (form.engine === "chromium" || form.engine === "firefox");
+      let profile = null;
+      if (canIsolate) {
+        const alloc = typeof opts.allocProfile === "function" ? opts.allocProfile : (() => allocTempDir("dsh-login-"));
+        try {
+          profile = opts.profileDir || alloc();
+        } catch {
+          profile = null;
+        }
+      }
+      const plan = intent === "isolated-login" ? isolatedPlan(pl, url, { inventory: inv, pick: picked, profileDir: profile, size: login.size, lang: login.lang }) : openPlan(pl, url, { inventory: inv, pick: picked });
+      const diagnostics = launchDiagnostics(inv, plan, picked);
+      const evidence = {
+        bin: plan.bin,
+        engine: plan.engine,
+        via: plan.via,
+        ownsWindow: plan.exitIsEvidence === true,
+        isolated: plan.isolated === true,
+        profile: plan.isolated ? profile : null,
+        watch: plan.watch === true,
+        exitCode: null,
+        exitSignal: null,
+        error: null,
+        diagnostics
+      };
+      const deferredRemove = typeof opts.rmTree === "function" ? opts.rmTree : removeTreeDeferred;
+      const fail = (reason, patch) => {
+        if (profile) deferredRemove(profile, 0);
+        return outcome(Object.assign({ ok: false, reason, url, evidence }, patch));
+      };
+      const desktopAvailable = typeof opts.desktopAvailable === "function" ? opts.desktopAvailable : desktop.sessionAvailable;
+      if (pl === "linux" && !desktopAvailable()) {
+        return fail("no-desktop-session");
+      }
+      if (!plan.bin) return fail("no-launcher");
+      if (!avail(plan.bin)) return fail("no-launcher");
+      if (canIsolate && !profile) {
+        evidence.error = "\u4E34\u65F6 profile \u76EE\u5F55\u5206\u914D\u5931\u8D25";
+        return fail("spawn-failed");
+      }
+      let child;
       try {
-        let db;
-        if ("defaultBrowser" in opts) db = opts.defaultBrowser;
-        else if (typeof opts.resolveDefault === "function") db = opts.resolveDefault(process.platform, opts.resolveDeps || {});
-        else db = resolveDefaultBrowser(process.platform, opts.resolveDeps || {});
-        const plan = isolatedPlan(process.platform, url, {
-          defaultBrowser: db,
-          profileDir: opts.profileDir,
-          size: opts.size,
-          lang: opts.lang
-        });
-        if (!avail(plan.bin)) return fail("no-launcher", { evidence: { bin: plan.bin, engine: plan.label, via: plan.isolated ? "browser" : "dispatcher" } });
-        const env = plan.envKind === "anti" ? antiEnv : sysEnv;
-        const p = spawnWith(plan.bin, plan.args, env, plan.watch ? onExit : void 0);
-        if (!p) return fail("spawn-failed");
-        return Object.assign(outcome({ ok: true, confirmed: false, handedOff: true, url }), { bin: plan.label, isolated: plan.isolated });
+        child = intent === "isolated-login" ? spawnWith(plan.bin, plan.args, plan.envKind === "anti" ? login.antiEnv : login.sysEnv, plan.watch ? opts.onExit : void 0) : spawnWith(plan.bin, plan.args);
       } catch (e) {
-        return fail("spawn-failed", { error: FAILURE_TEXT["spawn-failed"] + "\uFF08" + (e && e.code || e) + "\uFF09" });
+        evidence.error = e && e.code || String(e);
+        return fail("spawn-failed");
+      }
+      if (!child) return fail("spawn-failed");
+      if (evidence.profile) deferredRemove(evidence.profile, opts.profileMs === void 0 ? 30 * 60 * 1e3 : opts.profileMs);
+      const seen = await observe(child, observeMs, opts.setTimeout);
+      evidence.error = seen.stage === "error" ? String(seen.code) : null;
+      evidence.exitCode = seen.code === void 0 ? null : seen.code;
+      evidence.exitSignal = seen.signal === void 0 ? null : seen.signal;
+      if (seen.stage === "error") return outcome({ ok: false, reason: "spawn-failed", url, evidence });
+      const exitDecides = seen.stage === "exit" && plan.exitIsEvidence === true;
+      if (exitDecides && (seen.code !== 0 || seen.signal)) {
+        return outcome({
+          ok: false,
+          reason: seen.signal ? "killed-by-signal" : "exit-nonzero",
+          url,
+          evidence,
+          error: FAILURE_TEXT[seen.signal ? "killed-by-signal" : "exit-nonzero"] + "\uFF08" + (seen.signal || seen.code) + "\uFF09"
+        });
       }
+      return outcome({ ok: true, confirmed: exitDecides, handedOff: !exitDecides, url, evidence });
     }
     module2.exports = {
       openBrowser,
-      launchIsolated,
       openCommand,
       openPlan,
-      ownsItsWindow,
       isolatedPlan,
+      ownsItsWindow,
       observeSpawn,
       isSafeHttpUrl,
-      resolveDefaultBrowser,
-      resolveDefaultWin,
-      resolveDefaultMac,
-      resolveDefaultLinux,
+      binAvailable,
+      launchDiagnostics,
+      loginEnv,
+      // 探测层的解析原语经此转出（唯一实现处在 ./browser-inventory.js）：门禁与消费方按同一出口取用，
+      //   不在别处再写第二份平台解析。
       engineOf,
-      parseExecLine,
-      tokenizeExec,
-      regValueOf,
-      exeFromCmdLine,
-      binAvailable
+      detector
     };
   }
 });
@@ -6196,6 +7009,7 @@ var require_os = __commonJS({
     var execPath = require_exec_path();
     var desktop = require_desktop();
     var CAPABILITY_PROFILES = require_capability_profile();
+    var environment = require_environment();
     var PLATFORM = process.platform;
     var ARCH = process.arch;
     var isLinux = PLATFORM === "linux";
@@ -6250,6 +7064,7 @@ var require_os = __commonJS({
       }
       return p;
     }
+    environment.bind({ capabilities });
     module2.exports = {
       PLATFORM,
       ARCH,
@@ -6273,6 +7088,8 @@ var require_os = __commonJS({
       // 导出模块对象会抛 platform.notify is not a function，把升级终态误判成失败。
       notify: require_notify().notify,
       browser: require_browser(),
+      environment,
+      // 环境表单（外部打开链路的事实底座 + 选路依据）
       desktop,
       // 图形会话可用性（Linux 需实测 socket）
       autostart: require_autostart()
@@ -12391,6 +13208,60 @@ var require_access = __commonJS({
   }
 });
 
+// src/app/settings/browser.js
+var require_browser2 = __commonJS({
+  "src/app/settings/browser.js"(exports2, module2) {
+    "use strict";
+    var platform = require_os();
+    var { verifyPersisted } = require_access();
+    module2.exports = {
+      methods: {
+        /** 当前偏好 + 候选清单 + 这一拍的分发依据（面板据此渲染选择器并说明「现在实际会用谁」）。 */
+        externalBrowserStatus() {
+          try {
+            const form = platform.environment.form();
+            const v = platform.environment.checkPreference(platform.environment.preferenceId(), form);
+            return {
+              ok: true,
+              configured: !!form.preference && form.preference.configured === true,
+              value: form.preference && form.preference.id || null,
+              // stale=true：偏好所指已不在候选清单（被卸载/路径失效），本次分发已回落，需用户重选。
+              stale: !!(form.pick && form.pick.stale),
+              browser: v.browser,
+              candidates: v.candidates,
+              pick: form.pick || null,
+              platform: form.platform
+            };
+          } catch (e) {
+            return { ok: false, error: e.message };
+          }
+        },
+        /** 设置/清除浏览器偏好（空串=清除，回到「按系统默认或候选次序分发」）。 */
+        setExternalBrowser(id) {
+          try {
+            const form = platform.environment.form();
+            const v = platform.environment.checkPreference(id, form);
+            if (!v.ok) return { ok: false, error: v.error };
+            const cfg = this.config || {};
+            cfg.externalBrowser = v.id;
+            const patch = { externalBrowser: v.id };
+            if (this.configPath) {
+              this.state.persistConfigPatch(patch);
+              const persistError = verifyPersisted(this.configPath, patch);
+              if (persistError) return { ok: false, error: persistError };
+            }
+            platform.environment.invalidate();
+            if (this.events) this.events.append("external_browser_changed", { id: v.id, name: v.browser ? v.browser.name : null });
+            return { ok: true, configured: !!v.id, value: v.id, browser: v.browser };
+          } catch (e) {
+            return { ok: false, error: e.message };
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/platform/os/netinfo.js
 var require_netinfo = __commonJS({
   "src/platform/os/netinfo.js"(exports2, module2) {
@@ -12608,6 +13479,7 @@ var require_facets = __commonJS({
       { name: "settings/node-lts", mod: require_node_lts() },
       { name: "settings/versions", mod: require_versions() },
       { name: "settings/access", mod: require_access() },
+      { name: "settings/browser", mod: require_browser2() },
       { name: "settings/lan-panel", mod: require_lan_panel() }
     ];
     function installMethods(host2, methods) {
@@ -14150,6 +15022,7 @@ var require_core5 = __commonJS({
     function composeCore(host2, rawConfig, configPath) {
       host2.config = normalize(rawConfig, domainConfigExtension2());
       host2.configPath = typeof configPath === "string" ? configPath : null;
+      platform.environment.bind({ preference: () => host2.config && host2.config.externalBrowser || null });
       host2._fileProtectStatus = null;
       try {
         const fp = platform.fileProtect;
@@ -17684,89 +18557,13 @@ var require_forward_core = __commonJS({
   }
 });
 
-// src/domains/router/ops/browser.js
-var require_browser2 = __commonJS({
-  "src/domains/router/ops/browser.js"(exports2, module2) {
-    "use strict";
-    var platform = require_os();
-    var fs2 = require("node:fs");
-    var os2 = require("node:os");
-    var path2 = require("node:path");
-    var crypto = require("node:crypto");
-    function graphicalEnv() {
-      const out = {};
-      try {
-        const uid = process.getuid ? String(process.getuid()) : "";
-        const xdgRun = process.env.XDG_RUNTIME_DIR || "/run/user/" + uid;
-        if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
-          const x11 = "/tmp/.X11-unix";
-          try {
-            if (fs2.existsSync(x11)) {
-              const socks = fs2.readdirSync(x11).filter((f) => /^X\d+$/.test(f)).map((f) => parseInt(f.slice(1), 10)).sort((a, b) => a - b);
-              if (socks.length > 0) {
-                out.DISPLAY = ":" + socks[0];
-                const xauth = path2.join(os2.homedir(), ".Xauthority");
-                if (fs2.existsSync(xauth)) out.XAUTHORITY = xauth;
-              }
-            }
-          } catch {
-          }
-          if (!out.DISPLAY) {
-            try {
-              if (fs2.existsSync(xdgRun)) {
-                const wl = fs2.readdirSync(xdgRun).filter((f) => f.startsWith("wayland-")).sort();
-                if (wl.length > 0) out.WAYLAND_DISPLAY = wl[0];
-              }
-            } catch {
-            }
-          }
-        }
-        if (!process.env.DBUS_SESSION_BUS_ADDRESS && fs2.existsSync(path2.join(xdgRun, "bus"))) {
-          out.DBUS_SESSION_BUS_ADDRESS = "unix:path=" + path2.join(xdgRun, "bus");
-        }
-      } catch {
-      }
-      return out;
-    }
-    function openInBrowser(url, onExit) {
-      try {
-        const tmpProfile = path2.join(os2.tmpdir(), "dsh-oauth-" + crypto.randomBytes(8).toString("hex"));
-        const sysEnv = Object.assign({}, process.env, graphicalEnv());
-        const TZ_POOL = ["Asia/Shanghai", "Asia/Seoul", "Asia/Tokyo", "Asia/Singapore", "Europe/Berlin", "Europe/London", "Europe/Paris", "America/New_York", "America/Los_Angeles", "Australia/Sydney"];
-        const LANG_POOL = ["zh-CN", "en-US", "en-GB", "ja-JP", "ko-KR", "de-DE", "fr-FR", "zh-TW"];
-        const SIZE_POOL = [[1280, 800], [1366, 768], [1440, 900], [1536, 864], [1600, 900], [1680, 1050], [1920, 1080], [1024, 768], [1152, 864], [1280, 720]];
-        const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
-        const size = pick(SIZE_POOL);
-        const lang = pick(LANG_POOL);
-        const tz = pick(TZ_POOL);
-        const antiEnv = Object.assign({}, sysEnv, { TZ: tz, LANG: lang });
-        const r = platform.browser.launchIsolated(url, { profileDir: tmpProfile, size, lang, antiEnv, sysEnv, onExit });
-        if (!r || !r.ok) return { profile: null, result: r || { ok: false, reason: "spawn-failed" } };
-        if (r.isolated) {
-          const t30 = setTimeout(() => {
-            try {
-              fs2.rmSync(tmpProfile, { recursive: true, force: true });
-            } catch {
-            }
-          }, 30 * 60 * 1e3);
-          if (t30.unref) t30.unref();
-        }
-        return { profile: tmpProfile, result: r };
-      } catch (e) {
-        return { profile: null, result: { ok: false, reason: "spawn-failed", error: "\u6D4F\u89C8\u5668\u542F\u52A8\u5931\u8D25\uFF1A" + (e && e.message || e) } };
-      }
-    }
-    module2.exports = { graphicalEnv, openInBrowser };
-  }
-});
-
 // src/domains/router/ops/oauth.js
 var require_oauth = __commonJS({
   "src/domains/router/ops/oauth.js"(exports2, module2) {
     "use strict";
-    var fs2 = require("node:fs");
     var crypto = require("node:crypto");
     var { createServer } = require("node:http");
+    var { removeTreeDeferred } = require_fs();
     function createOAuthOps(deps) {
       const d = deps || {};
       const ports = d.ports;
@@ -17931,20 +18728,21 @@ var require_oauth = __commonJS({
         promise.catch(() => {
         });
         st._ccLoginPromise = promise;
-        const opened = openInBrowser(authUrl, () => {
+        const opened = await openInBrowser(authUrl, () => {
           if (st._ccLoginRound !== roundId) return;
           if (st._ccLoginReject) {
-            const r = st._ccLoginReject;
+            const r2 = st._ccLoginReject;
             st._ccLoginReject = null;
             st._ccLoginResolve = null;
             try {
-              r(new Error("\u6D4F\u89C8\u5668\u5DF2\u5173\u95ED\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88"));
+              r2(new Error("\u6D4F\u89C8\u5668\u5DF2\u5173\u95ED\uFF0C\u767B\u5F55\u5DF2\u53D6\u6D88"));
             } catch {
             }
           }
         });
-        const evidence = opened.result || {};
-        if (!opened.profile) {
+        const r = opened || { ok: false, reason: "spawn-failed" };
+        const ev = r.evidence || {};
+        if (!r.ok) {
           st._ccLoginPromise = null;
           st._ccLoginResolve = null;
           st._ccLoginReject = null;
@@ -17964,12 +18762,13 @@ var require_oauth = __commonJS({
             opened: false,
             confirmed: false,
             handedOff: false,
-            reason: evidence.reason || "no-launcher",
-            error: (evidence.error || "\u65E0\u6CD5\u8C03\u8D77\u7CFB\u7EDF\u6D4F\u89C8\u5668") + "\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u4E0B\u65B9\u5730\u5740\u5B8C\u6210\u6388\u6743"
+            reason: r.reason || "no-launcher",
+            evidence: r.evidence || null,
+            error: (r.error || "\u65E0\u6CD5\u8C03\u8D77\u7CFB\u7EDF\u6D4F\u89C8\u5668") + "\uFF0C\u8BF7\u624B\u52A8\u6253\u5F00\u4E0B\u65B9\u5730\u5740\u5B8C\u6210\u6388\u6743"
           };
         }
-        st._ccLogin = { state, port, server, tmpProfile: opened.profile };
-        return Object.assign({}, evidence, {
+        st._ccLogin = { state, port, server, tmpProfile: ev.profile || null };
+        return Object.assign({}, r, {
           ok: true,
           authUrl,
           url: authUrl,
@@ -17977,8 +18776,8 @@ var require_oauth = __commonJS({
           port,
           waitMs: 18e4,
           opened: true,
-          // 非隔离引擎（Safari/snap 包装器）由平台层降级：账号隔离不成立，换账号只能靠超时重发或手动窗口。
-          isolated: evidence.isolated === true
+          // 非隔离引擎（Safari/打包器包装）由平台层降级：账号隔离不成立，换账号只能靠超时重发或手动窗口。
+          isolated: ev.isolated === true
         });
       }
       async function commandcodeLoginWait(timeoutMs) {
@@ -18024,15 +18823,7 @@ var require_oauth = __commonJS({
           st._ccLoginResolve = st._ccLoginReject = null;
           return { ok: false, error: e.message };
         } finally {
-          if (tmpProfile) {
-            const t60 = setTimeout(() => {
-              try {
-                fs2.rmSync(tmpProfile, { recursive: true, force: true });
-              } catch {
-              }
-            }, 60 * 1e3);
-            if (t60.unref) t60.unref();
-          }
+          if (tmpProfile) removeTreeDeferred(tmpProfile, 60 * 1e3);
         }
       }
       return { commandcodeLoginStart, commandcodeLoginWait };
@@ -18486,8 +19277,8 @@ var require_router_ops = __commonJS({
     "use strict";
     require_port_segments();
     var ports = require_ports().shared;
+    var platform = require_os();
     var { maskKey } = require_base();
-    var { openInBrowser } = require_browser2();
     var { createOAuthOps } = require_oauth();
     var { createAppsRegistryOps } = require_apps_registry();
     var { createQuotaSyncOps } = require_quotasync();
@@ -18495,6 +19286,7 @@ var require_router_ops = __commonJS({
     function createAuxCore(deps) {
       const d = deps || {};
       const getProviders = d.getProviders || (() => []);
+      const openInBrowser = (url, onExit) => platform.browser.openBrowser(url, { intent: "isolated-login", onExit });
       const oauth = createOAuthOps({ ports, openInBrowser });
       const apps = createAppsRegistryOps({
         getProviders,
@@ -25512,7 +26304,7 @@ var require_guard = __commonJS({
     var fs2 = require("node:fs");
     var path2 = require("node:path");
     function owns(pathname) {
-      return pathname === "/changelog" || pathname.startsWith("/guard/") || pathname === "/autostart" || pathname.startsWith("/settings/") || pathname.startsWith("/self-update/") || pathname === "/env/dsh" || pathname === "/env/status" || pathname === "/env/node-lts" || pathname === "/env/open-url" || pathname === "/ports" || pathname === "/shutdown";
+      return pathname === "/changelog" || pathname.startsWith("/guard/") || pathname === "/autostart" || pathname.startsWith("/settings/") || pathname.startsWith("/self-update/") || pathname === "/env/dsh" || pathname === "/env/status" || pathname === "/env/node-lts" || pathname === "/env/open-url" || pathname === "/env/environment" || pathname === "/ports" || pathname === "/shutdown";
     }
     function fetchDshChangelog(res, sup) {
       const v = sup && sup.nativeManager ? sup.nativeManager.versionInfo() : {};
@@ -25524,7 +26316,7 @@ var require_guard = __commonJS({
       return res.end(md);
     }
     function handle(ctx) {
-      const { sup, req, res, pathname, identity, send, collectBody, originAllowed, browser } = ctx;
+      const { sup, req, res, pathname, identity, send, collectBody, originAllowed, browser, environment } = ctx;
       if (req.method === "GET" && pathname === "/changelog") {
         return fetchDshChangelog(res, sup);
       }
@@ -25630,6 +26422,31 @@ var require_guard = __commonJS({
         });
         return;
       }
+      if (req.method === "GET" && pathname === "/settings/external-browser") {
+        return send(200, sup.externalBrowserStatus());
+      }
+      if (req.method === "POST" && pathname === "/settings/external-browser") {
+        if (!originAllowed(req, sup.config.apiPort)) {
+          req.resume();
+          return send(403, {});
+        }
+        collectBody(req, res, 2048, (body) => {
+          let id = null;
+          let given = false;
+          try {
+            const j = body ? JSON.parse(body) : {};
+            if (typeof j.id === "string") {
+              id = j.id;
+              given = true;
+            }
+          } catch {
+          }
+          if (!given) return send(400, { ok: false, error: '\u9700\u8981 {"id":"<\u5019\u9009 id>"}\uFF08\u7A7A\u4E32\u6E05\u9664\u504F\u597D\uFF09' });
+          const r = sup.setExternalBrowser(id);
+          return send(r.ok ? 200 : 500, r);
+        });
+        return;
+      }
       if (req.method === "POST" && pathname === "/shutdown") {
         if (!originAllowed(req, sup.config.apiPort)) {
           req.resume();
@@ -25688,6 +26505,14 @@ var require_guard = __commonJS({
       if (req.method === "GET" && pathname === "/env/node-lts") {
         return sup.nodeLtsStatus().then((r) => send(200, r)).catch((e) => send(500, { ok: false, error: e.message }));
       }
+      if (req.method === "GET" && pathname === "/env/environment") {
+        if (!originAllowed(req, sup.config.apiPort)) {
+          req.resume();
+          return send(403, { ok: false, error: "cross-origin request rejected" });
+        }
+        const force = /[?&]force=1/.test(String(req.url || ""));
+        return Promise.resolve(environment.form({ force, persist: force })).then((r) => send(200, r)).catch((e) => send(500, { ok: false, error: "\u73AF\u5883\u8868\u5355\u88C5\u914D\u5931\u8D25\uFF1A" + (e && e.message || e) }));
+      }
       if (req.method === "POST" && pathname === "/env/open-url") {
         if (!identity.loopback) {
           req.resume();
@@ -26823,6 +27648,7 @@ var require_server = __commonJS({
     var { identify } = require_identity3();
     var { originAllowed, requestHasAccessKey, isShellOrigin } = require_security();
     var browserExit = require_browser();
+    var environmentExit = require_environment();
     function safeFail(res, err, where) {
       try {
         const body = JSON.stringify({ ok: false, error: err && err.message || String(err) });
@@ -26842,6 +27668,7 @@ var require_server = __commonJS({
     }
     function createServer(sup, deps) {
       const browser = deps && deps.browser || browserExit;
+      const environment = deps && deps.environment || environmentExit;
       return http2.createServer((req, res) => {
         const shellOrigin = (() => {
           const o = req.headers.origin;
@@ -26909,7 +27736,7 @@ var require_server = __commonJS({
         } catch (e) {
           return send(400, { error: "bad request encoding" });
         }
-        const ctx = { sup, req, res, pathname: decodedPathname, identity, send, collectBody, originAllowed, tokOf, browser };
+        const ctx = { sup, req, res, pathname: decodedPathname, identity, send, collectBody, originAllowed, tokOf, browser, environment };
         for (const d of API_DOMAINS) {
           if (d.owns(pathname)) {
             try {