@quanta-intellect/vessel-browser 0.1.16 → 0.1.18

package/out/main/index.js

@@ -26,7 +26,15 @@ const defaults = {
   chatProvider: null,
   maxToolIterations: 200,
   domainPolicy: { allowedDomains: [], blockedDomains: [] },
-  downloadPath: ""
+  downloadPath: "",
+  telemetryEnabled: true,
+  premium: {
+    status: "free",
+    customerId: "",
+    email: "",
+    validatedAt: "",
+    expiresAt: ""
+  }
 };
 const SETTABLE_KEYS = new Set(Object.keys(defaults));
 let settings = null;
@@ -80,12 +88,9 @@ function loadSettings() {
   return settings;
 }
 function saveSettings() {
-  try {
-    fs.mkdirSync(path.dirname(getSettingsPath()), { recursive: true });
-    fs.writeFileSync(getSettingsPath(), JSON.stringify(settings, null, 2));
-  } catch (err) {
-    console.error("[Vessel] Failed to save settings:", err);
-  }
+  fs.promises.mkdir(path.dirname(getSettingsPath()), { recursive: true }).then(
+    () => fs.promises.writeFile(getSettingsPath(), JSON.stringify(settings, null, 2))
+  ).catch((err) => console.error("[Vessel] Failed to save settings:", err));
 }
 function setSetting(key, value) {
   loadSettings();
@@ -528,11 +533,7 @@ function load$2() {
   return state$3;
 }
 function save$2() {
-  try {
-    fs.writeFileSync(getHighlightsPath(), JSON.stringify(state$3, null, 2), "utf-8");
-  } catch (err) {
-    console.error("[Vessel] Failed to save highlights:", err);
-  }
+  fs.promises.writeFile(getHighlightsPath(), JSON.stringify(state$3, null, 2), "utf-8").catch((err) => console.error("[Vessel] Failed to save highlights:", err));
 }
 function emit$2() {
   if (!state$3) return;
@@ -1202,16 +1203,13 @@ function load$1() {
   return state$2;
 }
 function save$1() {
-  try {
-    fs.mkdirSync(path.dirname(getHistoryPath()), { recursive: true });
-    fs.writeFileSync(
+  fs.promises.mkdir(path.dirname(getHistoryPath()), { recursive: true }).then(
+    () => fs.promises.writeFile(
       getHistoryPath(),
       JSON.stringify(state$2, null, 2),
       "utf-8"
-    );
-  } catch (err) {
-    console.error("[Vessel] Failed to save history:", err);
-  }
+    )
+  ).catch((err) => console.error("[Vessel] Failed to save history:", err));
 }
 function emit$1() {
   if (!state$2) return;
@@ -2344,6 +2342,13 @@ const Channels = {
   DOWNLOAD_STARTED: "download:started",
   DOWNLOAD_PROGRESS: "download:progress",
   DOWNLOAD_DONE: "download:done",
+  // Premium
+  PREMIUM_GET_STATE: "premium:get-state",
+  PREMIUM_ACTIVATE: "premium:activate",
+  PREMIUM_CHECKOUT: "premium:checkout",
+  PREMIUM_PORTAL: "premium:portal",
+  PREMIUM_RESET: "premium:reset",
+  PREMIUM_UPDATE: "premium:update",
   // Window controls
   WINDOW_MINIMIZE: "window:minimize",
   WINDOW_MAXIMIZE: "window:maximize",
@@ -4406,6 +4411,288 @@ function setMcpHealth(update) {
     }
   }
 }
+const VERIFICATION_API = process.env.VESSEL_PREMIUM_API || "https://vesselpremium.quantaintellect.com";
+const FREE_TOOL_ITERATION_LIMIT = 50;
+const REVALIDATION_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+const OFFLINE_GRACE_PERIOD_MS = 7 * 24 * 60 * 60 * 1e3;
+const PREMIUM_TOOLS = /* @__PURE__ */ new Set([
+  "screenshot",
+  "save_session",
+  "load_session",
+  "list_sessions",
+  "delete_session",
+  "flow_start",
+  "flow_advance",
+  "flow_status",
+  "flow_end",
+  "metrics",
+  "extract_table"
+]);
+function isPremium() {
+  const { premium } = loadSettings();
+  if (premium.status === "active" || premium.status === "trialing") {
+    return true;
+  }
+  if (premium.validatedAt && premium.status !== "free") {
+    const lastValidated = new Date(premium.validatedAt).getTime();
+    if (Date.now() - lastValidated < OFFLINE_GRACE_PERIOD_MS) {
+      return true;
+    }
+  }
+  return false;
+}
+function getPremiumState() {
+  return { ...loadSettings().premium };
+}
+function getEffectiveMaxIterations() {
+  if (isPremium()) {
+    return loadSettings().maxToolIterations || 200;
+  }
+  return FREE_TOOL_ITERATION_LIMIT;
+}
+function resetPremium() {
+  const fresh = {
+    status: "free",
+    customerId: "",
+    email: "",
+    validatedAt: "",
+    expiresAt: ""
+  };
+  setSetting("premium", fresh);
+  return fresh;
+}
+function isToolGated(toolName) {
+  return PREMIUM_TOOLS.has(toolName) && !isPremium();
+}
+async function getCheckoutUrl(email) {
+  try {
+    const params = new URLSearchParams();
+    if (email) params.set("email", email);
+    const res = await fetch(`${VERIFICATION_API}/checkout?${params}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      return { ok: false, error: body || `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 create checkout"
+    };
+  }
+}
+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"
+    };
+  }
+}
+async function verifySubscription(emailOrCustomerId) {
+  const current = loadSettings().premium;
+  const identifier = emailOrCustomerId || current.customerId || current.email;
+  if (!identifier) {
+    return current;
+  }
+  try {
+    const res = await fetch(`${VERIFICATION_API}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ identifier })
+    });
+    if (!res.ok) {
+      console.warn("[Vessel Premium] Verification API returned", res.status);
+      return current;
+    }
+    const data = await res.json();
+    const updated = {
+      status: data.status,
+      customerId: data.customerId,
+      email: data.email,
+      validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: data.expiresAt
+    };
+    setSetting("premium", updated);
+    return updated;
+  } catch (err) {
+    console.warn("[Vessel Premium] Verification failed:", err);
+    return current;
+  }
+}
+async function activateWithEmail(email) {
+  if (!email.trim()) {
+    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 };
+  }
+  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 lastValidated = premium.validatedAt ? new Date(premium.validatedAt).getTime() : 0;
+    if (Date.now() - lastValidated > REVALIDATION_INTERVAL_MS) {
+      void verifySubscription();
+    }
+  }
+  revalidationTimer = setInterval(() => {
+    const { premium: p } = loadSettings();
+    if (p.customerId || p.email) {
+      void verifySubscription();
+    }
+  }, REVALIDATION_INTERVAL_MS);
+}
+function stopBackgroundRevalidation() {
+  if (revalidationTimer) {
+    clearInterval(revalidationTimer);
+    revalidationTimer = null;
+  }
+}
+const POSTHOG_API_KEY = process.env.POSTHOG_API_KEY || "phc_OMeM3P5cxJwl14lOKxYad0Yre52xvjNfkLEFnPtXyM";
+const POSTHOG_HOST = process.env.POSTHOG_HOST || "https://us.i.posthog.com";
+const BATCH_INTERVAL_MS = 6e4;
+const MAX_BATCH_SIZE = 50;
+function getDeviceIdPath() {
+  return path.join(electron.app.getPath("userData"), ".vessel-device-id");
+}
+let deviceId = null;
+function getDeviceId() {
+  if (deviceId) return deviceId;
+  const idPath = getDeviceIdPath();
+  try {
+    deviceId = fs.readFileSync(idPath, "utf-8").trim();
+    if (deviceId) return deviceId;
+  } catch {
+  }
+  deviceId = crypto.randomUUID();
+  try {
+    fs.mkdirSync(path.dirname(idPath), { recursive: true });
+    fs.writeFileSync(idPath, deviceId, "utf-8");
+  } catch {
+  }
+  return deviceId;
+}
+let eventQueue = [];
+let flushTimer = null;
+let sessionStartedAt = null;
+function isEnabled() {
+  if (POSTHOG_API_KEY === "YOUR_POSTHOG_KEY_HERE") return false;
+  return loadSettings().telemetryEnabled !== false;
+}
+function trackEvent(event, properties = {}) {
+  if (!isEnabled()) return;
+  eventQueue.push({
+    event,
+    properties: {
+      ...properties,
+      premium_status: isPremium() ? "premium" : "free",
+      app_version: electron.app.getVersion(),
+      platform: process.platform,
+      arch: process.arch
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  if (eventQueue.length >= MAX_BATCH_SIZE) {
+    void flush();
+  }
+}
+function trackToolCall(toolName, pageType) {
+  trackEvent("tool_called", {
+    tool_name: toolName,
+    page_type: "unknown"
+  });
+}
+function trackProviderConfigured(providerId) {
+  trackEvent("provider_configured", {
+    provider_id: providerId
+  });
+}
+function startTelemetry() {
+  if (!isEnabled()) return;
+  sessionStartedAt = Date.now();
+  trackEvent("app_launched", {
+    electron_version: process.versions.electron,
+    chrome_version: process.versions.chrome
+  });
+  flushTimer = setInterval(() => {
+    void flush();
+  }, BATCH_INTERVAL_MS);
+}
+function stopTelemetry() {
+  if (sessionStartedAt) {
+    const durationMinutes = Math.round(
+      (Date.now() - sessionStartedAt) / 6e4
+    );
+    trackEvent("app_session_ended", {
+      duration_minutes: durationMinutes
+    });
+    sessionStartedAt = null;
+  }
+  if (flushTimer) {
+    clearInterval(flushTimer);
+    flushTimer = null;
+  }
+  void flush();
+}
+async function flush() {
+  if (eventQueue.length === 0) return;
+  if (!isEnabled()) {
+    eventQueue = [];
+    return;
+  }
+  const batch = eventQueue.splice(0);
+  const distinctId = getDeviceId();
+  const payload = {
+    api_key: POSTHOG_API_KEY,
+    batch: batch.map((e) => ({
+      event: e.event,
+      properties: {
+        distinct_id: distinctId,
+        ...e.properties
+      },
+      timestamp: e.timestamp
+    }))
+  };
+  try {
+    await fetch(`${POSTHOG_HOST}/batch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  } catch {
+    if (eventQueue.length < MAX_BATCH_SIZE * 2) {
+      eventQueue.unshift(...batch);
+    }
+  }
+}
 function isRichToolResult(value) {
   return typeof value === "object" && value !== null && value.__richResult === true;
 }
@@ -4419,7 +4706,6 @@ function makeImageResult(base64, description, mediaType = "image/png") {
   };
   return JSON.stringify(result);
 }
-const DEFAULT_MAX_ITERATIONS$1 = 200;
 class AnthropicProvider {
   client;
   model;
@@ -4467,7 +4753,7 @@ class AnthropicProvider {
       { role: "user", content: userMessage }
     ];
     try {
-      const maxIterations = loadSettings().maxToolIterations || DEFAULT_MAX_ITERATIONS$1;
+      const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
@@ -4708,7 +4994,6 @@ const PROVIDERS = {
     apiKeyHint: "Any OpenAI-compatible API endpoint"
   }
 };
-const DEFAULT_MAX_ITERATIONS = 200;
 function toOpenAITools(tools) {
   return tools.map((t) => ({
     type: "function",
@@ -4774,7 +5059,7 @@ class OpenAICompatProvider {
       { role: "user", content: userMessage }
     ];
     try {
-      const maxIterations = loadSettings().maxToolIterations || DEFAULT_MAX_ITERATIONS;
+      const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
@@ -7285,7 +7570,7 @@ function pruneToolsForContext(tools, pageType, query = "") {
   const ctx = pageType ?? "GENERAL";
   const hints = CONTEXT_HINTS[ctx] ?? {};
   const intents = inferIntent(query);
-  const scored = tools.filter((tool) => shouldIncludeTool(tool.name, ctx, intents)).map((tool) => ({
+  const scored = tools.filter((tool) => !isToolGated(tool.name)).filter((tool) => shouldIncludeTool(tool.name, ctx, intents)).map((tool) => ({
     tool,
     score: scoreForContext(tool.name, ctx)
   }));
@@ -7460,12 +7745,13 @@ function load() {
   return state;
 }
 function save() {
-  try {
-    fs.mkdirSync(path.dirname(getBookmarksPath()), { recursive: true });
-    fs.writeFileSync(getBookmarksPath(), JSON.stringify(state, null, 2), "utf-8");
-  } catch (err) {
-    console.error("[Vessel] Failed to save bookmarks:", err);
-  }
+  fs.promises.mkdir(path.dirname(getBookmarksPath()), { recursive: true }).then(
+    () => fs.promises.writeFile(
+      getBookmarksPath(),
+      JSON.stringify(state, null, 2),
+      "utf-8"
+    )
+  ).catch((err) => console.error("[Vessel] Failed to save bookmarks:", err));
 }
 function emit() {
   if (!state) return;
@@ -10782,6 +11068,10 @@ async function executeAction(name, args, ctx) {
   ].includes(name)) {
     return "Error: No active tab";
   }
+  trackToolCall(name);
+  if (isToolGated(name)) {
+    return `This tool (${name}) requires Vessel Premium. Upgrade at Settings > Premium to unlock screenshot, session management, workflow tracking, and more.`;
+  }
   const wc = tab?.view.webContents;
   const result = await ctx.runtime.runControlledAction({
     source: "ai",
@@ -17236,15 +17526,18 @@ function startMcpServer(tabManager, runtime2, port) {
         res.end("Not found");
         return;
       }
-      res.setHeader("Access-Control-Allow-Origin", "null");
-      res.setHeader(
-        "Access-Control-Allow-Methods",
-        "POST, GET, DELETE, OPTIONS"
-      );
-      res.setHeader(
-        "Access-Control-Allow-Headers",
-        "Content-Type, mcp-session-id, Authorization"
-      );
+      const origin = req.headers.origin;
+      if (origin && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader(
+          "Access-Control-Allow-Methods",
+          "POST, GET, DELETE, OPTIONS"
+        );
+        res.setHeader(
+          "Access-Control-Allow-Headers",
+          "Content-Type, mcp-session-id, Authorization"
+        );
+      }
       if (req.method === "OPTIONS") {
         res.writeHead(204);
         res.end();
@@ -17404,6 +17697,7 @@ function registerIpcHandlers(windowState, runtime2) {
     }
     try {
       activeChatProvider = createProvider(chatConfig);
+      trackProviderConfigured(chatConfig.id);
       const activeTab = tabManager.getActiveTab();
       await handleAIQuery(
         query,
@@ -17704,6 +17998,35 @@ function registerIpcHandlers(windowState, runtime2) {
     layoutViews(windowState);
     return clamped;
   });
+  electron.ipcMain.handle(Channels.PREMIUM_GET_STATE, () => {
+    return getPremiumState();
+  });
+  electron.ipcMain.handle(Channels.PREMIUM_ACTIVATE, async (_, email) => {
+    const result = await activateWithEmail(email);
+    if (result.ok) {
+      sendToRendererViews(Channels.PREMIUM_UPDATE, result.state);
+    }
+    return result;
+  });
+  electron.ipcMain.handle(Channels.PREMIUM_CHECKOUT, async (_, email) => {
+    const result = await getCheckoutUrl(email);
+    if (result.ok && result.url) {
+      tabManager.createTab(result.url);
+    }
+    return result;
+  });
+  electron.ipcMain.handle(Channels.PREMIUM_RESET, () => {
+    const state2 = resetPremium();
+    sendToRendererViews(Channels.PREMIUM_UPDATE, state2);
+    return state2;
+  });
+  electron.ipcMain.handle(Channels.PREMIUM_PORTAL, async () => {
+    const result = await getPortalUrl();
+    if (result.ok && result.url) {
+      tabManager.createTab(result.url);
+    }
+    return result;
+  });
   electron.ipcMain.handle(Channels.WINDOW_MINIMIZE, () => {
     mainWindow.minimize();
   });
@@ -18076,16 +18399,15 @@ ${progress}
       actions: this.state.actions.slice(-120),
       checkpoints: this.state.checkpoints.slice(-20)
     };
-    try {
-      fs$1.mkdirSync(path$1.dirname(getRuntimeStatePath()), { recursive: true });
-      fs$1.writeFileSync(
+    return fs$1.promises.mkdir(path$1.dirname(getRuntimeStatePath()), { recursive: true }).then(
+      () => fs$1.promises.writeFile(
         getRuntimeStatePath(),
         JSON.stringify(persisted, null, 2),
         "utf-8"
-      );
-    } catch (err) {
-      console.error("[Vessel] Failed to persist runtime state:", err);
-    }
+      )
+    ).catch(
+      (err) => console.error("[Vessel] Failed to persist runtime state:", err)
+    );
   }
   schedulePersist() {
     this.persistDirty = true;
@@ -18097,7 +18419,7 @@ ${progress}
   }
   /** Flush any pending debounced persist to disk immediately. Call on shutdown. */
   flushPersist() {
-    if (this.persistDirty) this.persistNow();
+    return this.persistDirty ? this.persistNow() : Promise.resolve();
   }
   emit() {
     this.schedulePersist();
@@ -18473,6 +18795,8 @@ async function bootstrap() {
     sidebarView.webContents.send(Channels.HISTORY_UPDATE, state2);
   });
   installDownloadHandler(chromeView);
+  startBackgroundRevalidation();
+  startTelemetry();
   const chromeUrl = rendererUrlFor("chrome");
   const sidebarUrl = rendererUrlFor("sidebar");
   const devtoolsUrl = rendererUrlFor("devtools");
@@ -18512,6 +18836,8 @@ electron.app.whenReady().then(bootstrap).catch((error) => {
 });
 electron.app.on("window-all-closed", () => {
   electron.globalShortcut.unregisterAll();
+  stopTelemetry();
+  stopBackgroundRevalidation();
   runtime?.flushPersist();
   void stopMcpServer().finally(() => {
     electron.app.quit();

package/out/preload/index.js

@@ -74,6 +74,13 @@ const Channels = {
   HISTORY_SEARCH: "history:search",
   HISTORY_CLEAR: "history:clear",
   HISTORY_UPDATE: "history:update",
+  // Premium
+  PREMIUM_GET_STATE: "premium:get-state",
+  PREMIUM_ACTIVATE: "premium:activate",
+  PREMIUM_CHECKOUT: "premium:checkout",
+  PREMIUM_PORTAL: "premium:portal",
+  PREMIUM_RESET: "premium:reset",
+  PREMIUM_UPDATE: "premium:update",
   // Window controls
   WINDOW_MINIMIZE: "window:minimize",
   WINDOW_MAXIMIZE: "window:maximize",
@@ -223,6 +230,18 @@ const api = {
       return () => electron.ipcRenderer.removeListener(Channels.HISTORY_UPDATE, handler);
     }
   },
+  premium: {
+    getState: () => electron.ipcRenderer.invoke(Channels.PREMIUM_GET_STATE),
+    activate: (email) => electron.ipcRenderer.invoke(Channels.PREMIUM_ACTIVATE, email),
+    checkout: (email) => electron.ipcRenderer.invoke(Channels.PREMIUM_CHECKOUT, email),
+    portal: () => electron.ipcRenderer.invoke(Channels.PREMIUM_PORTAL),
+    reset: () => electron.ipcRenderer.invoke(Channels.PREMIUM_RESET),
+    onUpdate: (cb) => {
+      const handler = (_, state) => cb(state);
+      electron.ipcRenderer.on(Channels.PREMIUM_UPDATE, handler);
+      return () => electron.ipcRenderer.removeListener(Channels.PREMIUM_UPDATE, handler);
+    }
+  },
   window: {
     minimize: () => electron.ipcRenderer.invoke(Channels.WINDOW_MINIMIZE),
     maximize: () => electron.ipcRenderer.invoke(Channels.WINDOW_MAXIMIZE),