cicy-desktop 2.1.91 → 2.1.93

package/bin/cicy-desktop

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const { spawn, execSync } = require("child_process");
+const { spawn, execSync, execFileSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
 const os = require("os");
@@ -13,10 +13,13 @@ const GLOBAL_CONFIG_FILE = path.join(HOME, "global.json");
 const STATE_FILE = path.join(HOME, ".cicy-cluster.json");
 const LOGS_DIR = path.join(HOME, "logs");
 const PACKAGE_ROOT = path.join(__dirname, "..");
-// CN defaults: a fresh machine has no cached electron binary, so npx's electron
-// postinstall would hit GitHub releases and fail (ECOMPROMISED). Mirror it +
-// the npm registry to npmmirror (overridable via the same-named env vars).
-const ELECTRON_MIRROR = process.env.ELECTRON_MIRROR || "https://npmmirror.com/mirrors/electron/";
+// CN/global defaults: a fresh machine has no cached electron binary, so the
+// electron postinstall (and our own self-provisioning below) would otherwise
+// hit GitHub releases, which is slow/blocked on many networks. Default to our
+// own Cloudflare R2 mirror — the three platform zips we ship are mirrored at
+// <ELECTRON_MIRROR>v<version>/electron-v<version>-<platform>.zip (+ SHASUMS256.txt),
+// the exact layout @electron/get expects. Overridable via the env var.
+const ELECTRON_MIRROR = process.env.ELECTRON_MIRROR || "https://r2.deepfetch.de5.net/electron/";
 const NPM_REGISTRY = process.env.CICY_NPM_REGISTRY || process.env.npm_config_registry || "https://registry.npmmirror.com";
 const MASTER_ENTRY = path.join(PACKAGE_ROOT, "src", "master", "master-main.js");
 
@@ -73,32 +76,70 @@ function globalElectronDir() {
   } catch { return null; }
 }
 
-// Make sure a USABLE electron exists before spawning the worker. Prefer a shared
-// GLOBAL electron (downloaded once, survives npx-cache eviction, and
-// resolveElectronSpawn() picks it first). If nothing healthy is found anywhere,
-// auto-install the PINNED version GLOBALLY with the npmmirror mirror — i.e. do the
-// `npm i -g electron@<pin>` step for the user, so a fresh `npx cicy-desktop`
-// self-provisions electron and starts first-try. Runs once per process.
+// The per-platform Electron artifact (mirror zip name + the in-dist executable
+// that path.txt must point at).
+function electronArtifact() {
+  const plat = process.platform === "win32" ? "win32" : process.platform === "darwin" ? "darwin" : "linux";
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  return {
+    zip: `electron-v${ELECTRON_VERSION}-${plat}-${arch}.zip`,
+    exe: process.platform === "win32" ? "electron.exe"
+       : process.platform === "darwin" ? "Electron.app/Contents/MacOS/Electron"
+       : "electron",
+  };
+}
+
+// Provision the Electron binary INTO the bundled npx copy ourselves: download the
+// platform zip from the mirror (R2) with curl, extract with the OS's own unzip,
+// then write path.txt. We deliberately do NOT use electron's install.js /
+// @electron/get: on Windows its bundled extract-zip only PARTIALLY unpacks
+// electron 41 (leaves no path.txt → "Electron failed to install correctly") even
+// though the downloaded zip is valid. curl + Expand-Archive/unzip is reliable,
+// mirror-only (no GitHub), and writes a complete dist/.
+function provisionElectronFromMirror(bundledDir) {
+  const { zip, exe } = electronArtifact();
+  const url = `${ELECTRON_MIRROR}v${ELECTRON_VERSION}/${zip}`;
+  const tmpZip = path.join(os.tmpdir(), `cicy-${zip}`);
+  const curl = isWindows ? "curl.exe" : "curl";
+  execFileSync(curl, ["-fL", "--retry", "5", "--retry-delay", "2", "--connect-timeout", "20", "-o", tmpZip, url], { stdio: "inherit" });
+  const distDir = path.join(bundledDir, "dist");
+  fs.rmSync(distDir, { recursive: true, force: true });
+  fs.mkdirSync(distDir, { recursive: true });
+  if (isWindows) {
+    execFileSync("powershell", ["-NoProfile", "-Command", `Expand-Archive -LiteralPath "${tmpZip}" -DestinationPath "${distDir}" -Force`], { stdio: "inherit" });
+  } else {
+    execFileSync("unzip", ["-o", "-q", tmpZip, "-d", distDir], { stdio: "inherit" });
+    try { fs.chmodSync(path.join(distDir, exe), 0o755); } catch {}
+  }
+  fs.writeFileSync(path.join(bundledDir, "path.txt"), exe);
+  try { fs.rmSync(tmpZip, { force: true }); } catch {}
+}
+
+// Make sure a USABLE electron exists before spawning the worker. A pre-existing
+// GLOBAL electron is reused if present. Otherwise we provision the binary LOCALLY
+// into the bundled npx copy straight from the R2 mirror — NO `npm i -g`, NO
+// GitHub, NO @electron/get. This is what lets a single `npx cicy-desktop`
+// self-provision electron and start first-try. Runs once per process.
 let _electronEnsured = false;
 function ensureElectron() {
   if (_electronEnsured) return;
   _electronEnsured = true;
-  // Already usable (global, or the resolvable bundled/npx copy)? nothing to do.
+  // Already usable (a shared global, or the resolvable bundled/npx copy)? done.
   if (electronBinaryHealthy(globalElectronDir())) return;
   let bundledDir = null;
   try { bundledDir = path.dirname(require.resolve("electron/package.json", { paths: [PACKAGE_ROOT] })); } catch {}
   if (electronBinaryHealthy(bundledDir)) return;
-  // None usable → install the pinned electron globally (with the mirror).
-  console.log(`⚙️  No usable Electron — installing electron@${ELECTRON_VERSION} -g (mirror), one-time…`);
+  if (!bundledDir) {
+    console.warn(`⚠️  electron package not resolvable under ${PACKAGE_ROOT}; cannot self-provision.`);
+    return;
+  }
+  console.log(`⚙️  Fetching Electron ${ELECTRON_VERSION} from mirror (one-time)…`);
   try {
-    execSync(`npm i -g electron@${ELECTRON_VERSION} --registry=${NPM_REGISTRY}`, {
-      stdio: "inherit",
-      env: { ...process.env, ELECTRON_MIRROR, npm_config_registry: NPM_REGISTRY },
-    });
-    _globalElectronBin = undefined; // bust the memo so resolveElectronSpawn re-finds the new global bin
+    provisionElectronFromMirror(bundledDir);
+    if (electronBinaryHealthy(bundledDir)) return;
+    console.warn(`⚠️  Electron provisioned but health check still failing.`);
   } catch (e) {
-    console.warn(`⚠️  Global electron install failed: ${e.message}`);
-    console.warn(`   Fix manually: set ELECTRON_MIRROR=${ELECTRON_MIRROR} && npm i -g electron@${ELECTRON_VERSION}`);
+    console.warn(`⚠️  Electron provision from mirror failed: ${e.message}`);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cicy-desktop",
-  "version": "2.1.91",
+  "version": "2.1.93",
   "description": "CiCy - AI-powered operating system browser",
   "main": "src/main.js",
   "bin": {
@@ -128,16 +128,16 @@
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.1",
     "zod": "3.25",
-    "electron-updater": "6.6.2",
-    "electron": "41.0.3"
+    "electron-updater": "6.6.2"
   },
   "//optionalDependencies": "Runtime Bundle v1 (主人指令): platform binaries delivered by `npm i -g cicy-desktop` itself — npm installs only the current-platform subpackage (os/cpu pinned in each), so first start seeds the runtime store with ZERO network, ZERO npx. Windows packages are named *-windows-* (npm spam filter 403s new names containing win32). cicy-msys2 added once published.",
   "optionalDependencies": {
-    "cicy-code-darwin-x64": "2.3.11",
-    "cicy-code-darwin-arm64": "2.3.11",
-    "cicy-code-linux-x64": "2.3.11",
-    "cicy-code-linux-arm64": "2.3.11",
-    "cicy-code-windows-x64": "2.3.11",
+    "electron": "41.0.3",
+    "cicy-code-darwin-x64": "2.3.12",
+    "cicy-code-darwin-arm64": "2.3.12",
+    "cicy-code-linux-x64": "2.3.12",
+    "cicy-code-linux-arm64": "2.3.12",
+    "cicy-code-windows-x64": "2.3.12",
     "cicy-mihomo-darwin-x64": "1.10.4",
     "cicy-mihomo-darwin-arm64": "1.10.4",
     "cicy-mihomo-linux-x64": "1.10.4",
@@ -149,6 +149,7 @@
     "@babel/core": "^7.29.0",
     "@babel/preset-env": "^7.29.0",
     "axios": "^1.13.5",
+    "electron": "41.0.3",
     "electron-builder": "^26.7.0",
     "jest": "^29.7.0",
     "prettier": "^3.8.1",

package/src/backends/homepage-preload.js

@@ -64,12 +64,26 @@ async function execShell(command, opts = {}) {
 
 contextBridge.exposeInMainWorld("electronRPC", (tool, args) => rpc(tool, args));
 
-// i18n: expose t(key, opts) and current locale to render. Resources are
-// loaded once in the main process and shipped synchronously over IPC. Since
-// preload runs in the main process for context-isolated windows, we can
-// require the i18n module directly.
+// i18n: expose t(key, opts) and current locale to render.
+//
+// IMPORTANT: this preload runs in the RENDERER process, so `require("../i18n")`
+// gives a SEPARATE i18n instance from the main process — it has no idea what
+// locale the app resolved. Left to its own lazy init() it would fall back to
+// English (pickLocale(undefined) → FALLBACK), which is exactly why the homepage
+// (e.g. the first-run terms gate) showed English even on zh-CN systems. So we
+// pull the resolved locale from main over a synchronous IPC and init THIS
+// instance with it. i18next.init() with inline resources is synchronous, so the
+// language is set immediately and `locale` below reads the correct value.
 let __i18n;
-try { __i18n = require("../i18n"); } catch (e) { __i18n = null; }
+try {
+  __i18n = require("../i18n");
+  let mainLng = "";
+  try { mainLng = ipcRenderer.sendSync("i18n:locale"); } catch (_) {}
+  __i18n.init(mainLng || undefined);
+  if (mainLng && __i18n.i18next.language !== __i18n.pickLocale(mainLng)) {
+    __i18n.i18next.changeLanguage(__i18n.pickLocale(mainLng));
+  }
+} catch (e) { __i18n = null; }
 contextBridge.exposeInMainWorld("cicyI18n", {
   t: (key, opts) => {
     if (!__i18n) return key;

package/src/main.js

@@ -81,6 +81,18 @@ const __initialLocale = (() => {
 })();
 i18n.init(__initialLocale);
 
+// Synchronous bridge so the homepage preload — which runs in the RENDERER
+// process and therefore holds its OWN separate i18n module instance — can
+// resolve the same locale the main process picked. Without this the preload's
+// lazy init() falls back to English regardless of OS language, so
+// window.cicyI18n.t() returned English even on zh-CN systems. Read live at call
+// time, so it reflects the ready-time changeLanguage() below.
+try {
+  require("electron").ipcMain.on("i18n:locale", (e) => {
+    e.returnValue = (i18n.i18next && i18n.i18next.language) || i18n.FALLBACK || "en";
+  });
+} catch {}
+
 // Single-instance lock: only one cicy-desktop process can hold the primary
 // instance. A second launch sends `second-instance` with argv to the primary
 // and exits itself. The primary focuses its homepage so the user sees the