cicy-desktop 2.1.30 → 2.1.31

package/package.json

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

package/src/sidecar/cicy-code.js

@@ -1,17 +1,18 @@
 // Discover / probe / spawn the cicy-code daemon for the Electron app.
 //
-// Principle (2026-05-29): cicy-desktop does NOT bundle cicy-code. The
-// daemon is acquired three ways, in priority order:
-//   1. An already-running instance on :8008 (helper-installed, user-run,
-//      or surviving from a previous launch). probeExisting wins → reuse.
-//   2. <userData>/cicy-code/<platform>-<arch>/cicy-code — written by
-//      src/sidecar/installer.js when the user clicks the in-app installer
-//      OR by the cloud Team Helper agent when it finishes onboarding.
-//   3. (no-op) if neither, return null — the homepage's Team Helper card
-//      will guide the user through install. No "bundled" fallback exists.
+// Principle (2026-06): the daemon is run via `npx cicy-code` — a single
+// source of truth. cicy-desktop neither bundles nor downloads a binary; the
+// per-version binary is fetched from npm by the launcher (CN: npmmirror).
+//   1. An already-running instance on :8008 (user-run, npx, surviving from a
+//      previous launch). probeExisting wins → reuse, never double-spawn.
+//   2. Otherwise spawn `npx cicy-code` on mac/linux.
 //
-// Windows is not bundled either — the daemon is WSL2-hosted via
-// src/sidecar/wsl.js. start() delegates there on win32.
+// This replaced the old src/sidecar/installer.js binary (~/.local/bin/
+// cicy-code), which raced the npx-launched daemon for :8008. The in-app
+// installer is no longer the daemon source.
+//
+// Windows is WSL2-hosted via src/sidecar/wsl.js; start() delegates there on
+// win32 (npx-in-WSL migration tracked separately).
 
 const fs = require("fs");
 const http = require("http");
@@ -20,32 +21,6 @@ const { spawn } = require("child_process");
 
 const DEFAULT_PORT = Number(process.env.CICY_CODE_PORT || 8008);
 
-function platformDir() {
-  if (process.platform === "darwin") return "darwin";
-  if (process.platform === "linux") return "linux";
-  return null;
-}
-function archDir() {
-  if (process.arch === "arm64") return "arm64";
-  if (process.arch === "x64") return "x64";
-  return null;
-}
-
-function bundledBinaryPath() {
-  const plat = platformDir();
-  const arch = archDir();
-  if (!plat || !arch) return null;
-  // Only the user-installed copy is considered. There is intentionally
-  // no <App>/Contents/Resources/cicy-code fallback — cicy-desktop no
-  // longer bundles the daemon (2026-05-29 principle).
-  try {
-    const installer = require("./installer");
-    const userBin = installer.userBinary();
-    if (userBin && fs.existsSync(userBin)) return userBin;
-  } catch {}
-  return null;
-}
-
 function probeExisting(port = DEFAULT_PORT, timeoutMs = 500) {
   return new Promise(resolve => {
     const req = http.get(
@@ -71,36 +46,25 @@ async function start({ logPath, port = DEFAULT_PORT, force = false } = {}) {
   }
 
   if (process.platform === "win32") {
-    // Windows uses WSL2 to host the linux-amd64 binary. The wsl module owns
-    // every wsl-touching command; here we just delegate.
+    // 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.)
     try {
-      const wsl = require("./wsl");
-      const status = await wsl.checkStatus();
-      if (!status.installed || !status.hasDistro) {
-        console.warn(`[cicy-code-sidecar] WSL not ready (${JSON.stringify(status)}) — homepage will guide install`);
+      const docker = require("./docker");
+      const r = await docker.start({ port });
+      if (!r) {
+        console.warn("[cicy-code-sidecar] Docker not ready — homepage will guide install");
         return null;
       }
-      if (!(await wsl.userInstalled())) {
-        console.warn("[cicy-code-sidecar] cicy-code not installed in WSL yet — homepage will trigger install");
-        return null;
-      }
-      const r = await wsl.start({ port, force });
-      // Treat WSL-internal pid as the child token so the outer code knows we're up.
-      child = { wsl: true, pid: r.pid };
-      console.log(`[cicy-code-sidecar] started inside WSL pid=${r.pid}`);
+      child = r; // { docker:true, container, id }
+      console.log(`[cicy-code-sidecar] started in Docker container ${r.container} (${r.id})`);
       return child;
     } catch (e) {
-      console.warn(`[cicy-code-sidecar] WSL start failed: ${e.message}`);
+      console.warn(`[cicy-code-sidecar] Docker start failed: ${e.message}`);
       return null;
     }
   }
 
-  const bin = bundledBinaryPath();
-  if (!bin || !fs.existsSync(bin)) {
-    console.warn(`[cicy-code-sidecar] no daemon binary found (user has not run the in-app installer or the cloud Team Helper); homepage's Team Helper card will guide install`);
-    return null;
-  }
-
   let stdio = ["ignore", "ignore", "ignore"];
   if (logPath) {
     fs.mkdirSync(path.dirname(logPath), { recursive: true });
@@ -108,12 +72,25 @@ async function start({ logPath, port = DEFAULT_PORT, force = false } = {}) {
     stdio = ["ignore", fd, fd];
   }
 
-  // cicy-code reads `PORT` env var. Strip the parent's PORT (set by the
-  // worker process to its own listen port, e.g. 8101) so it doesn't leak
-  // into the sidecar and clash with the worker's HTTP server.
-  const env = { ...process.env, CICY_CODE_PORT: String(port), PORT: String(port) };
-  child = spawn(bin, [], { stdio, detached: false, env });
-  console.log(`[cicy-code-sidecar] spawned ${bin} pid=${child.pid} port=${port} log=${logPath || "(none)"}`);
+  // Run the daemon via `npx cicy-code` — no bundled/downloaded binary. The
+  // launcher fetches the per-version binary from npm (default npmmirror for
+  // CN; override with CICY_NPM_REGISTRY) and does its own :8008 port hygiene.
+  // cicy-code reads PORT; we also set CICY_CODE_PORT and override the parent's
+  // PORT (the worker sets it to its own listen port, e.g. 8101) so it doesn't
+  // leak in and clash with the worker's HTTP server.
+  const registry = process.env.CICY_NPM_REGISTRY || "https://registry.npmmirror.com";
+  const env = {
+    ...process.env,
+    CICY_CODE_PORT: String(port),
+    PORT: String(port),
+    npm_config_registry: registry,
+  };
+  const npxBin = process.platform === "win32" ? "npx.cmd" : "npx";
+  const spec = process.env.CICY_CODE_VERSION
+    ? `cicy-code@${process.env.CICY_CODE_VERSION}`
+    : "cicy-code";
+  child = spawn(npxBin, ["-y", spec], { stdio, detached: false, env });
+  console.log(`[cicy-code-sidecar] spawned npx ${spec} pid=${child.pid} port=${port} registry=${registry} log=${logPath || "(none)"}`);
 
   child.on("exit", (code, signal) => {
     console.log(`[cicy-code-sidecar] exited code=${code} signal=${signal}`);
@@ -126,7 +103,12 @@ async function stop({ timeoutMs = 5000 } = {}) {
   if (!child) return;
   const p = child;
   child = null;
-  // WSL-launched: not a real ChildProcess, kill via wsl pkill instead.
+  // Docker-launched (win32): not a real ChildProcess — remove the container.
+  if (p && p.docker) {
+    try { await require("./docker").stop(); } catch {}
+    return;
+  }
+  // WSL-launched (legacy): not a real ChildProcess, kill via wsl pkill instead.
   if (p && p.wsl) {
     try { await require("./wsl").stop(); } catch {}
     return;
@@ -141,4 +123,4 @@ async function stop({ timeoutMs = 5000 } = {}) {
   }
 }
 
-module.exports = { start, stop, probeExisting, bundledBinaryPath };
+module.exports = { start, stop, probeExisting };

package/src/sidecar/docker.js

@@ -0,0 +1,113 @@
+// Windows sidecar backend: run cicy-code inside a Docker container.
+//
+// Platform split (2026-06): mac/linux start cicy-code locally via `npx
+// cicy-code` (see cicy-code.js); Windows runs it in Docker Desktop instead.
+// The base-env image's entrypoint installs cicy-code from npm at container
+// startup, so the image is version-independent. If the image isn't present
+// locally it's loaded from R2 (CN-friendly, no Docker Hub pull):
+//   https://r2.deepfetch.de5.net/docker/cicy-code-latest.tar.gz
+//
+// The container maps :8008 and persists ~/cicy-ai in a named volume.
+const { execFile } = require("child_process");
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const IMAGE     = process.env.CICY_DOCKER_IMAGE || "cicybot/cicy-code:latest";
+const R2_TARBALL = process.env.CICY_DOCKER_URL  || "https://r2.deepfetch.de5.net/docker/cicy-code-latest.tar.gz";
+const CONTAINER = process.env.CICY_DOCKER_CONTAINER || "cicy-code";
+const VOLUME    = process.env.CICY_DOCKER_VOLUME || "cicy-ai-data";
+// CICY_* env vars forwarded into the container (team onboarding, version pin…).
+const PASS_ENV = ["CICY_TEAM_TOKEN", "CICY_CODE_VERSION", "NPM_REGISTRY", "CICY_NPM_REGISTRY", "CICY_AGENTS", "ENABLE_CDN", "CICY_CLOUDFLARED_TOKEN"];
+
+function run(args, { timeout = 30000 } = {}) {
+  return new Promise((resolve, reject) => {
+    execFile("docker", args, { timeout, windowsHide: true }, (err, stdout, stderr) => {
+      if (err) { err.stdout = String(stdout || ""); err.stderr = String(stderr || ""); return reject(err); }
+      resolve({ stdout: String(stdout), stderr: String(stderr) });
+    });
+  });
+}
+
+async function dockerOk() {
+  try { await run(["version", "--format", "{{.Server.Version}}"], { timeout: 8000 }); return true; }
+  catch { return false; }
+}
+
+async function imagePresent() {
+  try { await run(["image", "inspect", IMAGE], { timeout: 8000 }); return true; }
+  catch { return false; }
+}
+
+function download(url, dest, hops = 5) {
+  return new Promise((resolve, reject) => {
+    if (hops <= 0) return reject(new Error("too many redirects"));
+    const lib = url.startsWith("https:") ? https : http;
+    const req = lib.get(url, { timeout: 60000 }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        return download(res.headers.location, dest, hops - 1).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) { res.resume(); return reject(new Error(`HTTP ${res.statusCode}`)); }
+      const out = fs.createWriteStream(dest);
+      res.pipe(out);
+      out.on("finish", () => out.close(() => resolve(dest)));
+      out.on("error", reject);
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+  });
+}
+
+async function loadImage() {
+  const tmp = path.join(os.tmpdir(), `cicy-code-image-${process.pid}.tar.gz`);
+  console.log(`[docker-sidecar] downloading image from ${R2_TARBALL}`);
+  await download(R2_TARBALL, tmp);
+  console.log(`[docker-sidecar] docker load…`);
+  await run(["load", "-i", tmp], { timeout: 300000 });
+  try { fs.unlinkSync(tmp); } catch {}
+}
+
+async function checkStatus() {
+  const installed = await dockerOk();
+  return { installed, imagePresent: installed ? await imagePresent() : false };
+}
+
+// Start the container. Returns a sidecar child token { docker:true, container,
+// id } or null when Docker isn't ready (homepage guides the user to install
+// Docker Desktop).
+async function start({ port = 8008 } = {}) {
+  if (!(await dockerOk())) {
+    console.warn("[docker-sidecar] Docker not available — homepage will guide install");
+    return null;
+  }
+  if (!(await imagePresent())) {
+    try { await loadImage(); }
+    catch (e) { console.warn(`[docker-sidecar] image load failed: ${e.message}`); return null; }
+  }
+  // Replace any stale container of the same name.
+  try { await run(["rm", "-f", CONTAINER]); } catch {}
+
+  const args = [
+    "run", "-d", "--name", CONTAINER, "--restart", "unless-stopped",
+    "-p", `${port}:8008`,
+    "-v", `${VOLUME}:/home/cicy/cicy-ai`,
+  ];
+  for (const k of PASS_ENV) {
+    if (process.env[k]) args.push("-e", `${k}=${process.env[k]}`);
+  }
+  args.push(IMAGE);
+
+  const { stdout } = await run(args, { timeout: 60000 });
+  const id = stdout.trim().slice(0, 12);
+  console.log(`[docker-sidecar] started container ${CONTAINER} (${id}) on :${port}`);
+  return { docker: true, container: CONTAINER, id };
+}
+
+async function stop() {
+  try { await run(["rm", "-f", CONTAINER]); } catch {}
+}
+
+module.exports = { start, stop, checkStatus, loadImage, imagePresent, dockerOk };