cicy-desktop 2.1.72 → 2.1.73

package/package.json

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

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/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;