cicy-desktop 2.1.134 → 2.1.136

package/package.json

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

package/src/backends/auth-loopback.js

@@ -47,6 +47,45 @@ const LOGIN_TIMEOUT_MS = 120_000;
 let _server = null;
 let _state = null;
 let _timeoutHandle = null;
+let _loginWindow = null;
+let _onResult = null;     // the caller's callback, for the user-closes-window case
+let _resultFired = false; // guard: onResult is delivered exactly once
+
+function closeLoginWindow() {
+  const w = _loginWindow;
+  _loginWindow = null;
+  if (w && !w.isDestroyed()) { try { w.removeAllListeners("closed"); w.close(); } catch {} }
+}
+
+// Open the login page in an IN-APP Electron window. This is the fix for "登录弹不出
+//网页": shell.openExternal needs a working default browser, which a fresh Windows
+// profile may not have. An in-app window has no such dependency, and the cloud's
+// 302 to http://127.0.0.1:<port>/cb lands right back in THIS window — the loopback
+// server answers it, firing onResult. Returns false if the window can't be made
+// (then the caller falls back to the system browser).
+function openLoginWindow(url) {
+  const { BrowserWindow } = require("electron");
+  try {
+    closeLoginWindow();
+    _loginWindow = new BrowserWindow({
+      width: 480, height: 760, title: "登录 CiCy", autoHideMenuBar: true, show: true,
+      webPreferences: { nodeIntegration: false, contextIsolation: true, partition: "persist:cicy-login" },
+    });
+    _loginWindow.loadURL(url);
+    // User closed the window before login completed → treat as cancel so the
+    // renderer's "登录中…" state is released instead of hanging until timeout.
+    _loginWindow.on("closed", () => {
+      _loginWindow = null;
+      if (_resultFired) return; // success already delivered; it shuts us down
+      try { _onResult && _onResult({ error: "login window closed" }); } catch {}
+      shutdown("login window closed by user");
+    });
+    return true;
+  } catch (e) {
+    log.warn(`[auth-loopback] in-app login window failed: ${e.message}`);
+    return false;
+  }
+}
 
 function shutdown(reason) {
   if (_timeoutHandle) { clearTimeout(_timeoutHandle); _timeoutHandle = null; }
@@ -54,6 +93,7 @@ function shutdown(reason) {
     try { _server.close(); } catch {}
     _server = null;
   }
+  closeLoginWindow();
   _state = null;
   if (reason) log.info(`[auth-loopback] shutdown: ${reason}`);
 }
@@ -64,6 +104,14 @@ async function startLogin({ onResult } = {}) {
 
   _state = crypto.randomBytes(16).toString("hex");
   const expectedState = _state;
+  _resultFired = false;
+  // Deliver the result to the caller exactly once — the server callback, the
+  // user-closes-window handler, and the timeout all race to be first.
+  _onResult = (payload) => {
+    if (_resultFired) return;
+    _resultFired = true;
+    try { onResult && onResult(payload); } catch {}
+  };
 
   _server = http.createServer((req, res) => {
     let url;
@@ -98,7 +146,7 @@ async function startLogin({ onResult } = {}) {
   <h1 style="color:#c00">登录失败</h1>
   <p>state 校验未通过，请回到 CiCy Desktop 重新点击 Login。</p>
 </body>`);
-      try { onResult && onResult({ error: "state mismatch" }); } catch {}
+      _onResult({ error: "state mismatch" });
       setTimeout(() => shutdown("state mismatch"), 500);
       return;
     }
@@ -110,14 +158,14 @@ async function startLogin({ onResult } = {}) {
   <h1 style="color:#c00">登录失败</h1>
   <p>未收到 token，请回到 CiCy Desktop 重试。</p>
 </body>`);
-      try { onResult && onResult({ error: "no token" }); } catch {}
+      _onResult({ error: "no token" });
       setTimeout(() => shutdown("no token"), 500);
       return;
     }
 
     res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
     res.end(SUCCESS_HTML);
-    try { onResult && onResult({ token, state, reused, accessToken, userId }); } catch {}
+    _onResult({ token, state, reused, accessToken, userId });
     setTimeout(() => shutdown("login complete"), 500);
   });
 
@@ -133,14 +181,18 @@ async function startLogin({ onResult } = {}) {
       });
       const url = `${LOGIN_BASE}?${params.toString()}`;
       log.info(`[auth-loopback] listening :${port}, opening ${url}`);
-      // Best-effort auto-open. On some setups (fresh Windows user with no default
-      // browser, locked-down shell) openExternal silently fails and the user is
-      // left stuck "等回调" with no recourse — so we ALSO return the url to the
-      // renderer (below) to show a manual "open / copy this link" fallback.
-      require("./open-external").openExternalRobust(url).catch((e) => log.warn(`[auth-loopback] open failed: ${e.message}`));
+      // Open the login page IN-APP (an Electron window) — works even when the
+      // machine has no/locked default browser, which is the "登录弹不出网页" bug.
+      // The cloud's 302 to http://127.0.0.1:<port>/cb lands back in this same
+      // window and the loopback server answers it. Only if the window can't be
+      // created do we fall back to the system browser. We still return the url so
+      // the renderer can offer a manual "open / copy link" last resort.
+      if (!openLoginWindow(url)) {
+        require("./open-external").openExternalRobust(url).catch((e) => log.warn(`[auth-loopback] open failed: ${e.message}`));
+      }
 
       _timeoutHandle = setTimeout(() => {
-        try { onResult && onResult({ error: "timeout" }); } catch {}
+        _onResult({ error: "timeout" });
         shutdown("timeout");
       }, LOGIN_TIMEOUT_MS);
 

package/src/sidecar/wsl-docker.js

@@ -121,6 +121,18 @@ function importTarball(dest, installDir) {
   });
 }
 
+// `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,
+// so startEngine's first `wsl -d` command times out, dockerd never launches, and
+// its log is never even created (exactly what we saw on a new Windows user). A
+// terminate + cold boot makes that first real command hit a clean distro.
+function wslTerminate() {
+  return new Promise((resolve) => {
+    execFile("wsl", ["--terminate", DISTRO], { timeout: 30000, windowsHide: true }, () => resolve());
+  });
+}
+
 async function installDistro({ emit } = {}) {
   // 1) Download the PRE-BAKED rootfs (Ubuntu+Docker+image baked in, ~444MB) with
   //    a real progress bar. curl is ~10× faster than node's downloader on OSS.
@@ -147,7 +159,13 @@ async function installDistro({ emit } = {}) {
     await ensureWslKernel({ emit });
     await importTarball(dest, installDir);
   }
-  // 3) Free the ~444MB package now that the distro has everything.
+  // 3) Force a clean cold boot. A freshly-imported distro is often wedged, so the
+  //    next `wsl -d` (startEngine) would time out → dockerd never starts. Terminate
+  //    now so that first real command boots a clean distro instead.
+  emit && emit({ phase: "container", status: "running", message: "重置运行环境(冷启动)…" });
+  try { await wslTerminate(); } catch {}
+
+  // 4) Free the ~444MB package now that the distro has everything.
   try { fs.unlinkSync(dest); } catch {}
 }
 
@@ -195,6 +213,7 @@ async function startEngine() {
   // 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();
+    let launchErr = null;
     log.info(`[startEngine] attempt ${attempt}/3 — (re)launch dockerd + wait for socket`);
     try {
       await wslRun(
@@ -213,17 +232,24 @@ 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 (e) { log.warn(`[startEngine] attempt ${attempt} launch/wait errored: ${e.message}`); }
+    } catch (e) { launchErr = 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.
-    try {
-      await wslRun(
-        "if ! pgrep dockerd >/dev/null 2>&1; then rm -f /var/run/docker.pid /run/docker.pid /var/run/docker.sock /run/docker.sock; fi; sleep 1",
-        { timeout: 15000 });
-    } catch {}
+    // Reset between attempts. If the launch itself ERRORED (timeout = WSL wedged /
+    // unresponsive — the post-import failure where the command can't even get into
+    // the distro), `wsl --terminate` so the next attempt cold-boots a CLEAN distro;
+    // clearing pid files inside a wedged WSL does nothing. Otherwise dockerd just
+    // died/is slow — clear stale runtime files only when it's actually gone.
+    if (launchErr) {
+      log.info(`[startEngine] launch errored → wsl --terminate for a clean cold boot`);
+      try { await wslTerminate(); } catch {}
+    } else {
+      try {
+        await wslRun(
+          "if ! pgrep dockerd >/dev/null 2>&1; then rm -f /var/run/docker.pid /run/docker.pid /var/run/docker.sock /run/docker.sock; fi; sleep 1",
+          { timeout: 15000 });
+      } catch {}
+    }
   }
   log.error("[startEngine] ✗ dockerd NOT up after 3 attempts");
   return false;