cicy-desktop 2.1.73 → 2.1.74

package/package.json

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

package/src/backends/homepage-preload.js

@@ -24,13 +24,17 @@ const { contextBridge, ipcRenderer, shell } = require("electron");
 // args, and the reply (or error) to the console. Skip noisy channels that
 // fire on every render tick to avoid drowning the console.
 const __noisy = new Set(["backends:list", "backends:health-all"]);
+// Per-IPC call/reply tracing floods the console on every render tick and is
+// pure debug noise for someone just running `npx cicy-desktop`. Off by default;
+// set CICY_DEBUG=1 to restore it. Errors are always logged.
+const __verbose = !!(process.env.CICY_DEBUG || process.env.CICY_VERBOSE);
 let __ipcSeq = 0;
 function logInvoke(channel, ...args) {
   const id = ++__ipcSeq;
   const noisy = __noisy.has(channel);
-  if (!noisy) console.log(`[ipc#${id}] call`, channel, ...args);
+  if (__verbose && !noisy) console.log(`[ipc#${id}] call`, channel, ...args);
   return ipcRenderer.invoke(channel, ...args).then(
-    (res) => { if (!noisy) console.log(`[ipc#${id}] reply`, channel, res); return res; },
+    (res) => { if (__verbose && !noisy) console.log(`[ipc#${id}] reply`, channel, res); return res; },
     (err) => { console.error(`[ipc#${id}] error`, channel, err); throw err; },
   );
 }

package/src/backends/homepage-window.js

@@ -72,8 +72,11 @@ async function openHomepage() {
 
   // Pipe renderer console + load failures to main-process stdout so we can
   // diagnose blank-page bugs from logs without opening DevTools.
+  const __verbose = !!(process.env.CICY_DEBUG || process.env.CICY_VERBOSE);
   homepage.webContents.on("console-message", (_e, level, msg, line, source) => {
-    if (level >= 1) console.log(`[homepage:console L${line}] ${msg}  (${source})`);
+    // Warnings/errors (level>=2) always surface — they're what diagnose a blank
+    // page. The chatty info stream only with CICY_DEBUG.
+    if (level >= 2 || (__verbose && level >= 1)) console.log(`[homepage:console L${line}] ${msg}  (${source})`);
   });
   // Log load failures (corrupt/missing install) — no remote fallback by
   // design: the homepage is the bundled SPA, full stop.

package/src/backends/local-teams.js

@@ -258,6 +258,20 @@ async function openTeam(id) {
     return { ok: true, windowId: existing.id, reused: true };
   }
 
+  // No window yet. Before opening one against a LOCAL sidecar, make sure the
+  // daemon is REALLY up (TCP 探活) — opening a window at a not-yet-ready :8008
+  // loads a blank page the user has to manually reload (主人 bug). Start it if
+  // it isn't running, then poll until it answers; bail (no blank window) if it
+  // never comes up. Remote/custom (non-localhost) teams skip this — their page
+  // shows its own connecting/login UI.
+  if (isLocalOrigin(url)) {
+    const ready = await ensureLocalSidecarAlive(url);
+    if (!ready) {
+      log.warn(`[local-teams] open ${id} → local sidecar not ready, not opening blank window`);
+      return { ok: false, error: "sidecar_not_ready" };
+    }
+  }
+
   const { createWindow } = require("../utils/window-utils");
   const win = createWindow(
     { url, title: `Local · ${node.name || id}` },
@@ -268,6 +282,31 @@ async function openTeam(id) {
   return { ok: true, windowId: win.id, reused: false };
 }
 
+// Is this URL served by something on the local machine (the cicy-code sidecar)?
+function isLocalOrigin(url) {
+  try { const h = new URL(url).hostname; return h === "127.0.0.1" || h === "localhost" || h === "::1"; }
+  catch { return false; }
+}
+
+// Ensure the local cicy-code daemon serving `url` actually answers before we
+// open a window at it. Already up → true immediately. Down → start it, then
+// poll a TCP probe (NOT /api/health, which is unreliable mid-boot) until it
+// binds or we time out.
+async function ensureLocalSidecarAlive(url, { timeoutMs = 15000 } = {}) {
+  let port;
+  try { port = Number(new URL(url).port) || 8008; } catch { return true; } // unparseable → don't block
+  let sidecar;
+  try { sidecar = require("../sidecar/cicy-code"); } catch { return true; }
+  if (await sidecar.probeExisting(port)) return true;       // already answering
+  try { await sidecar.start({ port }); } catch {}            // not up → bring it up
+  const t0 = Date.now();
+  while (Date.now() - t0 < timeoutMs) {
+    if (await sidecar.probeExisting(port)) return true;
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  return false;
+}
+
 function stripVolatile(u) {
   try {
     const p = new URL(u);
@@ -303,6 +342,25 @@ function reloadTeam(id) {
   }
 }
 
+// Close any open window served by the local sidecar (origin
+// http://127.0.0.1:<port> or http://localhost:<port>). Called when the sidecar
+// is STOPPED so a now-dead :8008 team window doesn't linger showing a broken
+// page (主人 bug report: stop 后应关掉 localhost 的 window).
+function closeLocalWindows(port = 8008) {
+  const origins = new Set([`http://127.0.0.1:${port}`, `http://localhost:${port}`]);
+  let closed = 0;
+  for (const w of BrowserWindow.getAllWindows()) {
+    if (!w || w.isDestroyed()) continue;
+    let origin = "";
+    try { origin = new URL(w.webContents.getURL()).origin; } catch { continue; }
+    if (origins.has(origin)) {
+      try { w.close(); closed++; } catch {}
+    }
+  }
+  if (closed) log.info(`[local-teams] closed ${closed} local window(s) on :${port} after stop`);
+  return closed;
+}
+
 // ── mutations ──────────────────────────────────────────────────────────
 //
 // add/remove/upgrade let an external caller (currently the cloud Team
@@ -737,4 +795,4 @@ async function upgradeTeam(id) {
   return result;
 }
 
-module.exports = { list, openTeam, reloadTeam, addTeam, removeTeam, updateTeam, upgradeTeam };
+module.exports = { list, openTeam, reloadTeam, closeLocalWindows, addTeam, removeTeam, updateTeam, upgradeTeam };

package/src/backends/sidecar-ipc.js

@@ -92,6 +92,9 @@ function register({ sidecarLogPath } = {}) {
   ipcMain.handle("sidecar:stop", async () => {
     try {
       await sidecar.stop();
+      // The daemon is gone — close any open team window pointing at it so the
+      // user isn't left staring at a dead :8008 page (主人 bug report).
+      try { require("./local-teams").closeLocalWindows(PORT); } catch {}
       return { ok: true };
     } catch (e) {
       return { ok: false, error: e.message };

package/src/utils/window-monitor.js

@@ -331,15 +331,21 @@ function initWindowMonitoring(win) {
     const logs = windowLogs.get(winId);
 
     const counters = windowIndexCounters.get(winId);
-    log.info(
-      `[${JSON.stringify({
-        timestamp: Date.now(),
-        level: ["verbose", "info", "warning", "error"][level] || "log",
-        message,
-        line,
-        source: sourceId,
-      })}`
-    );
+    // Mirror EVERY renderer console line into the main log only with CICY_DEBUG;
+    // by default forward warnings/errors (level>=2) so normal startup stays quiet
+    // but real problems still surface. The in-memory log store below is unaffected
+    // (the log-viewer API still sees everything).
+    if (level >= 2 || process.env.CICY_DEBUG || process.env.CICY_VERBOSE) {
+      log.info(
+        `[${JSON.stringify({
+          timestamp: Date.now(),
+          level: ["verbose", "info", "warning", "error"][level] || "log",
+          message,
+          line,
+          source: sourceId,
+        })}`
+      );
+    }
     if (logs && counters) {
       logs.push({
         index: ++counters.log,

package/workers/render/src/App.jsx

@@ -568,7 +568,7 @@ export default function App() {
           ))}
         </div>
 
-        {showLocal && <DockerSetup onReady={fetchLocalTeams} />}
+        {/* Docker 安装卡已下线 (主人令): Windows 走原生 cicy-code.exe --helper,不再用 Docker。 */}
         {showLocal && localList.length > 0 && <MitmConsentCard team={localList[0]} />}
 
         {profileError && (
@@ -1061,10 +1061,13 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
   };
   const BUSY_LABEL = { start: "启动中…", restart: "重启中…", update: "更新中…", stop: "停止中…" };
 
-  // 打开 is NEVER gated on /api/health — openTeam() in main doesn't check it,
-  // it just opens the window. health is an indicator, not a gate. When the
-  // LOCAL daemon is down we start it first; remote/other-port teams just open
-  // and let the loaded page show its own connecting/login/error UI.
+  // 打开 flow (主人 spec): start the LOCAL daemon if it's down (with a 启动中…
+  // toast), then open. The window itself is opened by openTeam() in main, which
+  // (1) reuses an already-open window for this team (list_windows check first),
+  // and (2) for a local team, TCP-探活 until :8008 actually answers before
+  // creating the window — so we never pop a blank page that needs a manual
+  // reload. (/api/health is NOT used — it's unreliable mid-boot; the gate is a
+  // raw TCP probe.) Remote/custom teams just open and show their own UI.
   const handleOpen = async () => {
     if (busy) return;
     if (!running && local && window.cicy?.sidecar?.start) {
@@ -1078,7 +1081,7 @@ function LocalTeamCard({ team, onOpen, onRename, onRefresh }) {
       }
       toast.dismiss(opToastId); // came up — no lingering toast, the window opens
     }
-    onOpen(); // open regardless of health — the window/page handles the rest
+    onOpen(); // openTeam() gates on list_windows + TCP liveness before showing
   };
   const openLabel = running
     ? tr("localTeams.open", "打开")