cicy-desktop 2.1.136 → 2.1.138

package/package.json

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

package/src/backends/sidecar-ipc.js

@@ -16,6 +16,10 @@ const { ipcMain } = require("electron");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
+const log = require("electron-log");
+// Background-computed docker status lives here; the homepage READS this (never
+// probes WSL live → never blocks the UI / strands it on 「重试检测」).
+const DOCKER_STATUS_FILE = path.join(os.homedir(), "cicy-ai", "db", "docker-status.json");
 const sidecar = require("../sidecar/cicy-code");
 const docker = require("../sidecar/docker");
 const wslDocker = require("../sidecar/wsl-docker"); // Docker-版 via WSL2+Ubuntu (方案 A, win32)
@@ -110,6 +114,46 @@ function register({ sidecarLogPath } = {}) {
   if (registered) return;
   registered = true;
 
+  // ---- Docker status: computed by a dedicated NON-BLOCKING background daemon ----
+  // The homepage's 「重试检测」 / 「未响应」 came from probing WSL live on the UI's
+  // status call: a cold/busy WSL2 VM takes 10-20s to answer, timed out, and got
+  // mis-read as unknown. Instead the daemon below detects status off the UI thread,
+  // caches it (memory + file), AND auto-starts whatever is installed-but-down. The
+  // docker:app-status handler just returns the cache — instant, never blocks.
+  let _dockerStatusCache = null;
+  let _dockerDaemonBusy = false;
+  async function refreshDockerStatus() {
+    try {
+      const s = await appDocker.status(APP_PORT); // { wsl, distro, engineUp, running, unknown }
+      _dockerStatusCache = { installed: !!s.distro, dockerRunning: !!s.engineUp, running: !!s.running, unknown: !!s.unknown, port: APP_PORT, platform: process.platform, ts: Date.now() };
+    } catch (e) {
+      _dockerStatusCache = { installed: false, dockerRunning: false, running: false, unknown: true, port: APP_PORT, platform: process.platform, error: e.message, ts: Date.now() };
+    }
+    try { fs.mkdirSync(path.dirname(DOCKER_STATUS_FILE), { recursive: true }); fs.writeFileSync(DOCKER_STATUS_FILE, JSON.stringify(_dockerStatusCache)); } catch {}
+    return _dockerStatusCache;
+  }
+  async function reconcileDocker() {
+    if (_dockerDaemonBusy) return _dockerStatusCache;
+    _dockerDaemonBusy = true;
+    try {
+      const s = await refreshDockerStatus();
+      // 没启动的给我启动: distro installed but :8009 not healthy (and WSL not unknown)
+      // → bring it up. bootstrap is idempotent: it skips done steps and just runs
+      // startEngine + the container. Skip when not installed (would silently pull
+      // the 444MB rootfs) or unknown (WSL not answering — let the next tick retry).
+      if (s.installed && !s.running && !s.unknown) {
+        log.info("[docker-daemon] installed but :8009 down → auto-starting (bootstrap idempotent)");
+        try { await appDocker.bootstrap(appOpts()); } catch (e) { log.warn(`[docker-daemon] auto-start failed: ${e.message}`); }
+        await refreshDockerStatus();
+      }
+    } finally { _dockerDaemonBusy = false; }
+    return _dockerStatusCache;
+  }
+  function startDockerStatusDaemon() {
+    setTimeout(() => { reconcileDocker().catch(() => {}); }, 2000);     // shortly after startup
+    setInterval(() => { reconcileDocker().catch(() => {}); }, 60000);   // keep fresh + self-heal
+  }
+
   ipcMain.handle("sidecar:status", async () => {
     const running = await sidecar.probeExisting(PORT);
     return { running };
@@ -170,13 +214,14 @@ function register({ sidecarLogPath } = {}) {
   // ---- Docker-版 cicy-code on :8009 — WSL2 + Ubuntu + Docker Engine (方案 A) ----
   // Card states (主人: 状态分清楚): running(:8009 healthy)→打开 / dockerRunning
   // (engine up)→启动 / installed(Ubuntu present)→启动 Docker / else→下载安装.
-  ipcMain.handle("docker:app-status", async () => {
-    try {
-      const s = await appDocker.status(APP_PORT); // { wsl, distro, engineUp, running, unknown }
-      return { installed: !!s.distro, dockerRunning: !!s.engineUp, running: !!s.running, unknown: !!s.unknown, port: APP_PORT, platform: process.platform };
-    } catch (e) {
-      return { installed: false, dockerRunning: false, running: false, port: APP_PORT, platform: process.platform, error: e.message };
-    }
+  ipcMain.handle("docker:app-status", () => {
+    // NON-BLOCKING: return what the background daemon already computed (memory →
+    // file). NEVER probe WSL live here — that's what froze the UI / stranded the
+    // card on 「重试检测」. Kick a refresh if we have nothing cached yet.
+    if (_dockerStatusCache) return _dockerStatusCache;
+    try { return JSON.parse(fs.readFileSync(DOCKER_STATUS_FILE, "utf8")); } catch {}
+    reconcileDocker().catch(() => {});
+    return { installed: false, dockerRunning: false, running: false, unknown: true, port: APP_PORT, platform: process.platform };
   });
 
   // Common run options for the :8009 instance: its own container/volume + the
@@ -422,6 +467,10 @@ function register({ sidecarLogPath } = {}) {
       });
     });
   });
+
+  // Kick the non-blocking docker status daemon: detect on startup + every 60s,
+  // cache to file, and auto-start what's installed-but-down. The UI just reads it.
+  startDockerStatusDaemon();
 }
 
 module.exports = { register };

package/src/sidecar/docker.js

@@ -567,7 +567,7 @@ async function wslMissing() {
   // (wsl didn't answer / timed out). null lets status() report `unknown` instead
   // of falsely concluding "not installed" when WSL is merely stuck.
   return await new Promise((resolve) => {
-    execFile("wsl", ["--status"], { timeout: 8000, windowsHide: true, encoding: "utf16le" }, (err, stdout, stderr) => {
+    execFile("wsl", ["--status"], { timeout: 25000, windowsHide: true, encoding: "utf16le" }, (err, stdout, stderr) => {
       const s = String((stdout || "") + (stderr || "") + (err && err.message ? err.message : ""));
       if (/未安装|not installed|--install/i.test(s)) return resolve(true);   // definitely missing
       if (err && (err.killed || err.signal || err.code === "ETIMEDOUT")) return resolve(null); // timed out → unknown

package/src/sidecar/wsl-docker.js

@@ -98,7 +98,11 @@ async function distroInstalled(distro = DISTRO) {
   if (process.platform !== "win32") return false;
   // ASYNC execFile (sync froze the main process on a cold/stuck WSL → "未响应").
   return await new Promise((resolve) => {
-    execFile("wsl", ["-l", "-q"], { timeout: 8000, windowsHide: true, encoding: "utf16le" }, (err, stdout) => {
+    // 25s, NOT 8s: a COLD WSL2 VM takes 10-20s just to boot before it answers the
+    // first `wsl -l -q`, so an 8s timeout falsely returns null(unknown) → the
+    // homepage gets stuck on 「重试检测」 instead of offering 「安装」. A warm WSL
+    // answers in <1s, so the longer ceiling never bites in the normal case.
+    execFile("wsl", ["-l", "-q"], { timeout: 25000, windowsHide: true, encoding: "utf16le" }, (err, stdout) => {
       // Our timeout killed it / it was signalled → WSL didn't answer → UNKNOWN.
       if (err && (err.killed || err.signal || err.code === "ETIMEDOUT")) return resolve(null);
       // Other errors (wsl missing / non-zero exit) → definitively not our distro.
@@ -115,12 +119,26 @@ async function distroInstalled(distro = DISTRO) {
 // Raw `wsl --import` of the rootfs as an ISOLATED v2 distro.
 function importTarball(dest, installDir) {
   return new Promise((resolve, reject) => {
+    // 240s, NOT 600s: a 444MB import finishes in well under 4min on a healthy WSL.
+    // If it runs longer it has WEDGED (the whole WSL subsystem hangs — every later
+    // `wsl` call then blocks and the app goes 未响应). Bound it short so we FAIL FAST
+    // and the caller can `wsl --shutdown` + retry instead of hanging 10 minutes.
     execFile("wsl", ["--import", DISTRO, installDir, dest, "--version", "2"],
-      { timeout: 600000, windowsHide: true },
+      { timeout: 240000, windowsHide: true },
       (err, _so, se) => { if (err) { err.stderr = String(se || ""); return reject(err); } resolve(); });
   });
 }
 
+// `wsl --shutdown`: hard-reset the ENTIRE WSL VM. This is the only reliable cure
+// when WSL wedges (a hung `wsl --import` leaves every subsequent `wsl` call
+// blocking → the app freezes). Unlike `wsl --list/-d` it doesn't query the wedged
+// VM, so it returns even when WSL is stuck. Use it as recovery between retries.
+function wslShutdown() {
+  return new Promise((resolve) => {
+    execFile("wsl", ["--shutdown"], { timeout: 30000, windowsHide: true }, () => resolve());
+  });
+}
+
 // `wsl --terminate <distro>`: stop the distro so the NEXT `wsl -d` cold-boots it
 // clean. This is the fix for the「引擎没起来」-on-fresh-install failure: a distro
 // straight out of `wsl --import` is frequently half-initialized / unresponsive,
@@ -153,10 +171,17 @@ async function installDistro({ emit } = {}) {
   try {
     await importTarball(dest, installDir);
   } catch (e) {
-    // Most likely the shared WSL2 kernel component is missing — install it
-    // (idempotent) and retry once.
-    emit && emit({ phase: "container", status: "running", message: "需要 WSL2 内核,正在安装后重试…" });
-    await ensureWslKernel({ emit });
+    // Import failed or WEDGED (our 4-min timeout fired). Recover hard, then retry once:
+    //   1) `wsl --shutdown` — clears a wedged WSL VM (the real cause of the 8-min hang
+    //      + app freeze). Without this the retry hits the same stuck VM and hangs again.
+    //   2) ensure the WSL2 kernel (import also fails when it's missing).
+    //   3) unregister any half-registered distro a wedged import left behind, so the
+    //      retry imports clean.
+    log.warn(`[installDistro] import failed/wedged (${e.message}) → wsl --shutdown + retry`);
+    emit && emit({ phase: "container", status: "running", message: "导入卡住,重置 WSL(--shutdown)后重试…" });
+    try { await wslShutdown(); } catch {}
+    try { await ensureWslKernel({ emit }); } catch {}
+    try { await new Promise((r) => execFile("wsl", ["--unregister", DISTRO], { timeout: 30000, windowsHide: true }, () => r())); } catch {}
     await importTarball(dest, installDir);
   }
   // 3) Force a clean cold boot. A freshly-imported distro is often wedged, so the