cicy-desktop 2.1.122 → 2.1.124

package/package.json

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

package/src/sidecar/docker.js

@@ -556,16 +556,19 @@ function launchElevated(exe, args, { emit } = {}) {
 // hangs on "正在启动 Docker Desktop". Detect a missing WSL. `wsl` prints UTF-16
 // and a fresh Windows without the feature says "未安装 / not installed / can be
 // installed by running wsl.exe --install".
-function wslMissing() {
+async function wslMissing() {
   if (process.platform !== "win32") return false;
-  try {
-    const out = execFileSync("wsl", ["--status"], { timeout: 8000, windowsHide: true, encoding: "utf16le", stdio: ["ignore", "pipe", "pipe"] });
-    return /未安装|not installed|--install/i.test(String(out));
-  } catch (e) {
-    const s = String((e.stdout || "") + (e.stderr || ""));
-    if (/未安装|not installed|--install/i.test(s)) return true;
-    return false; // wsl present but errored for another reason — assume OK
-  }
+  // ASYNC execFile, NOT execFileSync: this runs on the homepage's status poll,
+  // and a cold post-reboot WSL can take many seconds to answer `wsl --status`.
+  // A sync call there blocked the whole Electron main process → the window went
+  // "未响应". Capture stdout+stderr even on a non-zero exit (a fresh Windows
+  // without WSL prints the "not installed / --install" hint and exits non-zero).
+  return await new Promise((resolve) => {
+    execFile("wsl", ["--status"], { timeout: 8000, windowsHide: true, encoding: "utf16le" }, (err, stdout, stderr) => {
+      const s = String((stdout || "") + (stderr || "") + (err && err.message ? err.message : ""));
+      resolve(/未安装|not installed|--install/i.test(s));
+    });
+  });
 }
 
 // Read-only, works without elevation. True iff a Windows optional feature
@@ -601,7 +604,7 @@ async function dismEnableFeature(feature, label, { emit } = {}) {
 // features are verified-enabled (a Windows reboot is then needed before Docker
 // can use WSL2), or { failed } if a feature couldn't be enabled.
 async function ensureWsl({ emit } = {}) {
-  if (!wslMissing()) return { ok: true };
+  if (!(await wslMissing())) return { ok: true };
   emit && emit({ phase: "install-docker", status: "running", message: "Docker 需要 WSL2 后端，开始启用所需的 Windows 功能…" });
   const a = await dismEnableFeature("Microsoft-Windows-Subsystem-Linux", "启用 WSL 功能 1/2 · Linux 子系统", { emit });
   const b = await dismEnableFeature("VirtualMachinePlatform", "启用 WSL 功能 2/2 · 虚拟机平台", { emit });

package/src/sidecar/wsl-docker.js

@@ -16,6 +16,7 @@ const path = require("path");
 const os = require("os");
 const fs = require("fs");
 const docker = require("./docker"); // shared: downloads, waitUntil, probeHealth, launchElevated, ensureWsl…
+const log = require("electron-log"); // persisted main.log — bootstrap timing/failures land here
 
 // Dedicated distro name — NEVER reuse/clobber a user's own "Ubuntu" distro.
 const DISTRO   = process.env.CICY_WSL_DISTRO || "cicy-code-wsl";
@@ -88,13 +89,18 @@ function wslRunStream(cmd, { emit, phase = "install-docker", timeout = 900000, d
 }
 
 // Is `DISTRO` registered? `wsl -l -q` lists installed distros (UTF-16LE).
-function distroInstalled(distro = DISTRO) {
+async function distroInstalled(distro = DISTRO) {
   if (process.platform !== "win32") return false;
-  try {
-    const out = execFileSync("wsl", ["-l", "-q"], { timeout: 8000, windowsHide: true, encoding: "utf16le" });
-    return String(out).split(/\r?\n/).map((s) => s.replace(/\0/g, "").trim()).filter(Boolean)
-      .some((d) => d.toLowerCase() === distro.toLowerCase());
-  } catch { return false; }
+  // ASYNC execFile, NOT execFileSync: this runs on the homepage's status poll,
+  // and a sync `wsl -l -q` on a cold post-reboot WSL blocked the Electron main
+  // process for seconds → window "未响应". (waitUntil awaits the promise fine.)
+  return await new Promise((resolve) => {
+    execFile("wsl", ["-l", "-q"], { timeout: 8000, windowsHide: true, encoding: "utf16le" }, (err, stdout) => {
+      if (err) return resolve(false);
+      resolve(String(stdout || "").split(/\r?\n/).map((s) => s.replace(/\0/g, "").trim()).filter(Boolean)
+        .some((d) => d.toLowerCase() === distro.toLowerCase()));
+    });
+  });
 }
 
 // Install the Ubuntu distro WITHOUT launching its interactive first-run setup
@@ -182,6 +188,8 @@ async function startEngine() {
   // runtime files, (re)launches dockerd, and waits for the socket; between
   // attempts we hard-kill any half-dead daemon so the next launch is clean.
   for (let attempt = 1; attempt <= 3; attempt++) {
+    const at0 = Date.now();
+    log.info(`[startEngine] attempt ${attempt}/3 — (re)launch dockerd + wait for socket`);
     try {
       await wslRun(
         "update-alternatives --set iptables /usr/sbin/iptables-legacy >/dev/null 2>&1; " +
@@ -199,8 +207,9 @@ async function startEngine() {
         // cold again (a restart loop → 「引擎没起来」even though dockerd was fine).
         "for i in $(seq 1 120); do [ -S /var/run/docker.sock ] && docker version >/dev/null 2>&1 && break; sleep 1; done",
         { timeout: 150000 });
-    } catch {}
-    if (await dockerEngineUp()) return true;
+    } catch (e) { log.warn(`[startEngine] attempt ${attempt} launch/wait errored: ${e.message}`); }
+    if (await dockerEngineUp()) { log.info(`[startEngine] ✓ dockerd up on attempt ${attempt} (${((Date.now() - at0) / 1000).toFixed(1)}s)`); return true; }
+    log.warn(`[startEngine] attempt ${attempt} dockerd still not up after ${((Date.now() - at0) / 1000).toFixed(1)}s`);
     // Not up after the wait. Only hard-reset when dockerd actually DIED (crash) —
     // if it's still alive it's just slow/mid-init, so leave it and let the next
     // attempt's wait loop keep polling instead of killing a healthy daemon.
@@ -210,6 +219,7 @@ async function startEngine() {
         { timeout: 15000 });
     } catch {}
   }
+  log.error("[startEngine] ✗ dockerd NOT up after 3 attempts");
   return false;
 }
 
@@ -310,7 +320,11 @@ function ensureAutostart() {
   return new Promise((res) => {
     const tr = `wsl.exe -d ${DISTRO} -u root -e /usr/local/sbin/start-dockerd.sh`;
     execFile("schtasks", ["/create", "/tn", "cicy-docker-autostart", "/tr", tr, "/sc", "onlogon", "/rl", "HIGHEST", "/f"],
-      { windowsHide: true }, () => res());
+      { windowsHide: true }, (err, _stdout, stderr) => {
+        if (err) log.warn(`[ensureAutostart] schtasks create FAILED (dockerd won't auto-start after reboot): ${err.message}${stderr ? ` / ${String(stderr).trim()}` : ""}`);
+        else log.info("[ensureAutostart] logon task 'cicy-docker-autostart' registered → dockerd starts on next logon");
+        res();
+      });
   });
 }
 
@@ -350,8 +364,8 @@ function ensureDesktopShortcut(volume = "cicy-team-8009", port = 8009) {
 
 // Composite status for the card.
 async function status(port = 8009) {
-  const wsl = !docker.wslMissing();
-  const distro = wsl && distroInstalled();
+  const wsl = !(await docker.wslMissing());
+  const distro = wsl && (await distroInstalled());
   const engineUp = distro && (await dockerEngineUp());
   const running = engineUp && (await probeHealth(port));
   return { wsl, distro, engineUp, running };
@@ -375,65 +389,104 @@ async function bootstrap(opts = {}) {
 async function _bootstrap({ onProgress, port = 8009, container = "cicy-code-docker", volume = "cicy-team", env = {} } = {}) {
   const emit = (ev) => { try { onProgress && onProgress(ev); } catch {} };
 
+  // Structured, PERSISTED trace of the whole run (electron-log → main.log) so a
+  // failed "重启后起不来" is diagnosable AFTER the fact instead of staring at the
+  // ephemeral progress modal. Each step logs ▶start / ✓done(+duration, or "skip"
+  // when already satisfied) / ✗fail(+reason+duration); the final line gives the
+  // total time and the SLOWEST step, plus a [name,ms] breakdown of every step.
+  const BT0 = Date.now();
+  const secs = (t) => `${((Date.now() - t) / 1000).toFixed(1)}s`;
+  const steps = [];
+  let _pt = BT0, _pname = "";
+  const begin = (name) => { _pname = name; _pt = Date.now(); log.info(`[bootstrap] ▶ ${name}`); };
+  const done  = (skip) => { steps.push([_pname, Date.now() - _pt]); log.info(`[bootstrap] ✓ ${_pname}${skip ? " (skip)" : ""} ${secs(_pt)}`); };
+  const fail  = (reason, extra) => { steps.push([`${_pname}:FAIL`, Date.now() - _pt]); log.error(`[bootstrap] ✗ ${_pname} reason=${reason} ${secs(_pt)}${extra ? `\n${extra}` : ""}`); };
+  const finish = (ok, reason) => {
+    const slow = steps.slice().sort((a, b) => b[1] - a[1])[0];
+    log.info(`[bootstrap] ${ok ? "DONE ✓" : `ABORT ✗ reason=${reason}`} total=${secs(BT0)} slowest=${slow ? `${slow[0]} ${(slow[1] / 1000).toFixed(1)}s` : "n/a"} steps=${JSON.stringify(steps.map(([n, d]) => [n, Math.round(d)]))}`);
+  };
+  log.info(`[bootstrap] START port=${port} container=${container} volume=${volume}`);
+
   // 0) Fast path: already healthy → instant no-op (idempotent one-shot).
+  begin("probe-healthy");
   if (await probeHealth(port)) {
+    done();
     emit({ phase: "done", status: "done", message: "Docker cicy-code 已就绪 🎉" });
+    finish(true);
     return { ok: true, container };
   }
+  done();
 
   // 1) WSL2 platform
-  if (docker.wslMissing()) {
+  begin("ensure-wsl");
+  if (await docker.wslMissing()) {
     const w = await docker.ensureWsl({ emit });
-    if (w.needsReboot) { emit({ phase: "done", status: "reboot", message: "WSL2 正在安装——请【重启 Windows】后回来点「重试」继续。" }); return { ok: false, reason: "wsl_reboot_required" }; }
-  }
+    if (w.needsReboot) { fail("wsl_reboot_required"); emit({ phase: "done", status: "reboot", message: "WSL2 正在安装——请【重启 Windows】后回来点「重试」继续。" }); finish(false, "wsl_reboot_required"); return { ok: false, reason: "wsl_reboot_required" }; }
+    done();
+  } else done(true);
 
   // 2) Ubuntu distro
-  if (!distroInstalled()) {
-    try { await installDistro({ emit }); } catch (e) { emit({ phase: "install-docker", status: "error", message: `Ubuntu 安装失败：${e.message}（点重试）` }); return { ok: false, reason: "distro_install_failed" }; }
+  begin("ensure-distro");
+  if (!(await distroInstalled())) {
+    try { await installDistro({ emit }); } catch (e) { fail("distro_install_failed", e.message); emit({ phase: "install-docker", status: "error", message: `Ubuntu 安装失败：${e.message}（点重试）` }); finish(false, "distro_install_failed"); return { ok: false, reason: "distro_install_failed" }; }
     const t0 = Date.now();
     const ok = await docker.waitUntil(() => distroInstalled(), { totalMs: 600000, everyMs: 5000, onTick: () => emit({ phase: "install-docker", status: "running", message: `正在下载/注册 Ubuntu…（已 ${Math.round((Date.now() - t0) / 1000)}s,首次较慢请耐心）` }) });
-    if (!ok) { emit({ phase: "install-docker", status: "error", message: "Ubuntu 还没装好——稍等或点「重试」" }); return { ok: false, reason: "distro_not_ready" }; }
-  }
+    if (!ok) { fail("distro_not_ready"); emit({ phase: "install-docker", status: "error", message: "Ubuntu 还没装好——稍等或点「重试」" }); finish(false, "distro_not_ready"); return { ok: false, reason: "distro_not_ready" }; }
+    done();
+  } else done(true);
 
   // 3) Docker Engine inside Ubuntu
+  begin("install-docker-engine");
   if (!(await dockerInstalled())) {
-    try { await installDockerEngine({ emit }); } catch (e) { emit({ phase: "install-docker", status: "error", message: `Docker 安装失败：${e.message}（点重试）` }); return { ok: false, reason: "docker_install_failed" }; }
-  }
+    try { await installDockerEngine({ emit }); } catch (e) { fail("docker_install_failed", e.message); emit({ phase: "install-docker", status: "error", message: `Docker 安装失败：${e.message}（点重试）` }); finish(false, "docker_install_failed"); return { ok: false, reason: "docker_install_failed" }; }
+    done();
+  } else done(true);
 
   // 4) dockerd up (phase "container" = 启动服务)
+  begin("start-dockerd");
   if (!(await dockerEngineUp())) {
     emit({ phase: "container", status: "running", message: "启动 Docker 引擎（首次较慢，请耐心）…" });
     const started = await startEngine(); // 3 clean attempts internally
     const up = started || await docker.waitUntil(dockerEngineUp, { totalMs: 120000, everyMs: 3000 });
     if (!up) {
-      const log = await dockerdLogTail();
-      emit({ phase: "container", status: "error", message: "Docker 引擎没起来——点「重试」" + (log ? `\n\ndockerd 日志（最后几行）:\n${log}` : "") });
+      const dlog = await dockerdLogTail();
+      fail("dockerd_not_up", dlog ? `dockerd log:\n${dlog}` : "");
+      emit({ phase: "container", status: "error", message: "Docker 引擎没起来——点「重试」" + (dlog ? `\n\ndockerd 日志（最后几行）:\n${dlog}` : "") });
+      finish(false, "dockerd_not_up");
       return { ok: false, reason: "dockerd_not_up" };
     }
-  }
+    done();
+  } else done(true);
 
   // 5) Base image — pre-baked into the package, so this normally just confirms.
   //    The download-tarball path is a fallback for a non-pre-baked rootfs.
+  begin("ensure-image");
   if (!(await imagePresent())) {
     let tarball;
     try { tarball = await docker.downloadImageTarball({ emit }); }
-    catch (e) { emit({ phase: "image", status: "error", message: `镜像下载失败：${e.message}（点重试续传）` }); return { ok: false, reason: "image_download_failed" }; }
+    catch (e) { fail("image_download_failed", e.message); emit({ phase: "image", status: "error", message: `镜像下载失败：${e.message}（点重试续传）` }); finish(false, "image_download_failed"); return { ok: false, reason: "image_download_failed" }; }
     try { await loadImage(tarball, { emit }); }
-    catch (e) { emit({ phase: "image", status: "error", message: `镜像导入失败：${e.message}（点重试）` }); return { ok: false, reason: "image_load_failed" }; }
-  }
+    catch (e) { fail("image_load_failed", e.message); emit({ phase: "image", status: "error", message: `镜像导入失败：${e.message}（点重试）` }); finish(false, "image_load_failed"); return { ok: false, reason: "image_load_failed" }; }
+    done();
+  } else done(true);
 
   // 6) Container (phase "container" = 启动服务)
+  begin("run-container");
   if (!(await probeHealth(port))) {
     emit({ phase: "container", status: "running", message: "启动 cicy-code 服务…" });
     try { await runContainer({ port, container, volume, env }); }
-    catch (e) { emit({ phase: "container", status: "error", message: `服务启动失败：${e.message}（点重试）` }); return { ok: false, reason: "container_start_failed" }; }
-  }
+    catch (e) { fail("container_start_failed", e.message); emit({ phase: "container", status: "error", message: `服务启动失败：${e.message}（点重试）` }); finish(false, "container_start_failed"); return { ok: false, reason: "container_start_failed" }; }
+    done();
+  } else done(true);
 
   // 7) Health — the ONLY path to ok:true.
+  begin("wait-health");
   emit({ phase: "container", status: "running", message: "等待 cicy-code 就绪…" });
   const healthy = await docker.waitUntil(() => probeHealth(port), { totalMs: 120000, everyMs: 3000 });
-  if (healthy) { await ensureAutostart(); await ensureDesktopShortcut(volume, port); } // survive reboot + desktop shortcut
+  if (healthy) { done(); await ensureAutostart(); await ensureDesktopShortcut(volume, port); } // survive reboot + desktop shortcut
+  else fail("health_timeout");
   emit({ phase: healthy ? "done" : "container", status: healthy ? "done" : "error", message: healthy ? "Docker cicy-code 已就绪 🎉" : `服务起来了但 :${port} 还没响应——稍等或点「重试」` });
+  finish(healthy, healthy ? null : "health_timeout");
   return { ok: healthy, container };
 }