cicy-desktop 2.1.280 → 2.1.285

package/src/backends/homepage-react/index.html

@@ -6,7 +6,7 @@
   <link rel="icon" type="image/svg+xml" href="./favicon.svg" />
   <link rel="icon" type="image/png" sizes="256x256" href="./favicon-256.png" />
   <title>CiCy Desktop</title>
-  <script type="module" crossorigin src="./assets/index-Bok65e-y.js"></script>
+  <script type="module" crossorigin src="./assets/index-BzYBKzQW.js"></script>
   <link rel="stylesheet" crossorigin href="./assets/index-C6Zrdgc0.css">
 </head>
 <body>

package/src/backends/local-teams.js

@@ -308,10 +308,24 @@ async function openTeam(id, opts = {}) {
   // 共用同一份)—— 打开时**实时读 global.json**,cicy-code 轮换 token 也立刻跟得上,绝不吃 teams.json
   // 里可能已陈旧的快照(陈旧 → ?token= 旧值 → :8008 拒 → 卡登录/白屏)。opts.token(如 :8008 容器
   // 自己实时拿的)优先级最高;非本地团队仍用存的 node.api_token。
-  let isLocalUrl = false;
-  try { const h = new URL(baseUrl).hostname; isLocalUrl = h === "127.0.0.1" || h === "localhost" || h === "::1"; } catch {}
-  const token = (opts && opts.token)
-    || (isLocalUrl ? (readGlobal()?.api_token || node.api_token || "") : (node.api_token || ""));
+  let isLocalUrl = false, localPort = null;
+  try { const u = new URL(baseUrl); isLocalUrl = u.hostname === "127.0.0.1" || u.hostname === "localhost" || u.hostname === "::1"; localPort = Number(u.port) || 8008; } catch {}
+  // Windows 的 :8008 是 WSL Docker 容器,token 存在**容器卷里的 global.json**,和主机
+  // ~/cicy-ai/global.json 是两把不同的 token —— 绝不能 fallback 到主机的那把(会被容器拒,
+  // 卡在登录/白屏)。只有 mac/linux 的 native :8008 才与主机共用同一份 global.json。
+  const isWinDockerTeam = process.platform === "win32" && isLocalUrl
+    && (node.is_docker === true || localPort === Number(process.env.CICY_DOCKER_APP_PORT || 8008));
+  let token = (opts && opts.token) || "";
+  if (!token) {
+    if (isWinDockerTeam) {
+      try { token = String(await require("../sidecar/wsl-docker").readContainerToken(localPort) || "").trim(); } catch (e) { log.warn(`[local-teams] open ${id}: container token read failed: ${e.message}`); }
+      if (!token) return { ok: false, error: "container_token_unavailable", hint: "cicy-code 容器还没就绪(读不到容器内的 token)。稍等几秒或用卡片菜单「重启」。" };
+    } else if (isLocalUrl) {
+      token = readGlobal()?.api_token || node.api_token || "";
+    } else {
+      token = node.api_token || "";
+    }
+  }
   const url = token ? `${baseUrl}/?token=${encodeURIComponent(token)}` : baseUrl;
 
   // Compare by origin+pathname only — token + hash both vary per

package/src/backends/sidecar-ipc.js

@@ -139,6 +139,9 @@ function register({ sidecarLogPath } = {}) {
   // caches it (memory + file), AND auto-starts whatever is installed-but-down. The
   // docker:app-status handler just returns the cache — instant, never blocks.
   let _dockerStatusCache = null;
+  // 最近一次安装/启动失败的原因(reason + 人话 message),写进 docker-status.json 的
+  // lastError,卡片和排障都能看到"为什么装不上",而不是只看到 installed:false。
+  let _lastBootstrapError = null;
   let _dockerDaemonBusy = false;
   let _gatewayKeyMissingChecks = 0;
   let _autostartEnsured = false;
@@ -150,7 +153,7 @@ function register({ sidecarLogPath } = {}) {
       if (s.running) { try { ver = await require("../sidecar/version").running(APP_PORT); } catch {} }
       // installed: distro 装了 OR :8008 健康(WSL 抽风查不到 distro 但容器在跑 → 也算装了,
       // 否则卡片误显「下载安装」)。wslUnmanaged: 服务在跑但 WSL 管不到 → 卡片显式提示异常。
-      _dockerStatusCache = { installed: !!s.distro || !!s.healthy, dockerRunning: !!s.engineUp || !!s.healthy, running: !!s.running, unknown: !!s.unknown, wslUnmanaged: !!s.wslUnmanaged, wslWedged: !!s.wslWedged, version: ver, port: APP_PORT, platform: process.platform, chromeProxy: chromeProxyEnabled(), chromeProxyRunning: hostMihomo.running(), ts: Date.now() };
+      _dockerStatusCache = { installed: !!s.distro || !!s.healthy, dockerRunning: !!s.engineUp || !!s.healthy, running: !!s.running, unknown: !!s.unknown, wslUnmanaged: !!s.wslUnmanaged, wslWedged: !!s.wslWedged, version: ver, port: APP_PORT, platform: process.platform, chromeProxy: chromeProxyEnabled(), chromeProxyRunning: hostMihomo.running(), lastError: (!s.running && _lastBootstrapError) ? _lastBootstrapError : null, ts: Date.now() };
     } catch (e) {
       _dockerStatusCache = { installed: false, dockerRunning: false, running: false, unknown: true, port: APP_PORT, platform: process.platform, error: e.message, ts: Date.now() };
     }
@@ -285,6 +288,11 @@ function register({ sidecarLogPath } = {}) {
         port: PORT,
         onProgress: (ev) => { try { e.sender.send("docker:bootstrap-progress", ev); } catch {} },
       });
+      if (result && result.ok) _lastBootstrapError = null;
+      else if (result) {
+        _lastBootstrapError = { reason: result.reason || result.error || "bootstrap_failed", message: result.message || "", ts: Date.now() };
+        log.error(`[docker] bootstrap failed reason=${_lastBootstrapError.reason}${_lastBootstrapError.message ? ` — ${_lastBootstrapError.message}` : ""}`);
+      }
       // Healthy local stack → make sure it shows up as a team ("本地团队就加
       // 上去了"). addTeam dedups by host:port, so re-runs are no-ops. The
       // api_token must be the CONTAINER's own (volume global.json) — the
@@ -301,6 +309,8 @@ function register({ sidecarLogPath } = {}) {
       }
       return result;
     } catch (err) {
+      _lastBootstrapError = { reason: "bootstrap_exception", message: err.message, ts: Date.now() };
+      log.error(`[docker] bootstrap threw: ${err.message}`);
       return { ok: false, error: err.message };
     }
   });

package/src/main.js

@@ -168,8 +168,12 @@ if (process.platform === "win32") {
 const DEEPLINK_SCHEMES = ["cicy-desktop", "cicy"]; // primary, then legacy
 const isDeepLink = (u) =>
   typeof u === "string" && DEEPLINK_SCHEMES.some((s) => u.startsWith(`${s}://`));
+// Source/dev runs (`electron <appdir>`) must register execPath + the app dir,
+// otherwise Windows stores a bare `electron.exe "%1"` handler that launches an
+// empty Electron shell — and clobbers the installed app's registration.
+const deeplinkArgs = electronApp.isPackaged ? [] : [process.execPath, [path.resolve(process.argv[1] || electronApp.getAppPath())]];
 for (const s of DEEPLINK_SCHEMES) {
-  try { if (!electronApp.isDefaultProtocolClient(s)) electronApp.setAsDefaultProtocolClient(s); } catch {}
+  try { if (!electronApp.isDefaultProtocolClient(s, ...deeplinkArgs)) electronApp.setAsDefaultProtocolClient(s, ...deeplinkArgs); } catch {}
 }
 
 // Deep links can arrive before any BrowserWindow exists (cold start via
@@ -634,7 +638,7 @@ ipcMain.handle("rpc:guarded", async (event, toolName, args) => {
     const originOk = await ensureOriginAuthorized(event);
     if (!originOk) {
       audit({ kind: "rpc", channel: "rpc:guarded", origin, tool: toolName, dangerous: danger, ok: false, error: "origin-unauthorized", args: argsPreview(toolName, args) });
-      throw new Error(`未授权站点访问桌面 RPC（rpc:guarded：域名未加入白名单）`);
+      throw new Error(`未授权站点访问桌面 RPC（${origin} 未加入白名单或刚被拒绝；请在 CiCy Desktop 头像 → 受信任站点 中添加该域名，或稍后重试并在弹框中选择允许）`);
     }
   }
   if (danger) {

package/src/profiles/profile-store.js

@@ -305,6 +305,33 @@ function setProxy(backend, idx, url) {
   throw new Error(`Unknown backend: ${backend}`);
 }
 
+// removeProfile — drop the profile record. Electron: deletes account-<N>.json
+// (the caller is responsible for the session's storage). Returns true if it existed.
+function removeProfile(backend, idx) {
+  if (backend === "electron") {
+    const f = electronFile(idx);
+    if (!fs.existsSync(f)) return false;
+    fs.unlinkSync(f);
+    return true;
+  }
+  if (backend === "chrome") {
+    const cfg = readChromeConfig();
+    if (!cfg[`profile_${idx}`]) return false;
+    delete cfg[`profile_${idx}`];
+    fs.writeFileSync(CHROME_JSON, JSON.stringify(cfg, null, 2));
+    return true;
+  }
+  throw new Error(`Unknown backend: ${backend}`);
+}
+
+// setNote — free-form per-profile note (both backends).
+function setNote(backend, idx, note) {
+  const text = typeof note === "string" ? note.trim() : "";
+  if (backend === "chrome") return mutateChrome(idx, (e) => ({ ...e, note: text }));
+  if (backend === "electron") return mutateElectron(idx, (d) => ({ ...d, note: text }));
+  throw new Error(`Unknown backend: ${backend}`);
+}
+
 // setLogin — upsert a rich login record (any subset of LOGIN_FIELDS). Keyed by
 // `name` (site name). Works identically for both backends.
 function setLogin(backend, idx, login) {
@@ -345,6 +372,8 @@ module.exports = {
   listProfiles,
   getProfile,
   setProxy,
+  setNote,
+  removeProfile,
   setLogin,
   addLogin,
   removeLogin,

package/src/profiles/trusted-origins-store.js

@@ -35,7 +35,7 @@ function normalizeHost(input) {
   }
   s = s.split("/")[0].split("?")[0].split("#")[0]; // drop path/query/fragment
   s = s.replace(/:\d+$/, "");                       // drop :port
-  if (!/^[a-z0-9.-]+$/.test(s)) return "";          // basic host charset
+  if (!/^[a-z0-9._-]+$/.test(s)) return "";         // basic host charset (underscore is legal in real-world hostnames, e.g. xs_master.example.com)
   if (s.startsWith(".") || s.endsWith(".") || s.includes("..")) return "";
   return s;
 }
@@ -48,11 +48,41 @@ function readRaw() {
   } catch { return []; }
 }
 
-function writeRaw(origins) {
+function writeRaw(origins, dangerous) {
   fs.mkdirSync(path.dirname(STORE), { recursive: true });
-  fs.writeFileSync(STORE, JSON.stringify({ origins }, null, 2), { mode: 0o600 });
+  const cur = readRawObj();
+  const next = { origins, dangerous: Array.isArray(dangerous) ? dangerous : (Array.isArray(cur.dangerous) ? cur.dangerous : []) };
+  fs.writeFileSync(STORE, JSON.stringify(next, null, 2), { mode: 0o600 });
   try { fs.chmodSync(STORE, 0o600); } catch {}
 }
+function readRawObj() {
+  try { if (!fs.existsSync(STORE)) return {}; const j = JSON.parse(fs.readFileSync(STORE, "utf8")); return j && typeof j === "object" ? j : {}; } catch { return {}; }
+}
+
+// "此站点始终允许敏感操作":对已在白名单里的站点,持久跳过 exec/读写文件的逐次确认。
+// 只有白名单站点可以加入(不在白名单 → 拒绝),从白名单移除时一并撤销。
+function listDangerousAllowed() {
+  const set = new Set(listAll()); // built-ins (localhost/127.0.0.1) included — the local team page IS 127.0.0.1
+  return (Array.isArray(readRawObj().dangerous) ? readRawObj().dangerous : []).map(normalizeHost).filter((h) => h && set.has(h));
+}
+function isDangerousAllowed(host) {
+  const h = normalizeHost(host);
+  return !!h && listDangerousAllowed().includes(h);
+}
+function allowDangerous(input) {
+  const host = normalizeHost(input);
+  if (!host) return { ok: false, error: "无效的站点地址" };
+  if (!listAll().includes(host)) return { ok: false, error: "站点不在白名单中" };
+  const cur = listDangerousAllowed();
+  if (!cur.includes(host)) { writeRaw(listUser(), [...cur, host]); _audit({ kind: "auth", gate: "allowlist", host, decision: "dangerous-always-allow" }); }
+  return { ok: true };
+}
+function revokeDangerous(input) {
+  const host = normalizeHost(input);
+  const cur = listDangerousAllowed();
+  if (cur.includes(host)) { writeRaw(listUser(), cur.filter((h) => h !== host)); _audit({ kind: "auth", gate: "allowlist", host, decision: "dangerous-revoke" }); }
+  return { ok: true };
+}
 
 // User-managed origins only (normalized, de-duped, built-ins excluded).
 function listUser() {
@@ -91,8 +121,8 @@ function remove(input) {
   const host = normalizeHost(input);
   if (BUILTIN.includes(host)) return { ok: false, error: "内置站点不可删除" };
   const cur = listUser();
-  if (cur.includes(host)) { writeRaw(cur.filter((h) => h !== host)); _audit({ kind: "auth", gate: "allowlist", host, decision: "trust-remove" }); }
+  if (cur.includes(host)) { writeRaw(cur.filter((h) => h !== host), listDangerousAllowed().filter((h) => h !== host)); _audit({ kind: "auth", gate: "allowlist", host, decision: "trust-remove" }); }
   return { ok: true, origins: listForUi() };
 }
 
-module.exports = { STORE, BUILTIN, normalizeHost, listUser, listAll, listForUi, add, remove };
+module.exports = { STORE, BUILTIN, normalizeHost, listUser, listAll, listForUi, add, remove, listDangerousAllowed, isDangerousAllowed, allowDangerous, revokeDangerous };

package/src/sidecar/docker.js

@@ -11,6 +11,7 @@
 //   https://r2.deepfetch.de5.net/docker/cicy-code-latest.tar.gz
 //
 // The container maps :8008 and persists ~/cicy-ai in a named volume.
+const log = require("electron-log"); // bootstrap preflight failures must land in main.log
 const { execFile, execFileSync, spawn } = require("child_process");
 const https = require("https");
 const http = require("http");
@@ -660,7 +661,36 @@ async function dismEnableFeature(feature, label, { emit } = {}) {
 // { ok } when already present, { needsReboot } after the two required Windows
 // features are verified-enabled (a Windows reboot is then needed before Docker
 // can use WSL2), or { failed } if a feature couldn't be enabled.
+// CPU virtualization state (Windows). WSL2 cannot start when the firmware has
+// VT-x/AMD-V disabled — and nothing in software can flip that. Detect it up
+// front so the failure is EXPLAINED (log + card) instead of a mute install loop.
+// hypervisorPresent=true means a hypervisor already runs (Hyper-V/WSL2 active)
+// → virtualization is necessarily on, regardless of what the CPU field says.
+async function virtualizationStatus() {
+  if (process.platform !== "win32") return { known: false };
+  return new Promise((resolve) => {
+    const ps = "$cs=Get-CimInstance Win32_ComputerSystem; $cpu=Get-CimInstance Win32_Processor | Select-Object -First 1; Write-Output (\"\" + $cs.HypervisorPresent + \"|\" + $cpu.VirtualizationFirmwareEnabled + \"|\" + $cpu.VMMonitorModeExtensions + \"|\" + $cpu.Name)";
+    execFile("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps], { timeout: 20000, windowsHide: true }, (err, stdout) => {
+      const line = String(stdout || "").trim().split(/\r?\n/).pop() || "";
+      const [hv, fw, vmm, ...rest] = line.split("|");
+      if (err || !line || line.split("|").length < 3) return resolve({ known: false, raw: line, error: err && err.message });
+      const b = (v) => /^true$/i.test(String(v).trim());
+      const hypervisorPresent = b(hv), firmwareEnabled = b(fw), cpuSupports = b(vmm);
+      resolve({ known: true, hypervisorPresent, firmwareEnabled, cpuSupports, cpu: rest.join("|").trim(), ok: hypervisorPresent || firmwareEnabled });
+    });
+  });
+}
+
 async function ensureWsl({ emit } = {}) {
+  const virt = await virtualizationStatus();
+  if (virt.known && !virt.ok) {
+    const why = virt.cpuSupports
+      ? `CPU 虚拟化未在 BIOS/固件中开启（Virtualization Enabled In Firmware: No，CPU: ${virt.cpu || "?"}）。请重启进 BIOS 打开 Intel VT-x / AMD SVM 后再点「重试」。`
+      : `此 CPU 不支持硬件虚拟化（VM Monitor Mode Extensions: No，CPU: ${virt.cpu || "?"}），无法运行 WSL2 / Docker。`;
+    log.error(`[bootstrap] ✗ ensure-wsl reason=virtualization_disabled hypervisorPresent=${virt.hypervisorPresent} firmwareEnabled=${virt.firmwareEnabled} cpuSupports=${virt.cpuSupports} cpu=${virt.cpu}`);
+    emit && emit({ phase: "done", status: "error", message: why });
+    return { ok: false, needsReboot: false, failed: true, reason: "virtualization_disabled", message: why };
+  }
   const executableMissing = await wslMissing();
   const subsystemEnabled = await featureEnabled("Microsoft-Windows-Subsystem-Linux");
   const vmPlatformEnabled = await featureEnabled("VirtualMachinePlatform");
@@ -671,8 +701,10 @@ async function ensureWsl({ emit } = {}) {
   const a = await dismEnableFeature("Microsoft-Windows-Subsystem-Linux", "启用 WSL 功能 1/2 · Linux 子系统", { emit });
   const b = await dismEnableFeature("VirtualMachinePlatform", "启用 WSL 功能 2/2 · 虚拟机平台", { emit });
   if (!a || !b) {
-    emit && emit({ phase: "done", status: "error", message: "WSL 功能未能全部启用——请点「重试」" });
-    return { ok: false, needsReboot: false, failed: true };
+    const message = `WSL 功能未能全部启用（Linux 子系统=${a ? "已启用" : "失败"}，虚拟机平台=${b ? "已启用" : "失败"}；通常是 UAC 被取消或当前账号无管理员权限）——请以管理员身份重试。`;
+    log.error(`[bootstrap] ✗ ensure-wsl reason=wsl_enable_failed subsystem=${a} vmPlatform=${b}`);
+    emit && emit({ phase: "done", status: "error", message });
+    return { ok: false, needsReboot: false, failed: true, reason: "wsl_enable_failed", message };
   }
   // Best-effort: also pull the WSL2 kernel/plumbing when the executable itself
   // is missing. Feature-only repairs must stop here and wait for reboot.
@@ -779,7 +811,7 @@ module.exports = {
   start, stop, stopContainer, restart, checkStatus, loadImage, loadImageFromTarball,
   downloadImageTarball, imagePresent, dockerOk, installDocker,
   bootstrap, probeHealth, readContainerToken, dockerDesktopExe, desktopDir, downloadsDir, imageTarballPath,
-  launchElevated, wslMissing, ensureWsl,
+  launchElevated, wslMissing, ensureWsl, virtualizationStatus,
   // platform-agnostic download/retry primitives, reused by native.js
   ensureDownloaded, curlDownload, withRetry, waitUntil, run, headSize,
   // image freshness (修「重建仍用旧镜像」—— 校验 OSS ETag 变了才重下重载)

package/src/sidecar/wsl-docker.js

@@ -1162,7 +1162,7 @@ async function _bootstrap({ onProgress, port = 8008, container = "cicy-code-dock
   begin("ensure-wsl");
   const w = await docker.ensureWsl({ emit });
   if (w.needsReboot) { fail("wsl_reboot_required"); emit({ phase: "done", status: "reboot", message: "WSL2 所需功能已启用——请【重启 Windows】后回来点「重试」继续。" }); finish(false, "wsl_reboot_required"); return { ok: false, reason: "wsl_reboot_required" }; }
-  if (!w.ok) { fail("wsl_enable_failed"); finish(false, "wsl_enable_failed"); return { ok: false, reason: "wsl_enable_failed" }; }
+  if (!w.ok) { const reason = w.reason || "wsl_enable_failed"; fail(reason, w.message); finish(false, reason); return { ok: false, reason, message: w.message || "" }; }
   done(true);
 
   // 2) Ubuntu distro

package/src/tabbrowser/panel-cells.js

@@ -46,6 +46,7 @@ function profileForCell(url, requested) {
   const idx = Number(requested);
   return Number.isInteger(idx) && idx > 0 ? idx : DEFAULT_PROFILE;
 }
+const telegramIdentity = require("./telegram-identity");
 const appliedProxy = new Set(); // partitions whose proxy is already configured
 function ensureCellSessionProxy(idx) {
   const part = partitionFor(idx);
@@ -117,6 +118,7 @@ class PanelCells {
       },
     });
     const wc = view.webContents;
+    const rec = { view, url: "", profile: profileIdx, visible: true, identity: null };
     try { view.setBackgroundColor("#ffffff"); } catch (e) {}
     // Chromium uses a dark canvas for transparent/un-styled documents when the
     // app theme is dark (for example a plain `Not Found` response). Keep real
@@ -178,7 +180,7 @@ class PanelCells {
       let loading = false;
       try { loading = wc.isLoading(); } catch (e) {}
       const failed = /^chrome-error:/.test(url) || !!lastError;
-      this.sendState({ id: cellId, url, title, loading, wcId: wc.id, failed, error: failed ? lastError : null });
+      this.sendState({ id: cellId, url, title, loading, wcId: wc.id, failed, error: failed ? lastError : null, identity: rec.identity || null });
     };
     // Telegram Web 是 PWA:代理挂掉时 service worker 照样从缓存吐出 app shell,主框架
     // 「加载成功」、did-fail-load 不触发,可页面其实一点网都没有(用户看到的就是一片白
@@ -219,8 +221,38 @@ class PanelCells {
       push();
     };
 
-    wc.on("did-start-loading", () => { probeSeq++; this.sendState({ id: cellId, loading: true, wcId: wc.id }); });
-    wc.on("did-stop-loading", () => { push(); probeReachable(); });
+    // Telegram 身份:登录后从页面自己的 localStorage/IndexedDB 读出 @username,写进
+    // profile 的 logins(name=telegram),并推给面板列表。登录流程刚结束时用户表可能
+    // 还没落库,所以延迟探几次;拿到就停。
+    let identSeq = 0;
+    const detectIdentity = () => {
+      if (profileIdx === 0) return;
+      let url = ""; try { url = wc.getURL(); } catch (e) {}
+      if (!telegramIdentity.isTelegramUrl(url)) return;
+      const seq = ++identSeq;
+      const delays = [2500, 8000, 20000, 45000];
+      const tick = async (i) => {
+        if (seq !== identSeq || wc.isDestroyed()) return;
+        let raw = null;
+        try { raw = await wc.executeJavaScript(telegramIdentity.TELEGRAM_IDENTITY_SCRIPT, true); } catch (e) {}
+        const it = telegramIdentity.normalizeTelegramIdentity(raw);
+        if (seq !== identSeq) return;
+        if (it && (it.username || it.displayName || it.phone)) {
+          const prev = rec.identity;
+          rec.identity = it;
+          if (!prev || prev.username !== it.username || prev.displayName !== it.displayName || prev.phone !== it.phone) {
+            try { require("../profiles/profile-store").setLogin("electron", profileIdx, telegramIdentity.telegramLoginRecord(it)); } catch (e) {}
+            this.sendState({ id: cellId, wcId: wc.id, identity: it, loading: false, url, title: (() => { try { return wc.getTitle(); } catch (e) { return ""; } })() });
+          }
+          return;
+        }
+        if (i + 1 < delays.length) setTimeout(() => tick(i + 1), delays[i + 1]);
+      };
+      setTimeout(() => tick(0), delays[0]);
+    };
+
+    wc.on("did-start-loading", () => { probeSeq++; identSeq++; this.sendState({ id: cellId, loading: true, wcId: wc.id }); });
+    wc.on("did-stop-loading", () => { push(); probeReachable(); detectIdentity(); });
     wc.on("did-fail-load", (_e, errorCode, errorDescription, validatedURL, isMainFrame) => {
       if (isMainFrame === false || errorCode === -3) return; // 子框架 / ERR_ABORTED(用户导航打断)不算失败
       lastError = { code: errorCode, description: String(errorDescription || ""), url: String(validatedURL || "") };
@@ -232,7 +264,7 @@ class PanelCells {
     wc.on("did-navigate-in-page", push);
     wc.on("page-title-updated", push);
 
-    const rec = { view, url: "", profile: profileIdx, visible: true };
+    rec.view = view;
     this.views.set(String(cellId), rec);
     return rec;
   }
@@ -281,7 +313,7 @@ class PanelCells {
       if (!wc || wc.isDestroyed()) continue;
       let url = "", title = "", loading = false;
       try { url = wc.getURL(); title = wc.getTitle(); loading = wc.isLoading(); } catch (e) {}
-      out.push({ id, url, title, loading, wcId: wc.id, failed: /^chrome-error:/.test(url), error: wc.cicyLastError || null });
+      out.push({ id, url, title, loading, wcId: wc.id, failed: /^chrome-error:/.test(url), error: wc.cicyLastError || null, identity: rec.identity || null });
     }
     return out;
   }
@@ -359,6 +391,9 @@ function installIpc(findTab) {
           accountIdx: Number(p.accountIdx),
           name: String(p.name || ""),
           proxy: p.proxy && p.proxy.enabled ? String(p.proxy.url || "") : "",
+          note: String(p.note || ""),
+          telegram: telegramIdentity.telegramIdentityFromProfile(p),
+          ipInfo: p.ipInfo && p.ipInfo.ip ? { ip: String(p.ipInfo.ip), area: String(p.ipInfo.area || ""), probedAt: String(p.ipInfo.probedAt || "") } : null,
         }));
     } catch (err) { return []; }
   });
@@ -376,6 +411,50 @@ function installIpc(findTab) {
     await applyProfileProxy(profile.accountIdx, profile.proxy);
     return { accountIdx: profile.accountIdx, name: profile.name, proxy: profile.proxy.url };
   });
+  // 出口 IP / 地区:经该 profile 的 session(=它的代理)去问 IP 服务,结果写回 profile.ipInfo。
+  ipcMain.handle("panelcells:probe-ip", async (e, { accountIdx }) => {
+    if (!ctx(e)) throw new Error("Invalid panel");
+    const id = Number(accountIdx);
+    if (!Number.isInteger(id) || id <= 0) throw new Error("Invalid Electron profile ID");
+    const profileStore = require("../profiles/profile-store");
+    const { probeIpViaSession } = require("../utils/ip-probe");
+    const part = partitionFor(id);
+    // 没打开过的 profile 其 session 还没配代理,会探成本机 IP —— 先按存储的代理配好。
+    if (!appliedProxy.has(part)) {
+      const prof = profileStore.getProfile("electron", id);
+      const rules = profileStore.proxyRules(prof && prof.proxy);
+      await session.fromPartition(part).setProxy({ proxyRules: rules || "direct://", proxyBypassRules: "127.0.0.1,localhost,[::1]" });
+      appliedProxy.add(part);
+    }
+    const info = await probeIpViaSession(session.fromPartition(part));
+    if (!info.ip) return { accountIdx: id, ipInfo: null, error: "探测失败：代理不通或 IP 服务不可达" };
+    const view = profileStore.setIpInfo("electron", id, info);
+    return { accountIdx: id, ipInfo: view.ipInfo };
+  });
+  // 删除 profile:关掉所有面板里该 profile 的视图,清空其 session 存储(登录态、cookie),
+  // 再删记录。页面侧已二次确认。
+  ipcMain.handle("panelcells:remove-profile", async (e, { accountIdx }) => {
+    if (!ctx(e)) throw new Error("Invalid panel");
+    const id = Number(accountIdx);
+    if (!Number.isInteger(id) || id <= 0) throw new Error("Invalid Electron profile ID");
+    for (const pc of registry.values()) {
+      for (const [key, rec] of [...pc.views]) { if (rec.profile === id) pc.destroyCell(key); }
+    }
+    const part = partitionFor(id);
+    try { await session.fromPartition(part).clearStorageData(); } catch (err) {}
+    try { await session.fromPartition(part).clearCache(); } catch (err) {}
+    appliedProxy.delete(part);
+    const removed = require("../profiles/profile-store").removeProfile("electron", id);
+    return { accountIdx: id, removed };
+  });
+  ipcMain.handle("panelcells:set-profile-note", async (e, { accountIdx, note }) => {
+    if (!ctx(e)) throw new Error("Invalid panel");
+    const id = Number(accountIdx);
+    if (!Number.isInteger(id) || id <= 0) throw new Error("Invalid Electron profile ID");
+    const text = String(note || "").trim().slice(0, 500);
+    const profile = require("../profiles/profile-store").setNote("electron", id, text);
+    return { accountIdx: id, note: String(profile.note || "") };
+  });
   ipcMain.handle("panelcells:snapshots", async (e) => {
     const pc = ctx(e);
     return pc ? pc.snapshots() : [];

package/src/tabbrowser/panel-preload.js

@@ -15,6 +15,9 @@ contextBridge.exposeInMainWorld("panelAPI", {
   profiles: () => ipcRenderer.invoke("panelcells:profiles"),
   addProfile: () => ipcRenderer.invoke("panelcells:add-profile"),
   setProfileProxy: (accountIdx, proxy) => ipcRenderer.invoke("panelcells:set-profile-proxy", { accountIdx, proxy }),
+  setProfileNote: (accountIdx, note) => ipcRenderer.invoke("panelcells:set-profile-note", { accountIdx, note }),
+  probeIp: (accountIdx) => ipcRenderer.invoke("panelcells:probe-ip", { accountIdx }),
+  removeProfile: (accountIdx) => ipcRenderer.invoke("panelcells:remove-profile", { accountIdx }),
   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.

package/src/tabbrowser/telegram-identity.js

@@ -0,0 +1,77 @@
+// Copyright 2026 CiCy AI
+// SPDX-License-Identifier: Apache-2.0
+
+// telegram-identity.js — read "who is logged in" out of a Telegram Web (K)
+// session so the matrix list can show each profile's @username.
+//
+// Telegram Web K keeps the current account id in localStorage `user_auth`
+// ({id, dcID, date}) and caches user records in IndexedDB `tweb-account-<n>`
+// (store `users`, keyed by the stringified user id). The self record carries
+// username / first_name / last_name / phone. Nothing here touches auth keys.
+
+const TELEGRAM_HOST_RE = /(^|\.)web\.telegram\.org$/i;
+
+function isTelegramUrl(url) {
+  try { return TELEGRAM_HOST_RE.test(new URL(String(url || "")).hostname); } catch (e) { return false; }
+}
+
+// Runs inside the (sandboxed) Telegram page via executeJavaScript. Returns a
+// plain object or null; never throws (the caller treats any failure as "unknown").
+const TELEGRAM_IDENTITY_SCRIPT = `(async () => {
+  try {
+    const auth = JSON.parse(localStorage.getItem("user_auth") || "null");
+    const id = auth && (auth.id || auth.user_id);
+    if (!id) return null;
+    const key = String(id);
+    const names = (indexedDB.databases ? (await indexedDB.databases()).map((d) => d.name) : [])
+      .filter((n) => /^tweb-account-\\d+$/.test(String(n || "")));
+    if (!names.length) names.push("tweb-account-1");
+    for (const name of names) {
+      let db = null;
+      try {
+        db = await new Promise((res, rej) => { const r = indexedDB.open(name); r.onsuccess = () => res(r.result); r.onerror = () => rej(r.error); r.onblocked = () => rej(new Error("blocked")); });
+        if (!db.objectStoreNames.contains("users")) { db.close(); continue; }
+        const user = await new Promise((res) => { const tx = db.transaction("users", "readonly"); const r = tx.objectStore("users").get(key); r.onsuccess = () => res(r.result || null); r.onerror = () => res(null); });
+        db.close();
+        if (user && String(user.id) === key) {
+          return { id: key, username: user.username || "", firstName: user.first_name || "", lastName: user.last_name || "", phone: user.phone || "" };
+        }
+      } catch (e) { try { db && db.close(); } catch (_) {} }
+    }
+    return { id: key, username: "", firstName: "", lastName: "", phone: "" };
+  } catch (e) { return null; }
+})()`;
+
+function normalizeTelegramIdentity(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const s = (v) => (typeof v === "string" ? v.trim() : typeof v === "number" ? String(v) : "");
+  const id = s(raw.id);
+  if (!id) return null;
+  const username = s(raw.username).replace(/^@/, "");
+  // accepts the raw page shape (firstName/lastName) or an already-normalized one (displayName)
+  const displayName = s(raw.displayName) || [s(raw.firstName), s(raw.lastName)].filter(Boolean).join(" ");
+  return { id, username, displayName, phone: s(raw.phone) };
+}
+
+// Profile-store login record for this identity (keyed by name "telegram").
+function telegramLoginRecord(identity) {
+  const it = normalizeTelegramIdentity(identity);
+  if (!it) return null;
+  return {
+    url: "https://web.telegram.org",
+    name: "telegram",
+    username: it.username,
+    mobile: it.phone,
+    note: it.displayName,
+  };
+}
+
+// Reverse: identity view from a stored profile (for list rendering).
+function telegramIdentityFromProfile(profile) {
+  const logins = profile && Array.isArray(profile.logins) ? profile.logins : [];
+  const l = logins.find((x) => String((x && x.name) || "").toLowerCase() === "telegram");
+  if (!l) return null;
+  return { username: String(l.username || ""), displayName: String(l.note || ""), phone: String(l.mobile || "") };
+}
+
+module.exports = { isTelegramUrl, TELEGRAM_IDENTITY_SCRIPT, normalizeTelegramIdentity, telegramLoginRecord, telegramIdentityFromProfile };