cicy-desktop 2.1.91 → 2.1.92

package/bin/cicy-desktop

@@ -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,40 @@ 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.
+// Make sure a USABLE electron exists before spawning the worker. A pre-existing
+// GLOBAL electron is reused if present (downloaded once, shared). Otherwise we
+// provision the electron binary LOCALLY into the bundled npx copy by re-running
+// electron's own install.js against our R2 mirror — NO `npm i -g`, NO GitHub.
+// This is what lets a single `npx cicy-desktop` self-provision electron and
+// start first-try even when the install-time postinstall couldn't fetch the
+// binary (GitHub blocked/slow). 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;
+  }
+  // The electron package is installed but its binary wasn't downloaded. Fetch it
+  // INTO node_modules/electron from the mirror (R2) by invoking electron's own
+  // installer — @electron/get reads ELECTRON_MIRROR and pulls
+  // <mirror>v<version>/electron-v<version>-<platform>.zip. Local, no global.
+  console.log(`⚙️  Fetching Electron ${ELECTRON_VERSION} from mirror (one-time)…`);
   try {
-    execSync(`npm i -g electron@${ELECTRON_VERSION} --registry=${NPM_REGISTRY}`, {
+    execSync(`node "${path.join(bundledDir, "install.js")}"`, {
       stdio: "inherit",
+      cwd: bundledDir,
       env: { ...process.env, ELECTRON_MIRROR, npm_config_registry: NPM_REGISTRY },
     });
-    _globalElectronBin = undefined; // bust the memo so resolveElectronSpawn re-finds the new global bin
   } 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 download from mirror failed: ${e.message}`);
+    console.warn(`   Retry: ELECTRON_MIRROR=${ELECTRON_MIRROR} node "${path.join(bundledDir, "install.js")}"`);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cicy-desktop",
-  "version": "2.1.91",
+  "version": "2.1.92",
   "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