@quanta-intellect/vessel-browser 0.1.94 → 0.1.95

package/out/main/index.js

@@ -276,9 +276,10 @@ function persistNow() {
   return fs.promises.mkdir(path.dirname(getSettingsPath()), { recursive: true }).then(
     () => fs.promises.writeFile(
       getSettingsPath(),
-      JSON.stringify(buildPersistedSettings(settings), null, 2)
+      JSON.stringify(buildPersistedSettings(settings), null, 2),
+      { encoding: "utf-8", mode: 384 }
     )
-  ).catch((err) => logger$n.error("Failed to save settings:", err));
+  ).then(() => fs.promises.chmod(getSettingsPath(), 384).catch(() => void 0)).catch((err) => logger$n.error("Failed to save settings:", err));
 }
 function saveSettings() {
   saveDirty = true;
@@ -1133,7 +1134,7 @@ function createDebouncedJsonPersistence({
         data,
         typeof data === "string" ? { encoding: "utf-8", mode: 384 } : { mode: 384 }
       )
-    ).catch((err) => logger$l.error(`Failed to save ${logLabel}:`, err));
+    ).then(() => fs.promises.chmod(filePath2, 384).catch(() => void 0)).catch((err) => logger$l.error(`Failed to save ${logLabel}:`, err));
   };
   const schedule = () => {
     saveDirty2 = true;
@@ -4760,6 +4761,21 @@ 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;
+const SENSITIVE_STRING_VALUE_RE = /https?:\/\/|www\.|[^\s@]+@[^\s@]+\.[^\s@]+|bearer\s+\S+|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.|(?:sk|pk|rk|gh[pousr]|xox[baprs])-[-_A-Za-z0-9]{12,}/i;
+const EMPTY_PROPERTY_ALLOWLIST = /* @__PURE__ */ new Set();
+const TELEMETRY_PROPERTY_ALLOWLIST = {
+  app_launched: /* @__PURE__ */ new Set(["electron_version", "chrome_version"]),
+  app_session_ended: /* @__PURE__ */ new Set(["duration_minutes"]),
+  tool_called: /* @__PURE__ */ new Set(["tool_name", "page_type"]),
+  provider_configured: /* @__PURE__ */ new Set(["provider_id"]),
+  page_type_detected: /* @__PURE__ */ new Set(["page_type"]),
+  setting_changed: /* @__PURE__ */ new Set(["setting_key"]),
+  approval_mode_changed: /* @__PURE__ */ new Set(["mode"]),
+  bookmark_action: /* @__PURE__ */ new Set(["action"]),
+  vault_action: /* @__PURE__ */ new Set(["action"]),
+  extraction_failed: /* @__PURE__ */ new Set(["reason"]),
+  premium_funnel: /* @__PURE__ */ new Set(["step", "status", "reason"])
+};
 function getDeviceIdPath() {
   return path.join(electron.app.getPath("userData"), ".vessel-device-id");
 }
@@ -4775,7 +4791,8 @@ function getDeviceId() {
   deviceId = crypto$1.randomUUID();
   try {
     fs.mkdirSync(path.dirname(idPath), { recursive: true });
-    fs.writeFileSync(idPath, deviceId, "utf-8");
+    fs.writeFileSync(idPath, deviceId, { encoding: "utf-8", mode: 384 });
+    fs.chmodSync(idPath, 384);
   } catch {
   }
   return deviceId;
@@ -4788,11 +4805,15 @@ function isEnabled() {
   if (process.env.VESSEL_DEV === "1") return false;
   return loadSettings().telemetryEnabled !== false;
 }
-function sanitizeTelemetryProperties(properties) {
+function sanitizeTelemetryProperties(properties, allowedKeys) {
   const safe = {};
   for (const [key2, value] of Object.entries(properties)) {
-    if (SENSITIVE_PROPERTY_RE.test(key2)) continue;
+    if (allowedKeys && !allowedKeys.has(key2)) continue;
+    if (!allowedKeys?.has(key2) && SENSITIVE_PROPERTY_RE.test(key2)) continue;
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+      if (typeof value === "string" && SENSITIVE_STRING_VALUE_RE.test(value)) {
+        continue;
+      }
       safe[key2] = typeof value === "string" ? value.slice(0, 120) : value;
     }
   }
@@ -4800,10 +4821,11 @@ function sanitizeTelemetryProperties(properties) {
 }
 function trackEvent(event, properties = {}) {
   if (!isEnabled()) return;
+  const allowedKeys = TELEMETRY_PROPERTY_ALLOWLIST[event] ?? EMPTY_PROPERTY_ALLOWLIST;
   eventQueue.push({
     event,
     properties: {
-      ...sanitizeTelemetryProperties(properties),
+      ...sanitizeTelemetryProperties(properties, allowedKeys),
       premium_status: isPremium() ? "premium" : "free",
       app_version: electron.app.getVersion(),
       platform: process.platform,
@@ -6986,7 +7008,7 @@ function isClickReadLoop(names) {
   return clickReadPairs >= 2;
 }
 const ANTHROPIC_MAX_TOKENS = 4096;
-function isRecord(value) {
+function isRecord$1(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function anthropicModelLikelySupportsThinking(model) {
@@ -7110,7 +7132,7 @@ class AnthropicProvider {
             } else if (event.type === "content_block_stop" && currentToolUse) {
               try {
                 const input = JSON.parse(currentToolUse.inputJson || "{}");
-                if (!isRecord(input)) {
+                if (!isRecord$1(input)) {
                   throw new Error("Tool input must be a JSON object");
                 }
                 toolUseBlocks.push({
@@ -8523,6 +8545,9 @@ async function openExternalAllowlisted(url, rule) {
   if (!schemes.includes(parsed.protocol)) {
     throw new Error(`Blocked external URL scheme: ${parsed.protocol}`);
   }
+  if (parsed.username || parsed.password) {
+    throw new Error("Blocked external URL with embedded credentials");
+  }
   if (rule.hosts && !rule.hosts.includes(parsed.hostname)) {
     throw new Error(`Blocked external URL host: ${parsed.hostname}`);
   }
@@ -8593,54 +8618,6 @@ function parseTokenExpiry(accessToken) {
   }
   return Date.now() + 36e5;
 }
-async function exchangeIdTokenForApiKey(idToken) {
-  const body = new URLSearchParams({
-    grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
-    client_id: CLIENT_ID,
-    requested_token: "openai-api-key",
-    subject_token: idToken,
-    subject_token_type: "urn:ietf:params:oauth:token-type:id_token"
-  });
-  const response = await fetch(`${ISSUER}/oauth/token`, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: body.toString()
-  });
-  if (!response.ok) {
-    let errorMsg = `OpenAI API token exchange failed: ${response.status}`;
-    try {
-      const err = await response.json();
-      if (typeof err.error_description === "string") {
-        errorMsg = err.error_description;
-      } else if (typeof err.error === "string") {
-        errorMsg = err.error;
-      }
-    } catch {
-    }
-    throw new Error(errorMsg);
-  }
-  const data = await response.json();
-  if (!data.access_token) {
-    throw new Error("OpenAI API token exchange did not return an access token");
-  }
-  return data.access_token;
-}
-async function ensureCodexApiKey(tokens) {
-  if (tokens.apiKey) return tokens;
-  if (!tokens.idToken) return tokens;
-  try {
-    return {
-      ...tokens,
-      apiKey: await exchangeIdTokenForApiKey(tokens.idToken)
-    };
-  } catch (err) {
-    logger$g.warn(
-      "Codex API-key token exchange failed; continuing with ChatGPT OAuth tokens:",
-      err
-    );
-    return tokens;
-  }
-}
 async function exchangeCodeForTokens(code, redirectUri, codeVerifier) {
   const body = new URLSearchParams({
     grant_type: "authorization_code",
@@ -8678,7 +8655,7 @@ async function exchangeCodeForTokens(code, redirectUri, codeVerifier) {
     accountId: claims?.accountId || "",
     accountEmail: claims?.email
   };
-  return ensureCodexApiKey(tokens);
+  return tokens;
 }
 async function refreshAccessToken(tokens) {
   const body = new URLSearchParams({
@@ -8714,7 +8691,7 @@ async function refreshAccessToken(tokens) {
     accountId: claims?.accountId || tokens.accountId || "",
     accountEmail: claims?.email || tokens.accountEmail
   };
-  return ensureCodexApiKey(refreshedTokens);
+  return refreshedTokens;
 }
 function startServer(port, pkce, expectedState, resolve, reject) {
   const server = http.createServer(async (req, res) => {
@@ -8885,12 +8862,57 @@ const logger$f = createLogger("CodexProvider");
 const REFRESH_WINDOW_MS = 5 * 60 * 1e3;
 const CODEX_BACKEND_BASE_URL = "https://chatgpt.com/backend-api/codex";
 const CODEX_CLIENT_VERSION = "0.129.0";
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function createCodexFunctionCallOutput(functionCall, availableToolNames, onChunk, onToolCall) {
+  const callId = functionCall.call_id || functionCall.id || "";
+  const name = functionCall.name || "";
+  if (!callId) {
+    return {
+      type: "function_call_output",
+      call_id: callId,
+      output: "Error: Function call was missing a call_id. Please retry the tool call."
+    };
+  }
+  if (!name || !availableToolNames.has(name)) {
+    onChunk(`
+<<tool:${name || "unknown"}:⚠ unsupported>>
+`);
+    return {
+      type: "function_call_output",
+      call_id: callId,
+      output: `Error: Unsupported tool${name ? `: ${name}` : ""}. Use one of the provided tools.`
+    };
+  }
+  let args;
+  try {
+    const parsed = JSON.parse(functionCall.arguments || "{}");
+    if (!isRecord(parsed)) throw new Error("Tool arguments must be a JSON object");
+    args = parsed;
+  } catch {
+    onChunk(`
+<<tool:${name}:⚠ invalid args>>
+`);
+    return {
+      type: "function_call_output",
+      call_id: callId,
+      output: "Error: Invalid JSON in tool arguments. Please retry with a valid JSON object."
+    };
+  }
+  const output = await onToolCall(name, args);
+  return {
+    type: "function_call_output",
+    call_id: callId,
+    output
+  };
+}
 class CodexProvider {
   agentToolProfile;
   tokens;
   model;
   abortController = null;
-  constructor(tokens, model, _baseUrl) {
+  constructor(tokens, model) {
     this.tokens = tokens;
     this.model = model;
     this.agentToolProfile = "default";
@@ -8909,7 +8931,7 @@ class CodexProvider {
       );
     }
   }
-  backendHeaders() {
+  backendHeaders(turnState) {
     const headers = {
       Authorization: `Bearer ${this.tokens.accessToken}`,
       "Content-Type": "application/json",
@@ -8920,6 +8942,9 @@ class CodexProvider {
     if (this.tokens.accountId) {
       headers["ChatGPT-Account-ID"] = this.tokens.accountId;
     }
+    if (turnState) {
+      headers["x-codex-turn-state"] = turnState;
+    }
     return headers;
   }
   buildInput(userMessage, history) {
@@ -8928,7 +8953,7 @@ class CodexProvider {
       input.push({
         type: "message",
         role: msg.role,
-        content: [{ type: "input_text", text: msg.content }]
+        content: [{ type: msg.role === "assistant" ? "output_text" : "input_text", text: msg.content }]
       });
     }
     input.push({
@@ -8938,7 +8963,7 @@ class CodexProvider {
     });
     return input;
   }
-  handleStreamEvent(raw, onChunk, emittedTextFromDelta) {
+  handleStreamEvent(raw, onChunk, acc) {
     if (!raw.trim() || raw.trim() === "[DONE]") return;
     let event;
     try {
@@ -8947,13 +8972,28 @@ class CodexProvider {
       return;
     }
     if (event.type === "response.output_text.delta" && event.delta) {
-      emittedTextFromDelta.value = true;
+      acc.emittedTextFromDelta = true;
+      acc.text += event.delta;
       onChunk(event.delta);
       return;
     }
-    if (event.type === "response.output_item.done" && !emittedTextFromDelta.value) {
-      const text = event.item?.content?.filter((item) => item.type === "output_text" && item.text).map((item) => item.text).join("");
-      if (text) onChunk(text);
+    if (event.type === "response.function_call_arguments.delta" && event.delta) {
+      const key2 = event.call_id || event.item_id || "";
+      if (key2) {
+        acc.functionCallArgs.set(key2, (acc.functionCallArgs.get(key2) || "") + event.delta);
+      }
+      return;
+    }
+    if (event.type === "response.output_item.done" && event.item) {
+      const item = event.item;
+      if (item.type === "function_call") {
+        const key2 = item.call_id || item.id || "";
+        const args = acc.functionCallArgs.get(key2) || item.arguments || "";
+        acc.functionCallArgs.delete(key2);
+        acc.items.push({ ...item, arguments: args });
+      } else if (item.type === "message") {
+        acc.items.push(item);
+      }
       return;
     }
     if (event.type === "response.failed") {
@@ -8962,18 +9002,12 @@ class CodexProvider {
       throw new Error(message);
     }
   }
-  async streamCodexResponse(systemPrompt, userMessage, onChunk, history) {
+  async streamCodexResponse(requestBody, onChunk, turnState) {
     const response = await fetch(`${CODEX_BACKEND_BASE_URL}/responses`, {
       method: "POST",
-      headers: this.backendHeaders(),
+      headers: this.backendHeaders(turnState),
       signal: this.abortController?.signal,
-      body: JSON.stringify({
-        model: this.model,
-        instructions: systemPrompt,
-        input: this.buildInput(userMessage, history),
-        stream: true,
-        store: false
-      })
+      body: JSON.stringify(requestBody)
     });
     if (!response.ok) {
       const text = await response.text().catch(() => "");
@@ -8984,33 +9018,53 @@ class CodexProvider {
     if (!response.body) {
       throw new Error("Codex backend returned an empty response stream");
     }
+    const newTurnState = response.headers.get("x-codex-turn-state") || null;
     const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const emittedTextFromDelta = { value: false };
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      let separatorIndex;
-      while ((separatorIndex = buffer.indexOf("\n\n")) !== -1) {
-        const block = buffer.slice(0, separatorIndex);
-        buffer = buffer.slice(separatorIndex + 2);
-        const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
-        this.handleStreamEvent(data, onChunk, emittedTextFromDelta);
-      }
-    }
-    const trailing = buffer.trim();
-    if (trailing) {
-      const data = trailing.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
-      this.handleStreamEvent(data, onChunk, emittedTextFromDelta);
+    try {
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const acc = {
+        text: "",
+        items: [],
+        emittedTextFromDelta: false,
+        functionCallArgs: /* @__PURE__ */ new Map()
+      };
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let separatorIndex;
+        while ((separatorIndex = buffer.indexOf("\n\n")) !== -1) {
+          const block = buffer.slice(0, separatorIndex);
+          buffer = buffer.slice(separatorIndex + 2);
+          const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+          this.handleStreamEvent(data, onChunk, acc);
+        }
+      }
+      const trailing = buffer.trim();
+      if (trailing) {
+        const data = trailing.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+        this.handleStreamEvent(data, onChunk, acc);
+      }
+      return { text: acc.text, items: acc.items, turnState: newTurnState };
+    } finally {
+      reader.releaseLock();
     }
   }
   async streamQuery(systemPrompt, userMessage, onChunk, onEnd, history) {
     await this.ensureFreshTokens();
     this.abortController = new AbortController();
     try {
-      await this.streamCodexResponse(systemPrompt, userMessage, onChunk, history);
+      await this.streamCodexResponse(
+        {
+          model: this.model,
+          instructions: systemPrompt,
+          input: this.buildInput(userMessage, history),
+          stream: true,
+          store: false
+        },
+        onChunk
+      );
     } catch (err) {
       if (err.name !== "AbortError") {
         const msg = err instanceof Error ? err.message : String(err);
@@ -9024,11 +9078,59 @@ class CodexProvider {
       onEnd();
     }
   }
-  async streamAgentQuery(systemPrompt, userMessage, _tools, onChunk, _onToolCall, onEnd, history) {
+  async streamAgentQuery(systemPrompt, userMessage, tools, onChunk, onToolCall, onEnd, history) {
     await this.ensureFreshTokens();
     this.abortController = new AbortController();
+    const maxIterations = getEffectiveMaxIterations();
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
+    let iterationsUsed = 0;
+    const convertedTools = tools.map((tool) => ({
+      type: "function",
+      name: tool.name,
+      description: tool.description || "",
+      parameters: tool.input_schema
+    }));
+    let currentInput = this.buildInput(userMessage, history);
+    let turnState = null;
     try {
-      await this.streamCodexResponse(systemPrompt, userMessage, onChunk, history);
+      for (let i = 0; i < maxIterations; i++) {
+        iterationsUsed = i + 1;
+        const result = await this.streamCodexResponse(
+          {
+            model: this.model,
+            instructions: systemPrompt,
+            input: currentInput,
+            tools: convertedTools,
+            stream: true,
+            store: false
+          },
+          onChunk,
+          turnState || void 0
+        );
+        turnState = result.turnState || turnState;
+        const functionCalls = result.items.filter(
+          (item) => item.type === "function_call"
+        );
+        if (functionCalls.length === 0) {
+          break;
+        }
+        currentInput = [];
+        for (const fc of functionCalls) {
+          currentInput.push(
+            await createCodexFunctionCallOutput(
+              fc,
+              availableToolNames,
+              onChunk,
+              onToolCall
+            )
+          );
+        }
+      }
+      if (iterationsUsed >= maxIterations) {
+        onChunk(`
+
+[Reached maximum tool call limit (${maxIterations} steps). You can adjust this in Settings → Max Tool Iterations, or continue by sending another message.]`);
+      }
     } catch (err) {
       if (err.name !== "AbortError") {
         const msg = err instanceof Error ? err.message : String(err);
@@ -9112,11 +9214,11 @@ function buildLlamaCppCtxWarning(ctxSize) {
 }
 async function fetchCodexBackendModels(tokens) {
   const url = new URL("https://chatgpt.com/backend-api/codex/models");
-  url.searchParams.set("client_version", "0.129.0");
+  url.searchParams.set("client_version", CODEX_CLIENT_VERSION);
   const headers = {
     Authorization: `Bearer ${tokens.accessToken}`,
     originator: "codex_cli_rs",
-    "User-Agent": "codex_cli_rs/0.129.0 Vessel"
+    "User-Agent": `codex_cli_rs/${CODEX_CLIENT_VERSION} Vessel`
   };
   if (tokens.accountId) {
     headers["ChatGPT-Account-ID"] = tokens.accountId;
@@ -9219,7 +9321,7 @@ function createProvider(config) {
         "OpenAI Codex requires authentication. Open settings to connect your ChatGPT account."
       );
     }
-    return new CodexProvider(tokens, normalized.model, normalized.baseUrl);
+    return new CodexProvider(tokens, normalized.model);
   }
   return new OpenAICompatProvider(normalized);
 }
@@ -19524,6 +19626,16 @@ const logger$b = createLogger("VaultShared");
 const ALGORITHM = "aes-256-gcm";
 const IV_LENGTH = 12;
 const AUTH_TAG_LENGTH = 16;
+const KEY_STORAGE_PREFIX = "base64:";
+function encodeEncryptionKeyForStorage(key2) {
+  return `${KEY_STORAGE_PREFIX}${key2.toString("base64")}`;
+}
+function decodeEncryptionKeyFromStorage(value) {
+  if (value.startsWith(KEY_STORAGE_PREFIX)) {
+    return Buffer.from(value.slice(KEY_STORAGE_PREFIX.length), "base64");
+  }
+  return Buffer.from(value, "utf-8");
+}
 function assertSecretStorageAvailable(customMessage) {
   if (!electron.safeStorage.isEncryptionAvailable()) {
     throw new Error(
@@ -19536,11 +19648,17 @@ function getOrCreateEncryptionKey(keyFilename) {
   const keyPath = path$1.join(electron.app.getPath("userData"), keyFilename);
   if (fs$1.existsSync(keyPath)) {
     const encryptedKey = fs$1.readFileSync(keyPath);
-    return Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8");
+    const key22 = decodeEncryptionKeyFromStorage(
+      electron.safeStorage.decryptString(encryptedKey)
+    );
+    if (key22.length !== 32) {
+      throw new Error("Stored vault encryption key has an invalid length.");
+    }
+    return key22;
   }
   const key2 = crypto$2.randomBytes(32);
   fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
-  const encrypted = electron.safeStorage.encryptString(key2.toString("utf-8"));
+  const encrypted = electron.safeStorage.encryptString(encodeEncryptionKeyForStorage(key2));
   fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
   fs$1.chmodSync(keyPath, 384);
   return key2;
@@ -19607,7 +19725,7 @@ function createVaultIO(vaultFilename, encrypt2, decrypt2) {
     const encrypted = encrypt2(json);
     const vaultPath = getVaultPath();
     fs$1.mkdirSync(path$1.dirname(vaultPath), { recursive: true });
-    fs$1.writeFileSync(vaultPath, encrypted);
+    fs$1.writeFileSync(vaultPath, encrypted, { mode: 384 });
     fs$1.chmodSync(vaultPath, 384);
     cachedEntries = entries;
   }
@@ -19663,12 +19781,20 @@ function createAuditLog(filename, maxEntries) {
     try {
       const auditPath = getAuditPath2();
       fs$1.mkdirSync(path$1.dirname(auditPath), { recursive: true });
-      fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n");
+      fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n", {
+        encoding: "utf-8",
+        mode: 384
+      });
+      fs$1.chmodSync(auditPath, 384);
       try {
         const lines = fs$1.readFileSync(auditPath, "utf-8").split("\n").filter((l) => l.trim());
         if (lines.length > maxEntries) {
           const trimmed = lines.slice(-maxEntries);
-          fs$1.writeFileSync(auditPath, trimmed.join("\n") + "\n");
+          fs$1.writeFileSync(auditPath, trimmed.join("\n") + "\n", {
+            encoding: "utf-8",
+            mode: 384
+          });
+          fs$1.chmodSync(auditPath, 384);
         }
       } catch {
       }
@@ -19795,7 +19921,11 @@ function appendAuditEntry(entry) {
   try {
     const auditPath = getAuditPath();
     fs$1.mkdirSync(path$1.dirname(auditPath), { recursive: true });
-    fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n");
+    fs$1.appendFileSync(auditPath, JSON.stringify(entry) + "\n", {
+      encoding: "utf-8",
+      mode: 384
+    });
+    fs$1.chmodSync(auditPath, 384);
   } catch (err) {
     logger$a.error("Failed to write audit log:", err);
   }
@@ -20075,7 +20205,7 @@ function isDangerousMcpAction(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;
+  if (name === "remove_bookmark_folder" && args.delete_contents === true) return true;
   return false;
 }
 function getActiveTabSummary(tabManager) {
@@ -23909,6 +24039,43 @@ function uninstallKit(id, scheduledKitIds) {
     return errorResult("Failed to remove the kit file.");
   }
 }
+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 isManagedTabIpcSender(event, tabManager) {
+  return Boolean(tabManager.findTabByWebContentsId(event.sender.id));
+}
+function assertString(value, name) {
+  if (typeof value !== "string") throw new Error(`${name} must be a string`);
+}
+function assertOptionalString(value, name) {
+  if (value !== void 0 && typeof value !== "string") {
+    throw new Error(`${name} must be a string`);
+  }
+}
+function assertNumber(value, name) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new Error(`${name} must be a number`);
+  }
+}
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function isValidEmail(value) {
+  return EMAIL_RE.test(value.trim());
+}
+function getActiveTabInfo(tabManager) {
+  const tab = tabManager.getActiveTab();
+  if (!tab) return null;
+  const wc = tab.view.webContents;
+  if (wc.isDestroyed()) return null;
+  return { tab, wc };
+}
 const logger$7 = createLogger("Scheduler");
 let jobs = [];
 let removeIdleListener = null;
@@ -23932,7 +24099,13 @@ function loadJobs() {
 }
 function saveJobs() {
   try {
-    fs$1.writeFileSync(getJobsPath(), JSON.stringify(jobs, null, 2), "utf-8");
+    const jobsPath = getJobsPath();
+    fs$1.mkdirSync(path$1.dirname(jobsPath), { recursive: true });
+    fs$1.writeFileSync(jobsPath, JSON.stringify(jobs, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    fs$1.chmodSync(jobsPath, 384);
   } catch (err) {
     logger$7.warn("Failed to save jobs:", err);
   }
@@ -24136,8 +24309,12 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     tick(windowState, runtime2);
     setInterval(() => tick(windowState, runtime2), 6e4);
   }, msToNextMinute);
-  electron.ipcMain.handle(Channels.SCHEDULE_GET_ALL, () => jobs);
-  electron.ipcMain.handle(Channels.SCHEDULE_CREATE, (_, rawJob) => {
+  electron.ipcMain.handle(Channels.SCHEDULE_GET_ALL, (event) => {
+    assertTrustedIpcSender(event);
+    return jobs;
+  });
+  electron.ipcMain.handle(Channels.SCHEDULE_CREATE, (event, rawJob) => {
+    assertTrustedIpcSender(event);
     if (!isValidJobData(rawJob)) {
       throw new Error(
         "Invalid job data. Required: kitId, kitName, kitIcon, renderedPrompt, schedule, enabled."
@@ -24154,7 +24331,8 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     sendToAll(Channels.SCHEDULE_JOBS_UPDATE, jobs);
     return newJob;
   });
-  electron.ipcMain.handle(Channels.SCHEDULE_UPDATE, (_, id, updates) => {
+  electron.ipcMain.handle(Channels.SCHEDULE_UPDATE, (event, id, updates) => {
+    assertTrustedIpcSender(event);
     if (typeof id !== "string") throw new Error("id must be a string");
     const job = jobs.find((j) => j.id === id);
     if (!job) return null;
@@ -24180,7 +24358,8 @@ function registerScheduleHandlers(windowState, runtime2, sendToAll) {
     sendToAll(Channels.SCHEDULE_JOBS_UPDATE, jobs);
     return job;
   });
-  electron.ipcMain.handle(Channels.SCHEDULE_DELETE, (_, id) => {
+  electron.ipcMain.handle(Channels.SCHEDULE_DELETE, (event, id) => {
+    assertTrustedIpcSender(event);
     if (typeof id !== "string") throw new Error("id must be a string");
     const before = jobs.length;
     jobs = jobs.filter((j) => j.id !== id);
@@ -24190,40 +24369,6 @@ 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`);
-}
-function assertOptionalString(value, name) {
-  if (value !== void 0 && typeof value !== "string") {
-    throw new Error(`${name} must be a string`);
-  }
-}
-function assertNumber(value, name) {
-  if (typeof value !== "number" || Number.isNaN(value)) {
-    throw new Error(`${name} must be a number`);
-  }
-}
-const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-function isValidEmail(value) {
-  return EMAIL_RE.test(value.trim());
-}
-function getActiveTabInfo(tabManager) {
-  const tab = tabManager.getActiveTab();
-  if (!tab) return null;
-  const wc = tab.view.webContents;
-  if (wc.isDestroyed()) return null;
-  return { tab, wc };
-}
 const SAVE_DEBOUNCE_MS = 250;
 const PROFILE_FIELDS = [
   "label",
@@ -24563,24 +24708,29 @@ function sanitizeAutofillUpdates(value) {
   return updates;
 }
 function registerAutofillHandlers(windowState) {
-  electron.ipcMain.handle(Channels.AUTOFILL_LIST, () => {
+  electron.ipcMain.handle(Channels.AUTOFILL_LIST, (event) => {
+    assertTrustedIpcSender(event);
     return listProfiles();
   });
   electron.ipcMain.handle(
     Channels.AUTOFILL_ADD,
-    (_, profile) => {
+    (event, profile) => {
+      assertTrustedIpcSender(event);
       return addProfile(sanitizeAutofillProfile(profile));
     }
   );
-  electron.ipcMain.handle(Channels.AUTOFILL_UPDATE, (_, id, updates) => {
+  electron.ipcMain.handle(Channels.AUTOFILL_UPDATE, (event, id, updates) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return updateProfile(id, sanitizeAutofillUpdates(updates));
   });
-  electron.ipcMain.handle(Channels.AUTOFILL_DELETE, (_, id) => {
+  electron.ipcMain.handle(Channels.AUTOFILL_DELETE, (event, id) => {
+    assertTrustedIpcSender(event);
     assertString(id, "id");
     return deleteProfile(id);
   });
-  electron.ipcMain.handle(Channels.AUTOFILL_FILL, async (_, profileId) => {
+  electron.ipcMain.handle(Channels.AUTOFILL_FILL, async (event, profileId) => {
+    assertTrustedIpcSender(event);
     assertString(profileId, "profileId");
     const profile = getProfile(profileId);
     if (!profile) throw new Error("Profile not found");
@@ -24650,12 +24800,14 @@ function registerPageDiffHandlers(windowState, sendToRendererViews) {
   electron.ipcMain.on(Channels.PAGE_DIFF_ACTIVITY, (event) => {
     const wc = event.sender;
     if (!wc || wc.isDestroyed()) return;
+    if (!isManagedTabIpcSender(event, windowState.tabManager)) 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 (!isManagedTabIpcSender(event, windowState.tabManager)) return;
     if (!allowPageEvent(wc.id)) return;
     schedulePageSnapshotCapture(wc, sendToRendererViews);
   });
@@ -25802,19 +25954,22 @@ function getSafeBookmarkExportName(name) {
   return safeName || "folder";
 }
 function registerBookmarkHandlers() {
-  electron.ipcMain.handle(Channels.BOOKMARKS_GET, () => {
+  electron.ipcMain.handle(Channels.BOOKMARKS_GET, (event) => {
+    assertTrustedIpcSender(event);
     return getState();
   });
   electron.ipcMain.handle(
     Channels.FOLDER_CREATE,
-    (_, name, summary) => {
+    (event, name, summary) => {
+      assertTrustedIpcSender(event);
       trackBookmarkAction("folder_create");
       return createFolderWithSummary(name, summary);
     }
   );
   electron.ipcMain.handle(
     Channels.BOOKMARK_SAVE,
-    (_, url, title, folderId, note, intent, expectedContent, keyFields, agentHints) => {
+    (event, url, title, folderId, note, intent, expectedContent, keyFields, agentHints) => {
+      assertTrustedIpcSender(event);
       trackBookmarkAction("save");
       const result = saveBookmarkWithPolicy(url, title, folderId, note, {
         onDuplicate: "update",
@@ -25835,12 +25990,14 @@ function registerBookmarkHandlers() {
   );
   electron.ipcMain.handle(
     Channels.BOOKMARK_UPDATE,
-    (_, id, updates) => {
+    (event, id, updates) => {
+      assertTrustedIpcSender(event);
       trackBookmarkAction("save");
       return updateBookmark(id, updates);
     }
   );
-  electron.ipcMain.handle(Channels.BOOKMARK_REMOVE, (_, id) => {
+  electron.ipcMain.handle(Channels.BOOKMARK_REMOVE, (event, id) => {
+    assertTrustedIpcSender(event);
     trackBookmarkAction("remove");
     return removeBookmark(id);
   });
@@ -25933,22 +26090,26 @@ function registerBookmarkHandlers() {
     trackBookmarkAction("import");
     return importBookmarksFromJson(content);
   });
-  electron.ipcMain.handle(Channels.FOLDER_REMOVE, (_, id, deleteContents) => {
+  electron.ipcMain.handle(Channels.FOLDER_REMOVE, (event, id, deleteContents) => {
+    assertTrustedIpcSender(event);
     trackBookmarkAction("folder_remove");
     return removeFolder(id, deleteContents ?? false);
   });
   electron.ipcMain.handle(
     Channels.FOLDER_RENAME,
-    (_, id, newName, summary) => {
+    (event, id, newName, summary) => {
+      assertTrustedIpcSender(event);
       return renameFolder(id, newName, summary);
     }
   );
 }
 function registerHistoryHandlers() {
-  electron.ipcMain.handle(Channels.HISTORY_GET, () => {
+  electron.ipcMain.handle(Channels.HISTORY_GET, (event) => {
+    assertTrustedIpcSender(event);
     return getState$1();
   });
-  electron.ipcMain.handle(Channels.HISTORY_SEARCH, (_, query) => {
+  electron.ipcMain.handle(Channels.HISTORY_SEARCH, (event, query) => {
+    assertTrustedIpcSender(event);
     return search(query);
   });
   electron.ipcMain.handle(Channels.HISTORY_CLEAR, (event) => {
@@ -26073,10 +26234,12 @@ function registerPremiumHandlers(tabManager, sendToRendererViews) {
       void handleUrl(currentUrl);
     }
   };
-  electron.ipcMain.handle(Channels.PREMIUM_GET_STATE, () => {
+  electron.ipcMain.handle(Channels.PREMIUM_GET_STATE, (event) => {
+    assertTrustedIpcSender(event);
     return getPremiumState();
   });
-  electron.ipcMain.handle(Channels.PREMIUM_ACTIVATION_START, async (_, email) => {
+  electron.ipcMain.handle(Channels.PREMIUM_ACTIVATION_START, async (event, email) => {
+    assertTrustedIpcSender(event);
     assertString(email, "email");
     if (!isValidEmail(email)) {
       return errorResult("Invalid email format");
@@ -26090,7 +26253,8 @@ function registerPremiumHandlers(tabManager, sendToRendererViews) {
   });
   electron.ipcMain.handle(
     Channels.PREMIUM_ACTIVATION_VERIFY,
-    async (_, email, code, challengeToken) => {
+    async (event, email, code, challengeToken) => {
+      assertTrustedIpcSender(event);
       assertString(email, "email");
       assertString(code, "code");
       assertString(challengeToken, "challengeToken");
@@ -26112,7 +26276,8 @@ function registerPremiumHandlers(tabManager, sendToRendererViews) {
       return result;
     }
   );
-  electron.ipcMain.handle(Channels.PREMIUM_CHECKOUT, async (_, email) => {
+  electron.ipcMain.handle(Channels.PREMIUM_CHECKOUT, async (event, email) => {
+    assertTrustedIpcSender(event);
     trackPremiumFunnel("checkout_clicked");
     const result = await getCheckoutUrl(email);
     if (result.ok && result.url) {
@@ -26121,19 +26286,22 @@ function registerPremiumHandlers(tabManager, sendToRendererViews) {
     }
     return result;
   });
-  electron.ipcMain.handle(Channels.PREMIUM_RESET, () => {
+  electron.ipcMain.handle(Channels.PREMIUM_RESET, (event) => {
+    assertTrustedIpcSender(event);
     trackPremiumFunnel("reset");
     const state2 = resetPremium();
     sendToRendererViews(Channels.PREMIUM_UPDATE, state2);
     return state2;
   });
-  electron.ipcMain.handle(Channels.PREMIUM_TRACK_CONTEXT, (_, step) => {
+  electron.ipcMain.handle(Channels.PREMIUM_TRACK_CONTEXT, (event, step) => {
+    assertTrustedIpcSender(event);
     assertString(step, "step");
     if (PREMIUM_TRACKABLE_STEPS.includes(step)) {
       trackPremiumFunnel(step);
     }
   });
-  electron.ipcMain.handle(Channels.PREMIUM_PORTAL, async () => {
+  electron.ipcMain.handle(Channels.PREMIUM_PORTAL, async (event) => {
+    assertTrustedIpcSender(event);
     trackPremiumFunnel("portal_opened");
     const result = await getPortalUrl();
     if (result.ok && result.url) {
@@ -26143,18 +26311,22 @@ function registerPremiumHandlers(tabManager, sendToRendererViews) {
   });
 }
 function registerSessionHandlers(tabManager) {
-  electron.ipcMain.handle(Channels.SESSION_LIST, () => {
+  electron.ipcMain.handle(Channels.SESSION_LIST, (event) => {
+    assertTrustedIpcSender(event);
     return listNamedSessions();
   });
-  electron.ipcMain.handle(Channels.SESSION_SAVE, async (_, name) => {
+  electron.ipcMain.handle(Channels.SESSION_SAVE, async (event, name) => {
+    assertTrustedIpcSender(event);
     assertString(name, "name");
     return await saveNamedSession(tabManager, name);
   });
-  electron.ipcMain.handle(Channels.SESSION_LOAD, async (_, name) => {
+  electron.ipcMain.handle(Channels.SESSION_LOAD, async (event, name) => {
+    assertTrustedIpcSender(event);
     assertString(name, "name");
     return await loadNamedSession(tabManager, name);
   });
-  electron.ipcMain.handle(Channels.SESSION_DELETE, (_, name) => {
+  electron.ipcMain.handle(Channels.SESSION_DELETE, (event, name) => {
+    assertTrustedIpcSender(event);
     assertString(name, "name");
     return deleteNamedSession(name);
   });
@@ -26312,6 +26484,10 @@ function snapshot() {
 function emit() {
   broadcaster?.(Channels.PERMISSIONS_GET, snapshot());
 }
+function getDecision(origin, permission) {
+  const existing = records.find((r) => r.origin === origin && r.permission === permission);
+  return existing?.decision ?? sessionDecisions.get(key(origin, permission)) ?? null;
+}
 function save(origin, permission, decision) {
   const k = key(origin, permission);
   const existing = records.find((r) => key(r.origin, r.permission) === k);
@@ -26344,6 +26520,12 @@ function setPermissionBroadcaster(fn) {
   broadcaster = fn;
 }
 function installPermissionHandler() {
+  electron.session.defaultSession.setPermissionCheckHandler((webContents, permission, requestingOrigin) => {
+    if (!ALLOWED_PERMISSION_TYPES.has(permission)) return false;
+    const origin = parseOrigin(requestingOrigin || webContents.getURL());
+    if (!origin) return false;
+    return getDecision(origin, permission) === "allow";
+  });
   electron.session.defaultSession.setPermissionRequestHandler((webContents, permission, callback, details) => {
     if (!ALLOWED_PERMISSION_TYPES.has(permission)) {
       callback(false);
@@ -26355,19 +26537,21 @@ function installPermissionHandler() {
       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");
+    const decision = getDecision(origin, permission);
+    if (decision) {
+      callback(decision === "allow");
       return;
     }
     const result = electron.dialog.showMessageBoxSync({
       type: "question",
-      buttons: ["Deny", "Allow Once", "Allow Until Quit", "Always Allow"],
+      buttons: [
+        "Deny Once",
+        "Deny Until Quit",
+        "Always Deny",
+        "Allow Once",
+        "Allow Until Quit",
+        "Always Allow"
+      ],
       defaultId: 0,
       cancelId: 0,
       title: "Site permission request",
@@ -26375,20 +26559,29 @@ function installPermissionHandler() {
       detail: "Temporary choices are safer for camera, microphone, location, and clipboard access. Persistent choices can be cleared in Settings > Privacy."
     });
     if (result === 1) {
-      callback(true);
+      sessionDecisions.set(k, "deny");
+      callback(false);
       return;
     }
     if (result === 2) {
+      save(origin, permission, "deny");
+      callback(false);
+      return;
+    }
+    if (result === 3) {
+      callback(true);
+      return;
+    }
+    if (result === 4) {
       sessionDecisions.set(k, "allow");
       callback(true);
       return;
     }
-    if (result === 3) {
+    if (result === 5) {
       save(origin, permission, "allow");
       callback(true);
       return;
     }
-    save(origin, permission, "deny");
     callback(false);
   });
 }
@@ -26491,7 +26684,10 @@ function registerIpcHandlers(windowState, runtime2) {
     requireTrusted(event);
     createSecondaryWindow();
   });
-  electron.ipcMain.handle(Channels.IS_PRIVATE_MODE, () => false);
+  electron.ipcMain.handle(Channels.IS_PRIVATE_MODE, (event) => {
+    requireTrusted(event);
+    return false;
+  });
   let sidebarResizeRecoveryTimer = null;
   let sidebarResizeActive = false;
   let runtimeUpdateTimer = null;
@@ -26572,37 +26768,45 @@ function registerIpcHandlers(windowState, runtime2) {
   onAIStreamIdle(() => {
     sendToRendererViews(Channels.AI_STREAM_IDLE);
   });
-  electron.ipcMain.handle(Channels.TAB_CREATE, (_, url) => {
+  electron.ipcMain.handle(Channels.TAB_CREATE, (event, url) => {
+    requireTrusted(event);
     const id = tabManager.createTab(url || loadSettings().defaultUrl);
     layoutViews(windowState);
     return id;
   });
-  electron.ipcMain.handle(Channels.TAB_CLOSE, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_CLOSE, (event, id) => {
+    requireTrusted(event);
     tabManager.closeTab(id);
     layoutViews(windowState);
   });
-  electron.ipcMain.handle(Channels.TAB_SWITCH, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_SWITCH, (event, id) => {
+    requireTrusted(event);
     tabManager.switchTab(id);
     layoutViews(windowState);
   });
   electron.ipcMain.handle(
     Channels.TAB_NAVIGATE,
-    (_, id, url, postBody) => {
+    (event, id, url, postBody) => {
+      requireTrusted(event);
       assertString(id, "tabId");
       assertString(url, "url");
       return tabManager.navigateTab(id, url, postBody);
     }
   );
-  electron.ipcMain.handle(Channels.TAB_BACK, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_BACK, (event, id) => {
+    requireTrusted(event);
     tabManager.goBack(id);
   });
-  electron.ipcMain.handle(Channels.TAB_FORWARD, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_FORWARD, (event, id) => {
+    requireTrusted(event);
     tabManager.goForward(id);
   });
-  electron.ipcMain.handle(Channels.TAB_RELOAD, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_RELOAD, (event, id) => {
+    requireTrusted(event);
     tabManager.reloadTab(id);
   });
-  electron.ipcMain.handle(Channels.TAB_TOGGLE_AD_BLOCK, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_TOGGLE_AD_BLOCK, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     const tab = tabManager.getTab(id);
     if (!tab) return null;
@@ -26610,87 +26814,108 @@ function registerIpcHandlers(windowState, runtime2) {
     tab.setAdBlockingEnabled(newState);
     return newState;
   });
-  electron.ipcMain.handle(Channels.TAB_ZOOM_IN, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_ZOOM_IN, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.zoomIn(id);
   });
-  electron.ipcMain.handle(Channels.TAB_ZOOM_OUT, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_ZOOM_OUT, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.zoomOut(id);
   });
-  electron.ipcMain.handle(Channels.TAB_ZOOM_RESET, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_ZOOM_RESET, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.zoomReset(id);
   });
-  electron.ipcMain.handle(Channels.TAB_REOPEN_CLOSED, () => {
+  electron.ipcMain.handle(Channels.TAB_REOPEN_CLOSED, (event) => {
+    requireTrusted(event);
     const id = tabManager.reopenClosedTab();
     if (id) layoutViews(windowState);
     return id;
   });
-  electron.ipcMain.handle(Channels.TAB_DUPLICATE, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_DUPLICATE, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     const newId = tabManager.duplicateTab(id);
     if (newId) layoutViews(windowState);
     return newId;
   });
-  electron.ipcMain.handle(Channels.TAB_PIN, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_PIN, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.pinTab(id);
   });
-  electron.ipcMain.handle(Channels.TAB_UNPIN, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_UNPIN, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.unpinTab(id);
   });
-  electron.ipcMain.handle(Channels.TAB_GROUP_CREATE, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_GROUP_CREATE, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     return tabManager.createGroupFromTab(id);
   });
-  electron.ipcMain.handle(Channels.TAB_GROUP_ADD_TAB, (_, id, groupId) => {
+  electron.ipcMain.handle(Channels.TAB_GROUP_ADD_TAB, (event, id, groupId) => {
+    requireTrusted(event);
     assertString(id, "id");
     assertString(groupId, "groupId");
     tabManager.assignTabToGroup(id, groupId);
   });
-  electron.ipcMain.handle(Channels.TAB_GROUP_REMOVE_TAB, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_GROUP_REMOVE_TAB, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.removeTabFromGroup(id);
   });
-  electron.ipcMain.handle(Channels.TAB_GROUP_TOGGLE_COLLAPSED, (_, groupId) => {
+  electron.ipcMain.handle(Channels.TAB_GROUP_TOGGLE_COLLAPSED, (event, groupId) => {
+    requireTrusted(event);
     assertString(groupId, "groupId");
     return tabManager.toggleGroupCollapsed(groupId);
   });
   electron.ipcMain.handle(
     Channels.TAB_GROUP_SET_COLOR,
-    (_, groupId, color) => {
+    (event, groupId, color) => {
+      requireTrusted(event);
       assertString(groupId, "groupId");
       assertString(color, "color");
       tabManager.setGroupColor(groupId, color);
     }
   );
-  electron.ipcMain.handle(Channels.TAB_TOGGLE_MUTE, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_TOGGLE_MUTE, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     return tabManager.toggleMuted(id);
   });
-  electron.ipcMain.handle(Channels.TAB_PRINT, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_PRINT, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     tabManager.printTab(id);
   });
-  electron.ipcMain.handle(Channels.TAB_PRINT_TO_PDF, (_, id) => {
+  electron.ipcMain.handle(Channels.TAB_PRINT_TO_PDF, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     return tabManager.saveTabAsPdf(id);
   });
-  electron.ipcMain.on(Channels.TAB_CONTEXT_MENU, (_event, id) => {
+  electron.ipcMain.on(Channels.TAB_CONTEXT_MENU, (event, id) => {
+    requireTrusted(event);
     assertString(id, "id");
     showTabContextMenu(tabManager, id, mainWindow, () => layoutViews(windowState));
   });
-  electron.ipcMain.on(Channels.TAB_GROUP_CONTEXT_MENU, (_event, groupId) => {
+  electron.ipcMain.on(Channels.TAB_GROUP_CONTEXT_MENU, (event, groupId) => {
+    requireTrusted(event);
     assertString(groupId, "groupId");
     showGroupContextMenu(tabManager, groupId, mainWindow);
   });
-  electron.ipcMain.handle(Channels.TAB_STATE_GET, () => ({
-    tabs: tabManager.getAllStates(),
-    activeId: tabManager.getActiveTabId() || ""
-  }));
-  electron.ipcMain.handle(Channels.AI_QUERY, async (_, query, history) => {
+  electron.ipcMain.handle(Channels.TAB_STATE_GET, (event) => {
+    requireTrusted(event);
+    return {
+      tabs: tabManager.getAllStates(),
+      activeId: tabManager.getActiveTabId() || ""
+    };
+  });
+  electron.ipcMain.handle(Channels.AI_QUERY, async (event, query, history) => {
+    requireTrusted(event);
     const settings2 = loadSettings();
     const chatConfig = settings2.chatProvider;
     if (!chatConfig) {
@@ -26733,10 +26958,12 @@ function registerIpcHandlers(windowState, runtime2) {
     })();
     return { accepted: true };
   });
-  electron.ipcMain.handle(Channels.AI_CANCEL, () => {
+  electron.ipcMain.handle(Channels.AI_CANCEL, (event) => {
+    requireTrusted(event);
     activeChatProvider?.cancel();
   });
-  electron.ipcMain.handle(Channels.AI_FETCH_MODELS, async (_, config) => {
+  electron.ipcMain.handle(Channels.AI_FETCH_MODELS, async (event, config) => {
+    requireTrusted(event);
     try {
       if (!config || typeof config !== "object" || !("id" in config)) {
         return errorResult("Invalid provider configuration", { models: [] });
@@ -26748,12 +26975,14 @@ function registerIpcHandlers(windowState, runtime2) {
       return errorResult(getErrorMessage(err), { models: [] });
     }
   });
-  electron.ipcMain.handle(Channels.CONTENT_EXTRACT, async () => {
+  electron.ipcMain.handle(Channels.CONTENT_EXTRACT, async (event) => {
+    requireTrusted(event);
     const activeTab = tabManager.getActiveTab();
     if (!activeTab) return null;
     return extractContent(activeTab.view.webContents);
   });
-  electron.ipcMain.handle(Channels.READER_MODE_TOGGLE, async () => {
+  electron.ipcMain.handle(Channels.READER_MODE_TOGGLE, async (event) => {
+    requireTrusted(event);
     const activeTab = tabManager.getActiveTab();
     if (!activeTab) return;
     if (activeTab.state.isReaderMode) {
@@ -26773,7 +27002,8 @@ function registerIpcHandlers(windowState, runtime2) {
       );
     }
   });
-  electron.ipcMain.handle(Channels.SIDEBAR_TOGGLE, () => {
+  electron.ipcMain.handle(Channels.SIDEBAR_TOGGLE, (event) => {
+    requireTrusted(event);
     windowState.uiState.sidebarOpen = !windowState.uiState.sidebarOpen;
     layoutViews(windowState);
     return {
@@ -26781,7 +27011,8 @@ function registerIpcHandlers(windowState, runtime2) {
       width: windowState.uiState.sidebarWidth
     };
   });
-  electron.ipcMain.handle(Channels.SIDEBAR_NAVIGATE, (_, tab) => {
+  electron.ipcMain.handle(Channels.SIDEBAR_NAVIGATE, (event, tab) => {
+    requireTrusted(event);
     assertString(tab, "tab");
     if (!windowState.uiState.sidebarOpen) {
       windowState.uiState.sidebarOpen = true;
@@ -26795,7 +27026,8 @@ function registerIpcHandlers(windowState, runtime2) {
       width: windowState.uiState.sidebarWidth
     };
   });
-  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_START, () => {
+  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_START, (event) => {
+    requireTrusted(event);
     sidebarResizeActive = true;
     clearSidebarResizeRecoveryTimer();
     const [width, height] = windowState.mainWindow.getContentSize();
@@ -26810,14 +27042,16 @@ function registerIpcHandlers(windowState, runtime2) {
     });
     scheduleSidebarResizeRecovery();
   });
-  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE, (_, width) => {
+  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE, (event, width) => {
+    requireTrusted(event);
     assertNumber(width, "width");
     const clamped = Math.max(240, Math.min(800, Math.round(width)));
     windowState.uiState.sidebarWidth = clamped;
     resizeSidebarViews(windowState);
     return clamped;
   });
-  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_COMMIT, () => {
+  electron.ipcMain.handle(Channels.SIDEBAR_RESIZE_COMMIT, (event) => {
+    requireTrusted(event);
     sidebarResizeActive = false;
     clearSidebarResizeRecoveryTimer();
     setSetting("sidebarWidth", windowState.uiState.sidebarWidth);
@@ -26825,7 +27059,8 @@ function registerIpcHandlers(windowState, runtime2) {
   });
   electron.ipcMain.on(
     Channels.RENDERER_VIEW_READY,
-    (_event, view) => {
+    (event, view) => {
+      requireTrusted(event);
       if (view !== "sidebar") return;
       if (!windowState.uiState.sidebarOpen) {
         windowState.uiState.sidebarOpen = true;
@@ -26833,12 +27068,14 @@ function registerIpcHandlers(windowState, runtime2) {
       }
     }
   );
-  electron.ipcMain.handle(Channels.FOCUS_MODE_TOGGLE, () => {
+  electron.ipcMain.handle(Channels.FOCUS_MODE_TOGGLE, (event) => {
+    requireTrusted(event);
     windowState.uiState.focusMode = !windowState.uiState.focusMode;
     layoutViews(windowState);
     return windowState.uiState.focusMode;
   });
-  electron.ipcMain.handle(Channels.SETTINGS_VISIBILITY, (_, open) => {
+  electron.ipcMain.handle(Channels.SETTINGS_VISIBILITY, (event, open) => {
+    requireTrusted(event);
     windowState.uiState.settingsOpen = open;
     if (open) {
       windowState.uiState.sidebarOpen = false;
@@ -26846,10 +27083,14 @@ function registerIpcHandlers(windowState, runtime2) {
     layoutViews(windowState);
     return windowState.uiState.settingsOpen;
   });
-  electron.ipcMain.handle(Channels.SETTINGS_GET, () => {
+  electron.ipcMain.handle(Channels.SETTINGS_GET, (event) => {
+    requireTrusted(event);
     return getRendererSettings();
   });
-  electron.ipcMain.handle(Channels.SETTINGS_HEALTH_GET, () => getRuntimeHealth());
+  electron.ipcMain.handle(Channels.SETTINGS_HEALTH_GET, (event) => {
+    requireTrusted(event);
+    return getRuntimeHealth();
+  });
   electron.ipcMain.handle(Channels.MCP_REGENERATE_TOKEN, (event) => {
     requireTrusted(event);
     return regenerateMcpAuthToken();
@@ -26874,7 +27115,10 @@ function registerIpcHandlers(windowState, runtime2) {
     sendToRendererViews(Channels.SETTINGS_UPDATE, rendererSettings);
     return rendererSettings;
   });
-  electron.ipcMain.handle(Channels.AGENT_RUNTIME_GET, () => runtime2.getState());
+  electron.ipcMain.handle(Channels.AGENT_RUNTIME_GET, (event) => {
+    requireTrusted(event);
+    return runtime2.getState();
+  });
   electron.ipcMain.handle(Channels.AGENT_PAUSE, (event) => {
     requireTrusted(event);
     return runtime2.pause();
@@ -26905,24 +27149,27 @@ function registerIpcHandlers(windowState, runtime2) {
   );
   electron.ipcMain.handle(
     Channels.AGENT_CHECKPOINT_CREATE,
-    (_, name, note) => runtime2.createCheckpoint(name, note)
-  );
-  electron.ipcMain.handle(
-    Channels.AGENT_CHECKPOINT_RESTORE,
-    (_, checkpointId) => runtime2.restoreCheckpoint(checkpointId)
-  );
-  electron.ipcMain.handle(
-    Channels.AGENT_CHECKPOINT_UPDATE_NOTE,
-    (_, checkpointId, note) => runtime2.updateCheckpointNote(checkpointId, note || "")
-  );
-  electron.ipcMain.handle(
-    Channels.AGENT_UNDO_LAST_ACTION,
-    () => runtime2.undoLastAction()
-  );
-  electron.ipcMain.handle(
-    Channels.AGENT_SESSION_CAPTURE,
-    (_, note) => runtime2.captureSession(note)
+    (event, name, note) => {
+      requireTrusted(event);
+      return runtime2.createCheckpoint(name, note);
+    }
   );
+  electron.ipcMain.handle(Channels.AGENT_CHECKPOINT_RESTORE, (event, checkpointId) => {
+    requireTrusted(event);
+    return runtime2.restoreCheckpoint(checkpointId);
+  });
+  electron.ipcMain.handle(Channels.AGENT_CHECKPOINT_UPDATE_NOTE, (event, checkpointId, note) => {
+    requireTrusted(event);
+    return runtime2.updateCheckpointNote(checkpointId, note || "");
+  });
+  electron.ipcMain.handle(Channels.AGENT_UNDO_LAST_ACTION, (event) => {
+    requireTrusted(event);
+    return runtime2.undoLastAction();
+  });
+  electron.ipcMain.handle(Channels.AGENT_SESSION_CAPTURE, (event, note) => {
+    requireTrusted(event);
+    return runtime2.captureSession(note);
+  });
   electron.ipcMain.handle(
     Channels.AGENT_SESSION_RESTORE,
     (event, snapshot2) => {
@@ -26931,7 +27178,8 @@ function registerIpcHandlers(windowState, runtime2) {
     }
   );
   registerBookmarkHandlers();
-  electron.ipcMain.handle(Channels.HIGHLIGHT_CAPTURE, async () => {
+  electron.ipcMain.handle(Channels.HIGHLIGHT_CAPTURE, async (event) => {
+    requireTrusted(event);
     try {
       const activeTab = tabManager.getActiveTab();
       if (!activeTab) {
@@ -26975,10 +27223,12 @@ function registerIpcHandlers(windowState, runtime2) {
       logger$4.warn("Failed to persist auto-highlight selection:", err);
     }
   });
-  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_COUNT, () => {
+  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_COUNT, (event) => {
+    requireTrusted(event);
     return getActiveHighlightCountSafe();
   });
-  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_SCROLL, (_, index) => {
+  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_SCROLL, (event, index) => {
+    requireTrusted(event);
     const info = getActiveTabInfo(tabManager);
     if (!info) return false;
     try {
@@ -26988,7 +27238,8 @@ function registerIpcHandlers(windowState, runtime2) {
       return false;
     }
   });
-  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_REMOVE, async (_, index) => {
+  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_REMOVE, async (event, index) => {
+    requireTrusted(event);
     const info = getActiveTabInfo(tabManager);
     if (!info) return false;
     try {
@@ -27002,7 +27253,8 @@ function registerIpcHandlers(windowState, runtime2) {
       return false;
     }
   });
-  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_CLEAR, async () => {
+  electron.ipcMain.handle(Channels.HIGHLIGHT_NAV_CLEAR, async (event) => {
+    requireTrusted(event);
     const info = getActiveTabInfo(tabManager);
     if (!info) return false;
     try {
@@ -27017,22 +27269,27 @@ function registerIpcHandlers(windowState, runtime2) {
     }
   });
   const findBridge = createFindInPageBridge(tabManager, chromeView);
-  electron.ipcMain.handle(Channels.FIND_IN_PAGE_START, (_, text, options) => {
+  electron.ipcMain.handle(Channels.FIND_IN_PAGE_START, (event, text, options) => {
+    requireTrusted(event);
     return findBridge.start(text, options);
   });
-  electron.ipcMain.handle(Channels.FIND_IN_PAGE_NEXT, (_, forward) => {
+  electron.ipcMain.handle(Channels.FIND_IN_PAGE_NEXT, (event, forward) => {
+    requireTrusted(event);
     return findBridge.next(forward);
   });
-  electron.ipcMain.handle(Channels.FIND_IN_PAGE_STOP, (_, action) => {
+  electron.ipcMain.handle(Channels.FIND_IN_PAGE_STOP, (event, action) => {
+    requireTrusted(event);
     findBridge.stop(action);
   });
   registerHistoryHandlers();
-  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_TOGGLE, () => {
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_TOGGLE, (event) => {
+    requireTrusted(event);
     windowState.uiState.devtoolsPanelOpen = !windowState.uiState.devtoolsPanelOpen;
     layoutViews(windowState);
     return { open: windowState.uiState.devtoolsPanelOpen };
   });
-  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_RESIZE, (_, height) => {
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_RESIZE, (event, height) => {
+    requireTrusted(event);
     const clamped = Math.max(MIN_DEVTOOLS_PANEL, Math.min(MAX_DEVTOOLS_PANEL, Math.round(height)));
     windowState.uiState.devtoolsPanelHeight = clamped;
     layoutViews(windowState);
@@ -27045,7 +27302,8 @@ function registerIpcHandlers(windowState, runtime2) {
   registerHumanVaultHandlers();
   registerWindowControlHandlers(mainWindow);
   registerCodexHandlers();
-  electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, () => {
+  electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, (event) => {
+    requireTrusted(event);
     return getInstalledKits();
   });
   electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
@@ -27078,7 +27336,10 @@ function registerIpcHandlers(windowState, runtime2) {
   });
   setDownloadBroadcaster(sendToRendererViews);
   setPermissionBroadcaster(sendToRendererViews);
-  electron.ipcMain.handle(Channels.DOWNLOADS_GET, () => listDownloads());
+  electron.ipcMain.handle(Channels.DOWNLOADS_GET, (event) => {
+    requireTrusted(event);
+    return listDownloads();
+  });
   electron.ipcMain.handle(Channels.DOWNLOADS_CLEAR, (event) => {
     requireTrusted(event);
     clearDownloads();
@@ -27092,7 +27353,10 @@ function registerIpcHandlers(windowState, runtime2) {
     requireTrusted(event);
     return showDownloadInFolder(id);
   });
-  electron.ipcMain.handle(Channels.PERMISSIONS_GET, () => listPermissions());
+  electron.ipcMain.handle(Channels.PERMISSIONS_GET, (event) => {
+    requireTrusted(event);
+    return listPermissions();
+  });
   electron.ipcMain.handle(Channels.PERMISSIONS_CLEAR, (event) => {
     requireTrusted(event);
     clearPermissions();
@@ -27103,12 +27367,16 @@ function registerIpcHandlers(windowState, runtime2) {
     clearPermissionsForOrigin(origin);
     return true;
   });
-  electron.ipcMain.handle(Channels.UPDATES_CHECK, () => checkForUpdates());
+  electron.ipcMain.handle(Channels.UPDATES_CHECK, (event) => {
+    requireTrusted(event);
+    return checkForUpdates();
+  });
   electron.ipcMain.handle(Channels.UPDATES_OPEN_DOWNLOAD, (event) => {
     requireTrusted(event);
     return openUpdateDownload();
   });
-  electron.ipcMain.handle(Channels.TAB_TOGGLE_PIP, async () => {
+  electron.ipcMain.handle(Channels.TAB_TOGGLE_PIP, async (event) => {
+    requireTrusted(event);
     return togglePictureInPicture(tabManager);
   });
 }