cicy-desktop 2.1.72 → 2.1.74

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cicy-desktop",
-  "version": "2.1.72",
+  "version": "2.1.74",
   "description": "CiCy - AI-powered operating system browser",
   "main": "src/main.js",
   "bin": {

package/src/backends/homepage-preload.js

@@ -24,13 +24,17 @@ const { contextBridge, ipcRenderer, shell } = require("electron");
 // args, and the reply (or error) to the console. Skip noisy channels that
 // fire on every render tick to avoid drowning the console.
 const __noisy = new Set(["backends:list", "backends:health-all"]);
+// Per-IPC call/reply tracing floods the console on every render tick and is
+// pure debug noise for someone just running `npx cicy-desktop`. Off by default;
+// set CICY_DEBUG=1 to restore it. Errors are always logged.
+const __verbose = !!(process.env.CICY_DEBUG || process.env.CICY_VERBOSE);
 let __ipcSeq = 0;
 function logInvoke(channel, ...args) {
   const id = ++__ipcSeq;
   const noisy = __noisy.has(channel);
-  if (!noisy) console.log(`[ipc#${id}] call`, channel, ...args);
+  if (__verbose && !noisy) console.log(`[ipc#${id}] call`, channel, ...args);
   return ipcRenderer.invoke(channel, ...args).then(
-    (res) => { if (!noisy) console.log(`[ipc#${id}] reply`, channel, res); return res; },
+    (res) => { if (__verbose && !noisy) console.log(`[ipc#${id}] reply`, channel, res); return res; },
     (err) => { console.error(`[ipc#${id}] error`, channel, err); throw err; },
   );
 }

package/src/backends/homepage-window.js

@@ -72,8 +72,11 @@ async function openHomepage() {
 
   // Pipe renderer console + load failures to main-process stdout so we can
   // diagnose blank-page bugs from logs without opening DevTools.
+  const __verbose = !!(process.env.CICY_DEBUG || process.env.CICY_VERBOSE);
   homepage.webContents.on("console-message", (_e, level, msg, line, source) => {
-    if (level >= 1) console.log(`[homepage:console L${line}] ${msg}  (${source})`);
+    // Warnings/errors (level>=2) always surface — they're what diagnose a blank
+    // page. The chatty info stream only with CICY_DEBUG.
+    if (level >= 2 || (__verbose && level >= 1)) console.log(`[homepage:console L${line}] ${msg}  (${source})`);
   });
   // Log load failures (corrupt/missing install) — no remote fallback by
   // design: the homepage is the bundled SPA, full stop.

package/src/backends/local-teams.js

@@ -258,6 +258,20 @@ async function openTeam(id) {
     return { ok: true, windowId: existing.id, reused: true };
   }
 
+  // No window yet. Before opening one against a LOCAL sidecar, make sure the
+  // daemon is REALLY up (TCP 探活) — opening a window at a not-yet-ready :8008
+  // loads a blank page the user has to manually reload (主人 bug). Start it if
+  // it isn't running, then poll until it answers; bail (no blank window) if it
+  // never comes up. Remote/custom (non-localhost) teams skip this — their page
+  // shows its own connecting/login UI.
+  if (isLocalOrigin(url)) {
+    const ready = await ensureLocalSidecarAlive(url);
+    if (!ready) {
+      log.warn(`[local-teams] open ${id} → local sidecar not ready, not opening blank window`);
+      return { ok: false, error: "sidecar_not_ready" };
+    }
+  }
+
   const { createWindow } = require("../utils/window-utils");
   const win = createWindow(
     { url, title: `Local · ${node.name || id}` },
@@ -268,6 +282,31 @@ async function openTeam(id) {
   return { ok: true, windowId: win.id, reused: false };
 }
 
+// Is this URL served by something on the local machine (the cicy-code sidecar)?
+function isLocalOrigin(url) {
+  try { const h = new URL(url).hostname; return h === "127.0.0.1" || h === "localhost" || h === "::1"; }
+  catch { return false; }
+}
+
+// Ensure the local cicy-code daemon serving `url` actually answers before we
+// open a window at it. Already up → true immediately. Down → start it, then
+// poll a TCP probe (NOT /api/health, which is unreliable mid-boot) until it
+// binds or we time out.
+async function ensureLocalSidecarAlive(url, { timeoutMs = 15000 } = {}) {
+  let port;
+  try { port = Number(new URL(url).port) || 8008; } catch { return true; } // unparseable → don't block
+  let sidecar;
+  try { sidecar = require("../sidecar/cicy-code"); } catch { return true; }
+  if (await sidecar.probeExisting(port)) return true;       // already answering
+  try { await sidecar.start({ port }); } catch {}            // not up → bring it up
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (await sidecar.probeExisting(port)) return true;
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
 function stripVolatile(u) {
   try {
     const p = new URL(u);
@@ -303,6 +342,25 @@ function reloadTeam(id) {
   }
 }
 
+// Close any open window served by the local sidecar (origin
+// http://127.0.0.1:<port> or http://localhost:<port>). Called when the sidecar
+// is STOPPED so a now-dead :8008 team window doesn't linger showing a broken
+// page (主人 bug report: stop 后应关掉 localhost 的 window).
+function closeLocalWindows(port = 8008) {
+  const origins = new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
+  let closed = 0;
+  for (const w of BrowserWindow.getAllWindows()) {
+    if (!w || w.isDestroyed()) continue;
+    let origin = "";
+    try { origin = new URL(w.webContents.getURL()).origin; } catch { continue; }
+    if (origins.has(origin)) {
+      try { w.close(); closed++; } catch {}
+    }
+  }
+  if (closed) log.info(`[local-teams] closed ${closed} local window(s) on :${port} after stop`);
+  return closed;
+}
+
 // ── mutations ──────────────────────────────────────────────────────────
 //
 // add/remove/upgrade let an external caller (currently the cloud Team
@@ -737,4 +795,4 @@ async function upgradeTeam(id) {
   return result;
 }
 
-module.exports = { list, openTeam, reloadTeam, addTeam, removeTeam, updateTeam, upgradeTeam };
+module.exports = { list, openTeam, reloadTeam, closeLocalWindows, addTeam, removeTeam, updateTeam, upgradeTeam };

package/src/backends/sidecar-ipc.js

@@ -92,6 +92,9 @@ function register({ sidecarLogPath } = {}) {
   ipcMain.handle("sidecar:stop", async () => {
     try {
       await sidecar.stop();
+      // The daemon is gone — close any open team window pointing at it so the
+      // user isn't left staring at a dead :8008 page (主人 bug report).
+      try { require("./local-teams").closeLocalWindows(PORT); } catch {}
       return { ok: true };
     } catch (e) {
       return { ok: false, error: e.message };

package/src/sidecar/cicy-code.js

@@ -112,9 +112,22 @@ async function start({ logPath, port = DEFAULT_PORT, force = false, version = nu
   if (!exe) {
     try { exe = (await localbin.ensure({ version }))?.exe; }
     catch (e) { console.warn(`[cicy-code-sidecar] localbin ensure failed: ${e.message}`); }
+  } else {
+    // Present — let ensure() do a zero-network bundle upgrade if cicy-desktop
+    // itself was updated and now ships a newer cicy-code (版本高了就更新).
+    try { await localbin.ensure({ version }); } catch {}
   }
   if (!exe) { console.warn("[cicy-code-sidecar] no cicy-code binary available"); return null; }
 
+  // cicy-desktop ALSO owns the mihomo binary (same npm/localbin model). Seed it
+  // into ~/.local/bin/mihomo from the bundle (zero network) BEFORE the cicy-code
+  // daemon boots, so cicy-code's own startup finds it already present and skips
+  // its GitHub/COS download. Best-effort — never block cicy-code on it.
+  try {
+    const r = await localbin.ensure({ name: "mihomo" });
+    if (r?.exe) console.log(`[cicy-code-sidecar] mihomo ready at ${r.exe} (v${r.version || "?"})`);
+  } catch (e) { console.warn(`[cicy-code-sidecar] mihomo seed skipped: ${e.message}`); }
+
   let stdio = ["ignore", "ignore", "ignore"];
   if (logPath) {
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
@@ -248,8 +261,14 @@ async function update({ logPath, port = DEFAULT_PORT, emit } = {}) {
   const localbin = require("./localbin");
   try {
     e({ phase: "download", status: "running", message: "检查最新版本…" });
+    const cur = localbin.currentVersion();
     const latest = await localbin.latestVersion();
     if (!latest) throw new Error("无法获取最新版本号");
+    if (cur && localbin.cmpVer(latest, cur) <= 0) {
+      // Already current — no download, no restart (不重复下载/更新).
+      e({ phase: "done", status: "done", message: `已是最新 ${cur}` });
+      return null;
+    }
     await localbin.fetchToLocalBin(latest, { emit }); // download → ~/.local/bin → re-link
     e({ phase: "swap", status: "running", message: `切换到 ${latest}，启动…` });
     await stop({ port });

package/src/sidecar/localbin.js

@@ -1,35 +1,120 @@
-// ~/.local/bin install model for the cicy-code daemon binary.
+// ~/.local/bin install model for the binaries cicy-desktop OWNS.
 //
-// 主人指令 (2026-06): cicy-desktop OWNS the binary. It is bundled per-platform
-// (an optionalDependency of cicy-desktop). On first run we copy the bundled,
-// version-named binary into ~/.local/bin/cicy-code-<ver>-<plat> and point
-// ~/.local/bin/cicy-code at it (symlink on mac/linux; a plain COPY on Windows —
-// symlink/junction perms there are a minefield). The daemon is ALWAYS run from
-// that stable ~/.local/bin/cicy-code path — never `npx cicy-code`, which would
-// reuse a stale globally-installed copy and shadow updates.
+// 主人指令 (2026-06): cicy-desktop OWNS its runtime binaries and distributes
+// them THROUGH npm — one channel for everything. Today that's two components:
+//
+//   cicy-code  ← npm  cicy-code-<plat>     → ~/.local/bin/cicy-code
+//   mihomo     ← npm  cicy-mihomo-<plat>   → ~/.local/bin/mihomo
+//
+// Each is bundled per-platform as an optionalDependency of cicy-desktop. On
+// first run we copy the bundled, version-named binary into
+// ~/.local/bin/<base>-<ver>-<plat> and point ~/.local/bin/<base> at it
+// (symlink on mac/linux; a plain COPY on Windows — symlink/junction perms there
+// are a minefield). The binary is ALWAYS run from that stable ~/.local/bin path
+// — never `npx`, which would reuse a stale globally-installed copy and shadow
+// updates.
+//
+// Semantics (主人指令): 有就不装、没有就装、版本高了就更新、不重复下载/更新.
+//   - present & current     → reuse, no work, no network
+//   - absent                → seed from the bundle (zero network)
+//   - bundle newer than link → re-seed from the bundle (zero network upgrade,
+//                              e.g. after cicy-desktop itself updated)
+//   - explicit update()     → npm `pack` the latest per-platform subpackage,
+//                             ONLY when the registry is actually ahead.
 //
 // Updates use npm ONLY as a download channel: `npm pack` the per-platform
 // subpackage (sha512-verified), extract the binary, copy it in as a NEW
-// version-named file, then re-point the cicy-code link (re-copy on Windows).
+// version-named file, then re-point the link (re-copy on Windows). A version
+// manifest at ~/.local/bin/.cicy-localbin.json records what each link points
+// at, so version checks work cross-platform (including the Windows copy, which
+// has no symlink target to parse).
 
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { execFile } = require("child_process");
+const { execFile, execFileSync } = require("child_process");
 
 const IS_WIN = process.platform === "win32";
 const REGISTRY = process.env.CICY_NPM_REGISTRY || "https://registry.npmmirror.com";
 const LOCAL_BIN = path.join(os.homedir(), ".local", "bin");
+const MANIFEST = path.join(LOCAL_BIN, ".cicy-localbin.json");
+
+// The binaries we own. `pkgPrefix` + platform = the npm subpackage name;
+// `base` is the stable link/file base name. The default component everywhere is
+// cicy-code, so the legacy single-component callers keep working unchanged.
+const COMPONENTS = {
+  "cicy-code": { pkgPrefix: "cicy-code", base: "cicy-code" },
+  "mihomo": { pkgPrefix: "cicy-mihomo", base: "mihomo" },
+};
+const DEFAULT = "cicy-code";
+function comp(name) {
+  const c = COMPONENTS[name || DEFAULT];
+  if (!c) throw new Error(`unknown localbin component: ${name}`);
+  return c;
+}
 
 function plat() {
   const osStr = IS_WIN ? "windows" : process.platform === "darwin" ? "darwin" : "linux";
   const arch = process.arch === "arm64" ? "arm64" : "x64";
   return `${osStr}-${arch}`;
 }
-const PKG = () => `cicy-code-${plat()}`;
-const BIN = IS_WIN ? "cicy-code.exe" : "cicy-code";
-const LINK = path.join(LOCAL_BIN, IS_WIN ? "cicy-code.exe" : "cicy-code");
-const versioned = (ver) => path.join(LOCAL_BIN, `cicy-code-${ver}-${plat()}${IS_WIN ? ".exe" : ""}`);
+const pkgFor = (name) => `${comp(name).pkgPrefix}-${plat()}`;
+const binFor = (name) => comp(name).base + (IS_WIN ? ".exe" : "");
+const linkFor = (name) => path.join(LOCAL_BIN, binFor(name));
+const versionedFor = (name, ver) =>
+  path.join(LOCAL_BIN, `${comp(name).base}-${ver}-${plat()}${IS_WIN ? ".exe" : ""}`);
+
+// Legacy aliases (cicy-code is the default component).
+const BIN = binFor(DEFAULT);
+const LINK = linkFor(DEFAULT);
+const versioned = (ver, name = DEFAULT) => versionedFor(name, ver);
+
+// ── version helpers ───────────────────────────────────────────────────────
+// Normalize "v1.10.3" / "1.10.3" → [1,10,3]; compare numerically.
+function parseVer(v) {
+  return String(v || "").replace(/^v/i, "").split(/[.\-+]/).map((n) => parseInt(n, 10) || 0);
+}
+function cmpVer(a, b) {
+  const pa = parseVer(a), pb = parseVer(b);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function readManifest() {
+  try { return JSON.parse(fs.readFileSync(MANIFEST, "utf8")) || {}; } catch { return {}; }
+}
+function writeManifest(name, ver) {
+  const m = readManifest();
+  m[name] = ver;
+  try { fs.mkdirSync(LOCAL_BIN, { recursive: true }); fs.writeFileSync(MANIFEST, JSON.stringify(m, null, 2) + "\n"); } catch {}
+}
+
+// Best-effort: run the binary to read its version (fallback when the manifest
+// has no record — e.g. a binary installed by the old GitHub/COS path).
+function probeVersion(name) {
+  const link = linkFor(name);
+  if (!fs.existsSync(link)) return null;
+  const flag = name === "mihomo" ? "-v" : "--version";
+  try {
+    const out = execFileSync(link, [flag], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+    const m = out.match(/\bv?(\d+\.\d+\.\d+)\b/);
+    return m ? m[1] : null;
+  } catch { return null; }
+}
+
+// The version the ~/.local/bin link currently points at: manifest first (fast,
+// cross-platform), else probe the binary, else null.
+function currentVersion(name = DEFAULT) {
+  if (!fs.existsSync(linkFor(name))) return null;
+  const m = readManifest();
+  if (m[name]) return m[name];
+  const probed = probeVersion(name);
+  if (probed) { writeManifest(name, probed); return probed; }
+  return null;
+}
 
 function npmExec(args, timeout = 600000) {
   return new Promise((resolve, reject) => {
@@ -39,95 +124,145 @@ function npmExec(args, timeout = 600000) {
 }
 
 // Latest published version of the per-platform subpackage.
-async function latestVersion() {
-  return (await npmExec(["view", PKG(), "version", `--registry=${REGISTRY}`], 30000)).trim();
+async function latestVersion(name = DEFAULT) {
+  return (await npmExec(["view", pkgFor(name), "version", `--registry=${REGISTRY}`], 30000)).trim();
 }
 
-// Point ~/.local/bin/cicy-code at a version-named binary: symlink on POSIX, a
-// plain copy on Windows.
-function linkTo(verBinPath) {
+// Point ~/.local/bin/<base> at a version-named binary: symlink on POSIX, a plain
+// copy on Windows. Records the version in the manifest.
+function linkTo(name, verBinPath, ver) {
+  const link = linkFor(name);
   fs.mkdirSync(LOCAL_BIN, { recursive: true });
-  try { fs.rmSync(LINK, { force: true }); } catch {}
-  if (IS_WIN) {
-    fs.copyFileSync(verBinPath, LINK);
-  } else {
-    fs.symlinkSync(verBinPath, LINK);
-  }
-  return LINK;
+  try { fs.rmSync(link, { force: true }); } catch {}
+  if (IS_WIN) fs.copyFileSync(verBinPath, link);
+  else fs.symlinkSync(verBinPath, link);
+  if (ver) writeManifest(name, ver);
+  return link;
 }
 
-function placeBinary(srcBin, ver) {
+function placeBinary(name, srcBin, ver) {
   if (!fs.existsSync(srcBin)) throw new Error(`source binary missing: ${srcBin}`);
   fs.mkdirSync(LOCAL_BIN, { recursive: true });
-  const dst = versioned(ver);
+  const dst = versionedFor(name, ver);
   fs.copyFileSync(srcBin, dst);
   if (!IS_WIN) fs.chmodSync(dst, 0o755);
-  linkTo(dst);
-  return { exe: LINK, target: dst, version: ver };
+  linkTo(name, dst, ver);
+  return { exe: linkFor(name), target: dst, version: ver };
 }
 
 // The bundled per-platform subpackage shipped inside cicy-desktop (zero network).
-function bundledPkgDir() {
+function bundledPkgDir(name) {
+  const pkg = pkgFor(name);
   const candidates = [
-    path.join(__dirname, "..", "..", "node_modules", PKG()),         // npm install layout
-    path.join(process.resourcesPath || "", "runtime-pkgs", PKG()),   // packaged (NSIS/dmg) layout
+    path.join(__dirname, "..", "..", "node_modules", pkg),         // npm install layout
+    path.join(process.resourcesPath || "", "runtime-pkgs", pkg),   // packaged (NSIS/dmg) layout
   ];
   for (const p of candidates) {
     try { if (fs.existsSync(path.join(p, "package.json"))) return p; } catch {}
   }
   return null;
 }
+function bundledVersion(name) {
+  const dir = bundledPkgDir(name);
+  if (!dir) return null;
+  try { return JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).version || null; } catch { return null; }
+}
 
-// Install the binary from the bundled subpackage. null when not bundled.
-function fromBundle() {
-  const dir = bundledPkgDir();
+// Install/upgrade the binary from the bundled subpackage (zero network). Returns
+// {exe,version} or null when not bundled. Reuses the existing link when it is
+// already at the bundle version or newer (有就不装).
+function fromBundle(name = DEFAULT) {
+  const dir = bundledPkgDir(name);
   if (!dir) return null;
-  let ver;
-  try { ver = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")).version; } catch { return null; }
-  const src = path.join(dir, BIN);
+  const ver = bundledVersion(name);
+  if (!ver) return null;
+  const src = path.join(dir, binFor(name));
   if (!fs.existsSync(src)) return null;
-  if (fs.existsSync(versioned(ver))) { linkTo(versioned(ver)); return { exe: LINK, version: ver }; }
-  return placeBinary(src, ver);
+  const cur = currentVersion(name);
+  if (cur && currentLink(name) && cmpVer(cur, ver) >= 0) return { exe: linkFor(name), version: cur };
+  if (fs.existsSync(versionedFor(name, ver))) { linkTo(name, versionedFor(name, ver), ver); return { exe: linkFor(name), version: ver }; }
+  return placeBinary(name, src, ver);
 }
 
 // Download <pkg>@<ver> via `npm pack` and install it into ~/.local/bin. npm is
 // ONLY the download channel — we copy the binary out and run it from ~/.local/bin.
-async function fetchToLocalBin(ver, { emit } = {}) {
+// No-op download when that version is already on disk (不重复下载).
+async function fetchToLocalBin(ver, { emit, name = DEFAULT } = {}) {
   const e = emit || (() => {});
-  if (fs.existsSync(versioned(ver))) { linkTo(versioned(ver)); return { exe: LINK, version: ver }; }
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cicy-cc-"));
+  if (fs.existsSync(versionedFor(name, ver))) { linkTo(name, versionedFor(name, ver), ver); return { exe: linkFor(name), version: ver }; }
+  const label = comp(name).base;
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cicy-lb-"));
   try {
-    e({ phase: "download", status: "running", message: `下载 cicy-code ${ver}…` });
-    const out = await npmExec(["pack", `${PKG()}@${ver}`, `--registry=${REGISTRY}`, "--pack-destination", tmp]);
+    e({ phase: "download", status: "running", message: `下载 ${label} ${ver}…` });
+    const out = await npmExec(["pack", `${pkgFor(name)}@${ver}`, `--registry=${REGISTRY}`, "--pack-destination", tmp]);
     const tgz = path.join(tmp, out.trim().split("\n").pop().trim());
     await new Promise((resolve, reject) =>
       execFile("tar", ["-xzf", tgz, "-C", tmp], { windowsHide: true, timeout: 120000 }, (err) => (err ? reject(err) : resolve())));
-    const res = placeBinary(path.join(tmp, "package", BIN), ver);
-    e({ phase: "download", status: "done", message: `cicy-code ${ver} 就绪` });
+    const res = placeBinary(name, path.join(tmp, "package", binFor(name)), ver);
+    e({ phase: "download", status: "done", message: `${label} ${ver} 就绪` });
     return res;
   } finally {
     fs.rmSync(tmp, { recursive: true, force: true });
   }
 }
 
-// ~/.local/bin/cicy-code, if it exists.
-function currentLink() {
-  return fs.existsSync(LINK) ? LINK : null;
+// ~/.local/bin/<base>, if it exists.
+function currentLink(name = DEFAULT) {
+  return fs.existsSync(linkFor(name)) ? linkFor(name) : null;
 }
 
-// Ensure ~/.local/bin/cicy-code exists and points at a usable binary.
-//   - already linked → reuse (unless force)
-//   - else bundled subpackage (zero network, the "pre-installed" path)
-//   - else download latest (or a pinned version) via npm
-async function ensure({ version = null, force = false, emit = null } = {}) {
-  if (!force && currentLink()) return { exe: LINK };
+// Ensure ~/.local/bin/<base> exists and points at a usable binary, version-aware
+// and network-frugal:
+//   - present & no newer bundle → reuse as-is (有就不装, zero network)
+//   - present & bundle is newer → re-seed from the bundle (zero network upgrade)
+//   - pinned version            → reuse if already that version, else fetch it
+//   - absent                    → seed from the bundle, else fetch latest from npm
+async function ensure({ name = DEFAULT, version = null, force = false, emit = null } = {}) {
   const pin = version && version !== "latest" ? version : null;
-  if (!force && !pin) {
-    const b = fromBundle();
-    if (b) return b;
+
+  if (pin) {
+    const cur = currentVersion(name);
+    if (!force && cur && cmpVer(cur, pin) === 0) return { exe: linkFor(name), version: cur };
+    if (fs.existsSync(versionedFor(name, pin))) { linkTo(name, versionedFor(name, pin), pin); return { exe: linkFor(name), version: pin }; }
+    return fetchToLocalBin(pin, { emit, name });
+  }
+
+  if (!force && currentLink(name)) {
+    // Present — only touch it if the bundle ships something newer (zero network).
+    const cur = currentVersion(name);
+    const bv = bundledVersion(name);
+    if (bv && (!cur || cmpVer(bv, cur) > 0)) {
+      const b = fromBundle(name);
+      if (b) return b;
+    }
+    return { exe: linkFor(name), version: cur };
+  }
+
+  // Absent (or forced): prefer the zero-network bundle seed, else npm latest.
+  const b = fromBundle(name);
+  if (b) return b;
+  const ver = await latestVersion(name);
+  return fetchToLocalBin(ver, { emit, name });
+}
+
+// On-demand update from the registry (the 更新 button). Fetches the latest only
+// when the registry is actually ahead of what's installed (不重复下载/更新).
+async function update({ name = DEFAULT, emit } = {}) {
+  const e = emit || (() => {});
+  const cur = currentVersion(name);
+  const latest = await latestVersion(name);
+  if (!latest) throw new Error("无法获取最新版本号");
+  if (cur && cmpVer(latest, cur) <= 0) {
+    e({ phase: "done", status: "done", message: `已是最新 ${cur}` });
+    return { exe: linkFor(name), version: cur, updated: false };
   }
-  const ver = pin || (await latestVersion());
-  return fetchToLocalBin(ver, { emit });
+  const res = await fetchToLocalBin(latest, { emit, name });
+  return { ...res, updated: true };
 }
 
-module.exports = { LOCAL_BIN, LINK, plat, versioned, latestVersion, fromBundle, fetchToLocalBin, currentLink, ensure };
+module.exports = {
+  LOCAL_BIN, LINK, BIN, COMPONENTS, plat,
+  pkgFor, binFor, linkFor, versionedFor, versioned,
+  cmpVer, currentVersion, latestVersion,
+  fromBundle, bundledVersion, fetchToLocalBin, currentLink, ensure, update,
+};

package/src/utils/window-monitor.js

@@ -331,15 +331,21 @@ function initWindowMonitoring(win) {
     const logs = windowLogs.get(winId);
 
     const counters = windowIndexCounters.get(winId);
-    log.info(
-      `[${JSON.stringify({
-        timestamp: Date.now(),
-        level: ["verbose", "info", "warning", "error"][level] || "log",
-        message,
-        line,
-        source: sourceId,
-      })}`
-    );
+    // Mirror EVERY renderer console line into the main log only with CICY_DEBUG;
+    // by default forward warnings/errors (level>=2) so normal startup stays quiet
+    // but real problems still surface. The in-memory log store below is unaffected
+    // (the log-viewer API still sees everything).
+    if (level >= 2 || process.env.CICY_DEBUG || process.env.CICY_VERBOSE) {
+      log.info(
+        `[${JSON.stringify({
+          timestamp: Date.now(),
+          level: ["verbose", "info", "warning", "error"][level] || "log",
+          message,
+          line,
+          source: sourceId,
+        })}`
+      );
+    }
     if (logs && counters) {
       logs.push({
         index: ++counters.log,

package/workers/render/src/App.css

@@ -927,6 +927,10 @@ body {
 
 /* 首启门控条款页 (合规第一道整体同意) */
 .terms-gate { display: flex; align-items: center; justify-content: center; padding: 24px; }
+/* .shell sets -webkit-app-region: drag; only .shell--app un-drags itself. The
+   terms gate / splash screens are bare .shell, so without this the whole panel
+   is a window-drag region and its buttons can't be clicked. */
+.terms-gate__panel, .terms-gate__panel * { -webkit-app-region: no-drag; }
 .terms-gate__panel {
   position: relative; z-index: 1; width: min(680px, 94vw); max-height: 90vh;
   display: flex; flex-direction: column;

package/workers/render/src/App.jsx

@@ -568,7 +568,7 @@ export default function App() {
           ))}
         </div>
 
-        {showLocal && <DockerSetup onReady={fetchLocalTeams} />}
+        {/* Docker 安装卡已下线 (主人令): Windows 走原生 cicy-code.exe --helper,不再用 Docker。 */}
         {showLocal && localList.length > 0 && <MitmConsentCard team={localList[0]} />}
 
         {profileError && (
@@ -1061,10 +1061,13 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
   };
   const BUSY_LABEL = { start: "启动中…", restart: "重启中…", update: "更新中…", stop: "停止中…" };
 
-  // 打开 is NEVER gated on /api/health — openTeam() in main doesn't check it,
-  // it just opens the window. health is an indicator, not a gate. When the
-  // LOCAL daemon is down we start it first; remote/other-port teams just open
-  // and let the loaded page show its own connecting/login/error UI.
+  // 打开 flow (主人 spec): start the LOCAL daemon if it's down (with a 启动中…
+  // toast), then open. The window itself is opened by openTeam() in main, which
+  // (1) reuses an already-open window for this team (list_windows check first),
+  // and (2) for a local team, TCP-探活 until :8008 actually answers before
+  // creating the window — so we never pop a blank page that needs a manual
+  // reload. (/api/health is NOT used — it's unreliable mid-boot; the gate is a
+  // raw TCP probe.) Remote/custom teams just open and show their own UI.
   const handleOpen = async () => {
     if (busy) return;
     if (!running && local && window.cicy?.sidecar?.start) {
@@ -1078,7 +1081,7 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
       }
       toast.dismiss(opToastId); // came up — no lingering toast, the window opens
     }
-    onOpen(); // open regardless of health — the window/page handles the rest
+    onOpen(); // openTeam() gates on list_windows + TCP liveness before showing
   };
   const openLabel = running
     ? tr("localTeams.open", "打开")