@quanta-intellect/vessel-browser 0.1.45 → 0.1.46

package/out/main/index.js

@@ -32,12 +32,14 @@ const defaults = {
   premium: {
     status: "free",
     customerId: "",
+    verificationToken: "",
     email: "",
     validatedAt: "",
     expiresAt: ""
   }
 };
 const SAVE_DEBOUNCE_MS$3 = 150;
+const CHAT_PROVIDER_SECRET_FILENAME = "vessel-chat-provider-secret";
 const SETTABLE_KEYS = new Set(Object.keys(defaults));
 let settings = null;
 let settingsIssues = [];
@@ -52,6 +54,80 @@ function getUserDataPath() {
 function getSettingsPath() {
   return path.join(getUserDataPath(), "vessel-settings.json");
 }
+function getChatProviderSecretPath() {
+  return path.join(getUserDataPath(), CHAT_PROVIDER_SECRET_FILENAME);
+}
+function canUseSafeStorage() {
+  try {
+    return electron.safeStorage.isEncryptionAvailable();
+  } catch {
+    return false;
+  }
+}
+function readStoredProviderSecret() {
+  try {
+    const raw = fs.readFileSync(getChatProviderSecretPath());
+    const decoded = canUseSafeStorage() && electron.safeStorage.decryptString ? electron.safeStorage.decryptString(raw) : raw.toString("utf-8");
+    const parsed = JSON.parse(decoded);
+    if (parsed && typeof parsed === "object" && typeof parsed.providerId === "string" && typeof parsed.apiKey === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeStoredProviderSecret(secret) {
+  const filePath = getChatProviderSecretPath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const payload = JSON.stringify(secret);
+  if (canUseSafeStorage()) {
+    const encrypted = electron.safeStorage.encryptString(payload);
+    fs.writeFileSync(filePath, encrypted, { mode: 384 });
+    return;
+  }
+  fs.writeFileSync(filePath, payload, { mode: 384 });
+}
+function clearStoredProviderSecret() {
+  try {
+    fs.unlinkSync(getChatProviderSecretPath());
+  } catch {
+  }
+}
+function mergeChatProviderSecret(provider) {
+  if (!provider) return null;
+  const stored = readStoredProviderSecret();
+  const legacyApiKey = provider.apiKey?.trim() || "";
+  const apiKey = stored?.providerId === provider.id ? stored.apiKey : legacyApiKey;
+  if (legacyApiKey && stored?.providerId !== provider.id) {
+    writeStoredProviderSecret({ providerId: provider.id, apiKey: legacyApiKey });
+  }
+  return {
+    ...provider,
+    apiKey,
+    hasApiKey: Boolean(apiKey)
+  };
+}
+function buildPersistedSettings(source) {
+  return {
+    ...source,
+    chatProvider: source.chatProvider ? {
+      ...source.chatProvider,
+      apiKey: "",
+      hasApiKey: source.chatProvider.hasApiKey || Boolean(source.chatProvider.apiKey)
+    } : null
+  };
+}
+function getRendererSettings() {
+  const current = loadSettings();
+  return {
+    ...current,
+    chatProvider: current.chatProvider ? {
+      ...current.chatProvider,
+      apiKey: "",
+      hasApiKey: Boolean(current.chatProvider.apiKey)
+    } : null
+  };
+}
 function getSettingsLoadIssues() {
   return settingsIssues.map((issue) => ({ ...issue }));
 }
@@ -80,6 +156,7 @@ function loadSettings() {
     settings = {
       ...defaults,
       ...parsed,
+      chatProvider: mergeChatProviderSecret(parsed.chatProvider ?? null),
       mcpPort: sanitizePort(parsed.mcpPort ?? defaults.mcpPort),
       agentTranscriptMode: parsed.agentTranscriptMode === "off" || parsed.agentTranscriptMode === "summary" || parsed.agentTranscriptMode === "full" ? parsed.agentTranscriptMode : parsed.showAgentTranscript === false ? "off" : defaults.agentTranscriptMode
     };
@@ -104,7 +181,10 @@ function persistNow$3() {
     saveTimer$3 = null;
   }
   return fs.promises.mkdir(path.dirname(getSettingsPath()), { recursive: true }).then(
-    () => fs.promises.writeFile(getSettingsPath(), JSON.stringify(settings, null, 2))
+    () => fs.promises.writeFile(
+      getSettingsPath(),
+      JSON.stringify(buildPersistedSettings(settings), null, 2)
+    )
   ).catch((err) => console.error("[Vessel] Failed to save settings:", err));
 }
 function saveSettings() {
@@ -121,6 +201,30 @@ function setSetting(key, value) {
   loadSettings();
   if (key === "mcpPort") {
     settings.mcpPort = sanitizePort(value);
+  } else if (key === "chatProvider") {
+    const nextProvider = value;
+    if (!nextProvider) {
+      clearStoredProviderSecret();
+      settings.chatProvider = null;
+    } else {
+      const existingSecret = readStoredProviderSecret();
+      const incomingApiKey = nextProvider.apiKey.trim();
+      const preserveExisting = !incomingApiKey && nextProvider.hasApiKey === true && existingSecret?.providerId === nextProvider.id;
+      const resolvedApiKey = preserveExisting ? existingSecret?.apiKey || "" : incomingApiKey;
+      if (resolvedApiKey) {
+        writeStoredProviderSecret({
+          providerId: nextProvider.id,
+          apiKey: resolvedApiKey
+        });
+      } else {
+        clearStoredProviderSecret();
+      }
+      settings.chatProvider = {
+        ...nextProvider,
+        apiKey: resolvedApiKey,
+        hasApiKey: Boolean(resolvedApiKey)
+      };
+    }
   } else {
     settings[key] = value;
   }
@@ -160,7 +264,31 @@ function checkDomainPolicy(url) {
 function matchesDomain(hostname, policyDomain) {
   return hostname === policyDomain || hostname.endsWith("." + policyDomain);
 }
+const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
+function isSafeNavigationURL(url) {
+  try {
+    const parsed = new URL(url);
+    return ALLOWED_SCHEMES.has(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function assertSafeURL(url) {
+  if (!isSafeNavigationURL(url)) {
+    throw new Error(
+      `Blocked navigation to disallowed URL scheme: ${url.slice(0, 80)}`
+    );
+  }
+}
+function assertPermittedNavigationURL(url) {
+  assertSafeURL(url);
+  const policyError = checkDomainPolicy(url);
+  if (policyError) {
+    throw new Error(policyError);
+  }
+}
 const MAX_CUSTOM_HISTORY = 50;
+const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 class Tab {
   id;
   view;
@@ -181,6 +309,32 @@ class Tab {
   urlForwardStack = [];
   lastCommittedUrl = "";
   navigatingViaHistory = false;
+  isReaderModeDataUrl(url) {
+    return this._state.isReaderMode && url.startsWith(READER_MODE_DATA_URL_PREFIX);
+  }
+  getNavigationBlockReason(url) {
+    if (!url) {
+      return "Blocked navigation to empty URL";
+    }
+    if (url.startsWith("about:") || this.isReaderModeDataUrl(url)) {
+      return null;
+    }
+    try {
+      assertSafeURL(url);
+    } catch (error) {
+      return error instanceof Error ? error.message : "Blocked unsafe navigation";
+    }
+    return checkDomainPolicy(url);
+  }
+  guardedLoadURL(url, options) {
+    const blockReason = this.getNavigationBlockReason(url);
+    if (blockReason) {
+      console.warn(`[Tab] ${blockReason}`);
+      return blockReason;
+    }
+    void this.view.webContents.loadURL(url, options);
+    return null;
+  }
   constructor(id, url, onChange, options) {
     this.id = id;
     this.parentWindow = options?.parentWindow;
@@ -198,10 +352,11 @@ class Tab {
         nodeIntegration: false
       }
     });
+    const initialUrl = url || "about:blank";
     this._state = {
       id,
       title: "New Tab",
-      url: url || "about:blank",
+      url: initialUrl,
       favicon: "",
       isLoading: false,
       canGoBack: false,
@@ -222,13 +377,22 @@ class Tab {
     });
     this.setupListeners();
     if (url) {
-      this.lastCommittedUrl = url;
-      this.view.webContents.loadURL(url);
+      const error = this.guardedLoadURL(url);
+      if (error) {
+        this._state.url = "about:blank";
+      } else {
+        this.lastCommittedUrl = url;
+      }
     }
   }
   setupListeners() {
     const wc = this.view.webContents;
     wc.setWindowOpenHandler(({ url, disposition }) => {
+      const error = this.getNavigationBlockReason(url);
+      if (error) {
+        console.warn(`[Tab] ${error}`);
+        return { action: "deny" };
+      }
       this.onOpenUrl?.({
         url,
         background: disposition === "background-tab",
@@ -236,6 +400,18 @@ class Tab {
       });
       return { action: "deny" };
     });
+    const blockNavigation = (event, url, context) => {
+      const error = this.getNavigationBlockReason(url);
+      if (!error) return;
+      event.preventDefault();
+      console.warn(`[Tab] ${context}: ${error}`);
+    };
+    wc.on("will-navigate", (event, url) => {
+      blockNavigation(event, url, "Blocked top-level navigation");
+    });
+    wc.on("will-redirect", (event, url) => {
+      blockNavigation(event, url, "Blocked redirect");
+    });
     const syncNavigationState = () => {
       this._state.title = wc.getTitle() || this._state.title || "New Tab";
       this._state.url = wc.getURL() || this._state.url;
@@ -402,17 +578,12 @@ class Tab {
         url = `https://duckduckgo.com/?q=${encodeURIComponent(url)}`;
       }
     }
-    if (!/^https?:\/\//i.test(url) && !url.startsWith("about:")) {
-      return `Blocked navigation to disallowed URL scheme: ${url.slice(0, 80)}`;
-    }
-    const policyError = checkDomainPolicy(url);
-    if (policyError) return policyError;
     if (postBody) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(postBody)) {
         params.set(key, value);
       }
-      this.view.webContents.loadURL(url, {
+      return this.guardedLoadURL(url, {
         method: "POST",
         extraHeaders: "Content-Type: application/x-www-form-urlencoded\r\n",
         postData: [
@@ -422,27 +593,39 @@ class Tab {
           }
         ]
       });
-    } else {
-      this.view.webContents.loadURL(url);
     }
-    return null;
+    return this.guardedLoadURL(url);
   }
   goBack() {
     const previousUrl = this.urlHistory.pop();
     if (!previousUrl) return false;
+    const currentUrl = this.lastCommittedUrl;
     this.navigatingViaHistory = true;
-    this.urlForwardStack.push(this.lastCommittedUrl);
+    this.urlForwardStack.push(currentUrl);
+    const error = this.guardedLoadURL(previousUrl);
+    if (error) {
+      this.navigatingViaHistory = false;
+      this.urlForwardStack.pop();
+      this.urlHistory.push(previousUrl);
+      return false;
+    }
     this.lastCommittedUrl = previousUrl;
-    this.view.webContents.loadURL(previousUrl);
     return true;
   }
   goForward() {
     const nextUrl = this.urlForwardStack.pop();
     if (!nextUrl) return false;
+    const currentUrl = this.lastCommittedUrl;
     this.navigatingViaHistory = true;
-    this.urlHistory.push(this.lastCommittedUrl);
+    this.urlHistory.push(currentUrl);
+    const error = this.guardedLoadURL(nextUrl);
+    if (error) {
+      this.navigatingViaHistory = false;
+      this.urlHistory.pop();
+      this.urlForwardStack.push(nextUrl);
+      return false;
+    }
     this.lastCommittedUrl = nextUrl;
-    this.view.webContents.loadURL(nextUrl);
     return true;
   }
   canGoBack() {
@@ -2446,7 +2629,8 @@ const Channels = {
   DOWNLOAD_DONE: "download:done",
   // Premium
   PREMIUM_GET_STATE: "premium:get-state",
-  PREMIUM_ACTIVATE: "premium:activate",
+  PREMIUM_ACTIVATION_START: "premium:activation-start",
+  PREMIUM_ACTIVATION_VERIFY: "premium:activation-verify",
   PREMIUM_CHECKOUT: "premium:checkout",
   PREMIUM_PORTAL: "premium:portal",
   PREMIUM_RESET: "premium:reset",
@@ -3382,6 +3566,7 @@ function resetPremium() {
   const fresh = {
     status: "free",
     customerId: "",
+    verificationToken: "",
     email: "",
     validatedAt: "",
     expiresAt: ""
@@ -3414,39 +3599,22 @@ async function getCheckoutUrl(email) {
   }
 }
 async function getPortalUrl() {
-  const { premium } = loadSettings();
-  if (!premium.customerId) {
-    return { ok: false, error: "No active subscription" };
-  }
-  try {
-    const res = await fetch(`${VERIFICATION_API}/portal`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ customerId: premium.customerId })
-    });
-    if (!res.ok) {
-      return { ok: false, error: `HTTP ${res.status}` };
-    }
-    const { url } = await res.json();
-    return { ok: true, url };
-  } catch (err) {
-    return {
-      ok: false,
-      error: err instanceof Error ? err.message : "Failed to get portal URL"
-    };
-  }
+  return {
+    ok: false,
+    error: "Billing portal access is temporarily disabled while we harden the premium API. Use the Stripe billing link from your subscription email for now."
+  };
 }
-async function verifySubscription(emailOrCustomerId) {
+async function verifySubscription(identifier) {
   const current = loadSettings().premium;
-  const identifier = emailOrCustomerId || current.customerId || current.email;
-  if (!identifier) {
+  const verificationIdentifier = identifier || current.verificationToken || current.customerId;
+  if (!verificationIdentifier) {
     return current;
   }
   try {
     const res = await fetch(`${VERIFICATION_API}/verify`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ identifier })
+      body: JSON.stringify({ identifier: verificationIdentifier })
     });
     if (!res.ok) {
       console.warn("[Vessel Premium] Verification API returned", res.status);
@@ -3455,8 +3623,9 @@ async function verifySubscription(emailOrCustomerId) {
     const data = await res.json();
     const updated = {
       status: data.status,
-      customerId: data.customerId,
-      email: data.email,
+      customerId: data.customerId || current.customerId,
+      verificationToken: data.verificationToken || verificationIdentifier,
+      email: data.email || current.email,
       validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       expiresAt: data.expiresAt
     };
@@ -3467,34 +3636,104 @@ async function verifySubscription(emailOrCustomerId) {
     return current;
   }
 }
-async function activateWithEmail(email) {
-  if (!email.trim()) {
+async function requestActivationCode(email) {
+  const normalizedEmail = email.trim().toLowerCase();
+  if (!normalizedEmail) {
+    return { ok: false, error: "Email is required" };
+  }
+  try {
+    const res = await fetch(`${VERIFICATION_API}/activate/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ email: normalizedEmail })
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok || !data.challengeToken) {
+      return {
+        ok: false,
+        error: data.error || `HTTP ${res.status}`
+      };
+    }
+    return {
+      ok: true,
+      email: normalizedEmail,
+      challengeToken: data.challengeToken
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : "Failed to send code"
+    };
+  }
+}
+async function verifyActivationCode(email, code, challengeToken) {
+  const normalizedEmail = email.trim().toLowerCase();
+  const trimmedCode = code.trim();
+  if (!normalizedEmail) {
     return { ok: false, state: getPremiumState(), error: "Email is required" };
   }
-  const state2 = await verifySubscription(email.trim());
-  if (state2.status === "active" || state2.status === "trialing") {
-    return { ok: true, state: state2 };
+  if (!trimmedCode) {
+    return { ok: false, state: getPremiumState(), error: "Code is required" };
+  }
+  if (!challengeToken.trim()) {
+    return {
+      ok: false,
+      state: getPremiumState(),
+      error: "Request a new activation code and try again."
+    };
+  }
+  try {
+    const res = await fetch(`${VERIFICATION_API}/activate/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        email: normalizedEmail,
+        code: trimmedCode,
+        challengeToken: challengeToken.trim()
+      })
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      return {
+        ok: false,
+        state: getPremiumState(),
+        error: data.error || `HTTP ${res.status}`
+      };
+    }
+    const updated = {
+      status: data.status ?? "free",
+      customerId: data.customerId || "",
+      verificationToken: data.verificationToken || "",
+      email: data.email || normalizedEmail,
+      validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: data.expiresAt || ""
+    };
+    setSetting("premium", updated);
+    return { ok: isPremiumActiveState(updated), state: updated };
+  } catch (err) {
+    return {
+      ok: false,
+      state: getPremiumState(),
+      error: err instanceof Error ? err.message : "Failed to verify code"
+    };
   }
-  return {
-    ok: false,
-    state: state2,
-    error: state2.status === "canceled" ? "Subscription is canceled. Resubscribe to continue." : state2.status === "past_due" ? "Subscription payment is past due. Update your payment method." : "No active subscription found for this email."
-  };
 }
 let revalidationTimer = null;
 function startBackgroundRevalidation() {
   if (revalidationTimer) return;
   const { premium } = loadSettings();
-  if (premium.customerId || premium.email) {
+  const identifier = premium.verificationToken || premium.customerId;
+  if (identifier) {
     const lastValidated = premium.validatedAt ? new Date(premium.validatedAt).getTime() : 0;
     if (Date.now() - lastValidated > REVALIDATION_INTERVAL_MS) {
-      void verifySubscription();
+      void verifySubscription(identifier);
     }
   }
   revalidationTimer = setInterval(() => {
     const { premium: p } = loadSettings();
-    if (p.customerId || p.email) {
-      void verifySubscription();
+    const currentIdentifier = p.verificationToken || p.customerId;
+    if (currentIdentifier) {
+      void verifySubscription(currentIdentifier);
     }
   }, REVALIDATION_INTERVAL_MS);
 }
@@ -4185,6 +4424,20 @@ const DIRECT_EXTRACTION_SCRIPT = String.raw`
       return meta;
     }
 
+    function shouldExposeFieldValue(el) {
+      if (!(el instanceof HTMLInputElement)) return false;
+      var elType = (el.type || "").toLowerCase();
+      if (elType !== "number") return false;
+      var signals = [
+        el.name,
+        el.id,
+        el.getAttribute("placeholder"),
+        el.getAttribute("aria-label"),
+        labelFor(el),
+      ].filter(Boolean).join(" ").toLowerCase();
+      return /\b(qty|quantity|count|items?)\b/.test(signals);
+    }
+
     function serializeInteractive(el, kind) {
       var base = {
         type: kind,
@@ -4219,7 +4472,6 @@ const DIRECT_EXTRACTION_SCRIPT = String.raw`
         return {
           ...base,
           label: labelFor(el)?.slice(0, 100),
-          value: text(el.value),
           options: Array.from(el.options || []).map(function(option) { return { label: text(option.textContent || option.value) || option.value, value: option.value }; }).filter(function(o) { return o.label || o.value; }).slice(0, 25),
           required: el.hasAttribute("required") || undefined,
           ...fieldMeta(el),
@@ -4231,7 +4483,6 @@ const DIRECT_EXTRACTION_SCRIPT = String.raw`
           ...base,
           label: labelFor(el)?.slice(0, 100),
           placeholder: text(el.getAttribute("placeholder")),
-          value: text(el.value),
           required: el.hasAttribute("required") || undefined,
           ...fieldMeta(el),
         };
@@ -4243,7 +4494,7 @@ const DIRECT_EXTRACTION_SCRIPT = String.raw`
         label: labelFor(el)?.slice(0, 100),
         inputType: text(el.getAttribute("type")),
         placeholder: text(el.getAttribute("placeholder")),
-        value: (elType === "password" || elType === "checkbox" || elType === "radio") ? undefined : text(el.value),
+        value: shouldExposeFieldValue(el) ? text(el.value) : undefined,
         required: el.hasAttribute("required") || undefined,
         ...fieldMeta(el),
       };
@@ -4499,7 +4750,7 @@ const SAFE_EXTRACTION_SCRIPT = String.raw`
           label: labelFor(el)?.slice(0, 100),
           inputType: text(el.getAttribute && el.getAttribute("type")),
           placeholder: text(el.getAttribute && el.getAttribute("placeholder")),
-          value: tag === "select" ? text(el.value) : (elType === "password" || elType === "checkbox" || elType === "radio") ? undefined : text(el.value),
+          value: shouldExposeFieldValue(el) ? text(el.value) : undefined,
           options: tag === "select"
             ? Array.from(el.options || []).map(function(option) { return { label: text(option.textContent || option.value) || option.value, value: option.value }; }).filter(function(o) { return o.label || o.value; }).slice(0, 25)
             : undefined,
@@ -4752,11 +5003,13 @@ function normalizePageContent(value) {
 function generateReaderHTML(page) {
   const escapedTitle = escapeHtml(page.title);
   const escapedByline = escapeHtml(page.byline);
+  const renderedContent = renderReaderContent(page);
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; img-src data:; base-uri 'none'; form-action 'none'">
   <title>${escapedTitle}</title>
   <style>
     * { margin: 0; padding: 0; box-sizing: border-box; }
@@ -4827,13 +5080,20 @@ function generateReaderHTML(page) {
   <div class="reader-container">
     <h1>${escapedTitle}</h1>
     ${escapedByline ? `<div class="byline">${escapedByline}</div>` : ""}
-    <div class="reader-content">${page.htmlContent || escapeHtml(page.content)}</div>
+    <div class="reader-content">${renderedContent}</div>
   </div>
 </body>
 </html>`;
 }
+function renderReaderContent(page) {
+  const source = (page.content || page.excerpt || "").trim();
+  if (!source) {
+    return "<p>No readable content was available for this page.</p>";
+  }
+  return source.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean).map((block) => `<p>${escapeHtml(block).replace(/\n/g, "<br>")}</p>`).join("\n");
+}
 function escapeHtml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 const mcpStatusChangeListeners = /* @__PURE__ */ new Set();
 const runtimeHealthChangeListeners = /* @__PURE__ */ new Set();
@@ -4927,24 +5187,24 @@ function getVaultPath() {
 function getKeyPath() {
   return path$1.join(getVaultDir(), KEY_FILENAME);
 }
+function assertVaultSecretStorageAvailable() {
+  if (!electron.safeStorage.isEncryptionAvailable()) {
+    throw new Error(
+      "Agent Credential Vault requires OS-backed secret storage. Enable Keychain, DPAPI, or libsecret support and restart Vessel."
+    );
+  }
+}
 function getOrCreateEncryptionKey() {
+  assertVaultSecretStorageAvailable();
   const keyPath = getKeyPath();
   if (fs$1.existsSync(keyPath)) {
     const encryptedKey = fs$1.readFileSync(keyPath);
-    if (electron.safeStorage.isEncryptionAvailable()) {
-      return electron.safeStorage.decryptString ? Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8") : encryptedKey;
-    }
-    return encryptedKey;
+    return Buffer.from(electron.safeStorage.decryptString(encryptedKey), "utf-8");
   }
   const key = crypto$2.randomBytes(32);
   fs$1.mkdirSync(path$1.dirname(keyPath), { recursive: true });
-  if (electron.safeStorage.isEncryptionAvailable()) {
-    const encrypted = electron.safeStorage.encryptString(key.toString("utf-8"));
-    fs$1.writeFileSync(keyPath, encrypted);
-  } else {
-    fs$1.writeFileSync(keyPath, key);
-    fs$1.chmodSync(keyPath, 384);
-  }
+  const encrypted = electron.safeStorage.encryptString(key.toString("utf-8"));
+  fs$1.writeFileSync(keyPath, encrypted, { mode: 384 });
   return key;
 }
 function encrypt(plaintext) {
@@ -4985,8 +5245,9 @@ function loadVault() {
     return cachedEntries;
   } catch (err) {
     console.error("[Vessel Vault] Failed to load vault:", err);
-    cachedEntries = [];
-    return cachedEntries;
+    throw new Error(
+      "Could not unlock the Agent Credential Vault. Check that OS secret storage is available and that the stored vault key can be decrypted."
+    );
   }
 }
 function saveVault(entries) {
@@ -6728,6 +6989,10 @@ function limitItems(items, max = MAX_STRUCTURED_ITEMS) {
   if (items.length <= max) return items;
   return items.slice(0, max);
 }
+function shouldRenderFieldValue(el) {
+  const value = typeof el.value === "string" && el.value.trim() ? el.value.trim() : "";
+  return Boolean(value) && isQuantityLike(el);
+}
 function formatElementMeta(el) {
   const meta = [];
   if (el.context && el.context !== "content") {
@@ -6795,7 +7060,7 @@ function formatElementMeta(el) {
   if (el.description) {
     meta.push(`desc="${el.description.slice(0, 80)}"`);
   }
-  if (el.value !== void 0 && el.value !== null && el.value !== "") {
+  if (shouldRenderFieldValue(el)) {
     meta.push(`value="${el.value.slice(0, 60)}"`);
   }
   if (el.selector) {
@@ -6806,7 +7071,7 @@ function formatElementMeta(el) {
 }
 function summarizeElementValue(el) {
   const value = typeof el.value === "string" && el.value.trim() ? el.value.trim() : "";
-  if (!value) return null;
+  if (!value || !shouldRenderFieldValue(el)) return null;
   if (el.type === "select") {
     return { label: "selected", value: value.slice(0, 60) };
   }
@@ -10138,22 +10403,6 @@ function formatDeadLinkMessage(label, result) {
   const status = result.statusCode ? `HTTP ${result.statusCode}` : "dead link";
   return `Skipped stale link "${label}" because ${destination} returned ${status}. Try a different link or URL instead.`;
 }
-const ALLOWED_SCHEMES = /* @__PURE__ */ new Set(["http:", "https:"]);
-function isSafeNavigationURL(url) {
-  try {
-    const parsed = new URL(url);
-    return ALLOWED_SCHEMES.has(parsed.protocol);
-  } catch {
-    return false;
-  }
-}
-function assertSafeURL(url) {
-  if (!isSafeNavigationURL(url)) {
-    throw new Error(
-      `Blocked navigation to disallowed URL scheme: ${url.slice(0, 80)}`
-    );
-  }
-}
 async function captureScreenshot(wc) {
   for (let attempt = 0; attempt < 3; attempt += 1) {
     await new Promise((resolve) => setTimeout(resolve, 120 * (attempt + 1)));
@@ -10878,6 +11127,10 @@ function formatCompactToolResult(name, result) {
 const DEFAULT_PAGE_SCRIPT_TIMEOUT_MS = 1500;
 const QUIET_NAVIGATION_WINDOW_MS = 1200;
 const PAGE_SCRIPT_TIMEOUT = /* @__PURE__ */ Symbol("page-script-timeout");
+async function loadPermittedUrl$1(wc, url) {
+  assertPermittedNavigationURL(url);
+  await wc.loadURL(url);
+}
 function pageBusyError(action) {
   return `Error: Page is still busy; ${action} timed out waiting for page scripts. Retry in a moment.`;
 }
@@ -11987,8 +12240,7 @@ Go back and select a different product.`;
       const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
       if (hrefMatch) {
         try {
-          assertSafeURL(hrefMatch[1]);
-          await wc.loadURL(hrefMatch[1]);
+          await loadPermittedUrl$1(wc, hrefMatch[1]);
           await waitForLoad$1(wc, 8e3);
           const hrefUrl = wc.getURL();
           if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
@@ -12055,8 +12307,7 @@ Go back and select a different product.`;
       const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
       if (hrefMatch) {
         try {
-          assertSafeURL(hrefMatch[1]);
-          await wc.loadURL(hrefMatch[1]);
+          await loadPermittedUrl$1(wc, hrefMatch[1]);
           await waitForLoad$1(wc, 8e3);
           const hrefUrl = wc.getURL();
           if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
@@ -12151,8 +12402,7 @@ ${postActivationOverlayHint}`;
     const validation = await validateLinkDestination(elInfo.href);
     if (validation.status !== "dead") {
       try {
-        assertSafeURL(elInfo.href);
-        await wc.loadURL(elInfo.href);
+        await loadPermittedUrl$1(wc, elInfo.href);
         await waitForLoad$1(wc, 8e3);
         const hrefFallbackUrl = wc.getURL();
         if (hrefFallbackUrl !== beforeUrl) {
@@ -13704,8 +13954,7 @@ async function submitForm$1(wc, args) {
     if (formInfo.params) {
       url.search = formInfo.params;
     }
-    assertSafeURL(url.toString());
-    wc.loadURL(url.toString());
+    await loadPermittedUrl$1(wc, url.toString());
     await waitForPotentialNavigation$1(wc, beforeUrl);
     const afterUrl = wc.getURL();
     return afterUrl !== beforeUrl ? `Submitted form via GET -> ${afterUrl}` : "Submitted form via GET";
@@ -14342,8 +14591,7 @@ async function searchPage(wc, args) {
     const shortcut = buildSearchShortcut(wc.getURL(), query);
     if (shortcut) {
       const beforeUrl2 = wc.getURL();
-      assertSafeURL(shortcut.url);
-      wc.loadURL(shortcut.url);
+      await loadPermittedUrl$1(wc, shortcut.url);
       await waitForPotentialNavigation$1(wc, beforeUrl2, 4e3);
       const afterUrl2 = wc.getURL();
       const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
@@ -16775,6 +17023,10 @@ function clearMcpAuthFile() {
 function asTextResponse(text) {
   return { content: [{ type: "text", text }] };
 }
+async function loadPermittedUrl(wc, url) {
+  assertPermittedNavigationURL(url);
+  await wc.loadURL(url);
+}
 function asPromptResponse(text) {
   return {
     messages: [
@@ -17094,7 +17346,7 @@ async function clickResolvedSelector(wc, selector) {
       const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
       if (hrefMatch) {
         try {
-          await wc.loadURL(hrefMatch[1]);
+          await loadPermittedUrl(wc, hrefMatch[1]);
           await waitForLoad(wc, 8e3);
           const hrefUrl = wc.getURL();
           if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
@@ -17147,7 +17399,7 @@ ${overlayHint2}${actionsSuffix}`;
       const hrefMatch = typeof result === "string" ? result.match(/\nhref: (https?:\/\/\S+)/) : null;
       if (hrefMatch) {
         try {
-          await wc.loadURL(hrefMatch[1]);
+          await loadPermittedUrl(wc, hrefMatch[1]);
           await waitForLoad(wc, 8e3);
           const hrefUrl = wc.getURL();
           if (hrefUrl !== beforeUrl2) return `${result.split("\n")[0]} -> ${hrefUrl}`;
@@ -18058,8 +18310,7 @@ async function submitForm(wc, index, selector) {
     if (formInfo.params) {
       url.search = formInfo.params;
     }
-    assertSafeURL(url.toString());
-    wc.loadURL(url.toString());
+    await loadPermittedUrl(wc, url.toString());
     await waitForPotentialNavigation(wc, beforeUrl);
     const afterUrl = wc.getURL();
     return afterUrl !== beforeUrl ? `Submitted form via GET -> ${afterUrl}` : "Submitted form via GET";
@@ -22211,7 +22462,7 @@ function registerIpcHandlers(windowState, runtime2) {
     return windowState.uiState.settingsOpen;
   });
   electron.ipcMain.handle(Channels.SETTINGS_GET, () => {
-    return loadSettings();
+    return getRendererSettings();
   });
   electron.ipcMain.handle(Channels.SETTINGS_HEALTH_GET, () => getRuntimeHealth());
   electron.ipcMain.handle(Channels.SETTINGS_SET, async (_, key, value) => {
@@ -22229,8 +22480,9 @@ function registerIpcHandlers(windowState, runtime2) {
       await stopMcpServer();
       await startMcpServer(tabManager, runtime2, updatedSettings.mcpPort);
     }
-    sendToRendererViews(Channels.SETTINGS_UPDATE, updatedSettings);
-    return updatedSettings;
+    const rendererSettings = getRendererSettings();
+    sendToRendererViews(Channels.SETTINGS_UPDATE, rendererSettings);
+    return rendererSettings;
   });
   electron.ipcMain.handle(Channels.AGENT_RUNTIME_GET, () => runtime2.getState());
   electron.ipcMain.handle(Channels.AGENT_PAUSE, () => runtime2.pause());
@@ -22445,21 +22697,44 @@ function registerIpcHandlers(windowState, runtime2) {
   electron.ipcMain.handle(Channels.PREMIUM_GET_STATE, () => {
     return getPremiumState();
   });
-  electron.ipcMain.handle(Channels.PREMIUM_ACTIVATE, async (_, email) => {
+  electron.ipcMain.handle(Channels.PREMIUM_ACTIVATION_START, async (_, email) => {
     assertString(email, "email");
     if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.trim())) {
-      return { ok: false, state: getPremiumState(), error: "Invalid email format" };
+      return { ok: false, error: "Invalid email format" };
     }
     trackPremiumFunnel("activation_attempted");
-    const result = await activateWithEmail(email);
-    if (result.ok) {
-      trackPremiumFunnel("activation_succeeded", { status: result.state.status });
-      sendToRendererViews(Channels.PREMIUM_UPDATE, result.state);
-    } else {
-      trackPremiumFunnel("activation_failed", { status: result.state.status });
+    const result = await requestActivationCode(email);
+    if (!result.ok) {
+      trackPremiumFunnel("activation_failed");
     }
     return result;
   });
+  electron.ipcMain.handle(
+    Channels.PREMIUM_ACTIVATION_VERIFY,
+    async (_, email, code, challengeToken) => {
+      assertString(email, "email");
+      assertString(code, "code");
+      assertString(challengeToken, "challengeToken");
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.trim())) {
+        return {
+          ok: false,
+          state: getPremiumState(),
+          error: "Invalid email format"
+        };
+      }
+      trackPremiumFunnel("activation_attempted");
+      const result = await verifyActivationCode(email, code, challengeToken);
+      if (result.ok) {
+        trackPremiumFunnel("activation_succeeded", {
+          status: result.state.status
+        });
+        sendToRendererViews(Channels.PREMIUM_UPDATE, result.state);
+      } else {
+        trackPremiumFunnel("activation_failed", { status: result.state.status });
+      }
+      return result;
+    }
+  );
   electron.ipcMain.handle(Channels.PREMIUM_CHECKOUT, async (_, email) => {
     trackPremiumFunnel("checkout_clicked");
     const result = await getCheckoutUrl(email);