@quanta-intellect/vessel-browser 0.1.31 → 0.1.32

package/README.md

@@ -11,7 +11,7 @@
 </div>
 
 
-Open source chromium-based browser for persistent web agents on Linux (Mac/Windows support to come).
+Open source chromium-based browser for persistent web agents. Linux is the most mature install target today, and macOS release packaging is available from source.
 
 Vessel gives external agent harnesses a real browser with durable state, MCP control, and a human-visible supervisory UI. It is built for long-running workflows where the agent drives and the human audits, intervenes, and redirects when needed.
 
@@ -200,12 +200,25 @@ npm run dist:dir
 
 # Package a Linux AppImage
 npm run dist
+
+# Package an unpacked macOS app bundle (run on macOS)
+npm run dist:mac:dir
+
+# Package macOS DMG + ZIP artifacts (run on macOS)
+npm run dist:mac
+
+# Package signed macOS DMG + ZIP artifacts (run on macOS with signing set up)
+npm run dist:mac:signed
 ```
 
 Notes:
 
 - `npm run dev` still launches the stock Electron binary, so Linux may continue showing the default Electron gear icon in development
 - packaged builds created with `npm run dist` / `npm run dist:dir` use the Vessel app icon
+- `npm run build:icon:mac` regenerates `resources/vessel-icon.icns` from `resources/vessel-icon.png` for macOS packaging
+- `npm run dist:mac` and `npm run dist:mac:dir` intentionally disable auto-signing so local packaging works on any Mac without keychain setup
+- `npm run dist:mac:signed` and `npm run dist:mac:dir:signed` use normal `electron-builder` signing discovery; if your login keychain has duplicate Apple certs, clean those up or use a dedicated keychain before running the signed path
+- signed builds are still not notarized by this repo out of the box, so Gatekeeper warnings remain until notarization is added for release publishing
 - the tracked smoke test runs typecheck, build, the MCP stdio proxy regression check, and the Electron navigation regression harness
 - for headless CI, run the smoke test under `xvfb-run -a npm run smoke:test`
 

package/out/main/index.js

@@ -11509,6 +11509,325 @@ async function submitForm$1(wc, args) {
 async function clickElementBySelector(wc, selector) {
   return clickResolvedSelector$1(wc, selector);
 }
+const HUGGING_FACE_HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "www.huggingface.co"]);
+const HUGGING_FACE_MODEL_TASKS = [
+  {
+    value: "automatic-speech-recognition",
+    label: "automatic speech recognition",
+    phrases: ["automatic speech recognition", "speech recognition", "asr"]
+  },
+  {
+    value: "text-classification",
+    label: "text classification",
+    phrases: ["text classification", "classification"]
+  },
+  {
+    value: "token-classification",
+    label: "token classification",
+    phrases: ["token classification", "named entity recognition", "ner"]
+  },
+  {
+    value: "question-answering",
+    label: "question answering",
+    phrases: ["question answering", "qa"]
+  },
+  {
+    value: "sentence-similarity",
+    label: "sentence similarity",
+    phrases: ["sentence similarity", "semantic similarity"]
+  },
+  {
+    value: "feature-extraction",
+    label: "feature extraction",
+    phrases: ["feature extraction", "embeddings", "embedding"]
+  },
+  {
+    value: "image-classification",
+    label: "image classification",
+    phrases: ["image classification"]
+  },
+  {
+    value: "object-detection",
+    label: "object detection",
+    phrases: ["object detection"]
+  },
+  {
+    value: "image-to-text",
+    label: "image to text",
+    phrases: ["image to text", "image-to-text", "ocr"]
+  },
+  {
+    value: "text-to-image",
+    label: "text to image",
+    phrases: ["text to image", "text-to-image"]
+  },
+  {
+    value: "text-to-speech",
+    label: "text to speech",
+    phrases: ["text to speech", "text-to-speech", "tts"]
+  },
+  {
+    value: "text-generation",
+    label: "text generation",
+    phrases: [
+      "text generation",
+      "text-generation",
+      "llm",
+      "chat model",
+      "chat models",
+      "instruct model",
+      "instruct models"
+    ]
+  },
+  {
+    value: "text2text-generation",
+    label: "text2text generation",
+    phrases: [
+      "text2text generation",
+      "text-to-text generation",
+      "text to text generation"
+    ]
+  },
+  {
+    value: "summarization",
+    label: "summarization",
+    phrases: ["summarization", "summarize", "summarizer"]
+  },
+  {
+    value: "translation",
+    label: "translation",
+    phrases: ["translation", "translate", "translator"]
+  }
+];
+const HUGGING_FACE_MODEL_LIBRARIES = [
+  { value: "sentence-transformers", label: "sentence-transformers", phrases: ["sentence-transformers"] },
+  { value: "transformers.js", label: "transformers.js", phrases: ["transformers.js"] },
+  { value: "transformers", label: "transformers", phrases: ["transformers"] },
+  { value: "diffusers", label: "diffusers", phrases: ["diffusers"] },
+  { value: "safetensors", label: "safetensors", phrases: ["safetensors"] },
+  { value: "pytorch", label: "pytorch", phrases: ["pytorch"] },
+  { value: "tf", label: "tensorflow", phrases: ["tensorflow", "tf"] },
+  { value: "jax", label: "jax", phrases: ["jax"] },
+  { value: "onnx", label: "onnx", phrases: ["onnx"] },
+  { value: "gguf", label: "gguf", phrases: ["gguf"] },
+  { value: "mlx", label: "mlx", phrases: ["mlx"] }
+];
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripSearchPhrase(query, phrase) {
+  return query.replace(
+    new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "gi"),
+    " "
+  );
+}
+function collapseSearchTerms(query) {
+  return query.replace(/\b(on|in|for|with|without|from|by|to|of|the|a|an|and|or)\b/gi, " ").replace(/\b(find|show|search|browse|look(?:ing)?(?:\s+for)?|need|want)\b/gi, " ").replace(/\bhugging\s*face\b/gi, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeSearchQuery(query) {
+  return query.replace(/\s+/g, " ").trim();
+}
+function extractFirstMatchingFilter(query, filters) {
+  for (const filter of filters) {
+    for (const phrase of filter.phrases) {
+      const pattern = new RegExp(
+        `(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`,
+        "i"
+      );
+      if (!pattern.test(query)) continue;
+      return {
+        match: { value: filter.value, label: filter.label },
+        remainingQuery: stripSearchPhrase(query, phrase)
+      };
+    }
+  }
+  return { match: null, remainingQuery: query };
+}
+function mapHuggingFaceParameterBucket(query) {
+  const match = query.match(/\b(\d+(?:\.\d+)?)\s*(b|bn|billion|t|tn|trillion)\b/i);
+  if (!match) {
+    return { value: null, label: null, remainingQuery: query };
+  }
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { value: null, label: null, remainingQuery: query };
+  }
+  const unit = match[2].toLowerCase();
+  const billions = unit === "t" || unit === "tn" || unit === "trillion" ? amount * 1e3 : amount;
+  let value;
+  if (billions < 1) value = "n<1B";
+  else if (billions < 3) value = "1B<n<3B";
+  else if (billions < 6) value = "3B<n<6B";
+  else if (billions < 9) value = "6B<n<9B";
+  else if (billions < 12) value = "9B<n<12B";
+  else if (billions < 24) value = "12B<n<24B";
+  else if (billions < 32) value = "24B<n<32B";
+  else if (billions < 64) value = "32B<n<64B";
+  else if (billions < 128) value = "64B<n<128B";
+  else if (billions < 256) value = "128B<n<256B";
+  else if (billions < 500) value = "256B<n<500B";
+  else if (billions < 1e3) value = "500B<n<1T";
+  else value = "n>1T";
+  return {
+    value,
+    label: `${amount}${unit.startsWith("t") ? "T" : "B"} size bucket`,
+    remainingQuery: query.replace(match[0], " ")
+  };
+}
+function chooseHuggingFaceSection(url, query) {
+  const pathname = url.pathname.toLowerCase();
+  const normalized = query.toLowerCase();
+  const mentionsDatasets = /\b(dataset|datasets|corpus|benchmark|benchmarks)\b/.test(
+    normalized
+  );
+  const mentionsSpaces = /\b(space|spaces|app|apps|demo|demos|gradio|streamlit)\b/.test(
+    normalized
+  );
+  const mentionsModels = /\b(model|models|checkpoint|checkpoints|lora|loras|weights)\b/.test(
+    normalized
+  );
+  if (mentionsDatasets && !mentionsModels && !mentionsSpaces) return "datasets";
+  if (mentionsSpaces && !mentionsModels && !mentionsDatasets) return "spaces";
+  if (mentionsModels && !mentionsDatasets && !mentionsSpaces) return "models";
+  if (pathname.startsWith("/models")) return "models";
+  if (pathname.startsWith("/datasets")) return "datasets";
+  if (pathname.startsWith("/spaces")) return "spaces";
+  if (HUGGING_FACE_MODEL_TASKS.some(
+    (entry) => entry.phrases.some(
+      (phrase) => new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "i").test(
+        normalized
+      )
+    )
+  ) || HUGGING_FACE_MODEL_LIBRARIES.some(
+    (entry) => entry.phrases.some(
+      (phrase) => new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "i").test(
+        normalized
+      )
+    )
+  ) || /\b\d+(?:\.\d+)?\s*(b|bn|billion|t|tn|trillion)\b/i.test(normalized)) {
+    return "models";
+  }
+  return null;
+}
+function buildHuggingFaceSearchShortcut(currentUrl, rawQuery) {
+  let url;
+  try {
+    url = new URL(currentUrl);
+  } catch {
+    return null;
+  }
+  const hostname = url.hostname.toLowerCase();
+  if (!HUGGING_FACE_HUB_HOSTS.has(hostname)) {
+    return null;
+  }
+  const query = rawQuery.trim();
+  if (!query) return null;
+  const section = chooseHuggingFaceSection(url, query);
+  if (!section) return null;
+  let remainingQuery = query;
+  const target = new URL(`https://huggingface.co/${section}`);
+  const appliedFilters = [];
+  if (section === "models") {
+    const taskResult = extractFirstMatchingFilter(
+      remainingQuery,
+      HUGGING_FACE_MODEL_TASKS
+    );
+    remainingQuery = taskResult.remainingQuery;
+    if (taskResult.match) {
+      target.searchParams.append("pipeline_tag", taskResult.match.value);
+      appliedFilters.push(`task: ${taskResult.match.label}`);
+    }
+    const libraryResult = extractFirstMatchingFilter(
+      remainingQuery,
+      HUGGING_FACE_MODEL_LIBRARIES
+    );
+    remainingQuery = libraryResult.remainingQuery;
+    if (libraryResult.match) {
+      target.searchParams.append("library", libraryResult.match.value);
+      appliedFilters.push(`library: ${libraryResult.match.label}`);
+    }
+    const parameterResult = mapHuggingFaceParameterBucket(remainingQuery);
+    remainingQuery = parameterResult.remainingQuery;
+    if (parameterResult.value && parameterResult.label) {
+      target.searchParams.append("num_parameters", parameterResult.value);
+      appliedFilters.push(parameterResult.label);
+    }
+  }
+  remainingQuery = collapseSearchTerms(
+    remainingQuery.replace(/\bmodels?\b/gi, " ").replace(/\bdatasets?\b/gi, " ").replace(/\bspaces?\b/gi, " ").replace(/\bapps?\b/gi, " ")
+  );
+  if (remainingQuery) {
+    target.searchParams.set("search", remainingQuery);
+  }
+  if (!remainingQuery && appliedFilters.length === 0) {
+    return null;
+  }
+  if (section === "spaces" && remainingQuery) {
+    target.searchParams.set("includeNonRunning", "true");
+  }
+  return {
+    url: target.toString(),
+    source: "Hugging Face",
+    section,
+    appliedFilters
+  };
+}
+const COMMON_SEARCH_QUERY_PARAMS = [
+  "search",
+  "q",
+  "query",
+  "keyword",
+  "keywords",
+  "term",
+  "text"
+];
+const COMMON_PAGINATION_PARAMS = [
+  "p",
+  "page",
+  "offset",
+  "start",
+  "cursor",
+  "skip"
+];
+function looksLikeSearchResultsPath(pathname) {
+  return /\/(search|results|browse|discover|find)(\/|$)/i.test(pathname);
+}
+function buildCommonSearchUrlShortcut(currentUrl, rawQuery) {
+  let url;
+  try {
+    url = new URL(currentUrl);
+  } catch {
+    return null;
+  }
+  if (!/^https?:$/i.test(url.protocol)) {
+    return null;
+  }
+  const query = normalizeSearchQuery(rawQuery);
+  if (!query) return null;
+  const existingParam = COMMON_SEARCH_QUERY_PARAMS.find(
+    (param) => url.searchParams.has(param)
+  );
+  if (!existingParam && !looksLikeSearchResultsPath(url.pathname)) {
+    return null;
+  }
+  const target = new URL(url.toString());
+  const searchParam = existingParam ?? "q";
+  target.searchParams.set(searchParam, query);
+  for (const param of COMMON_PAGINATION_PARAMS) {
+    target.searchParams.delete(param);
+  }
+  if (target.toString() === url.toString()) {
+    return null;
+  }
+  return {
+    url: target.toString(),
+    source: "page URL",
+    appliedFilters: existingParam ? [`updated ${existingParam} query`] : []
+  };
+}
+function buildSearchShortcut(currentUrl, rawQuery) {
+  return buildHuggingFaceSearchShortcut(currentUrl, rawQuery) ?? buildCommonSearchUrlShortcut(currentUrl, rawQuery);
+}
 async function locateSearchTarget(wc, explicitSelector) {
   if (explicitSelector) {
     return { selector: explicitSelector, submitSelector: null };
@@ -11775,6 +12094,19 @@ async function searchPage(wc, args) {
   if (buttonLikePatterns.some((p) => queryLower.includes(p))) {
     return `Error: "${query}" looks like a button label, not a search query. Use the click tool to interact with this element instead.`;
   }
+  if (typeof args.selector !== "string") {
+    const shortcut = buildSearchShortcut(wc.getURL(), query);
+    if (shortcut) {
+      const beforeUrl2 = wc.getURL();
+      assertSafeURL(shortcut.url);
+      wc.loadURL(shortcut.url);
+      await waitForPotentialNavigation$1(wc, beforeUrl2, 4e3);
+      const afterUrl2 = wc.getURL();
+      const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
+      const destination = shortcut.section ? ` ${shortcut.section}` : "";
+      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}`;
+    }
+  }
   const searchInfo = await locateSearchTarget(
     wc,
     typeof args.selector === "string" ? args.selector : void 0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@quanta-intellect/vessel-browser",
   "mcpName": "io.github.unmodeled-tyler/vessel-browser",
-  "version": "0.1.31",
-  "description": "AI-native web browser for Linux — persistent browser runtime for autonomous agents with human supervision",
+  "version": "0.1.32",
+  "description": "AI-native web browser runtime for autonomous agents with human supervision",
   "main": "./out/main/index.js",
   "bin": {
     "vessel-browser": "./bin/vessel-browser.js"
@@ -18,8 +18,13 @@
   "scripts": {
     "dev": "ELECTRON_DISABLE_SANDBOX=1 electron-vite dev",
     "build": "electron-vite build",
+    "build:icon:mac": "scripts/build-macos-icon.sh",
     "dist": "npm run build && electron-builder --linux --publish never",
     "dist:dir": "npm run build && electron-builder --linux dir --publish never",
+    "dist:mac": "npm run build:icon:mac && npm run build && CSC_IDENTITY_AUTO_DISCOVERY=false electron-builder --mac dmg zip --publish never",
+    "dist:mac:dir": "npm run build:icon:mac && npm run build && CSC_IDENTITY_AUTO_DISCOVERY=false electron-builder --mac dir --publish never",
+    "dist:mac:signed": "npm run build:icon:mac && npm run build && electron-builder --mac dmg zip --publish never",
+    "dist:mac:dir:signed": "npm run build:icon:mac && npm run build && electron-builder --mac dir --publish never",
     "preview": "electron-vite preview",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",