cicy-desktop 2.1.107 → 2.1.109

package/package.json

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

package/src/sidecar/docker.js

@@ -504,15 +504,51 @@ function wslMissing() {
   }
 }
 
+// Read-only, works without elevation. True iff a Windows optional feature
+// reports State : Enabled.
+function featureEnabled(feature) {
+  return new Promise((resolve) => {
+    execFile("dism", ["/english", "/online", "/get-featureinfo", `/featurename:${feature}`],
+      { timeout: 30000, windowsHide: true },
+      (_e, out) => resolve(/State\s*:\s*Enabled/i.test(String(out || ""))));
+  });
+}
+
+// Enable ONE Windows optional feature, elevated, and WAIT until it actually
+// reports Enabled. The old `wsl --install` was fire-and-forget — it could
+// silently no-op, leaving the card stuck on "reboot required" forever. Here we
+// drive DISM and verify, streaming every step to the install drawer.
+async function dismEnableFeature(feature, label, { emit } = {}) {
+  if (await featureEnabled(feature)) {
+    emit && emit({ phase: "install-docker", status: "running", message: `${label}：已启用，跳过` });
+    return true;
+  }
+  emit && emit({ phase: "install-docker", status: "running", message: `${label}：正在启用（约 1–2 分钟，请稍候）…` });
+  await launchElevated("dism", ["/online", "/enable-feature", `/featurename:${feature}`, "/all", "/norestart"], { emit }).catch(() => {});
+  // launchElevated fires the elevated task and returns immediately; poll the
+  // real feature state (DISM exits 3010 = success + reboot-required).
+  const ok = await waitUntil(() => featureEnabled(feature), { totalMs: 240000, everyMs: 5000 });
+  emit && emit({ phase: "install-docker", status: ok ? "running" : "error", message: ok ? `${label}：已启用 ✓` : `${label}：未能确认启用（点「重试」）` });
+  return ok;
+}
+
 // Ensure the WSL2 backend exists; install it (elevated) if missing. Returns
-// { ok } when present, or { needsReboot } after kicking off `wsl --install`
-// (which requires admin + a Windows reboot before Docker can use it).
+// { ok } when already present, { needsReboot } after the two required Windows
+// 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 };
-  emit && emit({ phase: "install-docker", status: "running", message: "Docker 需要 WSL2 后端，正在安装 WSL（请在管理员授权框点「是」，装完需重启 Windows）…" });
-  // --no-distribution: just the WSL2 platform (Docker brings its own distro);
-  // falls back to plain `wsl --install` on older builds that reject the flag.
-  await launchElevated("wsl", ["--install", "--no-distribution"], { emit });
+  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 });
+  if (!a || !b) {
+    emit && emit({ phase: "done", status: "error", message: "WSL 功能未能全部启用——请点「重试」" });
+    return { ok: false, needsReboot: false, failed: true };
+  }
+  // Best-effort: also pull the WSL2 kernel/plumbing (no-op until reboot on some
+  // builds; harmless if it errors).
+  await launchElevated("wsl", ["--install", "--no-distribution"], { emit }).catch(() => {});
+  emit && emit({ phase: "install-docker", status: "running", message: "WSL2 功能已启用 ✓，需【重启 Windows】后回来点「重试」继续。" });
   return { ok: false, needsReboot: true };
 }
 

package/src/sidecar/wsl-docker.js

@@ -11,12 +11,21 @@
 // → health-probe :8009 from Windows. Every step checks-then-acts and is
 // idempotent, so 重试 resumes.
 
-const { execFile, execFileSync } = require("child_process");
+const { execFile, execFileSync, spawn } = require("child_process");
 const path = require("path");
+const os = require("os");
+const fs = require("fs");
 const docker = require("./docker"); // shared: downloads, waitUntil, probeHealth, launchElevated, ensureWsl…
 
 const DISTRO   = process.env.CICY_WSL_DISTRO || "Ubuntu";
 const IMAGE    = process.env.CICY_DOCKER_IMAGE || "cicybot/cicy-code:latest";
+// Ubuntu WSL rootfs from the Tsinghua TUNA mirror (CN-fast). We download it
+// ourselves (real progress bar) and `wsl --import` it, instead of
+// `wsl --install -d Ubuntu` (no parseable progress, needs the MS Store).
+const ROOTFS_URL = process.env.CICY_WSL_ROOTFS_URL ||
+  "https://mirrors.tuna.tsinghua.edu.cn/ubuntu-cloud-images/wsl/jammy/current/ubuntu-jammy-wsl-amd64-ubuntu22.04lts.rootfs.tar.gz";
+
+function rootfsPath() { return path.join(docker.downloadsDir(), "ubuntu-jammy-wsl-rootfs.tar.gz"); }
 
 // Run a bash command as root inside the distro. execFile (no host shell) → the
 // command string is passed verbatim to `bash -lc`, so only bash-level quoting
@@ -32,6 +41,34 @@ function wslRun(cmd, { timeout = 60000, distro = DISTRO } = {}) {
   });
 }
 
+// Like wslRun, but STREAMS each output line to the install drawer so the user
+// (and the customer) watch the real install proceed — apt fetching/unpacking,
+// `docker load` layers — instead of staring at a frozen spinner. Throttled so
+// rapid output doesn't flood the log; resolves { stdout } with the full tail.
+function wslRunStream(cmd, { emit, phase = "install-docker", timeout = 900000, distro = DISTRO } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("wsl", ["-d", distro, "-u", "root", "--", "bash", "-lc", cmd], { windowsHide: true });
+    let buf = "", tail = "", last = 0;
+    const pump = (chunk) => {
+      buf += chunk.toString("utf8");
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl).replace(/\r$/, "").trim();
+        buf = buf.slice(nl + 1);
+        if (!line) continue;
+        tail += line + "\n";
+        const now = Date.now();
+        if (emit && now - last > 350) { last = now; emit({ phase, status: "running", message: line.slice(0, 200) }); }
+      }
+    };
+    child.stdout.on("data", pump);
+    child.stderr.on("data", pump);
+    const timer = setTimeout(() => { try { child.kill("SIGKILL"); } catch {} reject(Object.assign(new Error("timeout"), { stdout: tail })); }, timeout);
+    child.on("error", (e) => { clearTimeout(timer); reject(e); });
+    child.on("close", (code) => { clearTimeout(timer); code === 0 ? resolve({ stdout: tail }) : reject(Object.assign(new Error(`exit ${code}`), { stdout: tail })); });
+  });
+}
+
 // Is `DISTRO` registered? `wsl -l -q` lists installed distros (UTF-16LE).
 function distroInstalled(distro = DISTRO) {
   if (process.platform !== "win32") return false;
@@ -46,16 +83,24 @@ function distroInstalled(distro = DISTRO) {
 // (--no-launch). We always run commands as root afterwards, so no user account
 // is needed. Elevated via the scheduled-task path (reliable on these machines).
 async function installDistro({ emit } = {}) {
-  emit && emit({ phase: "install-docker", status: "running", message: `安装 ${DISTRO} 子系统（首次下载较大，请耐心等待）…` });
-  // Try non-elevated first (adding a distro to an existing WSL is per-user);
-  // fall back to elevated if it errors.
-  try {
-    await new Promise((resolve, reject) => {
-      execFile("wsl", ["--install", "-d", DISTRO, "--no-launch"], { timeout: 600000, windowsHide: true }, (err) => err ? reject(err) : resolve());
-    });
-  } catch {
-    await docker.launchElevated("wsl", ["--install", "-d", DISTRO, "--no-launch"], { emit });
-  }
+  // 1) Download the rootfs with a REAL progress bar (Tsinghua mirror, resumable).
+  const dest = rootfsPath();
+  await docker.ensureDownloaded(ROOTFS_URL, dest, null, { emit, phase: "install-docker", label: "下载 Ubuntu" });
+  // 2) Ensure the WSL2 kernel exists (a feature-enable + reboot leaves the kernel
+  //    component missing → `--import --version 2` errors). Best-effort, non-fatal.
+  emit && emit({ phase: "install-docker", status: "running", message: "检查/更新 WSL2 内核…" });
+  await new Promise((res) => execFile("wsl", ["--update", "--web-download"], { timeout: 180000, windowsHide: true }, () => res()));
+  try { await new Promise((res) => execFile("wsl", ["--set-default-version", "2"], { timeout: 15000, windowsHide: true }, () => res())); } catch {}
+  // 3) Import it as a WSL2 distro (creates the VHD under installDir; no MS Store,
+  //    no interactive first-run — we run everything as root afterwards).
+  emit && emit({ phase: "install-docker", status: "running", message: "导入 Ubuntu 到 WSL2…" });
+  const installDir = path.join(process.env["LOCALAPPDATA"] || path.join(os.homedir(), "AppData", "Local"), "cicy-ubuntu");
+  try { fs.mkdirSync(installDir, { recursive: true }); } catch {}
+  await new Promise((resolve, reject) => {
+    execFile("wsl", ["--import", DISTRO, installDir, dest, "--version", "2"],
+      { timeout: 600000, windowsHide: true },
+      (err, _so, se) => err ? reject(Object.assign(err, { stderr: String(se || "") })) : resolve());
+  });
 }
 
 // docker CLI present inside the distro?
@@ -66,8 +111,8 @@ async function dockerInstalled() {
 
 // Install Docker Engine (docker.io) inside the distro.
 async function installDockerEngine({ emit } = {}) {
-  emit && emit({ phase: "install-docker", status: "running", message: "在 Ubuntu 里安装 Docker（apt，几分钟）…" });
-  await wslRun("apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y docker.io", { timeout: 900000 });
+  emit && emit({ phase: "install-docker", status: "running", message: "在 Ubuntu 里安装 Docker（apt,几分钟,下面是实时进度）…" });
+  await wslRunStream("apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y docker.io 2>&1", { emit, phase: "install-docker", timeout: 900000 });
 }
 
 // dockerd reachable inside the distro?
@@ -96,9 +141,9 @@ function toWslPath(winPath) {
 
 // docker load the (Windows-side) tarball into the distro's Docker + retag.
 async function loadImage(winTarballPath, { emit } = {}) {
-  emit && emit({ phase: "image", status: "loading", message: "正在导入镜像到 Docker（较大，约 1-3 分钟，请稍候）…" });
+  emit && emit({ phase: "image", status: "loading", message: "正在导入镜像到 Docker（较大,约 1-3 分钟,下面是实时进度）…" });
   const p = toWslPath(winTarballPath);
-  const { stdout } = await wslRun(`docker load -i "${p}"`, { timeout: 600000 });
+  const { stdout } = await wslRunStream(`docker load -i "${p}"`, { emit, phase: "image", timeout: 600000 });
   const m = String(stdout).match(/Loaded image:\s*(\S+)/i);
   if (m && m[1] !== IMAGE) { try { await wslRun(`docker tag ${m[1]} ${IMAGE}`, { timeout: 15000 }); } catch {} }
 }
@@ -155,7 +200,8 @@ async function bootstrap({ onProgress, port = 8009, container = "cicy-code-docke
   // 2) Ubuntu distro
   if (!distroInstalled()) {
     try { await installDistro({ emit }); } catch (e) { emit({ phase: "done", status: "error", message: `Ubuntu 安装失败：${e.message}（点重试）` }); return { ok: false, reason: "distro_install_failed" }; }
-    const ok = await docker.waitUntil(() => distroInstalled(), { totalMs: 600000, everyMs: 5000 });
+    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: "done", status: "error", message: "Ubuntu 还没装好——稍等或点「重试」" }); return { ok: false, reason: "distro_not_ready" }; }
   }