cicy-desktop 2.1.250 → 2.1.252

package/.github/workflows/build-wsl-package.yml

@@ -36,6 +36,7 @@ jobs:
           default = root
           [automount]
           enabled = true
+          options = "metadata"
           EOS
           cat > ctx/Dockerfile <<'EOF'
           FROM ubuntu:22.04

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cicy-desktop",
-  "version": "2.1.250",
+  "version": "2.1.252",
   "description": "CiCy - AI-powered operating system browser",
   "main": "src/main.js",
   "bin": {
@@ -139,10 +139,10 @@
   "//optionalDependencies": "(2026-06 回调): mac/linux 改回 native cicy-code(:8008,colima 在 16G mac 上压垮内存)→ 重新内置 cicy-code-<plat> / cicy-mihomo-<plat>,localbin.fromBundle 零网络 seed(npm 仅作更新通道,带 npmmirror→npmjs 回退)。这些由 scripts/sync-runtime-deps.cjs 在 tag-push 时同步到最新版。npm 的 os/cpu 字段保证每个平台只装自己那份。Windows 仍走 docker(WSL :8009),它那份 cicy-code-windows 用不到但 bundle 着无害。",
   "optionalDependencies": {
     "electron": "41.0.3",
-    "cicy-code-darwin-x64": "2.3.205",
-    "cicy-code-darwin-arm64": "2.3.205",
-    "cicy-code-linux-x64": "2.3.205",
-    "cicy-code-linux-arm64": "2.3.205",
+    "cicy-code-darwin-x64": "2.3.266",
+    "cicy-code-darwin-arm64": "2.3.266",
+    "cicy-code-linux-x64": "2.3.266",
+    "cicy-code-linux-arm64": "2.3.266",
     "cicy-code-windows-x64": "2.3.193",
     "cicy-mihomo-darwin-x64": "1.10.4",
     "cicy-mihomo-darwin-arm64": "1.10.4",

package/src/backends/local-teams.js

@@ -1153,6 +1153,28 @@ function avatarForUrl(url) {
   return "";
 }
 
+// Resolve the canonical team identity for a URL so every surface (team card,
+// normal open, restored tab) uses the same title/avatar/color seed.
+function teamIdentityForUrl(url) {
+  const key = stripVolatile(url);
+  try {
+    const avatars = readAvatars();
+    for (const [id, node] of Object.entries(readNodes())) {
+      const base = node && node.base_url;
+      if (!base) continue;
+      const teamKey = stripVolatile(base);
+      if (teamKey === key || key.startsWith(teamKey)) {
+        return {
+          id,
+          title: localizedTeamName(node.name) || id,
+          avatar: avatars[id] || node.avatar || "",
+        };
+      }
+    }
+  } catch (e) {}
+  return null;
+}
+
 // Remove teams tied to a cloud ACCOUNT (remote base_url — pulled from the cloud
 // via pullCustomTeams, or user-added remote nodes) so switching/leaving an account
 // doesn't leak them onto the next user. LOCAL machine teams on THIS device
@@ -1166,4 +1188,4 @@ function invalidateForAccountChange() {
   log.info("[local-teams] account changed → team-list cache invalidated (no delete; filter by user_id)");
 }
 
-module.exports = { list, openTeam, reloadTeam, closeLocalWindows, addTeam, removeTeam, updateTeam, upgradeTeam, syncAllLocalTeams, invalidateForAccountChange, setAvatar, getAvatars, avatarForUrl };
+module.exports = { list, openTeam, reloadTeam, closeLocalWindows, addTeam, removeTeam, updateTeam, upgradeTeam, syncAllLocalTeams, invalidateForAccountChange, setAvatar, getAvatars, avatarForUrl, teamIdentityForUrl };

package/src/chrome/chrome-launcher.js

@@ -255,7 +255,7 @@ function closeChromeProcess(pid) {
 
 // macOS / Windows focus-stealing prevention keeps the spawning Electron
 // app on top after we launch Chrome, so the user's keystrokes go into
-// Electron. Nudge the OS to bring Chrome forward.
+// Electron. Nudge the OS to bring Chrome forward without opening it again.
 function bringChromeAppToForeground(binaryPath) {
   try {
     if (process.platform === "darwin") {
@@ -265,7 +265,15 @@ function bringChromeAppToForeground(binaryPath) {
       }
       const match = resolved && resolved.match(/^(.+\.app)\//);
       if (!match) return;
-      spawn("open", ["-a", match[1]], { stdio: "ignore", detached: true }).unref();
+      // `open -a <bundle>` sends an OPEN event. With a managed Chrome already
+      // running under --user-data-dir, LaunchServices may handle that event by
+      // opening the default, argument-less Chrome too — one click then produces
+      // two Chrome windows. AppleScript `activate` only raises the running app.
+      const appName = path.basename(match[1], ".app").replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+      spawn("/usr/bin/osascript", ["-e", `tell application "${appName}" to activate`], {
+        stdio: "ignore",
+        detached: true,
+      }).unref();
       return;
     }
     if (process.platform === "win32") {

package/src/i18n/locales/en.json

@@ -577,7 +577,8 @@
   },
   "tabShell": {
     "myTeam": "My Team",
-    "newTabBtn": "New tab"
+    "newTabBtn": "New tab",
+    "newPanel": "New panel"
   },
   "dood": {
     "menu": "Use Docker in container",

package/src/i18n/locales/fr.json

@@ -577,7 +577,8 @@
   },
   "tabShell": {
     "myTeam": "Mon équipe",
-    "newTabBtn": "Nouvel onglet"
+    "newTabBtn": "Nouvel onglet",
+    "newPanel": "Nouveau panneau"
   },
   "dood": {
     "menu": "Utiliser Docker dans le conteneur",

package/src/i18n/locales/ja.json

@@ -577,7 +577,8 @@
   },
   "tabShell": {
     "myTeam": "マイチーム",
-    "newTabBtn": "新しいタブ"
+    "newTabBtn": "新しいタブ",
+    "newPanel": "新しいパネル"
   },
   "dood": {
     "menu": "コンテナ内で Docker を使う",

package/src/i18n/locales/zh-CN.json

@@ -577,7 +577,8 @@
   },
   "tabShell": {
     "myTeam": "我的团队",
-    "newTabBtn": "新建标签"
+    "newTabBtn": "新建标签",
+    "newPanel": "新建面板"
   },
   "dood": {
     "menu": "容器内使用 Docker",

package/src/main.js

@@ -1307,6 +1307,49 @@ electronApp.whenReady().then(async () => {
     }
   }
 
+  const profileStore = require("./profiles/profile-store");
+  const electronProfiles = (() => {
+    let rows = [];
+    try { rows = profileStore.listProfiles("electron"); } catch {}
+    // Profile 0 is the resident CiCy system window and must not be exposed in
+    // the macOS title/top-bar launcher. Profile 9 is Chrome's source template.
+    rows = rows.filter((p) => ![0, 9].includes(Number(p.accountIdx)));
+    return rows;
+  })();
+  const chromeProfiles = (() => {
+    try { return profileStore.listProfiles("chrome"); } catch { return []; }
+  })();
+  const showProfileError = (kind, e) => {
+    dialog.showMessageBox({
+      type: "error",
+      message: `${kind} profile 打开失败`,
+      detail: String((e && e.message) || e),
+      buttons: ["OK"],
+    });
+  };
+  const openElectronProfile = async (accountIdx) => {
+    try {
+      const tabs = require("./tools/tab-browser-tools");
+      await tabs.openTab(accountIdx, undefined, { activate: true });
+      const m = tabs.ensureManager(accountIdx);
+      if (m.win.isMinimized()) m.win.restore();
+      m.win.show();
+      m.win.focus();
+    } catch (e) { showProfileError("Electron", e); }
+  };
+  const openChromeProfile = async (accountIdx) => {
+    try {
+      await require("./tools/chrome-tools").launchOrActivateProfile({
+        accountIdx,
+        activateIfRunning: true,
+      });
+    } catch (e) { showProfileError("Chrome", e); }
+  };
+  const openNativeChrome = () => {
+    try { require("./tools/chrome-tools").launchNativeChrome(); }
+    catch (e) { showProfileError("Chrome", e); }
+  };
+
   const menuTemplate = [
     ...(process.platform === "darwin" ? [{ role: "appMenu" }] : []),
     {
@@ -1344,6 +1387,24 @@ electronApp.whenReady().then(async () => {
         { label: i18n.t("menu.toggleFullscreen"), role: "togglefullscreen" },
       ],
     },
+    {
+      label: "Electron",
+      submenu: electronProfiles.map((p) => ({
+        label: `Profile ${p.accountIdx}${p.name ? ` · ${p.name}` : ""}`,
+        click: () => openElectronProfile(Number(p.accountIdx)),
+      })),
+    },
+    {
+      label: "Chrome",
+      submenu: [
+        { label: "原生 Chrome", click: openNativeChrome },
+        { type: "separator" },
+        ...chromeProfiles.map((p) => ({
+          label: `Profile ${p.accountIdx}${p.gmail ? ` · ${p.gmail}` : p.note ? ` · ${p.note}` : ""}`,
+          click: () => openChromeProfile(Number(p.accountIdx)),
+        })),
+      ],
+    },
     {
       label: i18n.t("menu.window"),
       submenu: [

package/src/tabbrowser/newtab-protocol.js

@@ -12,8 +12,16 @@
 // If cicy-code is momentarily unreachable we fall back to a minimal inline page so
 // a fresh tab is never blank.
 const { protocol, session } = require("electron");
+const fs = require("fs");
+const path = require("path");
 const _handled = new WeakSet(); // sessions that already have the cicyui handler
 
+// cicyui://panel/<id> — the split-webview panel page (opened by the tab strip's
+// top-right "+"). <id> keeps each panel tab's URL unique so addTab's
+// origin+pathname reuse never collapses two panels into one; the page keys its
+// persisted layout off the same path.
+const PANEL_HTML = path.join(__dirname, "split-panel.html");
+
 // NOTE: scheme is "cicyui", NOT "cicy" — "cicy" is already an OS deep-link
 // protocol client (setAsDefaultProtocolClient), so navigating a webContents to
 // cicy://… gets dispatched externally (open-url) and the page never renders.
@@ -59,6 +67,14 @@ function handlerFor(ses, partition) {
     ses.protocol.handle("cicyui", async (request) => {
       let host = "";
       try { host = new URL(request.url).hostname; } catch (e) {}
+      if (host === "panel") {
+        // read per request (not cached) so dev edits to split-panel.html land on
+        // a simple tab reload, no Electron restart.
+        try {
+          const html = await fs.promises.readFile(PANEL_HTML, "utf8");
+          return new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } });
+        } catch (e) { return new Response("panel page missing", { status: 500 }); }
+      }
       if (host !== "newtab") return new Response("not found", { status: 404 });
       // Fetch the single-source page from cicy-code; fall back to the inline page.
       try {
@@ -83,4 +99,5 @@ function ensureForPartition(partition) {
   try { handlerFor(session.fromPartition(partition), partition); } catch (e) {}
 }
 
-module.exports = { NEWTAB_URL, registerScheme, installHandler, ensureForPartition, startPageHtml };
+const PANEL_URL_BASE = "cicyui://panel/";
+module.exports = { NEWTAB_URL, PANEL_URL_BASE, registerScheme, installHandler, ensureForPartition, startPageHtml };

package/src/tabbrowser/panel-cells.js

@@ -0,0 +1,292 @@
+// Copyright 2026 CiCy AI
+// SPDX-License-Identifier: Apache-2.0
+
+// panel-cells.js — BrowserView-backed cells for the split panel tab.
+//
+// Why not <webview>: windows opened from a <webview> guest NEVER get
+// window.opener in Electron (long-standing architectural limit), which kills
+// every OAuth popup flow (Google GSI posts the credential back via
+// postMessage(window.opener) — no opener, no login). Cells are therefore real
+// BrowserViews owned by main, layered ABOVE the panel tab's own BrowserView;
+// the panel page (split-panel.html) stays the chrome: it computes each cell's
+// body rect and syncs [{id,url,rect}] here over IPC. Bonus: each cell has a
+// webContentsId, so the electron_tab_* tools (eval/screenshot/navigate) work
+// on panel cells exactly like tabs.
+const { BrowserView, ipcMain, webContents, session } = require("electron");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+// Panel tabs only exist in profile 0, whose URL toolbar is hidden. Their page
+// starts immediately below the 40px tab strip, so native cell BrowserViews do too.
+const CHROME_H = 40;
+
+// Each cell picks its PROFILE (accountIdx → persist:sandbox-N), default 1.
+// Profile 0 is hard-forced DIRECT (no proxy — the gotty terminal ws must never
+// route into mihomo), so external sites (x.com / accounts.google.com) belong in
+// profile ≥1: per-profile proxy from account-N.json (fallback config.proxy)
+// with localhost ALWAYS bypassed — team pages (127.0.0.1:8008) stay direct in
+// every profile. Team auth is token-in-URL, so cookie isolation costs nothing.
+const DEFAULT_PROFILE = 1;
+const partitionFor = (idx) => `persist:sandbox-${idx}`;
+// URL → profile routing (用户定的规则): localhost/127.0.0.1 → profile 0(直连、
+// 与团队 tab 同会话);其余一律 profile 1(走代理)。按格子的目标 URL 定,变更时重建视图。
+function isLocalCicyCode(url) {
+  try {
+    const u = new URL(url);
+    const local = u.hostname === "127.0.0.1" || u.hostname === "localhost" || u.hostname === "[::1]" || u.hostname === "::1";
+    return local && (u.port || "80") === "8008";
+  } catch (e) {}
+  return false;
+}
+function profileForCell(url, requested) {
+  if (isLocalCicyCode(url)) return 0;
+  const idx = Number(requested);
+  return Number.isInteger(idx) && idx > 0 ? idx : DEFAULT_PROFILE;
+}
+const appliedProxy = new Set(); // partitions whose proxy is already configured
+function ensureCellSessionProxy(idx) {
+  const part = partitionFor(idx);
+  if (appliedProxy.has(part)) return;
+  appliedProxy.add(part);
+  if (idx === 0) return; // profile 0 stays direct — managed by window-utils, don't touch
+  try {
+    const profileStore = require("../profiles/profile-store");
+    let rules = "";
+    try { const p = profileStore.getProfile("electron", idx); rules = profileStore.proxyRules(p && p.proxy) || ""; } catch (e) {}
+    if (!rules) { try { rules = require("../config").config.proxy || ""; } catch (e) {} }
+    if (!rules) return;
+    session.fromPartition(part)
+      .setProxy({ proxyRules: rules, proxyBypassRules: "127.0.0.1,localhost,[::1]" })
+      .catch(() => {});
+  } catch (e) {}
+}
+
+// tab webContents.id -> PanelCells
+const registry = new Map();
+
+// strip CiCyDesktop/Electron UA tokens — Google OAuth rejects Electron UAs
+// ("this browser may not be secure").
+function scrubUA(wc) {
+  try { wc.setUserAgent(wc.getUserAgent().replace(/\s(CiCyDesktop|Electron)\/\S+/g, "")); } catch (e) {}
+}
+
+class PanelCells {
+  constructor(manager, tab) {
+    this.m = manager;          // owning TabManager
+    this.tabId = tab.id;       // panel tab's webContents.id
+    this.views = new Map();    // cellId(string) -> { view, url }
+    this.visible = manager.activeId === tab.id;
+    try {
+      tab.view.webContents.once("destroyed", () => this.destroyAll());
+    } catch (e) {}
+  }
+
+  tabWc() { try { return webContents.fromId(this.tabId); } catch (e) { return null; } }
+  sendState(payload) { const wc = this.tabWc(); if (wc && !wc.isDestroyed()) { try { wc.send("panelcells:state", payload); } catch (e) {} } }
+
+  create(cellId, profileIdx) {
+    ensureCellSessionProxy(profileIdx);
+    const view = new BrowserView({
+      webPreferences: {
+        // the cell's chosen profile session: proxied external web (profile ≥1),
+        // localhost bypassed. Plain sandboxed web content: no preload, no Node.
+        partition: partitionFor(profileIdx),
+        contextIsolation: true,
+        nodeIntegration: false,
+        sandbox: true,
+      },
+    });
+    const wc = view.webContents;
+    try { view.setBackgroundColor("#0d0d0f"); } catch (e) {}
+    try { wc.cicyAccountIdx = profileIdx; } catch (e) {}
+    scrubUA(wc);
+    try { require("../utils/context-menu-options").attachContextMenu(wc); } catch (e) {}
+    try { require("../utils/window-monitor").attachTabConsole(wc); } catch (e) {}
+
+    // Popups stay IN-APP as real child windows: `action:allow` keeps
+    // window.opener (OAuth needs it to postMessage the credential back).
+    // Named reuse: GSI opens the same frameName twice expecting to land in the
+    // SAME window (Chrome behavior); Electron creates a second one — so reuse
+    // by frameName manually, else Google login shows two windows.
+    const named = new Map(); // frameName -> BrowserWindow
+    try {
+      wc.setWindowOpenHandler(({ url, frameName }) => {
+        const ex = frameName && named.get(frameName);
+        if (ex && !ex.isDestroyed()) {
+          try { ex.loadURL(url); ex.focus(); } catch (e) {}
+          return { action: "deny" };
+        }
+        return {
+          action: "allow",
+          overrideBrowserWindowOptions: {
+            autoHideMenuBar: true,
+            webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true },
+          },
+        };
+      });
+      wc.on("did-create-window", (win, details) => {
+        scrubUA(win.webContents);
+        const fn = details && details.frameName;
+        if (fn) { named.set(fn, win); win.on("closed", () => { if (named.get(fn) === win) named.delete(fn); }); }
+      });
+    } catch (e) {}
+
+    // push nav state back to the panel chrome (url input / spinner / persistence)
+    const push = () => {
+      let url = "", title = "";
+      try { url = wc.getURL(); title = wc.getTitle(); } catch (e) {}
+      this.sendState({ id: cellId, url, title, loading: false, wcId: wc.id });
+    };
+    wc.on("did-start-loading", () => this.sendState({ id: cellId, loading: true, wcId: wc.id }));
+    wc.on("did-stop-loading", push);
+    wc.on("did-navigate", push);
+    wc.on("did-navigate-in-page", push);
+    wc.on("page-title-updated", push);
+
+    const rec = { view, url: "", profile: profileIdx };
+    this.views.set(String(cellId), rec);
+    return rec;
+  }
+
+  place(rec, rect) {
+    if (!rect) return;
+    const b = {
+      x: Math.max(0, Math.round(rect.x)),
+      y: Math.max(0, Math.round(rect.y)) + CHROME_H,
+      width: Math.max(0, Math.round(rect.w)),
+      height: Math.max(0, Math.round(rect.h)),
+    };
+    try { rec.view.setBounds(b); } catch (e) {}
+  }
+
+  // cells: [{id, url, rect:{x,y,w,h}}] in panel-page CSS coords
+  sync(cells) {
+    if (!Array.isArray(cells)) return;
+    const seen = new Set();
+    for (const c of cells.slice(0, 24)) {
+      if (c == null || c.id == null) continue;
+      const key = String(c.id);
+      seen.add(key);
+      const url = (c.url && String(c.url)) || "";
+      const prof = profileForCell(url, c.profile);
+      let rec = this.views.get(key);
+      // locality change (localhost ↔ external) → partition must change → rebuild
+      if (rec && rec.profile !== prof) { this.destroyCell(key); rec = null; }
+      if (!rec) rec = this.create(c.id, prof);
+      if (url && rec.url !== url) {
+        rec.url = url;
+        try { rec.view.webContents.loadURL(url); } catch (e) {}
+      }
+      this.place(rec, c.rect);
+    }
+    for (const key of [...this.views.keys()]) if (!seen.has(key)) this.destroyCell(key);
+    this.updateAttach();
+  }
+
+  reload(cellId) {
+    const rec = this.views.get(String(cellId));
+    if (rec) { try { rec.view.webContents.reload(); } catch (e) {} }
+  }
+
+  async snapshots() {
+    const out = [];
+    for (const [id, rec] of this.views) {
+      try {
+        const image = await rec.view.webContents.capturePage();
+        if (!image.isEmpty()) out.push({ id, dataUrl: image.toDataURL() });
+      } catch (e) {}
+    }
+    return out;
+  }
+
+  updateAttach() {
+    const win = this.m.win;
+    if (!win || win.isDestroyed()) return;
+    for (const rec of this.views.values()) {
+      try {
+        if (this.visible) win.addBrowserView(rec.view);   // no-op if already attached
+        else win.removeBrowserView(rec.view);
+      } catch (e) {}
+    }
+  }
+  show() { this.visible = true; this.updateAttach(); }
+  hide() { this.visible = false; this.updateAttach(); }
+
+  destroyCell(key) {
+    const rec = this.views.get(key);
+    if (!rec) return;
+    try { this.m.win.removeBrowserView(rec.view); } catch (e) {}
+    try { rec.view.webContents.close(); } catch (e) { try { rec.view.webContents.destroy(); } catch (_) {} }
+    this.views.delete(key);
+  }
+  destroyAll() {
+    for (const key of [...this.views.keys()]) this.destroyCell(key);
+    registry.delete(this.tabId);
+  }
+}
+
+function cellsForTab(manager, tab) {
+  let pc = registry.get(tab.id);
+  if (!pc) { pc = new PanelCells(manager, tab); registry.set(tab.id, pc); }
+  return pc;
+}
+
+// TabManager.activate hooks — hide the outgoing tab's cells, show the incoming's.
+function onTabShown(manager, tabId) { const pc = registry.get(tabId); if (pc) pc.show(); }
+function onTabHidden(manager, tabId) { const pc = registry.get(tabId); if (pc) pc.hide(); }
+
+// ── IPC (installed once) ─────────────────────────────────────────────────────
+let installed = false;
+function installIpc(findTab) {
+  if (installed) return;
+  installed = true;
+  // e.sender is the PANEL PAGE's webContents; findTab maps it to (manager, tab).
+  const ctx = (e) => {
+    const hit = findTab(e.sender.id);
+    return hit ? cellsForTab(hit.manager, hit.tab) : null;
+  };
+  ipcMain.on("panelcells:sync", (e, { cells }) => { const pc = ctx(e); if (pc) pc.sync(cells); });
+  ipcMain.on("panelcells:reload", (e, { id }) => { const pc = ctx(e); if (pc) pc.reload(id); });
+  ipcMain.handle("panelcells:profiles", (e) => {
+    if (!ctx(e)) return [];
+    try {
+      return require("../profiles/profile-store").listProfiles("electron")
+        .filter((p) => Number.isInteger(Number(p.accountIdx)) && Number(p.accountIdx) > 0 && Number(p.accountIdx) !== 9)
+        .map((p) => ({ accountIdx: Number(p.accountIdx), name: String(p.name || "") }));
+    } catch (err) { return []; }
+  });
+  ipcMain.handle("panelcells:snapshots", async (e) => {
+    const pc = ctx(e);
+    return pc ? pc.snapshots() : [];
+  });
+  ipcMain.handle("panelcells:agents", async (e) => {
+    if (!ctx(e)) return { ok: false, agents: [], error: "invalid panel" };
+    try {
+      const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), "cicy-ai", "global.json"), "utf8"));
+      const token = String(cfg.api_token || "");
+      const r = await fetch("http://127.0.0.1:8008/api/tmux/panes", {
+        headers: { Authorization: `Bearer ${token}` },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (!r.ok) throw new Error(`HTTP ${r.status}`);
+      const data = await r.json();
+      const panes = data?.panes || data?.data?.panes || [];
+      return {
+        ok: true,
+        agents: panes.map((p) => ({
+          id: String(p.pane_id || "").replace(/:.*$/, ""),
+          title: String(p.title || p.pane_id || ""),
+          type: String(p.agent_type || ""),
+        })).filter((p) => p.id),
+      };
+    } catch (err) {
+      return { ok: false, agents: [], error: err.message || String(err) };
+    }
+  });
+  // divider drag in the panel page: views would swallow pointer events — detach
+  // during the drag (page shows frame-only preview), reattach + re-place on up.
+  ipcMain.on("panelcells:drag", (e, { on }) => { const pc = ctx(e); if (pc) { if (on) pc.hide(); else pc.show(); } });
+}
+
+module.exports = { installIpc, onTabShown, onTabHidden };

package/src/tabbrowser/panel-preload.js

@@ -0,0 +1,24 @@
+// Copyright 2026 CiCy AI
+// SPDX-License-Identifier: Apache-2.0
+
+// Preload for the split panel page (cicyui://panel/<id>). Exposes window.panelAPI
+// so the page (pure chrome: headers/dividers/layout) drives main-process
+// BrowserView cells (panel-cells.js). Sandbox-safe: only contextBridge + ipcRenderer.
+const { contextBridge, ipcRenderer } = require("electron");
+
+contextBridge.exposeInMainWorld("panelAPI", {
+  // full desired state, main reconciles: [{id, url, rect:{x,y,w,h}}]
+  sync: (cells) => ipcRenderer.send("panelcells:sync", { cells }),
+  reload: (id) => ipcRenderer.send("panelcells:reload", { id }),
+  agents: () => ipcRenderer.invoke("panelcells:agents"),
+  profiles: () => ipcRenderer.invoke("panelcells:profiles"),
+  snapshots: () => ipcRenderer.invoke("panelcells:snapshots"),
+  // divider drag: BrowserViews sit ABOVE the page and would swallow pointermove —
+  // detach them for the duration of the drag (frame-only preview), reattach on up.
+  dragging: (on) => ipcRenderer.send("panelcells:drag", { on: !!on }),
+  onCellState: (cb) => {
+    const h = (_e, s) => { try { cb(s); } catch (e) {} };
+    ipcRenderer.on("panelcells:state", h);
+    return () => ipcRenderer.removeListener("panelcells:state", h);
+  },
+});