mcp-scraper 0.75.1 → 0.77.0

package/dist/{chunk-45AZ5CR2.js → chunk-GT6MP4SU.js}

@@ -1,6 +1,6 @@
 // release-message.json
 var release_message_default = {
-  message: "X-Ray now provides a production customer loop for consent-aware identity, journeys, event verification, attribution, CRM and call evidence, governed data movement, activation receipts, and durable automation."
+  message: "X-Ray Pixels can now render a published consent gateway on approved sites, and the visual event picker clearly confirms selected targets and editable drafts."
 };
 
 // src/install-terminal.ts

package/dist/chunk-IP7UDXMU.js

@@ -0,0 +1,223 @@
+import {
+  HttpMcpToolExecutor,
+  MEMORY_TOOL_REGISTRY,
+  SERVER_INSTRUCTIONS,
+  ScheduledResultsMcpExecutor,
+  hashOwnerId,
+  installInputFieldDescriptions,
+  permitsLocalNetworkAccess,
+  registerBrowserAgentMcpTools,
+  registerMemoryMcpTools,
+  registerPaaExtractorMcpTools,
+  registerScheduledResultsMcpTools,
+  registerSerpIntelligenceCaptureTools,
+  resolveDeploymentProfile
+} from "./chunk-DTJ56S5B.js";
+import {
+  renderInstallTerminal
+} from "./chunk-GT6MP4SU.js";
+import {
+  PACKAGE_VERSION
+} from "./chunk-7HF3T7P2.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" },
+      "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
+};

package/dist/{gmail-service-E52EE4GX.js → gmail-service-TIU4V5JA.js}

@@ -7,11 +7,11 @@ import {
   GmailServiceError,
   normalizeGmailMessage,
   parseGmailAddresses
-} from "./chunk-GLVWJCNU.js";
+} from "./chunk-E6Y3VCOJ.js";
 import "./chunk-PJEEKOUM.js";
 import "./chunk-T3MZISOF.js";
-import "./chunk-CXY5WV45.js";
 import "./chunk-6W4ADSWE.js";
+import "./chunk-CXY5WV45.js";
 import "./chunk-WEFPBAAG.js";
 export {
   GMAIL_ATTACHMENT_REF_TTL_MS,