scrapeless-mcp-server 0.4.4 → 0.4.6

package/README.md

@@ -98,6 +98,17 @@ Scrapeless MCP Server supports both **Stdio** and **Streamable HTTP** transport
 }
 ```
 
+#### Advanced Options
+
+Customize browser session behavior with optional parameters. These can be set via environment variables (for Stdio) or HTTP headers (for Streamable HTTP):
+
+| Stdio (Env Var)         | Streamable HTTP (HTTP Header) | Description                                                  |
+| ----------------------- | ----------------------------- | ------------------------------------------------------------ |
+| BROWSER_PROFILE_ID      | x-browser-profile-id          | Specifies a reusable browser profile ID for session continuity. |
+| BROWSER_PROFILE_PERSIST | x-browser-profile-persist     | Enables persistent storage for cookies, local storage, etc.  |
+| BROWSER_SESSION_TTL     | x-browser-session-ttl         | Defines the **maximum session timeout** in seconds. The session will automatically expire after this duration of inactivity. |
+
+
 ## Integration with Claude Desktop
 
 1. Open **Claude Desktop**

package/build/cf.js

@@ -5,7 +5,7 @@ import { API_KEY_NAME } from "./config.js";
 export class CfMcpServer extends McpAgent {
     server = new McpServer(serverOptions);
     async init() {
-        initMcpTools(this.server, this.props.apiKey);
+        initMcpTools(this.server, this.props.headers, this.props.apiKey);
     }
 }
 export default {
@@ -15,7 +15,7 @@ export default {
         if (!apiKeyHeader) {
             return new Response(`Unauthorized: Missing ${API_KEY_NAME} header`, { status: 401 });
         }
-        ctx.props = { apiKey: apiKeyHeader };
+        ctx.props = { apiKey: apiKeyHeader, headers: request.headers };
         if (url.pathname === "/sse" || url.pathname === "/sse/message") {
             return CfMcpServer.serveSSE("/sse").fetch(request, env, ctx);
         }

package/build/context-manager.js

@@ -0,0 +1,40 @@
+import { Context } from "./context.js";
+import { API_KEY } from "./config.js";
+export class ContextManager {
+    static instance;
+    contexts;
+    constructor() {
+        this.contexts = new Map();
+    }
+    static getInstance() {
+        if (!ContextManager.instance) {
+            ContextManager.instance = new ContextManager();
+        }
+        return ContextManager.instance;
+    }
+    getContext(apiKey) {
+        const key = apiKey ?? API_KEY;
+        if (!this.contexts.has(key)) {
+            console.log(`Creating new Context for API key: ${key?.substring(0, 8)}...`);
+            this.contexts.set(key, new Context(key));
+        }
+        else {
+            console.log(`Reusing existing Context for API key: ${key?.substring(0, 8)}...`);
+        }
+        return this.contexts.get(key);
+    }
+    clearContext(apiKey) {
+        const key = apiKey ?? API_KEY;
+        if (this.contexts.has(key)) {
+            this.contexts.delete(key);
+            console.log(`Cleared Context for API key: ${key?.substring(0, 8)}...`);
+        }
+    }
+    clearAllContexts() {
+        this.contexts.clear();
+        console.log("Cleared all Contexts");
+    }
+    getContextCount() {
+        return this.contexts.size;
+    }
+}

package/build/context.js

@@ -5,13 +5,13 @@ export class Context {
     currentSessionId = "default-session-id";
     apiKey;
     constructor(apiKey) {
-        this.sessionManager = new SessionManager();
+        this.sessionManager = SessionManager.getInstance();
         this.apiKey = apiKey;
     }
     getSession(id) {
         return this.sessionManager.getSession(`${id ?? this.currentSessionId}-${this.apiKey}`);
     }
-    async run(tool, params) {
+    async run(tool, params, headers) {
         if (!this.apiKey) {
             return {
                 content: [
@@ -29,7 +29,7 @@ export class Context {
         if (toolName === "browser_create") {
             const newSessionId = uuid();
             try {
-                await this.sessionManager.createSession(`${newSessionId}-${this.apiKey}`, this.apiKey);
+                await this.sessionManager.createSession(`${newSessionId}-${this.apiKey}`, this.apiKey, headers);
                 return {
                     content: [
                         {

package/build/server.js

@@ -1,20 +1,20 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ScrapelessClient } from "@scrapeless-ai/sdk";
 import { SCRAPELESS_CONFIG, API_KEY } from "./config.js";
-import * as toolsList from './tools/index.js';
-import * as browserTools from './tools/browser/browser.js';
-import { Context } from './context.js';
+import * as toolsList from "./tools/index.js";
+import * as browserTools from "./tools/browser/browser.js";
+import { ContextManager } from "./context-manager.js";
 export const serverOptions = {
     name: "scrapeless-mcp-server",
     version: "0.2.0",
     capabilities: { resources: {}, tools: {} },
 };
-export const createMcpServer = (apiKey) => {
+export const createMcpServer = (options) => {
     const server = new McpServer(serverOptions);
-    initMcpTools(server, apiKey);
+    initMcpTools(server, options?.headers, options?.apiKey);
     return server.server;
 };
-export const initMcpTools = (server, apiKey) => {
+export const initMcpTools = (server, headers, apiKey) => {
     const getScrapelessClient = () => {
         if (apiKey) {
             return new ScrapelessClient({
@@ -29,10 +29,10 @@ export const initMcpTools = (server, apiKey) => {
     Object.values(toolsList).forEach((tool) => {
         server.tool(tool.name, tool.description, tool.inputSchema, (params) => tool.handle(params, getScrapelessClient()));
     });
-    const context = new Context(apiKey ?? API_KEY);
+    const context = ContextManager.getInstance().getContext(apiKey ?? API_KEY);
     Object.values(browserTools).forEach((tool) => {
         server.tool(tool.name, tool.description, tool.inputSchema, async (params) => {
-            const result = await context.run(tool, params);
+            const result = await context.run(tool, params, headers);
             return result;
         });
     });
@@ -55,6 +55,6 @@ export class ServerList {
         await server.close();
     }
     async closeAll() {
-        await Promise.all(this._servers.map(server => server.close()));
+        await Promise.all(this._servers.map((server) => server.close()));
     }
 }

package/build/session-manager.js

@@ -1,17 +1,37 @@
 import { Scrapeless } from "@scrapeless-ai/sdk";
+import { getParamValue } from "@chatmcp/sdk/utils/index.js";
 import puppeteer from "puppeteer-core";
 export class SessionManager {
+    static instance;
     sessions;
     constructor() {
         this.sessions = new Map();
     }
-    async createSession(id, apiKey) {
+    static getInstance() {
+        if (!SessionManager.instance) {
+            SessionManager.instance = new SessionManager();
+        }
+        return SessionManager.instance;
+    }
+    async createSession(id, apiKey, headers) {
         if (!this.sessions.has(id)) {
             this.sessions.set(id, { browser: null, page: null, closed: true });
         }
         const scrapelessClient = new Scrapeless({ apiKey });
         const session = this.sessions.get(id);
-        const { browserWSEndpoint } = scrapelessClient.browser.create();
+        const { browserWSEndpoint } = scrapelessClient.browser.create({
+            session_ttl: Number(process.env.BROWSER_SESSION_TTL ||
+                getParamValue("BROWSER_SESSION_TTL") ||
+                headers?.["x-browser-session-ttl"] ||
+                30000),
+            profile_id: process.env.BROWSER_PROFILE_ID ||
+                getParamValue("BROWSER_PROFILE_ID") ||
+                headers?.["x-browser-profile-id"] ||
+                "",
+            profile_persist: Boolean(process.env.BROWSER_PROFILE_PERSIST ||
+                getParamValue("BROWSER_PROFILE_PERSIST") ||
+                headers?.["x-browser-profile-persist"]),
+        });
         const browser = await puppeteer.connect({
             browserWSEndpoint,
             defaultViewport: null,
@@ -22,6 +42,7 @@ export class SessionManager {
             session.closed = true;
             session.browser = null;
             session.page = null;
+            this.sessions.delete(id);
         });
         session.browser = browser;
         session.page = page;

package/build/transport.js

@@ -115,6 +115,6 @@ function createRemoteServerList(req, res) {
         res.end("Unauthorized: Missing x-api-token header");
         return null;
     }
-    const serverList = new ServerList(async () => createMcpServer(apiKey));
+    const serverList = new ServerList(async () => createMcpServer({ headers: req.headers, apiKey }));
     return serverList;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scrapeless-mcp-server",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -31,7 +31,7 @@
   "dependencies": {
     "@chatmcp/sdk": "^1.0.5",
     "@modelcontextprotocol/sdk": "^1.8.0",
-    "@scrapeless-ai/sdk": "^1.6.1",
+    "@scrapeless-ai/sdk": "^1.8.0",
     "agents": "^0.0.101",
     "axios": "^1.8.4",
     "express": "^5.1.0",