cicy-desktop 2.1.331 → 2.1.333

package/package.json

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

package/src/backends/homepage-window.js

@@ -4,11 +4,23 @@
 // Homepage window — primary CiCy Desktop window. Singleton; closing it
 // does NOT quit the app.
 //
-// URL selection (HARDCODED — no env/dev-URL switch, no Vite, no remote): ALL
-// platforms load the bundled local file:// SPA — works offline, fast, no
-// remote dependency, no mixed-content concerns when embedding the
-// team-assistant webview (the cicy-desktop preload's IPC bridge still
-// attaches).
+// URL selection: the homepage IS the deployed web build
+// (https://desktop.cicy-ai.com — the desktop-render Worker). Shipping homepage
+// changes then means deploying the Worker, not shipping a new desktop build.
+//
+// The bundled file:// snapshot stays in the package as the FALLBACK: a
+// main-frame load failure, or a load that never commits within 15s (a blank 200
+// from a broken deploy), swaps to it — a CDN outage can never leave the app with
+// no homepage. Set CICY_HOMEPAGE_URL to point somewhere else (e.g. a vite dev
+// server), or prefs.homepageRemote:false to pin a machine to the snapshot.
+//
+// Note what this grants: the home tab runs homepage-preload, whose bridge is the
+// UNGUARDED "rpc" channel — no origin gate, no dangerous-tool gate (see
+// utils/rpc-guard), because it predates the homepage ever being remote. The
+// homepage origin therefore has ungated exec_*/file_* on the machine, so
+// desktop.cicy-ai.com must be treated as first-party code, exactly like the
+// bundle it replaces: whoever can deploy that Worker can run commands on every
+// desktop.
 
 const path = require("path");
 const { BrowserWindow } = require("electron");
@@ -19,9 +31,56 @@ const FIXED_WIDTH = 930;
 const FIXED_HEIGHT = 640;
 
 const LOCAL_INDEX = path.join(__dirname, "homepage-react", "index.html");
+const LOCAL_URL = `file://${LOCAL_INDEX}`;
+const REMOTE_HOMEPAGE = "https://desktop.cicy-ai.com/";
+const REMOTE_FALLBACK_MS = 15000;
+
+function readHomepagePrefs() {
+  try {
+    const os = require("os");
+    const p = path.join(os.homedir(), "cicy-ai", "db", "prefs.json");
+    return JSON.parse(require("fs").readFileSync(p, "utf8")) || {};
+  } catch {
+    return {};
+  }
+}
 
 function pickHomepageURL() {
-  return `file://${LOCAL_INDEX}`;
+  const env = String(process.env.CICY_HOMEPAGE_URL || "").trim();
+  if (env) return env;
+  // Opt OUT only: an explicit false pins this machine to the bundled snapshot.
+  try {
+    if (readHomepagePrefs().homepageRemote === false) return LOCAL_URL;
+  } catch {}
+  return REMOTE_HOMEPAGE;
+}
+
+// Fall back to the bundled snapshot when a remote homepage fails to load or
+// never commits. Idempotent per webContents; a no-op once we are already local.
+function wireRemoteFallback(wc) {
+  if (!wc || wc.isDestroyed() || wc.__cicyHomeFallbackWired) return;
+  let current = "";
+  try { current = wc.getURL(); } catch {}
+  if (!current || current.startsWith("file://")) {
+    // getURL() is empty until the first commit, so only skip a known-local load.
+    if (current) return;
+  }
+  wc.__cicyHomeFallbackWired = true;
+  let settled = false;
+  const toLocal = (reason) => {
+    if (settled || wc.isDestroyed()) return;
+    let url = "";
+    try { url = wc.getURL(); } catch {}
+    if (url.startsWith("file://")) { settled = true; return; }
+    settled = true;
+    log.warn(`[homepage] remote homepage unusable (${reason}) → bundled snapshot`);
+    try { wc.loadURL(LOCAL_URL); } catch (e) { log.error(`[homepage] fallback failed: ${e.message}`); }
+  };
+  wc.on("did-fail-load", (_e, code, desc, _url, isMainFrame) => {
+    if (isMainFrame) toLocal(`${code} ${desc}`);
+  });
+  wc.once("did-finish-load", () => { settled = true; });
+  setTimeout(() => toLocal(`no load within ${REMOTE_FALLBACK_MS}ms`), REMOTE_FALLBACK_MS);
 }
 
 let homepage = null;    // standalone fallback window (only if the tab engine fails)
@@ -40,6 +99,7 @@ async function openHomepage(opts = {}) {
     if (wc) {
       homeTabWc = wc;
       try { wc.once("destroyed", () => { if (homeTabWc === wc) homeTabWc = null; }); } catch {}
+      try { wireRemoteFallback(wc); } catch (e) { log.warn(`[homepage] fallback wiring: ${e.message}`); }
     }
     log.info(`[homepage] opened as profile-0 resident tab (wc=${wc && wc.id})`);
     return win;
@@ -103,6 +163,7 @@ async function openHomepageStandalone() {
 
   const target = pickHomepageURL();
   log.info(`[homepage] loading ${target}`);
+  try { wireRemoteFallback(homepage.webContents); } catch (e) { log.warn(`[homepage] fallback wiring: ${e.message}`); }
   homepage.loadURL(target);
 
   // Pipe renderer console + load failures to main-process stdout so we can

package/test/homepage-remote.test.js

@@ -0,0 +1,119 @@
+// Copyright 2026 CiCy AI
+// SPDX-License-Identifier: Apache-2.0
+
+// The homepage URL was hardcoded to file://, so deploying the same SPA as the
+// desktop-render Worker (desktop.cicy-ai.com) changed nothing on any desktop —
+// the app never fetched it. It can now be pointed at the web build, but only
+// deliberately: the home tab runs homepage-preload, whose bridge is the
+// UNGUARDED "rpc" channel, so a remote origin there gets ungated exec_*/file_*.
+// Hence opt-in + an automatic fall back to the bundled snapshot.
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const SRC = path.join(__dirname, "..", "src", "backends", "homepage-window.js");
+const src = fs.readFileSync(SRC, "utf8");
+
+function withHome(fn) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), "cicy-home-"));
+  const prevHome = process.env.HOME,
+    prevUp = process.env.USERPROFILE;
+  const prevUrl = process.env.CICY_HOMEPAGE_URL;
+  process.env.HOME = home;
+  process.env.USERPROFILE = home;
+  delete process.env.CICY_HOMEPAGE_URL;
+  fs.mkdirSync(path.join(home, "cicy-ai", "db"), { recursive: true });
+  try {
+    return fn(home);
+  } finally {
+    process.env.HOME = prevHome;
+    if (prevUp === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = prevUp;
+    if (prevUrl === undefined) delete process.env.CICY_HOMEPAGE_URL;
+    else process.env.CICY_HOMEPAGE_URL = prevUrl;
+  }
+}
+
+// homepage-window requires electron; exercise the real pickHomepageURL by
+// evaluating just that function plus the helper it depends on.
+function loadPicker() {
+  const start = src.indexOf("const LOCAL_INDEX");
+  const end = src.indexOf("// Fall back to the bundled snapshot");
+  const body = src.slice(start, end);
+  const mod = { exports: {} };
+  const fn = new Function(
+    "require",
+    "path",
+    "module",
+    "__dirname",
+    body + "\nmodule.exports = { pickHomepageURL, LOCAL_URL, REMOTE_HOMEPAGE };"
+  );
+  fn(require, path, mod, path.dirname(SRC));
+  return mod.exports;
+}
+
+test("defaults to the deployed web build", () => {
+  withHome(() => {
+    const { pickHomepageURL, REMOTE_HOMEPAGE } = loadPicker();
+    assert.equal(pickHomepageURL(), REMOTE_HOMEPAGE);
+    assert.equal(REMOTE_HOMEPAGE, "https://desktop.cicy-ai.com/");
+  });
+});
+
+test("prefs.homepageRemote:false pins a machine to the bundled snapshot", () => {
+  withHome((home) => {
+    fs.writeFileSync(
+      path.join(home, "cicy-ai", "db", "prefs.json"),
+      JSON.stringify({ homepageRemote: false })
+    );
+    const { pickHomepageURL, LOCAL_URL } = loadPicker();
+    assert.equal(pickHomepageURL(), LOCAL_URL);
+    assert.match(pickHomepageURL(), /^file:\/\//);
+  });
+});
+
+test("any value other than an explicit false stays on the web build", () => {
+  withHome((home) => {
+    for (const v of [true, "false", 0, null]) {
+      fs.writeFileSync(
+        path.join(home, "cicy-ai", "db", "prefs.json"),
+        JSON.stringify({ homepageRemote: v })
+      );
+      const { pickHomepageURL, REMOTE_HOMEPAGE } = loadPicker();
+      assert.equal(pickHomepageURL(), REMOTE_HOMEPAGE, `homepageRemote=${JSON.stringify(v)}`);
+    }
+  });
+});
+
+test("CICY_HOMEPAGE_URL wins over prefs and the default", () => {
+  withHome((home) => {
+    fs.writeFileSync(
+      path.join(home, "cicy-ai", "db", "prefs.json"),
+      JSON.stringify({ homepageRemote: false })
+    );
+    process.env.CICY_HOMEPAGE_URL = "http://127.0.0.1:5173/";
+    try {
+      assert.equal(loadPicker().pickHomepageURL(), "http://127.0.0.1:5173/");
+    } finally {
+      delete process.env.CICY_HOMEPAGE_URL;
+    }
+  });
+});
+
+test("a malformed prefs file keeps the default rather than throwing", () => {
+  withHome((home) => {
+    fs.writeFileSync(path.join(home, "cicy-ai", "db", "prefs.json"), "{ not json");
+    const { pickHomepageURL, REMOTE_HOMEPAGE } = loadPicker();
+    assert.equal(pickHomepageURL(), REMOTE_HOMEPAGE);
+  });
+});
+
+test("a remote homepage always has a way back to the bundled snapshot", () => {
+  assert.match(src, /wc\.on\("did-fail-load"/);
+  assert.match(src, /setTimeout\(\(\) => toLocal\(`no load within/); // blank page that never commits
+  assert.match(src, /if \(url\.startsWith\("file:\/\/"\)\) \{ settled = true; return; \}/); // never loops on local
+  assert.match(src, /wireRemoteFallback\(wc\)/); // resident home tab
+  assert.match(src, /wireRemoteFallback\(homepage\.webContents\)/); // standalone window
+});