@quanta-intellect/vessel-browser 0.1.92 → 0.1.94

package/out/main/index.js

@@ -104,10 +104,23 @@ function canUseSafeStorage$1() {
     return false;
   }
 }
+function writePrivateFile(filePath2, data) {
+  fs.writeFileSync(filePath2, data, { mode: 384 });
+  try {
+    fs.chmodSync(filePath2, 384);
+  } catch {
+  }
+}
+function assertSafeStorageAvailable() {
+  if (!canUseSafeStorage$1()) {
+    throw new Error("OS-backed secret storage is unavailable; refusing to store secrets on disk.");
+  }
+}
 function readStoredProviderSecret() {
   try {
+    if (!canUseSafeStorage$1()) return null;
     const raw = fs.readFileSync(getChatProviderSecretPath());
-    const decoded = canUseSafeStorage$1() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const decoded = electron.safeStorage.decryptString(raw);
     const parsed = JSON.parse(decoded);
     if (parsed && typeof parsed === "object" && typeof parsed.providerId === "string" && typeof parsed.apiKey === "string") {
       return parsed;
@@ -117,15 +130,12 @@ function readStoredProviderSecret() {
   return null;
 }
 function writeStoredProviderSecret(secret) {
+  assertSafeStorageAvailable();
   const filePath2 = getChatProviderSecretPath();
   fs.mkdirSync(path.dirname(filePath2), { recursive: true });
   const payload = JSON.stringify(secret);
-  if (canUseSafeStorage$1()) {
-    const encrypted = electron.safeStorage.encryptString(payload);
-    fs.writeFileSync(filePath2, encrypted, { mode: 384 });
-    return;
-  }
-  fs.writeFileSync(filePath2, payload, { mode: 384 });
+  const encrypted = electron.safeStorage.encryptString(payload);
+  writePrivateFile(filePath2, encrypted);
 }
 function clearStoredProviderSecret() {
   try {
@@ -138,8 +148,9 @@ function getCodexTokensPath() {
 }
 function readStoredCodexTokens() {
   try {
+    if (!canUseSafeStorage$1()) return null;
     const raw = fs.readFileSync(getCodexTokensPath());
-    const decoded = canUseSafeStorage$1() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const decoded = electron.safeStorage.decryptString(raw);
     const parsed = JSON.parse(decoded);
     if (parsed && typeof parsed === "object" && typeof parsed.accessToken === "string" && typeof parsed.refreshToken === "string") {
       return parsed;
@@ -149,15 +160,12 @@ function readStoredCodexTokens() {
   return null;
 }
 function writeStoredCodexTokens(tokens) {
+  assertSafeStorageAvailable();
   const filePath2 = getCodexTokensPath();
   fs.mkdirSync(path.dirname(filePath2), { recursive: true });
   const payload = JSON.stringify(tokens);
-  if (canUseSafeStorage$1()) {
-    const encrypted = electron.safeStorage.encryptString(payload);
-    fs.writeFileSync(filePath2, encrypted, { mode: 384 });
-    return;
-  }
-  fs.writeFileSync(filePath2, payload, { mode: 384 });
+  const encrypted = electron.safeStorage.encryptString(payload);
+  writePrivateFile(filePath2, encrypted);
 }
 function clearStoredCodexTokens() {
   try {
@@ -375,6 +383,28 @@ function assertPermittedNavigationURL(url) {
     throw new Error(policyError);
   }
 }
+function loadPermittedNavigationURL(wc, url) {
+  assertPermittedNavigationURL(url);
+  return wc.loadURL(url);
+}
+function loadInternalDataURL(wc, dataUrl) {
+  if (!dataUrl.startsWith("data:text/html;charset=utf-8,")) {
+    throw new Error("Blocked unexpected internal data URL");
+  }
+  return wc.loadURL(dataUrl);
+}
+function loadTrustedAppURL(wc, url) {
+  const parsed = new URL(url);
+  if (!["file:", "http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Blocked unexpected app URL scheme: ${parsed.protocol}`);
+  }
+  const isHttp = parsed.protocol === "http:" || parsed.protocol === "https:";
+  const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  if (isHttp && !isLocalhost) {
+    throw new Error(`Blocked unexpected app URL host: ${parsed.hostname}`);
+  }
+  return wc.loadURL(parsed.toString());
+}
 const MAX_CUSTOM_HISTORY = 50;
 const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 const logger$m = createLogger("Tab");
@@ -1164,9 +1194,9 @@ function save$3() {
 }
 function emit$4() {
   if (!state$5) return;
-  const snapshot = { highlights: [...state$5.highlights] };
+  const snapshot2 = { highlights: [...state$5.highlights] };
   for (const listener of listeners$2) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function normalizeUrl$1(rawUrl) {
@@ -1897,9 +1927,9 @@ function save$2() {
 }
 function emit$3() {
   if (!state$4) return;
-  const snapshot = { entries: [...state$4.entries] };
+  const snapshot2 = { entries: [...state$4.entries] };
   for (const listener of listeners$1) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function getState$1() {
@@ -2093,6 +2123,8 @@ class DevToolsSession {
     this.tabId = tabId;
     this.wc = wc;
   }
+  tabId;
+  wc;
   attached = false;
   attachingPromise = null;
   consoleDomainEnabled = false;
@@ -3108,11 +3140,11 @@ class TabManager {
       note
     };
   }
-  restoreSession(snapshot) {
-    const tabs = snapshot.tabs.length > 0 ? snapshot.tabs : [{ id: "", url: "about:blank", title: "New Tab" }];
+  restoreSession(snapshot2) {
+    const tabs = snapshot2.tabs.length > 0 ? snapshot2.tabs : [{ id: "", url: "about:blank", title: "New Tab" }];
     const activeIndex = Math.max(
       0,
-      Math.min(snapshot.activeIndex, tabs.length - 1)
+      Math.min(snapshot2.activeIndex, tabs.length - 1)
     );
     this.destroyAllTabs();
     const restoredGroups = /* @__PURE__ */ new Map();
@@ -3375,6 +3407,7 @@ const Channels = {
   SETTINGS_UPDATE: "settings:update",
   SETTINGS_HEALTH_GET: "settings:health:get",
   SETTINGS_HEALTH_UPDATE: "settings:health:update",
+  MCP_REGENERATE_TOKEN: "mcp:regenerate-token",
   // Bookmarks
   BOOKMARKS_GET: "bookmarks:get",
   BOOKMARKS_UPDATE: "bookmarks:update",
@@ -3875,8 +3908,8 @@ function load$2() {
       const next = /* @__PURE__ */ new Map();
       if (!Array.isArray(raw)) return next;
       for (const entry of raw) {
-        const snapshot = normalizeStoredSnapshot(entry);
-        if (snapshot) next.set(snapshot.url, snapshot);
+        const snapshot2 = normalizeStoredSnapshot(entry);
+        if (snapshot2) next.set(snapshot2.url, snapshot2);
       }
       return next;
     }
@@ -3903,7 +3936,7 @@ function getSnapshot(normalizedUrl) {
 function saveSnapshot(rawUrl, title, textContent, headings) {
   const s = load$2();
   const key2 = normalizeUrl(rawUrl);
-  const snapshot = {
+  const snapshot2 = {
     url: key2,
     title,
     textContent: textContent.slice(0, MAX_TEXT_LENGTH),
@@ -3911,9 +3944,9 @@ function saveSnapshot(rawUrl, title, textContent, headings) {
     capturedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   s.delete(key2);
-  s.set(key2, snapshot);
+  s.set(key2, snapshot2);
   persistence$5.schedule();
-  return snapshot;
+  return snapshot2;
 }
 function flushPersist$2() {
   return persistence$5.flush();
@@ -4726,6 +4759,7 @@ const POSTHOG_API_KEY = process.env.POSTHOG_API_KEY || "phc_OMeM3P5cxJwl14lOKxYa
 const POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
 const BATCH_INTERVAL_MS = 6e4;
 const MAX_BATCH_SIZE = 50;
+const SENSITIVE_PROPERTY_RE = /url|uri|query|prompt|content|text|token|secret|key|password|credential|email|domain/i;
 function getDeviceIdPath() {
   return path.join(electron.app.getPath("userData"), ".vessel-device-id");
 }
@@ -4754,12 +4788,22 @@ function isEnabled() {
   if (process.env.VESSEL_DEV === "1") return false;
   return loadSettings().telemetryEnabled !== false;
 }
+function sanitizeTelemetryProperties(properties) {
+  const safe = {};
+  for (const [key2, value] of Object.entries(properties)) {
+    if (SENSITIVE_PROPERTY_RE.test(key2)) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      safe[key2] = typeof value === "string" ? value.slice(0, 120) : value;
+    }
+  }
+  return safe;
+}
 function trackEvent(event, properties = {}) {
   if (!isEnabled()) return;
   eventQueue.push({
     event,
     properties: {
-      ...properties,
+      ...sanitizeTelemetryProperties(properties),
       premium_status: isPremium() ? "premium" : "free",
       app_version: electron.app.getVersion(),
       platform: process.platform,
@@ -4794,8 +4838,8 @@ function trackBookmarkAction(action) {
 function trackVaultAction(action) {
   trackEvent("vault_action", { action });
 }
-function trackExtractionFailed(domain, reason) {
-  trackEvent("extraction_failed", { domain, reason });
+function trackExtractionFailed(_domain, reason) {
+  trackEvent("extraction_failed", { reason });
 }
 function trackPremiumFunnel(step, context) {
   trackEvent("premium_funnel", { step, ...context });
@@ -6774,9 +6818,9 @@ function getMcpStatus() {
   return state$3.mcp.status;
 }
 function emitRuntimeHealthChange() {
-  const snapshot = getRuntimeHealth();
+  const snapshot2 = getRuntimeHealth();
   for (const listener of runtimeHealthChangeListeners) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 const state$3 = {
@@ -8473,6 +8517,17 @@ class OpenAICompatProvider {
     this.abortController?.abort();
   }
 }
+async function openExternalAllowlisted(url, rule) {
+  const parsed = new URL(url);
+  const schemes = rule.schemes ?? ["https:"];
+  if (!schemes.includes(parsed.protocol)) {
+    throw new Error(`Blocked external URL scheme: ${parsed.protocol}`);
+  }
+  if (rule.hosts && !rule.hosts.includes(parsed.hostname)) {
+    throw new Error(`Blocked external URL host: ${parsed.hostname}`);
+  }
+  await electron.shell.openExternal(parsed.toString());
+}
 const logger$g = createLogger("CodexOAuth");
 const ISSUER = "https://auth.openai.com";
 const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -8809,7 +8864,7 @@ async function startCodexOAuth(onStatus) {
       activeFlow.port = port;
       const authUrl = buildAuthorizeUrl(port, pkce, state2);
       safeOnStatus("waiting");
-      electron.shell.openExternal(authUrl).catch((err) => {
+      openExternalAllowlisted(authUrl, { hosts: ["auth.openai.com"] }).catch((err) => {
         logger$g.warn("Failed to open browser, user will need the URL:", err);
       });
     }).catch(wrappedReject);
@@ -12476,9 +12531,9 @@ function assignDefinedBookmarkFields(bookmark, fields) {
 }
 function emit$2() {
   if (!state$2) return;
-  const snapshot = cloneState(state$2);
+  const snapshot2 = cloneState(state$2);
   for (const listener of listeners) {
-    listener(snapshot);
+    listener(snapshot2);
   }
 }
 function escapeBookmarkHtml(value) {
@@ -12999,7 +13054,7 @@ async function captureLiveHighlightSnapshot(wc, savedHighlights = []) {
     savedHighlights.map((highlight) => normalizeText(highlight.text)).filter(Boolean)
   );
   try {
-    const snapshot = await wc.executeJavaScript(`(() => {
+    const snapshot2 = await wc.executeJavaScript(`(() => {
       const selection = window.getSelection?.()?.toString().trim() || "";
       const pageHighlights = Array.from(
         document.querySelectorAll("mark.__vessel-highlight-text[data-vessel-highlight]")
@@ -13021,7 +13076,7 @@ async function captureLiveHighlightSnapshot(wc, savedHighlights = []) {
       };
     })()`, true);
     const seen = /* @__PURE__ */ new Set();
-    const pageHighlights = (snapshot.pageHighlights ?? []).map((highlight) => ({
+    const pageHighlights = (snapshot2.pageHighlights ?? []).map((highlight) => ({
       text: normalizeText(highlight.text),
       color: highlight.color?.trim() || void 0
     })).filter((highlight) => highlight.text.length > 0).filter((highlight) => {
@@ -13033,24 +13088,24 @@ async function captureLiveHighlightSnapshot(wc, savedHighlights = []) {
       ...highlight,
       persisted: savedTexts.has(highlight.text)
     }));
-    const activeSelection = normalizeText(snapshot.activeSelection) || void 0;
+    const activeSelection = normalizeText(snapshot2.activeSelection) || void 0;
     return { activeSelection, pageHighlights };
   } catch {
     return { pageHighlights: [] };
   }
 }
-function formatLiveSelectionSection(snapshot) {
+function formatLiveSelectionSection(snapshot2) {
   const sections = [];
-  if (snapshot.activeSelection) {
-    const preview = snapshot.activeSelection.length > 400 ? `${snapshot.activeSelection.slice(0, 397)}...` : snapshot.activeSelection;
+  if (snapshot2.activeSelection) {
+    const preview = snapshot2.activeSelection.length > 400 ? `${snapshot2.activeSelection.slice(0, 397)}...` : snapshot2.activeSelection;
     sections.push(
       `## Active User Selection
 The user currently has this text selected on screen:
 - "${preview}"`
     );
   }
-  if (snapshot.pageHighlights.length > 0) {
-    const lines = snapshot.pageHighlights.map((highlight) => {
+  if (snapshot2.pageHighlights.length > 0) {
+    const lines = snapshot2.pageHighlights.map((highlight) => {
       const preview = highlight.text.length > 180 ? `${highlight.text.slice(0, 177)}...` : highlight.text;
       const details = [
         highlight.persisted ? "saved" : "visible only",
@@ -13551,7 +13606,7 @@ async function saveNamedSession(tabManager, name) {
     const entries = await captureLocalStorageForOrigin(tabManager, origin);
     localStorage.push({ origin, entries });
   }
-  const snapshot = tabManager.snapshotSession(`Named session: ${normalizedName}`);
+  const snapshot2 = tabManager.snapshotSession(`Named session: ${normalizedName}`);
   const domains = [...new Set(cookies.map((cookie) => cookie.domain))].sort();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const data = {
@@ -13563,7 +13618,7 @@ async function saveNamedSession(tabManager, name) {
     domains,
     cookies,
     localStorage,
-    snapshot
+    snapshot: snapshot2
   };
   writeSessionFile(getSessionPath(normalizedName), data);
   return {
@@ -13918,8 +13973,8 @@ function compactSearchLikeResult(text) {
     return limitText(cleaned, 16, 1400);
   }
   const summary = cleaned.slice(0, markerIndex).trim();
-  const snapshot = cleaned.slice(markerIndex + marker.length).trim();
-  return [summary, compactReadPageResult(snapshot)].filter(Boolean).join("\n\n");
+  const snapshot2 = cleaned.slice(markerIndex + marker.length).trim();
+  return [summary, compactReadPageResult(snapshot2)].filter(Boolean).join("\n\n");
 }
 function compactCurrentTabResult(text) {
   try {
@@ -14968,7 +15023,7 @@ async function inspectElement(wc, selector, limit = 8) {
   return lines.join("\n");
 }
 async function getLocaleSnapshot(wc) {
-  const snapshot = await executePageScript(
+  const snapshot2 = await executePageScript(
     wc,
     `
     (function() {
@@ -14987,13 +15042,13 @@ async function getLocaleSnapshot(wc) {
       label: "locale snapshot"
     }
   );
-  if (!snapshot || snapshot === PAGE_SCRIPT_TIMEOUT || typeof snapshot !== "object") {
+  if (!snapshot2 || snapshot2 === PAGE_SCRIPT_TIMEOUT || typeof snapshot2 !== "object") {
     return null;
   }
   return {
-    lang: typeof snapshot.lang === "string" ? snapshot.lang.trim() : "",
-    url: typeof snapshot.url === "string" ? snapshot.url : wc.getURL(),
-    title: typeof snapshot.title === "string" ? snapshot.title : wc.getTitle()
+    lang: typeof snapshot2.lang === "string" ? snapshot2.lang.trim() : "",
+    url: typeof snapshot2.url === "string" ? snapshot2.url : wc.getURL(),
+    title: typeof snapshot2.title === "string" ? snapshot2.title : wc.getTitle()
   };
 }
 function primaryLanguageTag(value) {
@@ -15009,31 +15064,31 @@ function localeChanged(before, after) {
   const localeHint = /[?&](lang|locale|language|hl)=|\/(ja|jp|en|fr|de|es|it|ko|zh)(\/|$)/i;
   return before.url !== after.url && localeHint.test(after.url);
 }
-async function restoreLocaleSnapshot(wc, snapshot) {
-  if (!snapshot || wc.isDestroyed()) return;
+async function restoreLocaleSnapshot(wc, snapshot2) {
+  if (!snapshot2 || wc.isDestroyed()) return;
   try {
     if (typeof wc.canGoBack === "function" && wc.canGoBack()) {
       wc.goBack();
       await waitForLoad(wc, 3e3);
       const reverted = await getLocaleSnapshot(wc);
-      if (!localeChanged(snapshot, reverted)) {
+      if (!localeChanged(snapshot2, reverted)) {
         return;
       }
     }
   } catch (err) {
     logger$c.warn("Failed to restore locale via history navigation, trying URL reload fallback:", err);
   }
-  if (snapshot.url && snapshot.url !== wc.getURL()) {
+  if (snapshot2.url && snapshot2.url !== wc.getURL()) {
     try {
-      assertSafeURL(snapshot.url);
-      await wc.loadURL(snapshot.url);
+      assertSafeURL(snapshot2.url);
+      await wc.loadURL(snapshot2.url);
       await waitForLoad(wc, 3e3);
       return;
     } catch (err) {
       logger$c.warn("Failed to restore locale via safe URL load, trying page reload fallback:", err);
     }
   }
-  if (snapshot.url) {
+  if (snapshot2.url) {
     try {
       await wc.reload();
       await waitForLoad(wc, 3e3);
@@ -18983,9 +19038,9 @@ function capturePageToVault({
   if (page.excerpt.trim()) {
     bodyLines.push("## Excerpt", "", page.excerpt.trim(), "");
   }
-  const snapshot = trimContent(page.content);
-  if (snapshot) {
-    bodyLines.push("## Page Snapshot", "", snapshot, "");
+  const snapshot2 = trimContent(page.content);
+  if (snapshot2) {
+    bodyLines.push("## Page Snapshot", "", snapshot2, "");
   }
   return writeMemoryNote({
     title: noteTitle,
@@ -19410,8 +19465,8 @@ Exception: ${result.exceptionDetails}`);
         {},
         async () => {
           const session = getOrCreateSession(tabManager);
-          const snapshot = await session.getPerformanceSnapshot();
-          return JSON.stringify(snapshot, null, 2);
+          const snapshot2 = await session.getPerformanceSnapshot();
+          return JSON.stringify(snapshot2, null, 2);
         }
       );
     }
@@ -19487,6 +19542,7 @@ function getOrCreateEncryptionKey(keyFilename) {
   fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
   const encrypted = electron.safeStorage.encryptString(key2.toString("utf-8"));
   fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
+  fs$1.chmodSync(keyPath, 384);
   return key2;
 }
 function createEncryptDecrypt(keyFilename) {
@@ -19560,15 +19616,21 @@ function createVaultIO(vaultFilename, encrypt2, decrypt2) {
   }
   return { loadVault: loadVault2, saveVault: saveVault2, resetCache };
 }
-function domainMatches(pattern, hostname) {
-  const p = pattern.toLowerCase().trim();
-  const h = hostname.toLowerCase().trim();
-  if (p === h) return true;
-  if (p.startsWith("*.")) {
-    const suffix = p.slice(2);
-    return h === suffix || h.endsWith("." + suffix);
+function normalizeCredentialHost(value) {
+  try {
+    const parsed = new URL(value.includes("://") ? value : `https://${value}`);
+    return parsed.hostname.toLowerCase().replace(/^www\./, "");
+  } catch {
+    const normalized = value.toLowerCase().trim().replace(/^(https?:\/\/)?(www\.)?/, "").replace(/\/.*$/, "");
+    return normalized && !normalized.includes(" ") ? normalized : null;
   }
-  return false;
+}
+function domainMatches(pattern, hostname) {
+  const isWildcard = pattern.trim().startsWith("*.");
+  const p = normalizeCredentialHost(isWildcard ? pattern.slice(2) : pattern);
+  const h = normalizeCredentialHost(hostname);
+  if (!p || !h) return false;
+  return isWildcard ? h.endsWith("." + p) : p === h;
 }
 function generateTotpCode(secret) {
   const epoch = Math.floor(Date.now() / 1e3);
@@ -19639,12 +19701,8 @@ function listEntries$1() {
   return loadVault$1().map(({ password, totpSecret, ...rest }) => rest);
 }
 function findEntriesForDomain(url) {
-  let hostname;
-  try {
-    hostname = new URL(url).hostname;
-  } catch {
-    return [];
-  }
+  const hostname = normalizeCredentialHost(url);
+  if (!hostname) return [];
   return loadVault$1().filter((e) => domainMatches(e.domainPattern, hostname)).map(({ password, totpSecret, ...rest }) => rest);
 }
 function addEntry(entry) {
@@ -19767,12 +19825,7 @@ const auditLog = createAuditLog(
   AUDIT_MAX_ENTRIES
 );
 function extractDomain(url) {
-  try {
-    const parsed = new URL(url.startsWith("http") ? url : `https://${url}`);
-    return parsed.hostname.toLowerCase();
-  } catch {
-    return url.toLowerCase().replace(/^(https?:\/\/)?(www\.)?/, "").replace(/\/.*$/, "");
-  }
+  return normalizeCredentialHost(url) ?? "";
 }
 function listEntries() {
   return loadVault().map(({ password, totpSecret, ...rest }) => rest);
@@ -19957,6 +20010,7 @@ function writeMcpAuthFile(endpoint, token) {
       JSON.stringify({ endpoint, token, pid: process.pid }, null, 2) + "\n",
       { mode: 384 }
     );
+    fs$1.chmodSync(filePath2, 384);
   } catch (err) {
     logger$9.warn("Failed to write auth file:", err);
   }
@@ -19982,10 +20036,18 @@ function clearMcpAuthFile() {
       ) + "\n",
       { mode: 384 }
     );
+    fs$1.chmodSync(filePath2, 384);
   } catch (err) {
     logger$9.warn("Failed to clear auth file:", err);
   }
 }
+function regenerateMcpAuthToken() {
+  const endpoint = getRuntimeHealth().mcp.endpoint;
+  if (!httpServer || !endpoint) return null;
+  mcpAuthToken = crypto$2.randomBytes(32).toString("hex");
+  writeMcpAuthFile(endpoint, mcpAuthToken);
+  return { endpoint };
+}
 function asTextResponse(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -20011,6 +20073,11 @@ function asPromptResponse(text) {
 function isDangerousMcpAction(name) {
   return name === "close_tab" || isDangerousAction(name);
 }
+function requiresExplicitMcpApproval(name, args) {
+  if (name === "delete_session" || name === "close_tab" || name === "load_session") return true;
+  if (name === "remove_folder" && args.delete_contents === true) return true;
+  return false;
+}
 function getActiveTabSummary(tabManager) {
   const activeTab = tabManager.getActiveTab();
   const activeTabId = tabManager.getActiveTabId();
@@ -20099,6 +20166,7 @@ async function withAction(runtime2, tabManager, name, args, executor) {
       args,
       tabId: tabManager.getActiveTabId(),
       dangerous: isDangerousMcpAction(name),
+      requiresApproval: requiresExplicitMcpApproval(name, args),
       executor
     });
     const stateInfo = await getPostActionState(tabManager, name);
@@ -24122,6 +24190,16 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     return true;
   });
 }
+const trustedIpcSenderIds = /* @__PURE__ */ new Set();
+function registerTrustedIpcSender(wc) {
+  trustedIpcSenderIds.add(wc.id);
+  wc.once("destroyed", () => trustedIpcSenderIds.delete(wc.id));
+}
+function assertTrustedIpcSender(event) {
+  if (!trustedIpcSenderIds.has(event.sender.id)) {
+    throw new Error("Blocked IPC from untrusted renderer");
+  }
+}
 function assertString(value, name) {
   if (typeof value !== "string") throw new Error(`${name} must be a string`);
 }
@@ -24537,13 +24615,26 @@ function registerAutofillHandlers(windowState) {
   });
 }
 function registerPageDiffHandlers(windowState, sendToRendererViews) {
-  electron.ipcMain.handle(Channels.PAGE_DIFF_GET, () => {
+  const pageEventBuckets = /* @__PURE__ */ new Map();
+  const allowPageEvent = (webContentsId) => {
+    const now = Date.now();
+    const bucket = pageEventBuckets.get(webContentsId);
+    if (!bucket || bucket.resetAt <= now) {
+      pageEventBuckets.set(webContentsId, { count: 1, resetAt: now + 1e3 });
+      return true;
+    }
+    bucket.count += 1;
+    return bucket.count <= 20;
+  };
+  electron.ipcMain.handle(Channels.PAGE_DIFF_GET, (event) => {
+    assertTrustedIpcSender(event);
     const activeTab = windowState.tabManager.getActiveTab();
     const wc = activeTab?.view.webContents;
     if (!wc) return null;
     return getLatestPageDiff(wc.getURL());
   });
-  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, () => {
+  electron.ipcMain.handle(Channels.PAGE_DIFF_HISTORY, (event) => {
+    assertTrustedIpcSender(event);
     try {
       if (!isPremiumActiveState(getPremiumState())) {
         return { error: "Premium required" };
@@ -24559,21 +24650,25 @@ function registerPageDiffHandlers(windowState, sendToRendererViews) {
   electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
+    if (!allowPageEvent(wc.id)) return;
     notePageMutationActivity(wc, sendToRendererViews);
   });
   electron.ipcMain.on(Channels.PAGE_DIFF_DIRTY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
+    if (!allowPageEvent(wc.id)) return;
     schedulePageSnapshotCapture(wc, sendToRendererViews);
   });
 }
 function registerVaultHandlers() {
-  electron.ipcMain.handle(Channels.VAULT_LIST, () => {
+  electron.ipcMain.handle(Channels.VAULT_LIST, (event) => {
+    assertTrustedIpcSender(event);
     return listEntries$1();
   });
   electron.ipcMain.handle(
     Channels.VAULT_ADD,
-    (_, entry) => {
+    (event, entry) => {
+      assertTrustedIpcSender(event);
       if (!entry || typeof entry !== "object") {
         throw new Error("Invalid vault entry");
       }
@@ -24598,7 +24693,8 @@ function registerVaultHandlers() {
   );
   electron.ipcMain.handle(
     Channels.VAULT_UPDATE,
-    (_, id, updates) => {
+    (event, id, updates) => {
+      assertTrustedIpcSender(event);
       assertString(id, "id");
       if (!updates || typeof updates !== "object") {
         throw new Error("Invalid updates");
@@ -24606,12 +24702,14 @@ function registerVaultHandlers() {
       return updateEntry$1(id, updates) !== null;
     }
   );
-  electron.ipcMain.handle(Channels.VAULT_REMOVE, (_, id) => {
+  electron.ipcMain.handle(Channels.VAULT_REMOVE, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     trackVaultAction("credential_removed");
     return removeEntry$1(id);
   });
-  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (_, limit) => {
+  electron.ipcMain.handle(Channels.VAULT_AUDIT_LOG, (event, limit) => {
+    assertTrustedIpcSender(event);
     return readAuditLog$1(limit);
   });
 }
@@ -24630,17 +24728,20 @@ function normalizeTags(value) {
   return tags.length > 0 ? tags : void 0;
 }
 function registerHumanVaultHandlers() {
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_LIST, (_, domain) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_LIST, (event, domain) => {
+    assertTrustedIpcSender(event);
     if (domain !== void 0) assertString(domain, "domain");
     return domain ? findForDomain(domain) : listEntries();
   });
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_GET, (_, id) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_GET, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return getEntrySafe(id);
   });
   electron.ipcMain.handle(
     Channels.HUMAN_VAULT_SAVE,
-    (_, input) => {
+    (event, input) => {
+      assertTrustedIpcSender(event);
       if (!input || typeof input !== "object") {
         throw new Error("Invalid credential entry");
       }
@@ -24670,7 +24771,8 @@ function registerHumanVaultHandlers() {
   );
   electron.ipcMain.handle(
     Channels.HUMAN_VAULT_UPDATE,
-    (_, id, updates) => {
+    (event, id, updates) => {
+      assertTrustedIpcSender(event);
       assertString(id, "id");
       if (!updates || typeof updates !== "object") {
         throw new Error("Invalid updates");
@@ -24712,26 +24814,31 @@ function registerHumanVaultHandlers() {
       return safe;
     }
   );
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_REMOVE, (_, id) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_REMOVE, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return removeEntry(id);
   });
-  electron.ipcMain.handle(Channels.HUMAN_VAULT_AUDIT_LOG, (_, limit) => {
+  electron.ipcMain.handle(Channels.HUMAN_VAULT_AUDIT_LOG, (event, limit) => {
+    assertTrustedIpcSender(event);
     return readAuditLog(limit);
   });
 }
 function registerWindowControlHandlers(mainWindow) {
-  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, (event) => {
+    assertTrustedIpcSender(event);
     mainWindow.minimize();
   });
-  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_MAXIMIZE, (event) => {
+    assertTrustedIpcSender(event);
     if (mainWindow.isMaximized()) {
       mainWindow.unmaximize();
     } else {
       mainWindow.maximize();
     }
   });
-  electron.ipcMain.handle(Channels.WINDOW_CLOSE, () => {
+  electron.ipcMain.handle(Channels.WINDOW_CLOSE, (event) => {
+    assertTrustedIpcSender(event);
     mainWindow.close();
   });
 }
@@ -24870,6 +24977,32 @@ function installAdBlockingForSession(ses, tabManager) {
   });
 }
 const filePath$1 = () => path$1.join(electron.app.getPath("userData"), "vessel-downloads.json");
+const EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".appimage",
+  ".bat",
+  ".cmd",
+  ".command",
+  ".desktop",
+  ".exe",
+  ".msi",
+  ".ps1",
+  ".scr",
+  ".sh"
+]);
+function hasMisleadingDoubleExtension(filename) {
+  return /\.(pdf|docx?|xlsx?|pptx?|png|jpe?g|gif|txt|zip)\.(exe|msi|bat|cmd|ps1|sh|scr|appimage)$/i.test(filename);
+}
+function isExecutableDownload(savePath) {
+  return EXECUTABLE_EXTENSIONS.has(path$1.extname(savePath).toLowerCase());
+}
+function executableWarningDetail(item) {
+  return [
+    "This file can run code on your computer. Only open it if you trust the source.",
+    item.url ? `Source: ${item.url}` : null,
+    item.mimeType ? `Type: ${item.mimeType}` : null,
+    hasMisleadingDoubleExtension(item.filename) ? "Warning: this filename uses a misleading double extension." : null
+  ].filter(Boolean).join("\n");
+}
 function parse(raw) {
   if (!raw || typeof raw !== "object") return { items: [] };
   const items = Array.isArray(raw.items) ? raw.items : [];
@@ -24888,13 +25021,13 @@ function persist() {
   persistence$1.schedule();
 }
 function emit$1() {
-  broadcaster$1?.(Channels.DOWNLOADS_UPDATE, state.items);
+  broadcaster$1?.(Channels.DOWNLOADS_UPDATE, listDownloads());
 }
 function setDownloadBroadcaster(fn) {
   broadcaster$1 = fn;
 }
 function listDownloads() {
-  return state.items;
+  return state.items.map((item) => ({ ...item }));
 }
 function upsertDownload(input) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -24918,7 +25051,19 @@ function clearDownloads() {
 }
 async function openDownload(id) {
   const item = state.items.find((d) => d.id === id);
-  if (!item || !fs$1.existsSync(item.savePath)) return false;
+  if (!item || item.state !== "completed" || !fs$1.existsSync(item.savePath)) return false;
+  if (isExecutableDownload(item.savePath)) {
+    const result = electron.dialog.showMessageBoxSync({
+      type: "warning",
+      buttons: ["Cancel", "Open Anyway"],
+      defaultId: 0,
+      cancelId: 0,
+      title: "Open executable download?",
+      message: `Open ${item.filename}?`,
+      detail: executableWarningDetail(item)
+    });
+    if (result !== 1) return false;
+  }
   return await electron.shell.openPath(item.savePath) === "";
 }
 async function showDownloadInFolder(id) {
@@ -24969,6 +25114,8 @@ function installDownloadHandlerForSession(targetSession, chromeView) {
     const info = {
       filename,
       savePath,
+      url: item.getURL(),
+      mimeType: typeof item.getMimeType === "function" ? item.getMimeType() : void 0,
       totalBytes: item.getTotalBytes(),
       receivedBytes: 0,
       state: "progressing"
@@ -25016,9 +25163,9 @@ function loadRenderers(chromeView, sidebarView, devtoolsPanelView) {
   const sidebarUrl = rendererUrlFor("sidebar");
   const devtoolsUrl = rendererUrlFor("devtools");
   if (chromeUrl && sidebarUrl && devtoolsUrl) {
-    chromeView.webContents.loadURL(chromeUrl);
-    sidebarView.webContents.loadURL(sidebarUrl);
-    devtoolsPanelView.webContents.loadURL(devtoolsUrl);
+    void loadTrustedAppURL(chromeView.webContents, chromeUrl);
+    void loadTrustedAppURL(sidebarView.webContents, sidebarUrl);
+    void loadTrustedAppURL(devtoolsPanelView.webContents, devtoolsUrl);
   } else {
     const rendererFile = resolveRendererFile();
     chromeView.webContents.loadFile(rendererFile, {
@@ -25244,7 +25391,7 @@ function loadPrivateRenderer(chromeView) {
     const url = new URL(devUrl);
     url.searchParams.set("view", "chrome");
     url.searchParams.set("private", "1");
-    chromeView.webContents.loadURL(url.toString());
+    void loadTrustedAppURL(chromeView.webContents, url.toString());
   } else {
     chromeView.webContents.loadFile(resolveRendererFile(), {
       query: { view: "chrome", private: "1" }
@@ -25479,7 +25626,7 @@ function loadSecondaryRenderer(chromeView) {
     const url = new URL(devUrl);
     url.searchParams.set("view", "chrome");
     url.searchParams.set("secondary", "1");
-    chromeView.webContents.loadURL(url.toString());
+    void loadTrustedAppURL(chromeView.webContents, url.toString());
   } else {
     chromeView.webContents.loadFile(resolveRendererFile(), {
       query: { view: "chrome", secondary: "1" }
@@ -25699,7 +25846,8 @@ function registerBookmarkHandlers() {
   });
   electron.ipcMain.handle(
     Channels.BOOKMARKS_EXPORT_HTML,
-    async (_, options) => {
+    async (event, options) => {
+      assertTrustedIpcSender(event);
       const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
         title: "Export Bookmarks",
         defaultPath: "vessel-bookmarks.html",
@@ -25717,7 +25865,8 @@ function registerBookmarkHandlers() {
       };
     }
   );
-  electron.ipcMain.handle(Channels.BOOKMARKS_EXPORT_JSON, async () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_EXPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Export Vessel Bookmark Archive",
       defaultPath: "vessel-bookmarks.json",
@@ -25734,7 +25883,8 @@ function registerBookmarkHandlers() {
   });
   electron.ipcMain.handle(
     Channels.FOLDER_EXPORT_HTML,
-    async (_, folderId, options) => {
+    async (event, folderId, options) => {
+      assertTrustedIpcSender(event);
       const folder = getFolder(folderId);
       if (!folder) return null;
       const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
@@ -25755,7 +25905,8 @@ function registerBookmarkHandlers() {
       };
     }
   );
-  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_HTML, async () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_HTML, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import Bookmarks",
       filters: [
@@ -25768,7 +25919,8 @@ function registerBookmarkHandlers() {
     trackBookmarkAction("import");
     return importBookmarksFromHtml(content);
   });
-  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_JSON, async () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_IMPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import Bookmarks",
       filters: [
@@ -25799,10 +25951,12 @@ function registerHistoryHandlers() {
   electron.ipcMain.handle(Channels.HISTORY_SEARCH, (_, query) => {
     return search(query);
   });
-  electron.ipcMain.handle(Channels.HISTORY_CLEAR, () => {
+  electron.ipcMain.handle(Channels.HISTORY_CLEAR, (event) => {
+    assertTrustedIpcSender(event);
     clearAll$1();
   });
-  electron.ipcMain.handle(Channels.HISTORY_EXPORT_HTML, async () => {
+  electron.ipcMain.handle(Channels.HISTORY_EXPORT_HTML, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Export History",
       defaultPath: "vessel-history.html",
@@ -25813,7 +25967,8 @@ function registerHistoryHandlers() {
     await fs.promises.writeFile(filePath2, content, "utf-8");
     return { filePath: filePath2, count: getState$1().entries.length };
   });
-  electron.ipcMain.handle(Channels.HISTORY_EXPORT_JSON, async () => {
+  electron.ipcMain.handle(Channels.HISTORY_EXPORT_JSON, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePath: filePath2 } = await electron.dialog.showSaveDialog({
       title: "Export History",
       defaultPath: "vessel-history.json",
@@ -25824,7 +25979,8 @@ function registerHistoryHandlers() {
     await fs.promises.writeFile(filePath2, content, "utf-8");
     return { filePath: filePath2, count: getState$1().entries.length };
   });
-  electron.ipcMain.handle(Channels.HISTORY_IMPORT, async () => {
+  electron.ipcMain.handle(Channels.HISTORY_IMPORT, async (event) => {
+    assertTrustedIpcSender(event);
     const { canceled, filePaths } = await electron.dialog.showOpenDialog({
       title: "Import History",
       filters: [
@@ -26035,7 +26191,8 @@ function buildCertificateDetailsHtml(state2) {
 </html>`;
 }
 function registerSecurityHandlers(tabManager) {
-  electron.ipcMain.handle(Channels.SECURITY_SHOW_DETAILS, async (_, state2) => {
+  electron.ipcMain.handle(Channels.SECURITY_SHOW_DETAILS, async (event, state2) => {
+    assertTrustedIpcSender(event);
     const domain = (() => {
       try {
         return new URL(state2.url).hostname || state2.url;
@@ -26056,13 +26213,15 @@ function registerSecurityHandlers(tabManager) {
         spellcheck: false
       }
     });
-    void win.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(content)}`);
+    void loadInternalDataURL(win.webContents, `data:text/html;charset=utf-8,${encodeURIComponent(content)}`);
   });
-  electron.ipcMain.handle(Channels.SECURITY_PROCEED_ANYWAY, (_, tabId) => {
+  electron.ipcMain.handle(Channels.SECURITY_PROCEED_ANYWAY, (event, tabId) => {
+    assertTrustedIpcSender(event);
     assertString(tabId, "tabId");
     tabManager.proceedAnyway(tabId);
   });
-  electron.ipcMain.handle(Channels.SECURITY_GO_BACK_TO_SAFETY, (_, tabId) => {
+  electron.ipcMain.handle(Channels.SECURITY_GO_BACK_TO_SAFETY, (event, tabId) => {
+    assertTrustedIpcSender(event);
     assertString(tabId, "tabId");
     tabManager.goBackToSafety(tabId);
   });
@@ -26070,6 +26229,7 @@ function registerSecurityHandlers(tabManager) {
 const logger$5 = createLogger("CodexIPC");
 function registerCodexHandlers() {
   electron.ipcMain.handle(Channels.CODEX_START_AUTH, async (event) => {
+    assertTrustedIpcSender(event);
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) {
       return {
@@ -26100,29 +26260,57 @@ function registerCodexHandlers() {
       };
     }
   });
-  electron.ipcMain.handle(Channels.CODEX_CANCEL_AUTH, () => {
+  electron.ipcMain.handle(Channels.CODEX_CANCEL_AUTH, (event) => {
+    assertTrustedIpcSender(event);
     cancelCodexOAuth();
     return { ok: true };
   });
-  electron.ipcMain.handle(Channels.CODEX_DISCONNECT, () => {
+  electron.ipcMain.handle(Channels.CODEX_DISCONNECT, (event) => {
+    assertTrustedIpcSender(event);
     clearStoredCodexTokens();
     return { ok: true };
   });
 }
 const filePath = () => path$1.join(electron.app.getPath("userData"), "vessel-permissions.json");
+const ALLOWED_PERMISSION_TYPES = /* @__PURE__ */ new Set([
+  "clipboard-read",
+  "fullscreen",
+  "geolocation",
+  "media",
+  "midiSysex",
+  "notifications",
+  "pointerLock"
+]);
+function parseOrigin(value) {
+  try {
+    const origin = new URL(value).origin;
+    return origin === "null" ? null : origin;
+  } catch {
+    return null;
+  }
+}
+function isPermissionRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.origin === "string" && parseOrigin(record.origin) === record.origin && typeof record.permission === "string" && ALLOWED_PERMISSION_TYPES.has(record.permission) && (record.decision === "allow" || record.decision === "deny") && typeof record.updatedAt === "string";
+}
 let records = loadJsonFile({
   filePath: filePath(),
   fallback: [],
-  parse: (raw) => Array.isArray(raw) ? raw : []
+  parse: (raw) => Array.isArray(raw) ? raw.filter(isPermissionRecord) : []
 });
 const persistence = createDebouncedJsonPersistence({ debounceMs: 250, filePath: filePath(), getValue: () => records, logLabel: "permissions" });
+const sessionDecisions = /* @__PURE__ */ new Map();
 let broadcaster = null;
 function key(origin, permission) {
   return `${origin}
 ${permission}`;
 }
+function snapshot() {
+  return records.map((record) => ({ ...record }));
+}
 function emit() {
-  broadcaster?.(Channels.PERMISSIONS_GET, records);
+  broadcaster?.(Channels.PERMISSIONS_GET, snapshot());
 }
 function save(origin, permission, decision) {
   const k = key(origin, permission);
@@ -26134,15 +26322,21 @@ function save(origin, permission, decision) {
   emit();
 }
 function listPermissions() {
-  return records;
+  return snapshot();
 }
 function clearPermissions() {
   records = [];
+  sessionDecisions.clear();
   persistence.schedule();
   emit();
 }
 function clearPermissionsForOrigin(origin) {
+  if (!parseOrigin(origin)) return;
   records = records.filter((record) => record.origin !== origin);
+  for (const storedKey of sessionDecisions.keys()) {
+    if (storedKey.startsWith(`${origin}
+`)) sessionDecisions.delete(storedKey);
+  }
   persistence.schedule();
   emit();
 }
@@ -26151,27 +26345,54 @@ function setPermissionBroadcaster(fn) {
 }
 function installPermissionHandler() {
   electron.session.defaultSession.setPermissionRequestHandler((webContents, permission, callback, details) => {
-    const origin = new URL(details.requestingUrl || webContents.getURL()).origin;
+    if (!ALLOWED_PERMISSION_TYPES.has(permission)) {
+      callback(false);
+      return;
+    }
+    const origin = parseOrigin(details.requestingUrl || webContents.getURL());
+    if (!origin) {
+      callback(false);
+      return;
+    }
+    const k = key(origin, permission);
     const existing = records.find((r) => r.origin === origin && r.permission === permission);
     if (existing) {
       callback(existing.decision === "allow");
       return;
     }
+    const sessionDecision = sessionDecisions.get(k);
+    if (sessionDecision) {
+      callback(sessionDecision === "allow");
+      return;
+    }
     const result = electron.dialog.showMessageBoxSync({
       type: "question",
-      buttons: ["Deny", "Allow"],
+      buttons: ["Deny", "Allow Once", "Allow Until Quit", "Always Allow"],
       defaultId: 0,
       cancelId: 0,
       title: "Site permission request",
       message: `${origin} wants to use ${permission}`,
-      detail: "Vessel will remember your choice. You can clear saved permissions in Settings > Privacy."
+      detail: "Temporary choices are safer for camera, microphone, location, and clipboard access. Persistent choices can be cleared in Settings > Privacy."
     });
-    const decision = result === 1 ? "allow" : "deny";
-    save(origin, permission, decision);
-    callback(decision === "allow");
+    if (result === 1) {
+      callback(true);
+      return;
+    }
+    if (result === 2) {
+      sessionDecisions.set(k, "allow");
+      callback(true);
+      return;
+    }
+    if (result === 3) {
+      save(origin, permission, "allow");
+      callback(true);
+      return;
+    }
+    save(origin, permission, "deny");
+    callback(false);
   });
 }
-const NPM_PACKAGE_URL = "https://registry.npmjs.org/@quanta-intellect%2Fvessel-browser/latest";
+const GITHUB_LATEST_RELEASE_API_URL = "https://api.github.com/repos/unmodeled-tyler/quanta-vessel-browser/releases/latest";
 const RELEASES_URL = "https://github.com/unmodeled-tyler/quanta-vessel-browser/releases/latest";
 function normalizeVersion(version) {
   return version.replace(/^v/i, "").split(/[.-]/).slice(0, 3).map((part) => {
@@ -26192,21 +26413,22 @@ async function checkForUpdates() {
   const currentVersion = electron.app.getVersion();
   const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    const response = await fetch(NPM_PACKAGE_URL, {
-      headers: { accept: "application/json", "user-agent": `Vessel/${currentVersion}` }
+    const response = await fetch(GITHUB_LATEST_RELEASE_API_URL, {
+      headers: { accept: "application/vnd.github+json", "user-agent": `Vessel/${currentVersion}` }
     });
     if (!response.ok) {
-      throw new Error(`Registry responded with ${response.status}`);
+      throw new Error(`GitHub Releases responded with ${response.status}`);
     }
     const body = await response.json();
-    const latestVersion = typeof body.version === "string" ? body.version : null;
-    if (!latestVersion) throw new Error("Registry response did not include a version");
+    const latestVersion = typeof body.tag_name === "string" ? body.tag_name : null;
+    if (!latestVersion) throw new Error("GitHub release response did not include a tag name");
+    const releaseUrl = typeof body.html_url === "string" && body.html_url.startsWith("https://github.com/") ? body.html_url : RELEASES_URL;
     return {
       currentVersion,
       latestVersion,
       updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
       checkedAt,
-      releaseUrl: RELEASES_URL
+      releaseUrl
     };
   } catch (error) {
     return {
@@ -26220,7 +26442,7 @@ async function checkForUpdates() {
   }
 }
 async function openUpdateDownload() {
-  await electron.shell.openExternal(RELEASES_URL);
+  await openExternalAllowlisted(RELEASES_URL, { hosts: ["github.com"] });
 }
 let activeChatProvider = null;
 const logger$4 = createLogger("IPC");
@@ -26255,10 +26477,18 @@ async function togglePictureInPicture(tabManager) {
 }
 function registerIpcHandlers(windowState, runtime2) {
   const { tabManager, chromeView, sidebarView, devtoolsPanelView, mainWindow } = windowState;
-  electron.ipcMain.handle(Channels.OPEN_PRIVATE_WINDOW, () => {
+  registerTrustedIpcSender(chromeView.webContents);
+  registerTrustedIpcSender(sidebarView.webContents);
+  registerTrustedIpcSender(devtoolsPanelView.webContents);
+  const requireTrusted = (event) => {
+    assertTrustedIpcSender(event);
+  };
+  electron.ipcMain.handle(Channels.OPEN_PRIVATE_WINDOW, (event) => {
+    requireTrusted(event);
     createPrivateWindow();
   });
-  electron.ipcMain.handle(Channels.OPEN_NEW_WINDOW, () => {
+  electron.ipcMain.handle(Channels.OPEN_NEW_WINDOW, (event) => {
+    requireTrusted(event);
     createSecondaryWindow();
   });
   electron.ipcMain.handle(Channels.IS_PRIVATE_MODE, () => false);
@@ -26530,14 +26760,15 @@ function registerIpcHandlers(windowState, runtime2) {
       const originalUrl = activeTab.readerOriginalUrl;
       activeTab.setReaderMode(false);
       if (originalUrl) {
-        activeTab.view.webContents.loadURL(originalUrl);
+        void loadPermittedNavigationURL(activeTab.view.webContents, originalUrl);
       }
     } else {
       const originalUrl = activeTab.state.url;
       const content = await extractContent(activeTab.view.webContents);
       const html = generateReaderHTML(content);
       activeTab.setReaderMode(true, originalUrl);
-      activeTab.view.webContents.loadURL(
+      void loadInternalDataURL(
+        activeTab.view.webContents,
         `data:text/html;charset=utf-8,${encodeURIComponent(html)}`
       );
     }
@@ -26619,7 +26850,12 @@ function registerIpcHandlers(windowState, runtime2) {
     return getRendererSettings();
   });
   electron.ipcMain.handle(Channels.SETTINGS_HEALTH_GET, () => getRuntimeHealth());
-  electron.ipcMain.handle(Channels.SETTINGS_SET, async (_, key2, value) => {
+  electron.ipcMain.handle(Channels.MCP_REGENERATE_TOKEN, (event) => {
+    requireTrusted(event);
+    return regenerateMcpAuthToken();
+  });
+  electron.ipcMain.handle(Channels.SETTINGS_SET, async (event, key2, value) => {
+    requireTrusted(event);
     assertString(key2, "key");
     if (!SETTABLE_KEYS.has(key2)) {
       throw new Error(`Unknown setting key: ${key2}`);
@@ -26639,11 +26875,18 @@ function registerIpcHandlers(windowState, runtime2) {
     return rendererSettings;
   });
   electron.ipcMain.handle(Channels.AGENT_RUNTIME_GET, () => runtime2.getState());
-  electron.ipcMain.handle(Channels.AGENT_PAUSE, () => runtime2.pause());
-  electron.ipcMain.handle(Channels.AGENT_RESUME, () => runtime2.resume());
+  electron.ipcMain.handle(Channels.AGENT_PAUSE, (event) => {
+    requireTrusted(event);
+    return runtime2.pause();
+  });
+  electron.ipcMain.handle(Channels.AGENT_RESUME, (event) => {
+    requireTrusted(event);
+    return runtime2.resume();
+  });
   electron.ipcMain.handle(
     Channels.AGENT_SET_APPROVAL_MODE,
-    (_, mode) => {
+    (event, mode) => {
+      requireTrusted(event);
       assertString(mode, "mode");
       if (!VALID_APPROVAL_MODES.includes(mode)) {
         throw new Error(`Invalid approval mode: ${mode}`);
@@ -26655,7 +26898,10 @@ function registerIpcHandlers(windowState, runtime2) {
   );
   electron.ipcMain.handle(
     Channels.AGENT_APPROVAL_RESOLVE,
-    (_, approvalId, approved) => runtime2.resolveApproval(approvalId, approved)
+    (event, approvalId, approved) => {
+      requireTrusted(event);
+      return runtime2.resolveApproval(approvalId, approved);
+    }
   );
   electron.ipcMain.handle(
     Channels.AGENT_CHECKPOINT_CREATE,
@@ -26679,7 +26925,10 @@ function registerIpcHandlers(windowState, runtime2) {
   );
   electron.ipcMain.handle(
     Channels.AGENT_SESSION_RESTORE,
-    (_, snapshot) => runtime2.restoreSession(snapshot)
+    (event, snapshot2) => {
+      requireTrusted(event);
+      return runtime2.restoreSession(snapshot2);
+    }
   );
   registerBookmarkHandlers();
   electron.ipcMain.handle(Channels.HIGHLIGHT_CAPTURE, async () => {
@@ -26799,17 +27048,20 @@ function registerIpcHandlers(windowState, runtime2) {
   electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, () => {
     return getInstalledKits();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async () => {
+  electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
+    requireTrusted(event);
     return await installKitFromFile();
   });
-  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (_event, id) => {
+  electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     return uninstallKit(id, getScheduledKitIds());
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
   registerAutofillHandlers(windowState);
   registerPageDiffHandlers(windowState, sendToRendererViews);
-  electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (_, options) => {
+  electron.ipcMain.handle(Channels.CLEAR_BROWSING_DATA, async (event, options) => {
+    requireTrusted(event);
     const { cache, cookies, history, localStorage: clearLs, timeRange } = options;
     if (cache) {
       await electron.session.defaultSession.clearCache();
@@ -26827,23 +27079,35 @@ function registerIpcHandlers(windowState, runtime2) {
   setDownloadBroadcaster(sendToRendererViews);
   setPermissionBroadcaster(sendToRendererViews);
   electron.ipcMain.handle(Channels.DOWNLOADS_GET, () => listDownloads());
-  electron.ipcMain.handle(Channels.DOWNLOADS_CLEAR, () => {
+  electron.ipcMain.handle(Channels.DOWNLOADS_CLEAR, (event) => {
+    requireTrusted(event);
     clearDownloads();
     return true;
   });
-  electron.ipcMain.handle(Channels.DOWNLOADS_OPEN, (_event, id) => openDownload(id));
-  electron.ipcMain.handle(Channels.DOWNLOADS_SHOW_IN_FOLDER, (_event, id) => showDownloadInFolder(id));
+  electron.ipcMain.handle(Channels.DOWNLOADS_OPEN, (event, id) => {
+    requireTrusted(event);
+    return openDownload(id);
+  });
+  electron.ipcMain.handle(Channels.DOWNLOADS_SHOW_IN_FOLDER, (event, id) => {
+    requireTrusted(event);
+    return showDownloadInFolder(id);
+  });
   electron.ipcMain.handle(Channels.PERMISSIONS_GET, () => listPermissions());
-  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR, () => {
+  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR, (event) => {
+    requireTrusted(event);
     clearPermissions();
     return true;
   });
-  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR_ORIGIN, (_event, origin) => {
+  electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR_ORIGIN, (event, origin) => {
+    requireTrusted(event);
     clearPermissionsForOrigin(origin);
     return true;
   });
   electron.ipcMain.handle(Channels.UPDATES_CHECK, () => checkForUpdates());
-  electron.ipcMain.handle(Channels.UPDATES_OPEN_DOWNLOAD, () => openUpdateDownload());
+  electron.ipcMain.handle(Channels.UPDATES_OPEN_DOWNLOAD, (event) => {
+    requireTrusted(event);
+    return openUpdateDownload();
+  });
   electron.ipcMain.handle(Channels.TAB_TOGGLE_PIP, async () => {
     return togglePictureInPicture(tabManager);
   });
@@ -27276,6 +27540,7 @@ class AgentRuntime {
     this.state = this.loadPersistedState();
     onMcpStatusChange(() => this.emit());
   }
+  tabManager;
   state;
   updateListener = null;
   pendingResolvers = /* @__PURE__ */ new Map();
@@ -27287,11 +27552,11 @@ class AgentRuntime {
     }
   }
   getState() {
-    const snapshot = clone(this.state);
-    snapshot.mcpStatus = getMcpStatus();
-    snapshot.canUndo = this.canUndo();
-    snapshot.undoInfo = this.getUndoInfo();
-    return snapshot;
+    const snapshot2 = clone(this.state);
+    snapshot2.mcpStatus = getMcpStatus();
+    snapshot2.canUndo = this.canUndo();
+    snapshot2.undoInfo = this.getUndoInfo();
+    return snapshot2;
   }
   onTabStateChanged() {
     this.captureSession();
@@ -27327,13 +27592,13 @@ class AgentRuntime {
     return this.getState();
   }
   createCheckpoint(name, note) {
-    const snapshot = this.captureSession(note);
+    const snapshot2 = this.captureSession(note);
     const checkpoint = {
       id: crypto$2.randomUUID(),
       name: name?.trim() || `Checkpoint ${this.state.checkpoints.length + 1}`,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       note: note?.trim() || void 0,
-      snapshot
+      snapshot: snapshot2
     };
     this.state.checkpoints = [...this.state.checkpoints, checkpoint].slice(
       -20
@@ -27367,26 +27632,26 @@ class AgentRuntime {
     return { actionName: latest.actionName, capturedAt: latest.capturedAt };
   }
   undoLastAction() {
-    const snapshot = this.undoSnapshots.at(-1);
-    if (!snapshot) return null;
+    const snapshot2 = this.undoSnapshots.at(-1);
+    if (!snapshot2) return null;
     try {
-      this.tabManager.restoreSession(snapshot.snapshot);
+      this.tabManager.restoreSession(snapshot2.snapshot);
       this.undoSnapshots.pop();
     } catch (error) {
       logger$3.error("Failed to restore undo snapshot", error);
       return null;
     }
-    this.captureSession(`Undid ${snapshot.actionName}`);
-    return snapshot.actionName;
+    this.captureSession(`Undid ${snapshot2.actionName}`);
+    return snapshot2.actionName;
   }
   captureSession(note) {
-    const snapshot = this.tabManager.snapshotSession(note);
-    this.state.session = snapshot;
+    const snapshot2 = this.tabManager.snapshotSession(note);
+    this.state.session = snapshot2;
     this.emit();
-    return clone(snapshot);
+    return clone(snapshot2);
   }
-  restoreSession(snapshot) {
-    const target = snapshot || this.state.session;
+  restoreSession(snapshot2) {
+    const target = snapshot2 || this.state.session;
     if (!target) {
       return this.captureSession("No saved session to restore");
     }
@@ -27528,6 +27793,7 @@ ${progress}
     args = {},
     tabId = null,
     dangerous = false,
+    requiresApproval = false,
     undoable,
     executor
   }) {
@@ -27547,7 +27813,7 @@ ${progress}
       streamId: transcriptStreamId,
       mode: "replace"
     });
-    const approvalReason = this.getApprovalReason(dangerous);
+    const approvalReason = this.getApprovalReason(dangerous, requiresApproval);
     if (approvalReason) {
       this.publishTranscript({
         source,
@@ -27625,8 +27891,8 @@ ${progress}
       capturedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  pushUndoSnapshot(snapshot) {
-    this.undoSnapshots = [...this.undoSnapshots, snapshot].slice(
+  pushUndoSnapshot(snapshot2) {
+    this.undoSnapshots = [...this.undoSnapshots, snapshot2].slice(
       -10
     );
   }
@@ -27770,10 +28036,13 @@ ${progress}
       )
     };
   }
-  getApprovalReason(dangerous) {
+  getApprovalReason(dangerous, requiresApproval) {
     if (this.state.supervisor.paused) {
       return "Agent execution is paused";
     }
+    if (requiresApproval) {
+      return "Approval required: high-risk action";
+    }
     if (this.state.supervisor.approvalMode === "manual") {
       return "Approval required: ask every time mode";
     }