mcp-scraper 0.88.2 → 0.89.0

package/dist/chunk-LFW2FRPJ.js

@@ -1,224 +0,0 @@
-import {
-  HttpMcpToolExecutor,
-  MEMORY_TOOL_REGISTRY,
-  SERVER_INSTRUCTIONS,
-  ScheduledResultsMcpExecutor,
-  hashOwnerId,
-  installInputFieldDescriptions,
-  permitsLocalNetworkAccess,
-  registerBrowserAgentMcpTools,
-  registerMemoryMcpTools,
-  registerPaaExtractorMcpTools,
-  registerScheduledResultsMcpTools,
-  registerSerpIntelligenceCaptureTools,
-  resolveDeploymentProfile
-} from "./chunk-PKZS6SHW.js";
-import {
-  renderInstallTerminal
-} from "./chunk-ABF2CGOZ.js";
-import {
-  PACKAGE_VERSION
-} from "./chunk-K45K75OF.js";
-
-// src/mcp/stdio-runtime.ts
-import { readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-import { serveStdio } from "@modelcontextprotocol/server/stdio";
-import { McpServer } from "@modelcontextprotocol/server";
-
-// src/mcp/hosted-memory-mcp-tool-executor.ts
-var publicToolNameByUpstreamName = new Map(
-  MEMORY_TOOL_REGISTRY.map((schema) => [schema.upstreamName, schema.id])
-);
-function parseJsonRpcEnvelope(text) {
-  const payloads = text.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter(Boolean);
-  if (!payloads.length) return JSON.parse(text);
-  for (const payload of payloads) {
-    const parsed = JSON.parse(payload);
-    if (parsed.result || parsed.error) return parsed;
-  }
-  throw new Error("hosted MCP returned no JSON-RPC result");
-}
-function errorResult(message) {
-  return {
-    content: [{ type: "text", text: JSON.stringify({ ok: false, error: message }) }],
-    isError: true
-  };
-}
-var HostedMemoryMcpToolExecutor = class {
-  baseUrl;
-  apiKey;
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl.replace(/\/$/, "");
-    this.apiKey = apiKey;
-  }
-  async callMemoryTool(upstreamName, args) {
-    const publicToolName = publicToolNameByUpstreamName.get(upstreamName);
-    if (!publicToolName) return errorResult(`unknown memory tool: ${upstreamName}`);
-    try {
-      const res = await fetch(`${this.baseUrl}/mcp`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          accept: "application/json, text/event-stream",
-          "x-api-key": this.apiKey
-        },
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: `memory:${publicToolName}`,
-          method: "tools/call",
-          params: { name: publicToolName, arguments: args }
-        })
-      });
-      const text = await res.text();
-      if (!res.ok) return errorResult(`hosted memory ${publicToolName} failed (HTTP ${res.status})`);
-      const envelope = parseJsonRpcEnvelope(text);
-      if (envelope.error) {
-        return errorResult(envelope.error.message ?? `hosted memory ${publicToolName} failed`);
-      }
-      return envelope.result ?? errorResult(`hosted memory ${publicToolName} returned no result`);
-    } catch (err) {
-      return errorResult(err instanceof Error ? err.message : `hosted memory ${publicToolName} call failed`);
-    }
-  }
-};
-
-// src/mcp/exact-tool-registration.ts
-function installExactToolRegistrationGuard(server, requiredToolNames) {
-  if (requiredToolNames.length === 0) {
-    throw new Error("Restricted MCP tool allowlist must contain at least one tool name");
-  }
-  const required = /* @__PURE__ */ new Set();
-  for (const rawName of requiredToolNames) {
-    if (typeof rawName !== "string" || rawName.trim() !== rawName || rawName.length === 0) {
-      throw new Error("Restricted MCP tool allowlist contains a malformed tool name");
-    }
-    if (required.has(rawName)) {
-      throw new Error(`Restricted MCP tool allowlist contains duplicate tool name: ${rawName}`);
-    }
-    required.add(rawName);
-  }
-  const registered = /* @__PURE__ */ new Set();
-  const mutableServer = server;
-  const registerTool = mutableServer.registerTool.bind(server);
-  mutableServer.registerTool = (name, config, callback) => {
-    if (!required.has(name)) return void 0;
-    registered.add(name);
-    return registerTool(name, config, callback);
-  };
-  return {
-    assertComplete() {
-      const missing = [...required].filter((name) => !registered.has(name));
-      if (missing.length > 0) {
-        throw new Error(`Restricted MCP tool allowlist contains unknown or unavailable tool names: ${missing.join(", ")}`);
-      }
-    },
-    registeredToolNames() {
-      return [...registered];
-    }
-  };
-}
-
-// src/mcp/stdio-runtime.ts
-var ALL_STDIO_TOOLSETS = /* @__PURE__ */ new Set([
-  "paa",
-  "serp",
-  "browser-agent",
-  "scheduled-results",
-  "memory"
-]);
-function readApiKeyFile() {
-  const explicitPath = process.env.MCP_SCRAPER_KEY_PATH?.trim();
-  const fileNames = [explicitPath, join(homedir(), ".mcp-scraper-key")].filter(Boolean);
-  for (const fileName of fileNames) {
-    try {
-      const value = readFileSync(fileName, "utf8").trim();
-      if (value) return value;
-    } catch {
-    }
-  }
-  return void 0;
-}
-function buildStdioServer(requiredApiKey, options = {}) {
-  const toolsets = options.toolsets ?? ALL_STDIO_TOOLSETS;
-  const baseUrl = process.env.MCP_SCRAPER_BASE_URL?.trim() || process.env.MCP_BASE_URL?.trim() || "https://mcpscraper.dev";
-  const deploymentProfile = resolveDeploymentProfile();
-  const localNetworkAccess = permitsLocalNetworkAccess({
-    deploymentProfile,
-    transportProfile: "stdio",
-    baseUrl,
-    explicitlyEnabled: process.env.MCP_SCRAPER_ALLOW_PRIVATE_NETWORK === "1"
-  });
-  const consoleBaseUrl = process.env.BROWSER_AGENT_CONSOLE_URL?.trim() || baseUrl;
-  const server = new McpServer({ name: "mcp-scraper", version: PACKAGE_VERSION }, {
-    instructions: SERVER_INSTRUCTIONS,
-    cacheHints: {
-      "server/discover": { ttlMs: 3e5, cacheScope: "private" },
-      "tools/list": { ttlMs: 3e5, cacheScope: "private" },
-      "prompts/list": { ttlMs: 3e5, cacheScope: "private" },
-      "resources/list": { ttlMs: 3e5, cacheScope: "private" },
-      "resources/templates/list": { ttlMs: 3e5, cacheScope: "private" },
-      "resources/read": { ttlMs: 6e4, cacheScope: "private" }
-    }
-  });
-  installInputFieldDescriptions(server);
-  const registrationGuard = options.allowedToolNames ? installExactToolRegistrationGuard(server, options.allowedToolNames) : void 0;
-  const httpExecutor = options.httpExecutor ?? new HttpMcpToolExecutor(baseUrl, requiredApiKey, { localNetworkAccess });
-  if (toolsets.has("paa")) {
-    registerPaaExtractorMcpTools(server, httpExecutor, {
-      ownerId: hashOwnerId(requiredApiKey),
-      deploymentProfile,
-      transportProfile: "stdio",
-      baseUrl,
-      localNetworkAccess,
-      taskHandleSecret: requiredApiKey
-    });
-  }
-  if (toolsets.has("serp")) {
-    registerSerpIntelligenceCaptureTools(server, httpExecutor, {
-      exposeDevelopmentDiagnostics: deploymentProfile === "development" || deploymentProfile === "test"
-    });
-  }
-  if (toolsets.has("browser-agent")) {
-    registerBrowserAgentMcpTools(server, { baseUrl, apiKey: requiredApiKey, consoleBaseUrl });
-  }
-  if (toolsets.has("scheduled-results")) {
-    registerScheduledResultsMcpTools(server, new ScheduledResultsMcpExecutor(baseUrl, requiredApiKey));
-  }
-  if (toolsets.has("memory")) {
-    registerMemoryMcpTools(server, new HostedMemoryMcpToolExecutor(baseUrl, requiredApiKey));
-  }
-  registrationGuard?.assertComplete();
-  return server;
-}
-function runMcpScraperStdio(options = {}) {
-  const forceStdio = process.argv.includes("--stdio") || process.env.MCP_SCRAPER_FORCE_STDIO === "1";
-  const interactiveTerminal = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-  const wantsHelp = process.argv.includes("--help") || process.argv.includes("-h");
-  if (!forceStdio && (interactiveTerminal || wantsHelp)) {
-    const noColor = process.argv.includes("--no-color") || process.env.NO_COLOR !== void 0 || process.env.FORCE_COLOR === "0" || !process.stdout.isTTY;
-    process.stdout.write(renderInstallTerminal({
-      version: PACKAGE_VERSION,
-      color: !noColor,
-      apiKeyConfigured: Boolean(process.env.MCP_SCRAPER_API_KEY?.trim())
-    }));
-    process.exit(0);
-  }
-  const apiKey = (process.env.MCP_SCRAPER_API_KEY ?? process.env.MCP_SCRAPER_KEY ?? process.env.MCP_API_KEY ?? readApiKeyFile())?.trim();
-  if (!apiKey) {
-    process.stderr.write("MCP_SCRAPER_API_KEY env var or ~/.mcp-scraper-key is required\n");
-    process.exit(1);
-  }
-  serveStdio(() => buildStdioServer(apiKey, options), {
-    legacy: "serve",
-    onerror(error) {
-      process.stderr.write(`${error.message}
-`);
-    }
-  });
-}
-
-export {
-  runMcpScraperStdio
-};