cicy-desktop 2.1.64 → 2.1.65

package/package.json

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

package/src/backends/local-teams.js

@@ -180,7 +180,7 @@ async function list({ refresh = false } = {}) {
 // dom-ready electronRPC injection — bare `new BrowserWindow` strips
 // the SPA of every desktop tool, which was the regression in the
 // previous implementation.
-function openTeam(id) {
+async function openTeam(id) {
   const node = readNodes()[id];
   if (!node) return { ok: false, error: "team not found" };
   const baseUrl = (node.base_url || "").replace(/\/$/, "");
@@ -201,6 +201,21 @@ function openTeam(id) {
     try { if (existing.isMinimized()) existing.restore(); } catch {}
     try { existing.show(); } catch {}
     try { existing.focus(); } catch {}
+    // A reused window can be STUCK at the login screen (its original load
+    // had a stale/absent token, e.g. after a token rotation) — focusing it
+    // would loop the user at login forever. If the page holds no token,
+    // re-navigate with the current ?token= so the SPA can consume it. An
+    // authenticated workspace (token present) is left untouched.
+    if (token) {
+      try {
+        const hasTok = await existing.webContents.executeJavaScript(
+          "!!localStorage.getItem('api_token')", true);
+        if (!hasTok) {
+          log.info(`[local-teams] open ${id} → reused win.id=${existing.id} had no token, re-navigating`);
+          existing.loadURL(url);
+        }
+      } catch { /* page not ready / JS blocked — leave as-is */ }
+    }
     log.info(`[local-teams] open ${id} → reused win.id=${existing.id}`);
     return { ok: true, windowId: existing.id, reused: true };
   }

package/src/sidecar/cicy-code.js

@@ -46,9 +46,26 @@ async function start({ logPath, port = DEFAULT_PORT, force = false, version = nu
   }
 
   if (process.platform === "win32") {
-    // Windows runs cicy-code in Docker Desktop (the container's entrypoint
-    // npx-installs cicy-code). The docker module owns image-load-from-R2 +
-    // container run; here we just delegate. (Replaced the old WSL path.)
+    // NATIVE route (2026-06 方向): cicy-code.exe + bundled slim MSYS2, no
+    // Docker/WSL. Gated behind CICY_WIN_NATIVE=1 while in 联调; the Docker
+    // container route below remains the transitional default until native
+    // ships.
+    if (process.env.CICY_WIN_NATIVE === "1") {
+      try {
+        const native = require("./native");
+        const r = await native.start({ port, logPath });
+        if (!r) { console.warn("[cicy-code-sidecar] native start failed"); return null; }
+        child = r; // { native:true, pid|adopted, port }
+        console.log(`[cicy-code-sidecar] started native exe (${r.adopted ? "adopted" : `pid=${r.pid}`}) on :${port}`);
+        return child;
+      } catch (e) {
+        console.warn(`[cicy-code-sidecar] native start failed: ${e.message}`);
+        return null;
+      }
+    }
+    // Transitional: Windows runs cicy-code in Docker Desktop (the container's
+    // entrypoint npx-installs cicy-code). The docker module owns
+    // image-load-from-R2 + container run; here we just delegate.
     try {
       const docker = require("./docker");
       const r = await docker.start({ port });
@@ -138,7 +155,8 @@ async function killPortListeners(port = DEFAULT_PORT, timeoutMs = 5000) {
 }
 
 async function stop({ timeoutMs = 5000, port = DEFAULT_PORT } = {}) {
-  // 1) The child we spawned this session (npx) or the Docker container.
+  // 1) The child we spawned this session (npx), the Docker container, or the
+  // native exe.
   if (child) {
     const p = child;
     child = null;
@@ -146,6 +164,10 @@ async function stop({ timeoutMs = 5000, port = DEFAULT_PORT } = {}) {
       try { await require("./docker").stop(); } catch {}
       return;
     }
+    if (p.native) {
+      try { await require("./native").stop({ port }); } catch {}
+      return;
+    }
     try { p.kill("SIGTERM"); } catch {}
     const t0 = Date.now();
     while (p.exitCode === null && Date.now() - t0 < timeoutMs) {

package/src/sidecar/docker.js

@@ -166,7 +166,7 @@ async function ensureDownloaded(url, dest, mirror, { emit, phase, label } = {})
   }
   const sources = mirror ? [url, mirror] : [url];
   let lastPct = -1; // throttle: chunks arrive dozens/s — only emit on whole-percent change
-  return withRetry(async (attempt) => {
+  const attempted = withRetry(async (attempt) => {
     const src = sources[Math.min(attempt - 1, sources.length - 1)];
     await download(src, dest, {
       resume: true,
@@ -187,6 +187,18 @@ async function ensureDownloaded(url, dest, mirror, { emit, phase, label } = {})
     onAttempt: ({ attempt, tries, error }) =>
       emit && emit({ phase, status: "retry", message: `${label}：重试 (${attempt}/${tries})`, error }),
   });
+  return attempted.catch((e) => {
+    // Offline fallback: the network (and HEAD) may be dead while a complete
+    // file from an earlier run sits on disk — use it instead of dying. Only
+    // when we CAN'T prove it incomplete (no expected size, or sizes match).
+    let have = 0; try { have = fs.statSync(dest).size; } catch {}
+    if (have > 0 && (expected === 0 || have === expected)) {
+      console.warn(`[docker-sidecar] download failed (${e.message}) — using existing ${dest} (${have}B, unverified)`);
+      emit && emit({ phase, status: "skip", message: `${label}：网络不可达，使用本地已有文件`, progress: 100 });
+      return dest;
+    }
+    throw e;
+  });
 }
 
 // The container's cicy-code mints its own api_token in its volume-persisted
@@ -372,4 +384,9 @@ async function bootstrap({ onProgress, port = 8008 } = {}) {
   return { ok: healthy, container: CONTAINER };
 }
 
-module.exports = { start, stop, checkStatus, loadImage, imagePresent, dockerOk, installDocker, bootstrap, probeHealth, readContainerToken };
+module.exports = {
+  start, stop, checkStatus, loadImage, imagePresent, dockerOk, installDocker,
+  bootstrap, probeHealth, readContainerToken,
+  // platform-agnostic download/retry primitives, reused by native.js
+  ensureDownloaded, withRetry, waitUntil, run,
+};

package/src/sidecar/native.js

@@ -0,0 +1,186 @@
+// Windows NATIVE sidecar backend: run cicy-code.exe directly — no Docker, no
+// WSL. (2026-06 方向变更: the Docker route in docker.js is transitional and
+// being retired; this module replaces it once stable.)
+//
+// The exe is a native Go build (w-10084's line). It shells out to a slim
+// bundled MSYS2 (bash/tmux/coreutils…) which it locates itself via
+// CICY_MSYS_ROOT probing — nothing to do here beyond optionally passing the
+// env through. Known exe-side behaviors we rely on:
+//   - reads PORT / CICY_CODE_PORT for the listen port
+//   - missing optional deps degrade to warnings (never os.Exit)
+//   - cold tmux-server start may need ConPTY (w-10084's ensureTmuxServer, WIP)
+//
+// Gate: cicy-code.js picks this module over docker.js when
+// CICY_WIN_NATIVE === "1" (dev flag until the native route ships by default).
+const { spawn, execFile } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const docker = require("./docker"); // ensureDownloaded/withRetry/waitUntil/probeHealth/run
+
+// Exe acquisition (主人指令 2026-06-07): the PRODUCT path is npm — the
+// cicy-code-win32-x64 subpackage (optionalDependency of cicy-code, os/cpu
+// pinned) carries cicy-code.exe, installed via npmmirror with npm's own
+// caching/resume/version management. NO R2 download in product. The R2
+// direct-pull below survives ONLY for w-10084↔w-10026 联调, gated on an
+// explicitly set CICY_CODE_EXE_URL.
+// dev/联调 only — read LAZILY (not at require time) so tests/tools can set the
+// env var after loading the module.
+const devExeUrl = () => process.env.CICY_CODE_EXE_URL || "";
+const EXE_PKG  = process.env.CICY_CODE_EXE_PKG || "cicy-code-win32-x64";
+const REGISTRY = process.env.CICY_NPM_REGISTRY || "https://registry.npmmirror.com";
+const BIN_DIR  = path.join(os.homedir(), "cicy-ai", "bin");
+// npm prefix dir owned by the sidecar (isolated from the user's global npm).
+const NPM_PREFIX = path.join(os.homedir(), "cicy-ai", "sidecar-npm");
+const DEV_EXE_PATH = process.env.CICY_CODE_EXE_PATH || path.join(BIN_DIR, "cicy-code.exe");
+const PID_FILE = path.join(BIN_DIR, "cicy-code.pid");
+
+function npmExePath() {
+  return path.join(NPM_PREFIX, "node_modules", EXE_PKG, "cicy-code.exe");
+}
+
+const probeHealth = docker.probeHealth;
+
+// Acquire (or reuse) the exe.
+//   PRODUCT: npm-install the win32 subpackage into the sidecar's own prefix
+//   and resolve the exe inside it — npm brings caching/integrity/versioning,
+//   npmmirror keeps CN viable. `version` ("latest" from update()) re-resolves.
+//   DEV (联调 only): CICY_CODE_EXE_URL set → resumable R2 download.
+async function ensureExe({ emit, version = null } = {}) {
+  if (devExeUrl()) {
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+    await docker.ensureDownloaded(devExeUrl(), DEV_EXE_PATH, null, {
+      emit, phase: "exe", label: "下载 cicy-code.exe (dev)",
+    });
+    return DEV_EXE_PATH;
+  }
+  const exe = npmExePath();
+  if (!version && fs.existsSync(exe)) return exe;
+  const e = emit || (() => {});
+  e({ phase: "exe", status: "running", message: "npm 安装 cicy-code (win32)…" });
+  fs.mkdirSync(NPM_PREFIX, { recursive: true });
+  const spec = `${EXE_PKG}@${version || "latest"}`;
+  // npm on Windows is npm.cmd — Node ≥18 (CVE-2024-27980) refuses to spawn
+  // .cmd/.bat without shell:true (spawn EINVAL). shell:true concatenates args
+  // un-escaped, so quote the one arg that can contain spaces (user dir).
+  const quotedPrefix = /\s/.test(NPM_PREFIX) ? `"${NPM_PREFIX}"` : NPM_PREFIX;
+  await new Promise((resolve, reject) => {
+    execFile("npm", ["i", spec, "--prefix", quotedPrefix, `--registry=${REGISTRY}`, "--no-audit", "--no-fund", "--loglevel=error"],
+      { windowsHide: true, timeout: 600000, shell: true },
+      (err, _o, stderr) => err ? reject(new Error(`npm i ${spec}: ${String(stderr).slice(0, 200)}`)) : resolve());
+  });
+  if (!fs.existsSync(exe)) throw new Error(`installed ${spec} but ${exe} missing`);
+  e({ phase: "exe", status: "done", message: "cicy-code.exe 就绪" });
+  return exe;
+}
+
+// One-time migration off the Docker route: the legacy containers (`cicy` from
+// the old flow, `cicy-code` from docker.js) hold :8008 and `--restart
+// unless-stopped` revives them on every daemon start — rm -f BOTH or the port
+// is never free. Best-effort: no Docker installed → nothing to clear.
+async function clearDockerLegacy() {
+  for (const name of ["cicy", "cicy-code"]) {
+    try { await docker.run(["rm", "-f", name], { timeout: 20000 }); console.log(`[native-sidecar] removed legacy container ${name}`); }
+    catch { /* absent or no docker — fine */ }
+  }
+}
+
+function readPid() {
+  try { return Number(fs.readFileSync(PID_FILE, "utf8").trim()) || 0; } catch { return 0; }
+}
+
+function pidAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+// PIDs listening on :port via netstat (Windows has no lsof).
+function listPortPids(port) {
+  return new Promise((resolve) => {
+    execFile("netstat", ["-ano", "-p", "TCP"], { windowsHide: true, timeout: 15000 }, (err, stdout) => {
+      if (err) return resolve([]);
+      const pids = new Set();
+      for (const line of String(stdout).split(/\r?\n/)) {
+        if (line.includes(`:${port} `) && /LISTENING/i.test(line)) {
+          const pid = Number(line.trim().split(/\s+/).pop());
+          if (pid) pids.add(pid);
+        }
+      }
+      resolve([...pids]);
+    });
+  });
+}
+
+function taskkill(pid) {
+  return new Promise((resolve) => {
+    execFile("taskkill", ["/f", "/t", "/pid", String(pid)], { windowsHide: true, timeout: 15000 }, () => resolve());
+  });
+}
+
+// Start cicy-code.exe on :port. Adopts an already-healthy instance. When
+// taking the canonical :8008, clears the legacy Docker containers first so
+// they can't fight for the bind.
+async function start({ port = 8008, logPath = null, emit, version = null } = {}) {
+  if (await probeHealth(port)) {
+    console.log(`[native-sidecar] :${port} already healthy — adopting`);
+    return { native: true, adopted: true, port };
+  }
+  const exe = await ensureExe({ emit, version });
+  if (port === 8008) await clearDockerLegacy();
+
+  let stdio = ["ignore", "ignore", "ignore"];
+  if (logPath) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    const fd = fs.openSync(logPath, "a");
+    stdio = ["ignore", fd, fd];
+  }
+  const env = {
+    ...process.env,
+    PORT: String(port),
+    CICY_CODE_PORT: String(port),
+  };
+  const child = spawn(exe, [], { stdio, detached: true, windowsHide: true, env });
+  child.unref();
+  try { fs.writeFileSync(PID_FILE, String(child.pid)); } catch {}
+  console.log(`[native-sidecar] spawned ${exe} pid=${child.pid} port=${port} log=${logPath || "(none)"}`);
+
+  const up = await docker.waitUntil(() => probeHealth(port), { totalMs: 60000, everyMs: 2000 });
+  if (!up) {
+    console.warn(`[native-sidecar] :${port} not healthy after 60s (exe may still be warming up)`);
+    return null;
+  }
+  return { native: true, pid: child.pid, port };
+}
+
+// Stop whatever serves :port — pidfile first, then netstat by port.
+async function stop({ port = 8008 } = {}) {
+  const pid = readPid();
+  if (pidAlive(pid)) await taskkill(pid);
+  for (const p of await listPortPids(port)) await taskkill(p);
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
+async function restart({ port = 8008, logPath = null } = {}) {
+  await stop({ port });
+  await new Promise((r) => setTimeout(r, 1000));
+  return start({ port, logPath });
+}
+
+// Update: npm route re-resolves @latest; dev route unlinks the cached exe to
+// defeat ensureDownloaded's size-match skip. Then restart on the new build.
+async function update({ port = 8008, logPath = null, emit } = {}) {
+  await stop({ port });
+  if (devExeUrl()) { try { fs.unlinkSync(DEV_EXE_PATH); } catch {} }
+  return start({ port, logPath, emit, version: devExeUrl() ? null : "latest" });
+}
+
+async function checkStatus({ port = 8008 } = {}) {
+  return {
+    exePresent: fs.existsSync(devExeUrl() ? DEV_EXE_PATH : npmExePath()),
+    running: await probeHealth(port),
+    pid: readPid() || null,
+  };
+}
+
+module.exports = { start, stop, restart, update, checkStatus, ensureExe, clearDockerLegacy, probeHealth, npmExePath };