@quanta-intellect/vessel-browser 0.1.137 → 0.1.138

package/out/main/index.js

@@ -10,6 +10,8 @@ const OpenAI = require("openai");
 const crypto$2 = require("node:crypto");
 const http = require("http");
 const path$1 = require("node:path");
+const readability = require("@mozilla/readability");
+const linkedom = require("linkedom");
 const node_module = require("node:module");
 const http$1 = require("node:http");
 const os = require("node:os");
@@ -494,6 +496,10 @@ function assertSafeURL(url) {
 }
 function assertPermittedNavigationURL(url) {
   assertSafeURL(url);
+  const airGapError = getAirGapBlockReason(url);
+  if (airGapError) {
+    throw new Error(airGapError);
+  }
   const policyError = checkDomainPolicy(url);
   if (policyError) {
     throw new Error(policyError);
@@ -589,11 +595,11 @@ class Tab {
       return null;
     }
     try {
-      assertSafeURL(url);
+      assertPermittedNavigationURL(url);
     } catch (error) {
       return error instanceof Error ? error.message : "Blocked unsafe navigation";
     }
-    return checkDomainPolicy(url);
+    return null;
   }
   guardedLoadURL(url, options) {
     const blockReason = this.getNavigationBlockReason(url);
@@ -3705,6 +3711,8 @@ const AutofillChannels = {
 const AutomationChannels = {
   AUTOMATION_GET_INSTALLED: "automation:get-installed",
   AUTOMATION_INSTALL_FROM_FILE: "automation:install-from-file",
+  AUTOMATION_CREATE_FROM_TEXT: "automation:create-from-text",
+  AUTOMATION_UPDATE_FROM_TEXT: "automation:update-from-text",
   AUTOMATION_UNINSTALL: "automation:uninstall",
   AUTOMATION_ACTIVITY_START: "automation:activity-start",
   AUTOMATION_ACTIVITY_CHUNK: "automation:activity-chunk",
@@ -4251,10 +4259,28 @@ function buildPageSnapshotKey(rawUrl) {
     return normalizePageUrl(rawUrl);
   }
 }
+function isDocumentViewerUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    const pathname = decodeURIComponent(url.pathname).toLowerCase();
+    if (/\.(pdf|epub|mobi|cbz|cbr)(?:$|[?#])/.test(pathname)) {
+      return true;
+    }
+    const host = url.hostname.toLowerCase().replace(/^www\./, "");
+    if (host === "archive.org") {
+      return /^\/(details|stream|download)\//.test(pathname);
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
 function isTrackablePageUrl(rawUrl) {
   try {
     const url = new URL(rawUrl);
-    return url.protocol === "http:" || url.protocol === "https:";
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    return !isDocumentViewerUrl(rawUrl);
   } catch {
     return false;
   }
@@ -4951,6 +4977,11 @@ const PREMIUM_TOOLS = /* @__PURE__ */ new Set([
   "human_vault_list",
   "human_vault_fill",
   "human_vault_remove",
+  "memory_note_create",
+  "memory_note_append",
+  "memory_note_list",
+  "memory_note_search",
+  "memory_page_capture",
   "research_confirm_brief",
   "research_approve_objectives",
   "research_export_report"
@@ -6663,7 +6694,7 @@ async function extractContentInner(webContents) {
     webContents
   );
 }
-async function extractContent$1(webContents) {
+async function extractContent(webContents) {
   const cacheKey = `${webContents.id}:${webContents.getURL() || ""}`;
   const cached = extractionCache.get(cacheKey);
   if (cached) {
@@ -6881,7 +6912,7 @@ async function capturePageSnapshot(url, wc, sendToRendererViews) {
     if (!shouldTrackSnapshotUrl(url)) return;
     const key2 = normalizeUrl(url);
     const oldSnap = getSnapshot(key2);
-    const content = await extractContent$1(wc);
+    const content = await extractContent(wc);
     const textContent = content.content || "";
     const title = content.title || "";
     const headings = content.headings || [];
@@ -12113,7 +12144,7 @@ async function resolveSelector(wc, index, selector) {
   if (typeof fallbackSelector === "string" && fallbackSelector) {
     return fallbackSelector;
   }
-  const page = await extractContent$1(wc);
+  const page = await extractContent(wc);
   const extractedSelector = findSelectorByIndex(page, index);
   if (extractedSelector) return extractedSelector;
   return null;
@@ -12186,6 +12217,15 @@ async function validateLinkDestination(url, timeoutMs = 3500) {
       detail: "Non-HTTP URL"
     };
   }
+  try {
+    assertPermittedNavigationURL(url);
+  } catch (error) {
+    return {
+      status: "unknown",
+      checkedUrl: url,
+      detail: error instanceof Error ? error.message : "Navigation policy blocked URL"
+    };
+  }
   try {
     const headResponse = await requestUrl(url, "HEAD", timeoutMs);
     if (!HEAD_FALLBACK_STATUS_CODES.has(headResponse.status)) {
@@ -14849,6 +14889,22 @@ function getGlanceExtractScript() {
     };
   })()`;
 }
+function cleanArticleText(value) {
+  return value.replace(/\u00a0/g, " ").replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/(\n\s*){3,}/g, "\n\n").trim();
+}
+function articleTextResultToOutput(result, mode, source, elapsedMs) {
+  const sections = [
+    `# ${result.title || "(untitled)"}`,
+    `URL: ${result.url}`,
+    "",
+    `[read_page mode=${mode} — ${source}, ${elapsedMs}ms]`
+  ];
+  if (result.headings.length > 0) {
+    sections.push("", "## Headings", ...result.headings);
+  }
+  sections.push("", "## Article Text", "", result.text);
+  return sections.join("\n");
+}
 async function glanceExtract(wc) {
   const startMs = Date.now();
   const result = await executePageScript(wc, getGlanceExtractScript(), { timeoutMs: 2500, label: "glance-extract" });
@@ -14896,6 +14952,168 @@ async function glanceExtract(wc) {
   }
   return sections.join("\n");
 }
+async function fastArticleTextExtract(wc, mode) {
+  const startMs = Date.now();
+  const result = await executePageScript(
+    wc,
+    `(function() {
+      function clean(value) {
+        return String(value || '').replace(/[ \\t]+/g, ' ').replace(/(\\n\\s*){3,}/g, '\\n\\n').trim();
+      }
+
+      var rootSelectors = [
+        '#mw-content-text .mw-parser-output',
+        '#mw-content-text',
+        'main article',
+        'article',
+        'main',
+        '[role="main"]',
+        '#content'
+      ];
+      var root = null;
+      for (var i = 0; i < rootSelectors.length; i++) {
+        var candidate = document.querySelector(rootSelectors[i]);
+        if (candidate && clean(candidate.textContent).length > 300) {
+          root = candidate;
+          break;
+        }
+      }
+      if (!root) return null;
+
+      var unwantedSelector = [
+        'script',
+        'style',
+        'noscript',
+        'nav',
+        'header',
+        'footer',
+        'aside',
+        '.mw-editsection',
+        '.reference',
+        '.reflist',
+        '.navbox',
+        '.infobox',
+        '.metadata',
+        '.ambox',
+        '.toc',
+        '#toc'
+      ].join(',');
+
+      var headings = [];
+      var parts = [];
+      var nodes = root.querySelectorAll('h1, h2, h3, p, li');
+      for (var j = 0; j < nodes.length && parts.length < 180; j++) {
+        var node = nodes[j];
+        if (node.closest && node.closest(unwantedSelector)) continue;
+        var tag = String(node.tagName || '').toLowerCase();
+        var text = clean(node.textContent);
+        if (!text) continue;
+        if (/^h[1-3]$/.test(tag)) {
+          if (text.length < 180) headings.push(tag + ': ' + text);
+          parts.push('\\n## ' + text);
+          continue;
+        }
+        if (text.length < 40) continue;
+        parts.push(text);
+      }
+
+      var articleText = clean(parts.join('\\n\\n'));
+      if (articleText.length < 300) {
+        articleText = clean(root.textContent).slice(0, 12000);
+      }
+      if (articleText.length < 300) return null;
+
+      return {
+        title: document.title || '',
+        url: location.href,
+        headings: headings.slice(0, 18),
+        text: articleText.slice(0, ${mode === "summary" ? 9e3 : 14e3}),
+      };
+    })()`,
+    {
+      timeoutMs: 1800,
+      label: "fast article text"
+    }
+  );
+  if (!result || result === PAGE_SCRIPT_TIMEOUT || !result.text.trim()) {
+    return null;
+  }
+  return articleTextResultToOutput(
+    {
+      title: result.title || wc.getTitle() || "(untitled)",
+      url: result.url || wc.getURL(),
+      headings: result.headings,
+      text: result.text
+    },
+    mode,
+    "fast article text",
+    Date.now() - startMs
+  );
+}
+async function fetchArticleTextExtract(wc, mode) {
+  const startMs = Date.now();
+  const url = wc.getURL();
+  try {
+    assertSafeURL(url);
+  } catch {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 4500);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        Accept: "text/html,application/xhtml+xml",
+        "User-Agent": "VesselBrowser/0.1 read-page-fallback"
+      }
+    });
+    if (!response.ok) return null;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType && !/text\/html|application\/xhtml\+xml/i.test(contentType)) {
+      return null;
+    }
+    const contentLength = Number(response.headers.get("content-length") || "0");
+    if (contentLength > 5e6) return null;
+    const html = await response.text();
+    if (html.trim().length < 300) return null;
+    const { document } = linkedom.parseHTML(html);
+    const readable = new readability.Readability(document, {
+      charThreshold: 300
+    }).parse();
+    const title = cleanArticleText(readable?.title || document.title || wc.getTitle()) || wc.getTitle() || "(untitled)";
+    const headings = Array.from(document.querySelectorAll("h1, h2, h3")).map((node) => {
+      const tag = String(node.tagName || "").toLowerCase();
+      const text2 = cleanArticleText(node.textContent || "");
+      return text2.length > 0 && text2.length < 180 ? `${tag}: ${text2}` : "";
+    }).filter(Boolean).slice(0, 18);
+    const fallbackRoot = document.querySelector("article") || document.querySelector("main") || document.querySelector('[role="main"]') || document.body;
+    const text = cleanArticleText(
+      readable?.textContent || fallbackRoot?.textContent || ""
+    );
+    if (text.length < 300) return null;
+    return articleTextResultToOutput(
+      {
+        title,
+        url,
+        headings,
+        text: text.slice(0, mode === "summary" ? 9e3 : 14e3)
+      },
+      mode,
+      "network article fallback",
+      Date.now() - startMs
+    );
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      logger$k.warn("Network article fallback timed out:", url);
+    } else {
+      logger$k.warn("Network article fallback failed:", err);
+    }
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 function normalizeReadPageMode(mode, pageContent) {
   if (typeof mode === "string") {
     const normalized = mode.trim().toLowerCase();
@@ -14967,7 +15185,7 @@ async function getPostSearchSummary(wc) {
   await waitForLoad(wc, 2e3);
   try {
     const content = await Promise.race([
-      extractContent$1(wc),
+      extractContent(wc),
       new Promise((resolve) => setTimeout(() => resolve(null), 2500))
     ]);
     if (content && content.content.length > 0) {
@@ -14989,7 +15207,7 @@ Search results snapshot unavailable. Use read_page(mode="results_only") if neede
 async function getPostClickNavSummary(wc, toolProfile) {
   try {
     const content = await Promise.race([
-      extractContent$1(wc),
+      extractContent(wc),
       new Promise((resolve) => setTimeout(() => resolve(null), 3e3))
     ]);
     if (content && content.content.length > 0) {
@@ -16715,8 +16933,11 @@ async function tryAcceptCookiesQuickly(wc) {
   const dismissed = await executePageScript(
     wc,
     `
-      (function() {
-        var selectors = [
+      (async function() {
+        var delay = function(ms) {
+          return new Promise(function(resolve) { setTimeout(resolve, ms); });
+        };
+        var selectorTargets = [
           '#onetrust-accept-btn-handler',
           '#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll',
           '[data-cookiefirst-action="accept"]',
@@ -16736,60 +16957,237 @@ async function tryAcceptCookiesQuickly(wc) {
           '.message-component.message-button.no-children.focusable.sp_choice_type_11',
           '[class*="truste"] [class*="accept"]',
           '[id*="consent-accept"]',
-          '[class*="cmp-accept"]',
+          '[class*="cmp-accept"]'
         ];
-        var textPatterns = [
-          'accept all',
-          'accept cookies',
-          'allow all',
-          'allow cookies',
-          'agree',
-          'got it',
-          'ok',
-          'i agree',
-          'i accept',
-          'consent',
-          'continue',
-          'accept and continue',
-          'accept & continue'
+        var surfaceSelectors = [
+          '#onetrust-consent-sdk',
+          '#CybotCookiebotDialog',
+          '[id*="cookie" i]',
+          '[id*="consent" i]',
+          '[id*="cmp" i]',
+          '[id*="sp_message" i]',
+          '[class*="cookie" i]',
+          '[class*="consent" i]',
+          '[class*="cmp" i]',
+          '[class*="sp_message" i]',
+          '[class*="truste" i]',
+          '[class*="didomi" i]',
+          '[data-testid*="cookie" i]',
+          '[data-testid*="consent" i]',
+          '[aria-label*="cookie" i]',
+          '[aria-label*="consent" i]',
+          '.fc-consent-root'
         ];
-        for (var i = 0; i < selectors.length; i++) {
-          var el = document.querySelector(selectors[i]);
-          if (el && el instanceof HTMLElement) {
-            el.click();
-            return "Dismissed cookie banner via: " + selectors[i];
+        var actionSelector = [
+          'button',
+          '[role="button"]',
+          'a[role="button"]',
+          'a.message-component',
+          'input[type="button"]',
+          'input[type="submit"]'
+        ].join(',');
+        var seen = [];
+
+        function normalize(text) {
+          return String(text || '').replace(/\\s+/g, ' ').trim();
+        }
+
+        function lower(text) {
+          return normalize(text).toLowerCase();
+        }
+
+        function isElementVisible(el) {
+          if (!(el instanceof HTMLElement)) return false;
+          var style = window.getComputedStyle(el);
+          if (style.display === 'none' || style.visibility === 'hidden') return false;
+          if (Number(style.opacity || '1') < 0.05) return false;
+          var rect = el.getBoundingClientRect();
+          return rect.width > 2 &&
+            rect.height > 2 &&
+            rect.bottom > 0 &&
+            rect.right > 0 &&
+            rect.top < window.innerHeight &&
+            rect.left < window.innerWidth;
+        }
+
+        function elementText(el) {
+          if (!(el instanceof HTMLElement)) return '';
+          return normalize([
+            el.getAttribute('aria-label'),
+            el.getAttribute('title'),
+            el.getAttribute('value'),
+            el.textContent
+          ].filter(Boolean).join(' '));
+        }
+
+        function looksLikeCookieSurface(el) {
+          if (!isElementVisible(el)) return false;
+          var text = lower([
+            el.getAttribute('aria-label'),
+            el.getAttribute('id'),
+            el.getAttribute('class'),
+            el.textContent
+          ].filter(Boolean).join(' ')).slice(0, 1600);
+          if (!/(cookie|consent|privacy|tracking|personalise|personalize|advertis|data choices|your choices|cmp|onetrust|truste|didomi)/.test(text)) {
+            return false;
           }
+
+          var rect = el.getBoundingClientRect();
+          var style = window.getComputedStyle(el);
+          var fixedLike = style.position === 'fixed' || style.position === 'sticky';
+          var sizeable = rect.width >= Math.min(window.innerWidth * 0.35, 360) && rect.height >= 48;
+          var bottomBanner = fixedLike && rect.bottom > window.innerHeight * 0.58 && rect.height >= 64;
+          var dialog = el.getAttribute('role') === 'dialog' || el.getAttribute('aria-modal') === 'true';
+          var namedSurface = /(cookie|consent|cmp|onetrust|truste|didomi|sp_message)/.test(lower([
+            el.getAttribute('id'),
+            el.getAttribute('class'),
+            el.getAttribute('data-testid')
+          ].filter(Boolean).join(' ')));
+
+          return sizeable && (namedSurface || bottomBanner || dialog);
         }
-        var buttons = document.querySelectorAll('button, a[role="button"], [type="submit"]');
-        for (var j = 0; j < buttons.length; j++) {
-          var btn = buttons[j];
-          var text = (btn.textContent || '').trim().toLowerCase();
-          for (var k = 0; k < textPatterns.length; k++) {
-            if (text === textPatterns[k] || text.startsWith(textPatterns[k])) {
-              btn.click();
-              return "Dismissed cookie banner via text match: " + text;
+
+        function cookieSurfaces() {
+          var surfaces = [];
+          function addSurface(el) {
+            if (surfaces.indexOf(el) === -1 && looksLikeCookieSurface(el)) {
+              surfaces.push(el);
             }
           }
+
+          for (var i = 0; i < surfaceSelectors.length; i++) {
+            try {
+              document.querySelectorAll(surfaceSelectors[i]).forEach(addSurface);
+            } catch {
+              // Ignore unsupported selectors in older page engines.
+            }
+          }
+
+          document.querySelectorAll('div, section, aside, footer, form, [role="dialog"]').forEach(function(el) {
+            if (!(el instanceof HTMLElement)) return;
+            var style = window.getComputedStyle(el);
+            if (style.position === 'fixed' || style.position === 'sticky' || el.getAttribute('role') === 'dialog') {
+              addSurface(el);
+            }
+          });
+
+          return surfaces;
+        }
+
+        function hasCookieSurface() {
+          return cookieSurfaces().length > 0;
+        }
+
+        function labelScore(label) {
+          var text = lower(label);
+          if (!text) return 0;
+          if (/^(accept all|accept cookies|allow all|allow cookies|accept and continue|accept & continue|agree and continue)$/.test(text)) {
+            return 220;
+          }
+          if (/^(i agree|i accept|agree|accept|allow|ok|okay|got it|continue|yes)$/.test(text)) {
+            return 190;
+          }
+          if (/^(reject all|decline|deny|necessary only|essential only|save preferences|confirm choices|submit preferences)$/.test(text)) {
+            return 170;
+          }
+          if (/\\b(accept all|allow all|accept cookies|allow cookies|accept and continue|accept & continue|agree and continue)\\b/.test(text)) {
+            return 160;
+          }
+          if (/\\b(reject all|save preferences|confirm choices|necessary only|essential only)\\b/.test(text)) {
+            return 145;
+          }
+          if (/^(consent|cookie consent|cookies|privacy|privacy policy|cookie policy|learn more|more information|settings|preferences|manage options|customize|customise)$/.test(text)) {
+            return 0;
+          }
+          return 0;
+        }
+
+        function addCandidate(el, source, baseScore) {
+          if (!(el instanceof HTMLElement) || seen.indexOf(el) !== -1 || !isElementVisible(el)) return;
+          var label = elementText(el);
+          var score = labelScore(label);
+          if (score <= 0 && baseScore < 160) return;
+          seen.push(el);
+          candidates.push({
+            el: el,
+            label: label || source,
+            source: source,
+            score: baseScore + score
+          });
+        }
+
+        var beforeHadSurface = hasCookieSurface();
+        var candidates = [];
+
+        for (var i = 0; i < selectorTargets.length; i++) {
+          try {
+            document.querySelectorAll(selectorTargets[i]).forEach(function(el) {
+              addCandidate(el, selectorTargets[i], 160);
+            });
+          } catch {
+            // Ignore unsupported selectors in older page engines.
+          }
+        }
+
+        var surfaces = cookieSurfaces();
+        surfaces.forEach(function(surface) {
+          surface.querySelectorAll(actionSelector).forEach(function(el) {
+            addCandidate(el, 'cookie surface', 120);
+          });
+        });
+
+        if (beforeHadSurface) {
+          document.querySelectorAll(actionSelector).forEach(function(el) {
+            addCandidate(el, 'page action', 40);
+          });
         }
+
+        candidates.sort(function(a, b) { return b.score - a.score; });
+
+        var tried = 0;
+        for (var j = 0; j < Math.min(candidates.length, 8); j++) {
+          var candidate = candidates[j];
+          tried += 1;
+          candidate.el.click();
+          await delay(220);
+          if (!hasCookieSurface()) {
+            return {
+              status: 'dismissed',
+              message: 'Dismissed cookie banner via: ' + candidate.label.slice(0, 80)
+            };
+          }
+        }
+
+        if (beforeHadSurface || tried > 0) {
+          return {
+            status: 'still_visible',
+            message: tried > 0
+              ? 'Cookie consent banner is still visible after trying ' + tried + ' candidate control(s). Try clear_overlays or dismiss_popup.'
+              : 'Cookie consent banner appears visible, but no reliable accept/reject button was found. Try clear_overlays or dismiss_popup.'
+          };
+        }
+
         return null;
       })()
     `,
     {
       label: "accept cookies",
-      timeoutMs: 1200
+      timeoutMs: 2200,
+      userGesture: true
     }
   );
   if (dismissed) return dismissed;
-  return tryDismissConsentIframe(wc);
+  const iframeDismissed = await tryDismissConsentIframe(wc);
+  return iframeDismissed ? { status: "dismissed", message: iframeDismissed } : null;
 }
 async function clearOverlays(wc, strategy = "auto") {
   const quickCookieResult = await tryAcceptCookiesQuickly(wc);
   if (quickCookieResult === PAGE_SCRIPT_TIMEOUT) {
     return pageBusyError("clear_overlays");
   }
-  if (quickCookieResult) {
+  if (quickCookieResult?.status === "dismissed") {
     return [
-      quickCookieResult,
+      quickCookieResult.message,
       "Stopped after a lightweight consent pass to keep the page responsive. Re-run only if the banner is still blocking the page."
     ].join("\n");
   }
@@ -17738,6 +18136,94 @@ async function locateSearchTarget(wc, explicitSelector) {
     }
   );
 }
+async function locateImplicitTextTarget(wc) {
+  return executePageScript(
+    wc,
+    `
+      (function() {
+        function normalize(value) {
+          return value == null ? "" : String(value).trim().toLowerCase();
+        }
+
+        function isVisible(el) {
+          if (!(el instanceof HTMLElement)) return true;
+          const style = window.getComputedStyle(el);
+          if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+          if (el.hasAttribute("hidden") || el.getAttribute("aria-hidden") === "true") return false;
+          const rect = el.getBoundingClientRect();
+          return rect.width > 0 && rect.height > 0;
+        }
+
+        function inViewport(el) {
+          if (!(el instanceof HTMLElement)) return true;
+          const rect = el.getBoundingClientRect();
+          const vw = window.innerWidth || document.documentElement?.clientWidth || 0;
+          const vh = window.innerHeight || document.documentElement?.clientHeight || 0;
+          return rect.bottom > 0 && rect.right > 0 && rect.top < vh && rect.left < vw;
+        }
+
+        function isFillable(el) {
+          if (!(el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) return false;
+          if (el.disabled || el.readOnly || el.getAttribute("aria-disabled") === "true") return false;
+          const type = el instanceof HTMLTextAreaElement ? "text" : normalize(el.getAttribute("type") || el.type || "text");
+          return ["", "search", "text", "email", "url", "tel", "number", "password"].includes(type);
+        }
+
+        function nearestSearchScope(input) {
+          return input.closest('[role="search"], form, header, nav, [class*="search" i], [id*="search" i]');
+        }
+
+        ${selectorHelpersJS(["data-testid", "name", "form", "aria-label", "placeholder"])}
+
+        const active = document.activeElement;
+        if (active && isFillable(active) && isVisible(active) && inViewport(active)) {
+          return selectorFor(active);
+        }
+
+        const candidates = Array.from(
+          document.querySelectorAll('input:not([type="hidden"]):not([type="submit"]):not([type="button"]):not([type="image"]), textarea')
+        ).filter((el) => isFillable(el) && isVisible(el));
+
+        let best = null;
+        let bestScore = -1;
+        for (const el of candidates) {
+          let score = 0;
+          if (inViewport(el)) score += 100;
+          const rect = el.getBoundingClientRect();
+          score += Math.max(0, 36 - Math.min(36, Math.floor(Math.max(0, rect.top) / 22)));
+
+          const type = el instanceof HTMLTextAreaElement ? "text" : normalize(el.getAttribute("type") || el.type);
+          const name = normalize(el.getAttribute("name"));
+          const placeholder = normalize(el.getAttribute("placeholder"));
+          const aria = normalize(el.getAttribute("aria-label"));
+          const role = normalize(el.getAttribute("role"));
+          const id = normalize(el.getAttribute("id"));
+
+          if (type === "search") score += 80;
+          if (role === "searchbox") score += 70;
+          if (name === "q" || name === "query" || name === "search") score += 65;
+          if (placeholder.includes("search")) score += 55;
+          if (aria.includes("search")) score += 55;
+          if (id.includes("search")) score += 35;
+
+          const scope = nearestSearchScope(el);
+          if (scope) score += 35;
+
+          if (score > bestScore) {
+            best = el;
+            bestScore = score;
+          }
+        }
+
+        return best ? selectorFor(best) : null;
+      })()
+    `,
+    {
+      timeoutMs: 2200,
+      label: "find implicit text input"
+    }
+  );
+}
 async function searchPage(wc, args) {
   const query = String(args.query || "");
   if (!query) return "Error: No search query provided.";
@@ -18227,8 +18713,19 @@ async function executeAction(name, args, ctx) {
         }
         case "type_text": {
           if (!wc) return "Error: No active tab";
-          const selector = await resolveSelector(wc, args.index, args.selector);
-          if (!selector) return "Error: No element index or selector provided";
+          let selector = await resolveSelector(wc, args.index, args.selector);
+          if (selector === PAGE_SCRIPT_TIMEOUT) {
+            return pageBusyError("type_text");
+          }
+          if (!selector) {
+            selector = await locateImplicitTextTarget(wc);
+          }
+          if (selector === PAGE_SCRIPT_TIMEOUT) {
+            return pageBusyError("type_text");
+          }
+          if (!selector) {
+            return "Error: No element index or selector provided, and no focused or visible text input could be found.";
+          }
           const mode = typeof args.mode === "string" ? args.mode : "default";
           if (mode === "keystroke") {
             return typeKeystroke(wc, selector, String(args.text || ""));
@@ -18324,6 +18821,23 @@ async function executeAction(name, args, ctx) {
           if (requestedGlance) {
             return glanceExtract(wc);
           }
+          const requestedTextMode = typeof args.mode === "string" ? args.mode.trim().toLowerCase() : "";
+          if (requestedTextMode === "summary" || requestedTextMode === "text_only") {
+            const fastArticleText = await fastArticleTextExtract(
+              wc,
+              requestedTextMode
+            );
+            if (fastArticleText) {
+              return fastArticleText;
+            }
+            const fetchedArticleText = await fetchArticleTextExtract(
+              wc,
+              requestedTextMode
+            );
+            if (fetchedArticleText) {
+              return fetchedArticleText;
+            }
+          }
           let content = null;
           try {
             content = await Promise.race([
@@ -19020,7 +19534,7 @@ ${steps.join("\n")}`;
           if (dismissed === PAGE_SCRIPT_TIMEOUT) {
             return pageBusyError("accept_cookies");
           }
-          if (dismissed) return dismissed;
+          if (dismissed) return dismissed.message;
           return "No cookie consent banner detected. Try dismiss_popup for other overlays.";
         }
         case "extract_table": {
@@ -20272,13 +20786,31 @@ async function showDownloadInFolder(id) {
 }
 const defaultDownloadViews = /* @__PURE__ */ new Set();
 let defaultDownloadHandlerInstalled = false;
+function sanitizeDownloadFilename(filename) {
+  const normalized = filename.replace(/\\/g, "/");
+  const basename = path.posix.basename(normalized).trim();
+  const safeName = basename.replace(/[\0-\x1f\x7f]/g, "_");
+  if (!safeName || safeName === "." || safeName === "..") {
+    return "download";
+  }
+  return safeName;
+}
+function isPathInside(parentDir, candidatePath) {
+  const relative = path.relative(parentDir, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 function resolveDownloadPath(downloadDir, filename) {
   fs$1.mkdirSync(downloadDir, { recursive: true });
-  const parsed = path.parse(filename);
+  const rootDir = path.resolve(downloadDir);
+  const safeFilename = sanitizeDownloadFilename(filename);
+  const parsed = path.parse(safeFilename);
   let attempt = 0;
   while (true) {
-    const candidateName = attempt === 0 ? filename : `${parsed.name} (${attempt})${parsed.ext}`;
-    const candidatePath = path.join(downloadDir, candidateName);
+    const candidateName = attempt === 0 ? safeFilename : `${parsed.name} (${attempt})${parsed.ext}`;
+    const candidatePath = path.resolve(rootDir, candidateName);
+    if (!isPathInside(rootDir, candidatePath)) {
+      throw new Error("Blocked unsafe download filename");
+    }
     if (!fs$1.existsSync(candidatePath)) {
       return candidatePath;
     }
@@ -21455,7 +21987,7 @@ async function handleAIQuery(query, provider, activeWebContents, onChunk, onEnd,
   const isSummarize = lowerQuery.startsWith("summarize") || lowerQuery.startsWith("tldr") || lowerQuery === "summary";
   if (provider.streamAgentQuery && tabManager && activeWebContents && runtime2) {
     try {
-      const pageContent = await extractContent$1(activeWebContents);
+      const pageContent = await extractContent(activeWebContents);
       const pageType = detectPageType(pageContent);
       const defaultReadMode = chooseAgentReadMode(pageContent);
       if (provider.agentToolProfile === "compact") {
@@ -21556,7 +22088,7 @@ ${trackerCtx}`;
   let prompt;
   if (activeWebContents) {
     try {
-      const pageContent = await extractContent$1(activeWebContents);
+      const pageContent = await extractContent(activeWebContents);
       if (isSummarize) {
         prompt = buildSummarizePrompt(pageContent);
       } else {
@@ -21837,7 +22369,7 @@ function registerContentHandlers(windowState2) {
     assertTrustedIpcSender(event);
     const activeTab = tabManager.getActiveTab();
     if (!activeTab) return null;
-    return extractContent$1(activeTab.view.webContents);
+    return extractContent(activeTab.view.webContents);
   });
   electron.ipcMain.handle(Channels.READER_MODE_TOGGLE, async (event) => {
     assertTrustedIpcSender(event);
@@ -21851,7 +22383,7 @@ function registerContentHandlers(windowState2) {
       }
     } else {
       const originalUrl = activeTab.state.url;
-      const content = await extractContent$1(activeTab.view.webContents);
+      const content = await extractContent(activeTab.view.webContents);
       const html = generateReaderHTML(content);
       activeTab.setReaderMode(true, originalUrl);
       void loadInternalDataURL(
@@ -22177,6 +22709,13 @@ function broadcastState(tabManager) {
   stateListener(getDevToolsPanelState(tabId));
 }
 async function withDevToolsAction(runtime2, tabManager, name, args, executor) {
+  try {
+    assertFeatureUnlocked("devtools", "DevTools");
+  } catch (error) {
+    return asTextResponse$1(
+      `Error: ${error instanceof Error ? error.message : "DevTools require Vessel Premium."}`
+    );
+  }
   const activityEntry = {
     id: ++activityCounter,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23034,7 +23573,7 @@ async function getPostActionState(tabManager, name) {
   if (navActions.includes(name)) {
     let warning = "";
     try {
-      const page = await extractContent$1(wc);
+      const page = await extractContent(wc);
       const issue = getRecoverableAccessIssue(page);
       if (issue) {
         const blockedUrl = wc.getURL();
@@ -23900,7 +24439,7 @@ function registerMemoryTools(server, tabManager, runtime2) {
         "memory_page_capture",
         { title, folder, tags },
         async () => {
-          const page = await extractContent$1(tab.view.webContents);
+          const page = await extractContent(tab.view.webContents);
           const saved = await capturePageToVault({
             page,
             title,
@@ -24667,7 +25206,7 @@ function registerTools(server, tabManager, runtime2) {
           const wc = activeTab.view.webContents;
           pageUrl = wc.getURL();
           pageTitle = wc.getTitle();
-          const page = await extractContent$1(wc);
+          const page = await extractContent(wc);
           pageType = detectPageType(page);
         } catch (err) {
           logger$b.warn("Failed to detect page type for tool scoring, falling back to GENERAL:", err);
@@ -24833,7 +25372,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const effectiveMode = mode || "full";
         return asTextResponse(
           await buildExtractResponse(
@@ -24865,7 +25404,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const effectiveMode = mode || "full";
         return asTextResponse(
           await buildExtractResponse(
@@ -25000,7 +25539,7 @@ ${buildScopedContext(pageContent, mode)}`;
       const tab = tabManager.getActiveTab();
       if (!tab) return asNoActiveTabResponse();
       try {
-        const pageContent = await extractContent$1(tab.view.webContents);
+        const pageContent = await extractContent(tab.view.webContents);
         const requestedType = typeof type === "string" && type.trim() ? type.trim().toLowerCase() : "";
         const entities = (pageContent.structuredData ?? []).filter(
           (entity) => requestedType ? entity.types.some(
@@ -26082,7 +26621,7 @@ ${flow.steps.map((s, i) => `  ${i === 0 ? "→" : " "} ${s.label}`).join("\n")}`
       const wc = tab.view.webContents;
       let page;
       try {
-        page = await extractContent$1(wc);
+        page = await extractContent(wc);
       } catch (err) {
         logger$b.warn("Failed to extract page while generating suggestions:", err);
         return asTextResponse(
@@ -27643,11 +28182,7 @@ const VALID_KIT_CATEGORIES = /* @__PURE__ */ new Set([
   "productivity",
   "forms"
 ]);
-const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set([
-  "research-collect",
-  "price-scout",
-  "form-filler"
-]);
+const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set();
 const KIT_ID_UNSAFE_CHAR_PATTERN = /[/\\\0]/;
 function isSafeAutomationKitId(id) {
   return id.length > 0 && !KIT_ID_UNSAFE_CHAR_PATTERN.test(id);
@@ -27697,18 +28232,18 @@ async function getInstalledKits() {
       if (isValidKit(parsed)) {
         kits.push(parsed);
       } else {
-        logger$9.warn(`Skipping invalid kit file: ${file}`);
+        logger$9.warn(`Skipping invalid skill file: ${file}`);
       }
     } catch (err) {
-      logger$9.warn(`Failed to read kit file: ${file}`, err);
+      logger$9.warn(`Failed to read skill file: ${file}`, err);
     }
   }
   return kits;
 }
 async function installKitFromFile() {
   const { canceled, filePaths } = await electron.dialog.showOpenDialog({
-    title: "Install Automation Kit",
-    filters: [{ name: "Automation Kit", extensions: ["kit.json", "json"] }],
+    title: "Import Skill",
+    filters: [{ name: "Skills", extensions: ["skill.json", "json"] }],
     properties: ["openFile"]
   });
   if (canceled || filePaths.length === 0) {
@@ -27718,62 +28253,128 @@ async function installKitFromFile() {
   try {
     raw = await readFile(filePaths[0], "utf-8");
   } catch (err) {
-    logger$9.warn("Failed to read selected kit file:", err);
+    logger$9.warn("Failed to read selected skill file:", err);
     return errorResult("Could not read the selected file.");
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
-    logger$9.warn("Selected kit file is not valid JSON:", err);
+    logger$9.warn("Selected skill file is not valid JSON:", err);
     return errorResult("File is not valid JSON.");
   }
   if (!isValidKit(parsed)) {
     return errorResult(
-      "File is not a valid automation kit. Required fields: id, name, description, icon, inputs, promptTemplate."
+      "File is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
+    );
+  }
+  if (BUNDLED_KIT_IDS.has(parsed.id)) {
+    return errorResult(
+      `Skill id "${parsed.id}" conflicts with a built-in skill and cannot be overwritten.`
+    );
+  }
+  await ensureKitsDir();
+  const dest = getKitFilePath(parsed.id);
+  if (!dest) {
+    return errorResult("Skill id contains unsupported characters.");
+  }
+  try {
+    await writeFile(dest, JSON.stringify(parsed, null, 2), "utf-8");
+  } catch (err) {
+    logger$9.warn("Failed to save skill file:", err);
+    return errorResult("Failed to save the skill file.");
+  }
+  return okResult({ kit: parsed });
+}
+async function createKitFromText(source) {
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    logger$9.warn("Created skill text is not valid JSON:", err);
+    return errorResult("Skill text is not valid JSON.");
+  }
+  if (!isValidKit(parsed)) {
+    return errorResult(
+      "Text is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
     );
   }
   if (BUNDLED_KIT_IDS.has(parsed.id)) {
     return errorResult(
-      `Kit id "${parsed.id}" conflicts with a built-in kit and cannot be overwritten.`
+      `Skill id "${parsed.id}" conflicts with a built-in skill and cannot be overwritten.`
     );
   }
   await ensureKitsDir();
   const dest = getKitFilePath(parsed.id);
   if (!dest) {
-    return errorResult("Kit id contains unsupported characters.");
+    return errorResult("Skill id contains unsupported characters.");
   }
   try {
     await writeFile(dest, JSON.stringify(parsed, null, 2), "utf-8");
   } catch (err) {
-    logger$9.warn("Failed to save kit file:", err);
-    return errorResult("Failed to save the kit file.");
+    logger$9.warn("Failed to save created skill:", err);
+    return errorResult("Failed to save the skill.");
+  }
+  return okResult({ kit: parsed });
+}
+async function updateKitFromText(id, source) {
+  if (BUNDLED_KIT_IDS.has(id)) {
+    return errorResult("Built-in skills cannot be edited.");
+  }
+  const target = getKitFilePath(id);
+  if (!target) {
+    return errorResult("Skill id contains unsupported characters.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch (err) {
+    logger$9.warn("Updated skill text is not valid JSON:", err);
+    return errorResult("Skill text is not valid JSON.");
+  }
+  if (!isValidKit(parsed)) {
+    return errorResult(
+      "Text is not a valid skill. Required fields: id, name, description, icon, inputs, promptTemplate."
+    );
+  }
+  if (parsed.id !== id) {
+    return errorResult("Skill id cannot be changed while editing.");
+  }
+  await ensureKitsDir();
+  if (!await pathExists(target)) {
+    return errorResult("Skill not found.");
+  }
+  try {
+    await writeFile(target, JSON.stringify(parsed, null, 2), "utf-8");
+  } catch (err) {
+    logger$9.warn("Failed to update skill:", err);
+    return errorResult("Failed to update the skill.");
   }
   return okResult({ kit: parsed });
 }
 async function uninstallKit(id, scheduledKitIds) {
   if (BUNDLED_KIT_IDS.has(id)) {
-    return errorResult("Built-in kits cannot be removed.");
+    return errorResult("Built-in skills cannot be removed.");
   }
   if (scheduledKitIds?.has(id)) {
     return errorResult(
-      "This kit has active scheduled jobs. Delete or reassign them first."
+      "This skill has active scheduled jobs. Delete or reassign them first."
     );
   }
   await ensureKitsDir();
   const target = getKitFilePath(id);
   if (!target) {
-    return errorResult("Kit id contains unsupported characters.");
+    return errorResult("Skill id contains unsupported characters.");
   }
   if (!await pathExists(target)) {
-    return errorResult("Kit not found.");
+    return errorResult("Skill not found.");
   }
   try {
     await unlink(target);
     return okResult();
   } catch (err) {
-    logger$9.warn("Failed to remove kit file:", err);
-    return errorResult("Failed to remove the kit file.");
+    logger$9.warn("Failed to remove skill file:", err);
+    return errorResult("Failed to remove the skill file.");
   }
 }
 const logger$8 = createLogger("Scheduler");
@@ -27958,7 +28559,7 @@ async function fireJob(job, windowState2, runtime2) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : "Unknown error";
     appendActivity(`
-[Scheduled Kit Error: ${msg}]`);
+[Scheduled Skill Error: ${msg}]`);
     finishActivity("failed");
   }
 }
@@ -28016,10 +28617,12 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   }, msToNextMinute);
   electron.ipcMain.handle(Channels.SCHEDULE_GET_ALL, (event) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return jobs;
   });
   electron.ipcMain.handle(Channels.SCHEDULE_CREATE, (event, rawJob) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (!isValidJobData(rawJob)) {
       throw new Error(
         "Invalid job data. Required: kitId, kitName, kitIcon, renderedPrompt, schedule, enabled."
@@ -28038,6 +28641,7 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   });
   electron.ipcMain.handle(Channels.SCHEDULE_UPDATE, (event, id, updates) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (typeof id !== "string") throw new Error("id must be a string");
     const job = jobs.find((j) => j.id === id);
     if (!job) return null;
@@ -28065,6 +28669,7 @@ function registerScheduleHandlers(windowState2, runtime2, sendToAll) {
   });
   electron.ipcMain.handle(Channels.SCHEDULE_DELETE, (event, id) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     if (typeof id !== "string") throw new Error("id must be a string");
     const before = jobs.length;
     jobs = jobs.filter((j) => j.id !== id);
@@ -28089,6 +28694,7 @@ function stopScheduler() {
   }
 }
 const KitIdSchema = zod.z.string().min(1);
+const SkillSourceSchema = zod.z.string().min(1).max(1e5);
 const OriginSchema = zod.z.string().min(1);
 function registerSystemHandlers(windowState2, sendToRendererViews) {
   const { tabManager } = windowState2;
@@ -28107,14 +28713,32 @@ function registerSystemHandlers(windowState2, sendToRendererViews) {
   });
   electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, async (event) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return await getInstalledKits();
   });
   electron.ipcMain.handle(Channels.AUTOMATION_INSTALL_FROM_FILE, async (event) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return await installKitFromFile();
   });
+  electron.ipcMain.handle(Channels.AUTOMATION_CREATE_FROM_TEXT, async (event, source) => {
+    assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await createKitFromText(
+      parseIpc(SkillSourceSchema, source, "source")
+    );
+  });
+  electron.ipcMain.handle(Channels.AUTOMATION_UPDATE_FROM_TEXT, async (event, id, source) => {
+    assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
+    return await updateKitFromText(
+      parseIpc(KitIdSchema, id, "id"),
+      parseIpc(SkillSourceSchema, source, "source")
+    );
+  });
   electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, async (event, id) => {
     assertTrustedIpcSender(event);
+    assertFeatureUnlocked("automation_kits", "Skills");
     return await uninstallKit(
       parseIpc(KitIdSchema, id, "id"),
       getScheduledKitIds()
@@ -29577,7 +30201,7 @@ function registerAutofillHandlers(windowState2) {
     const activeTab = windowState2.tabManager.getActiveTab();
     const wc = activeTab?.view.webContents;
     if (!wc) throw new Error("No active tab");
-    const content = await extractContent$1(wc);
+    const content = await extractContent(wc);
     const elements = content.interactiveElements || [];
     const matches = matchFields(elements, profile);
     if (matches.length === 0) {