@meltingpixels/harvey-tools 1.0.0

package/.env.example

@@ -0,0 +1,10 @@
+# Grok API (xAI)
+XAI_API_KEY=
+
+# x402 Payment
+PAYMENT_WALLET=2MB8Gk4PebwhP6yaiiMjofHYoQvvQ8iWo3hdkUHQ1Wdq
+X402_FACILITATOR=https://facilitator.payai.network
+
+# Server
+PORT=8403
+NODE_ENV=production

package/ecosystem.config.cjs

@@ -0,0 +1,17 @@
+module.exports = {
+  apps: [
+    {
+      name: "harvey-tools",
+      script: "dist/index.js",
+      cwd: "/home/deploy/projects/harvey-tools",
+      node_args: "--enable-source-maps",
+      env: {
+        NODE_ENV: "production",
+        PORT: 8403,
+      },
+      max_memory_restart: "512M",
+      autorestart: true,
+      watch: false,
+    },
+  ],
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@meltingpixels/harvey-tools",
+  "version": "1.0.0",
+  "description": "x402-paid MCP server for web scraping, code review, content generation, and analysis. Pay-per-call USDC on Solana.",
+  "type": "module",
+  "mcpName": "io.github.meltingpixelsai/harvey-tools",
+  "keywords": ["mcp", "x402", "usdc", "ai-agents", "web-scraping", "code-review", "content-generation", "sentiment-analysis"],
+  "author": "MeltingPixels <jeremy@meltingpixels.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/meltingpixelsai/harvey-tools"
+  },
+  "homepage": "https://tools.rugslayer.com",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.5",
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "dotenv": "^16.4.7",
+    "hono": "^4.9.6",
+    "mcp-handler": "^1.0.2",
+    "mcpay": "^0.1.17",
+    "playwright": "^1.50.0",
+    "x402": "^0.6.5",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  }
+}

package/server.json

@@ -0,0 +1,30 @@
+{
+  "name": "io.github.meltingpixelsai/harvey-tools",
+  "description": "Web scraping, code review, content generation, and analysis tools for AI agents. Pay-per-call USDC.",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@meltingpixels/harvey-tools",
+      "transport": {
+        "type": "streamable-http",
+        "url": "https://tools.rugslayer.com/mcp"
+      }
+    }
+  ],
+  "_meta": {
+    "x402": {
+      "network": "solana",
+      "currency": "USDC",
+      "facilitator": "https://facilitator.payai.network",
+      "tools": {
+        "scrape_url": "$0.005",
+        "screenshot_url": "$0.005",
+        "extract_structured_data": "$0.02",
+        "review_code": "$0.03",
+        "generate_content": "$0.05",
+        "analyze_sentiment": "$0.01"
+      },
+      "free_tools": ["list_tools", "health"]
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,34 @@
+export const config = {
+  port: parseInt(process.env.PORT || "8403", 10),
+
+  // Grok API (xAI)
+  grok: {
+    apiKey: process.env.XAI_API_KEY || "",
+    model: "grok-4-1-fast",
+    apiUrl: "https://api.x.ai/v1/chat/completions",
+  },
+
+  // x402 payment config
+  payment: {
+    wallet: process.env.PAYMENT_WALLET || "2MB8Gk4PebwhP6yaiiMjofHYoQvvQ8iWo3hdkUHQ1Wdq",
+    facilitator: process.env.X402_FACILITATOR || "https://facilitator.payai.network",
+    network: "solana" as const,
+    currency: "USDC",
+  },
+
+  // Tool pricing (in USD)
+  pricing: {
+    scrape_url: 0.005,
+    screenshot_url: 0.005,
+    extract_structured_data: 0.02,
+    review_code: 0.03,
+    generate_content: 0.05,
+    analyze_sentiment: 0.01,
+  },
+
+  // Browser config
+  browser: {
+    timeout: 30_000,
+    maxContentLength: 50_000,
+  },
+} as const;

package/src/discovery.ts

@@ -0,0 +1,277 @@
+import type { Hono } from "hono";
+
+/** Register all agent discovery routes on the Hono app */
+export function registerDiscoveryRoutes(app: Hono): void {
+  app.get("/llms.txt", (c) => {
+    return c.text(LLMS_TXT, 200, {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Cache-Control": "public, max-age=3600",
+      "Access-Control-Allow-Origin": "*",
+    });
+  });
+
+  app.get("/.well-known/agent-card.json", (c) => {
+    return c.json(AGENT_CARD, 200, {
+      "Cache-Control": "public, max-age=3600",
+      "Access-Control-Allow-Origin": "*",
+    });
+  });
+
+  app.get("/.well-known/mcp.json", (c) => {
+    return c.json(MCP_CARD, 200, {
+      "Cache-Control": "public, max-age=3600",
+      "Access-Control-Allow-Origin": "*",
+    });
+  });
+}
+
+// ── Static Content ────────────────────────────────────────────
+
+const LLMS_TXT = `# Harvey Tools - General-Purpose Agent Tools MCP Server
+
+> MCP server for AI agents. Web scraping, screenshots, structured data extraction, code review, content generation, sentiment analysis.
+> Pay per call with USDC via x402 micropayments. No account needed.
+> Built by MeltingPixels.
+
+## Tools (8 total, 2 free + 6 paid)
+- [list_tools](https://tools.rugslayer.com/mcp): List all tools with pricing (FREE)
+- [health](https://tools.rugslayer.com/mcp): Server status and payment config (FREE)
+- [scrape_url](https://tools.rugslayer.com/mcp): Scrape any URL, return cleaned text ($0.005)
+- [screenshot_url](https://tools.rugslayer.com/mcp): Full-page screenshot as base64 PNG ($0.005)
+- [extract_structured_data](https://tools.rugslayer.com/mcp): Scrape URL + LLM extract structured JSON ($0.02)
+- [review_code](https://tools.rugslayer.com/mcp): Security + quality code review ($0.03)
+- [generate_content](https://tools.rugslayer.com/mcp): Generate blog posts, docs, descriptions ($0.05)
+- [analyze_sentiment](https://tools.rugslayer.com/mcp): Sentiment analysis + entity extraction ($0.01)
+
+## Connection
+- [MCP Endpoint](https://tools.rugslayer.com/mcp): Connect directly via MCP
+- [npm](https://www.npmjs.com/package/@meltingpixels/harvey-tools): @meltingpixels/harvey-tools
+- [Claude Code](https://tools.rugslayer.com/mcp): claude mcp add harvey-tools --transport http https://tools.rugslayer.com/mcp
+
+## Authentication
+- [x402 USDC](https://tools.rugslayer.com/mcp): Pay per call on Solana, no account needed
+
+## Pricing
+- scrape_url: $0.005 USDC per call
+- screenshot_url: $0.005 USDC per call
+- extract_structured_data: $0.02 USDC per call
+- review_code: $0.03 USDC per call
+- generate_content: $0.05 USDC per call
+- analyze_sentiment: $0.01 USDC per call
+`;
+
+const AGENT_CARD = {
+  name: "Harvey Tools",
+  description:
+    "MCP server for AI agents providing web scraping, screenshots, structured data extraction, code review, content generation, and sentiment analysis. Pay per call with USDC via x402.",
+  url: "https://tools.rugslayer.com/mcp",
+  version: "1.0.0",
+  provider: {
+    organization: "MeltingPixels",
+    url: "https://rugslayer.com",
+  },
+  capabilities: {
+    streaming: false,
+    pushNotifications: false,
+    stateTransitionHistory: false,
+  },
+  authentication: {
+    schemes: ["x402"],
+  },
+  defaultInputModes: ["application/json"],
+  defaultOutputModes: ["application/json"],
+  skills: [
+    {
+      id: "web-scraping",
+      name: "Web Scraping",
+      description: "Scrape any URL and return cleaned text content. Powered by Playwright headless browser.",
+      tags: ["scraping", "web", "playwright", "text-extraction"],
+      examples: ["Scrape this webpage for me", "Get the text content from this URL"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+    {
+      id: "screenshots",
+      name: "URL Screenshots",
+      description: "Capture full-page screenshots of any URL. Returns base64-encoded PNG.",
+      tags: ["screenshot", "web", "playwright", "image"],
+      examples: ["Take a screenshot of this website", "Capture this page"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+    {
+      id: "structured-data",
+      name: "Structured Data Extraction",
+      description: "Scrape a URL and extract structured JSON data matching a provided schema using AI.",
+      tags: ["scraping", "extraction", "ai", "json", "structured-data"],
+      examples: ["Extract product prices from this page", "Get all the contact info from this URL"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+    {
+      id: "code-review",
+      name: "Code Review",
+      description: "AI-powered security and quality review of submitted code. Finds vulnerabilities, anti-patterns, and suggests improvements.",
+      tags: ["code-review", "security", "quality", "ai"],
+      examples: ["Review this code for security issues", "Check this function for bugs"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+    {
+      id: "content-generation",
+      name: "Content Generation",
+      description: "Generate blog posts, product descriptions, documentation, social posts, and emails.",
+      tags: ["content", "generation", "ai", "writing"],
+      examples: ["Write a blog post about AI agents", "Generate a product description"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+    {
+      id: "sentiment-analysis",
+      name: "Sentiment Analysis",
+      description: "Analyze sentiment of text with entity extraction, key phrases, and confidence scores.",
+      tags: ["sentiment", "analysis", "nlp", "ai"],
+      examples: ["What's the sentiment of this review?", "Analyze the tone of this text"],
+      inputModes: ["application/json"],
+      outputModes: ["application/json"],
+    },
+  ],
+};
+
+const MCP_CARD = {
+  mcp_version: "2025-11-25",
+  name: "harvey-tools",
+  display_name: "Harvey Tools - General-Purpose Agent Tools",
+  description:
+    "MCP server for AI agents. Web scraping, screenshots, structured data extraction, code review, content generation, and sentiment analysis. Pay per call with USDC via x402.",
+  version: "1.0.0",
+  vendor: "MeltingPixels",
+  homepage: "https://tools.rugslayer.com",
+  endpoints: {
+    streamable_http: "https://tools.rugslayer.com/mcp",
+  },
+  pricing: {
+    model: "paid",
+    free_tools: ["list_tools", "health"],
+    paid_tools: {
+      scrape_url: "$0.005",
+      screenshot_url: "$0.005",
+      extract_structured_data: "$0.02",
+      review_code: "$0.03",
+      generate_content: "$0.05",
+      analyze_sentiment: "$0.01",
+    },
+    payment_methods: ["x402_usdc_solana"],
+  },
+  rate_limits: {
+    x402: "unlimited (pay per call)",
+  },
+  tools: [
+    {
+      name: "list_tools",
+      description: "List all available tools with pricing and input requirements.",
+      price: "FREE",
+      input_schema: { type: "object", properties: {} },
+    },
+    {
+      name: "health",
+      description: "Server status, uptime, and payment network configuration.",
+      price: "FREE",
+      input_schema: { type: "object", properties: {} },
+    },
+    {
+      name: "scrape_url",
+      description: "Scrape any URL and return cleaned markdown text. Powered by Playwright.",
+      price: "$0.005 USDC",
+      input_schema: {
+        type: "object",
+        required: ["url"],
+        properties: {
+          url: { type: "string", description: "URL to scrape" },
+          max_length: { type: "number", description: "Max content length in chars (default: 10000)" },
+        },
+      },
+    },
+    {
+      name: "screenshot_url",
+      description: "Full-page screenshot of any URL. Returns base64-encoded PNG.",
+      price: "$0.005 USDC",
+      input_schema: {
+        type: "object",
+        required: ["url"],
+        properties: {
+          url: { type: "string", description: "URL to screenshot" },
+          full_page: { type: "boolean", description: "Capture full page (default: true)" },
+          width: { type: "number", description: "Viewport width (default: 1280)" },
+          height: { type: "number", description: "Viewport height (default: 720)" },
+        },
+      },
+    },
+    {
+      name: "extract_structured_data",
+      description: "Scrape URL then extract structured JSON via AI per your schema description.",
+      price: "$0.02 USDC",
+      input_schema: {
+        type: "object",
+        required: ["url", "schema_description"],
+        properties: {
+          url: { type: "string", description: "URL to scrape" },
+          schema_description: { type: "string", description: "Description of data to extract and desired JSON structure" },
+        },
+      },
+    },
+    {
+      name: "review_code",
+      description: "AI-powered security and quality code review.",
+      price: "$0.03 USDC",
+      input_schema: {
+        type: "object",
+        required: ["code"],
+        properties: {
+          code: { type: "string", description: "Code to review" },
+          language: { type: "string", description: "Programming language (auto-detected if omitted)" },
+          focus: { type: "string", description: "Focus area: security, quality, performance, or all (default: all)" },
+        },
+      },
+    },
+    {
+      name: "generate_content",
+      description: "Generate blog posts, product descriptions, documentation, social posts, emails.",
+      price: "$0.05 USDC",
+      input_schema: {
+        type: "object",
+        required: ["type", "topic"],
+        properties: {
+          type: { type: "string", description: "Content type: blog_post, product_description, documentation, social_post, email" },
+          topic: { type: "string", description: "Topic or subject to write about" },
+          tone: { type: "string", description: "Tone: professional, casual, technical, friendly (default: professional)" },
+          length: { type: "string", description: "Length: short, medium, long (default: medium)" },
+          keywords: { type: "string", description: "Comma-separated keywords to include" },
+        },
+      },
+    },
+    {
+      name: "analyze_sentiment",
+      description: "Sentiment analysis with entity extraction and key phrases.",
+      price: "$0.01 USDC",
+      input_schema: {
+        type: "object",
+        required: ["text"],
+        properties: {
+          text: { type: "string", description: "Text to analyze" },
+        },
+      },
+    },
+  ],
+  install: {
+    npm: "npx -y @meltingpixels/harvey-tools",
+    claude_code: "claude mcp add harvey-tools --transport http https://tools.rugslayer.com/mcp",
+    claude_desktop: {
+      command: "npx",
+      args: ["-y", "@meltingpixels/harvey-tools"],
+      env: {},
+    },
+  },
+  categories: ["web-scraping", "code-review", "content-generation", "analysis"],
+  tags: ["scraping", "playwright", "ai", "code-review", "content", "sentiment", "x402", "usdc"],
+};

package/src/index.ts

@@ -0,0 +1,259 @@
+import "dotenv/config";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { createMcpPaidHandler } from "mcpay/handler";
+import { z } from "zod";
+import { config } from "./config.js";
+import { registerDiscoveryRoutes } from "./discovery.js";
+import { scrapeUrl, screenshotUrl, extractStructuredData } from "./tools/scraping.js";
+import { reviewCode } from "./tools/code-review.js";
+import { generateContent } from "./tools/content.js";
+import { analyzeSentiment } from "./tools/sentiment.js";
+
+// ── Shared tool callback helpers ─────────────────────────────
+
+function toolResult(data: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+function toolError(err: unknown) {
+  return {
+    content: [{ type: "text" as const, text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+    isError: true as const,
+  };
+}
+
+// ── Free tool data ───────────────────────────────────────────
+
+function listTools() {
+  return {
+    server: "harvey-tools",
+    version: "1.0.0",
+    payment: { network: config.payment.network, currency: config.payment.currency, method: "x402" },
+    tools: [
+      { name: "list_tools", description: "List all tools with pricing", price: "FREE" },
+      { name: "health", description: "Server status and payment config", price: "FREE" },
+      { name: "scrape_url", description: "Scrape any URL, return cleaned text", price: "$0.005" },
+      { name: "screenshot_url", description: "Full-page screenshot as base64 PNG", price: "$0.005" },
+      { name: "extract_structured_data", description: "Scrape URL + AI extract structured JSON", price: "$0.02" },
+      { name: "review_code", description: "Security + quality code review", price: "$0.03" },
+      { name: "generate_content", description: "Generate blog posts, docs, descriptions", price: "$0.05" },
+      { name: "analyze_sentiment", description: "Sentiment analysis + entity extraction", price: "$0.01" },
+    ],
+  };
+}
+
+function health() {
+  return {
+    status: "ok",
+    server: "harvey-tools",
+    version: "1.0.0",
+    uptime: Math.floor(process.uptime()),
+    payment: {
+      network: config.payment.network,
+      currency: config.payment.currency,
+      wallet: config.payment.wallet,
+      facilitator: config.payment.facilitator,
+      method: "x402",
+    },
+    capabilities: ["web-scraping", "screenshots", "structured-extraction", "code-review", "content-generation", "sentiment-analysis"],
+  };
+}
+
+// ── Tool registration ────────────────────────────────────────
+// Server typed as `any` because mcpay bundles its own @modelcontextprotocol/sdk
+// version, making its McpServer type incompatible at compile time.
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+function registerFreeTools(server: any): void {
+  server.tool(
+    "list_tools",
+    "List all available Harvey Tools with pricing and input requirements. Use this for discovery.",
+    {},
+    async () => toolResult(listTools())
+  );
+
+  server.tool(
+    "health",
+    "Check Harvey Tools server status, uptime, and payment network configuration.",
+    {},
+    async () => toolResult(health())
+  );
+}
+
+// ── x402 Paid Handler ────────────────────────────────────────
+
+const paidHandler = createMcpPaidHandler(
+  (server) => {
+    registerFreeTools(server);
+
+    // ── Scraping tools ──
+
+    server.paidTool(
+      "scrape_url",
+      "Scrape any URL and return cleaned text content. Powered by Playwright headless browser. Returns title, content, word count.",
+      "$0.005",
+      {
+        url: z.string().url().describe("URL to scrape"),
+        max_length: z.number().min(100).max(50000).optional().describe("Max content length in chars (default: 10000)"),
+      },
+      {},
+      async ({ url, max_length }: { url: string; max_length?: number }) => {
+        try {
+          return toolResult(await scrapeUrl(url, max_length ?? 10_000));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+
+    server.paidTool(
+      "screenshot_url",
+      "Take a full-page screenshot of any URL. Returns base64-encoded PNG image.",
+      "$0.005",
+      {
+        url: z.string().url().describe("URL to screenshot"),
+        full_page: z.boolean().optional().describe("Capture full page scroll height (default: true)"),
+        width: z.number().min(320).max(3840).optional().describe("Viewport width in pixels (default: 1280)"),
+        height: z.number().min(240).max(2160).optional().describe("Viewport height in pixels (default: 720)"),
+      },
+      {},
+      async ({ url, full_page, width, height }: { url: string; full_page?: boolean; width?: number; height?: number }) => {
+        try {
+          return toolResult(await screenshotUrl(url, full_page ?? true, width ?? 1280, height ?? 720));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+
+    server.paidTool(
+      "extract_structured_data",
+      "Scrape a URL then use AI to extract structured JSON data matching your schema description. Combines Playwright scraping with Grok LLM extraction.",
+      "$0.02",
+      {
+        url: z.string().url().describe("URL to scrape"),
+        schema_description: z.string().describe("Description of the data to extract and desired JSON structure. Example: 'Extract all product names and prices as {products: [{name, price}]}'"),
+      },
+      {},
+      async ({ url, schema_description }: { url: string; schema_description: string }) => {
+        try {
+          return toolResult(await extractStructuredData(url, schema_description));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+
+    // ── Code review ──
+
+    server.paidTool(
+      "review_code",
+      "AI-powered security and quality code review. Analyzes for vulnerabilities, anti-patterns, performance issues, and best practices. Returns issues with severity, suggestions, and an overall score.",
+      "$0.03",
+      {
+        code: z.string().describe("Source code to review"),
+        language: z.string().optional().describe("Programming language (auto-detected if omitted)"),
+        focus: z.string().optional().describe("Focus area: security, quality, performance, or all (default: all)"),
+      },
+      {},
+      async ({ code, language, focus }: { code: string; language?: string; focus?: string }) => {
+        try {
+          return toolResult(await reviewCode(code, language, focus));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+
+    // ── Content generation ──
+
+    server.paidTool(
+      "generate_content",
+      "Generate high-quality written content. Supports blog posts, product descriptions, documentation, social posts, and emails. Customizable tone, length, and keywords.",
+      "$0.05",
+      {
+        type: z.enum(["blog_post", "product_description", "documentation", "social_post", "email"]).describe("Content type"),
+        topic: z.string().describe("Topic or subject to write about"),
+        tone: z.enum(["professional", "casual", "technical", "friendly"]).optional().describe("Writing tone (default: professional)"),
+        length: z.enum(["short", "medium", "long"]).optional().describe("Target length (default: medium)"),
+        keywords: z.string().optional().describe("Comma-separated keywords to include"),
+      },
+      {},
+      async ({ type, topic, tone, length, keywords }: { type: string; topic: string; tone?: string; length?: string; keywords?: string }) => {
+        try {
+          return toolResult(await generateContent(type, topic, tone, length, keywords));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+
+    // ── Sentiment analysis ──
+
+    server.paidTool(
+      "analyze_sentiment",
+      "Analyze sentiment of text with entity extraction, confidence scores, and key phrase identification. Returns positive/negative/neutral/mixed with detailed breakdown.",
+      "$0.01",
+      {
+        text: z.string().describe("Text to analyze for sentiment"),
+      },
+      {},
+      async ({ text }: { text: string }) => {
+        try {
+          return toolResult(await analyzeSentiment(text));
+        } catch (err) {
+          return toolError(err);
+        }
+      }
+    );
+  },
+  {
+    facilitator: {
+      url: config.payment.facilitator as `${string}://${string}`,
+    },
+    recipient: {
+      svm: {
+        address: config.payment.wallet,
+        isTestnet: false,
+      },
+    },
+  },
+  {
+    serverInfo: { name: "harvey-tools", version: "1.0.0" },
+  },
+  {
+    maxDuration: 300,
+    verboseLogs: process.env.NODE_ENV !== "production",
+  }
+);
+
+// ── Hono HTTP Server ─────────────────────────────────────────
+
+const app = new Hono();
+
+// Health + pricing endpoints (outside MCP, for monitoring/discovery)
+app.get("/health", (c) => c.json(health()));
+app.get("/pricing", (c) => c.json(listTools()));
+
+// Agent discovery routes
+registerDiscoveryRoutes(app);
+
+// MCP handler — x402 only (no API key auth needed)
+app.all("*", async (c) => {
+  return paidHandler(c.req.raw);
+});
+
+// ── Start ────────────────────────────────────────────────────
+
+serve({ fetch: app.fetch, port: config.port }, () => {
+  console.log(`Harvey Tools MCP server running on port ${config.port}`);
+  console.log(`  MCP endpoint: http://localhost:${config.port}/`);
+  console.log(`  Health: http://localhost:${config.port}/health`);
+  console.log(`  Pricing: http://localhost:${config.port}/pricing`);
+  console.log(`  Auth: x402 USDC only`);
+  console.log(`  Payment wallet: ${config.payment.wallet}`);
+  console.log(`  Facilitator: ${config.payment.facilitator}`);
+  console.log(`  Network: ${config.payment.network} (${config.payment.currency})`);
+});

package/src/lib/browser.ts

@@ -0,0 +1,75 @@
+import { chromium, type Browser, type Page } from "playwright";
+import { config } from "../config.js";
+
+let browser: Browser | null = null;
+
+/** Get or create the shared Playwright browser instance */
+async function getBrowser(): Promise<Browser> {
+  if (!browser || !browser.isConnected()) {
+    browser = await chromium.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+    });
+  }
+  return browser;
+}
+
+/** Create a new page with standard config. Caller MUST close the page when done. */
+export async function createPage(options?: {
+  blockMedia?: boolean;
+  width?: number;
+  height?: number;
+}): Promise<Page> {
+  const b = await getBrowser();
+  const page = await b.newPage({
+    viewport: {
+      width: options?.width ?? 1280,
+      height: options?.height ?? 720,
+    },
+    userAgent:
+      "Mozilla/5.0 (compatible; HarveyTools/1.0; +https://tools.rugslayer.com) AppleWebKit/537.36 Chrome/120.0.0.0",
+  });
+
+  // Block heavy resources for scraping (faster + cheaper)
+  if (options?.blockMedia !== false) {
+    await page.route("**/*", (route) => {
+      const type = route.request().resourceType();
+      if (["image", "font", "media", "stylesheet"].includes(type)) {
+        return route.abort();
+      }
+      return route.continue();
+    });
+  }
+
+  page.setDefaultTimeout(config.browser.timeout);
+  return page;
+}
+
+/** Navigate to URL and wait for content to settle */
+export async function navigateTo(page: Page, url: string): Promise<void> {
+  await page.goto(url, { waitUntil: "networkidle", timeout: config.browser.timeout });
+}
+
+/** Extract text content from the current page */
+export async function extractText(page: Page, maxLength: number): Promise<{ title: string; content: string }> {
+  const title = await page.title();
+  const content = await page.evaluate(() => {
+    // Remove script/style/nav/footer noise
+    const remove = document.querySelectorAll("script, style, nav, footer, header, aside, [role=banner], [role=navigation]");
+    remove.forEach((el) => el.remove());
+    return document.body?.innerText?.trim() || "";
+  });
+
+  return {
+    title,
+    content: content.slice(0, maxLength),
+  };
+}
+
+/** Gracefully close the browser (for cleanup) */
+export async function closeBrowser(): Promise<void> {
+  if (browser) {
+    await browser.close();
+    browser = null;
+  }
+}

package/src/lib/grok-client.ts

@@ -0,0 +1,63 @@
+import { config } from "../config.js";
+
+interface GrokMessage {
+  role: "system" | "user" | "assistant";
+  content: string;
+}
+
+interface GrokOptions {
+  temperature?: number;
+  maxTokens?: number;
+}
+
+interface GrokResponse {
+  content: string;
+  model: string;
+  usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+}
+
+/** Call Grok API and return the assistant's response text */
+export async function callGrok(
+  messages: GrokMessage[],
+  options?: GrokOptions
+): Promise<GrokResponse> {
+  if (!config.grok.apiKey) {
+    throw new Error("XAI_API_KEY not configured");
+  }
+
+  const res = await fetch(config.grok.apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.grok.apiKey}`,
+    },
+    body: JSON.stringify({
+      model: config.grok.model,
+      messages,
+      temperature: options?.temperature ?? 0.3,
+      max_tokens: options?.maxTokens ?? 4096,
+    }),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Grok API error ${res.status}: ${body}`);
+  }
+
+  const data = (await res.json()) as {
+    choices: Array<{ message: { content: string } }>;
+    model: string;
+    usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
+  };
+
+  const content = data.choices?.[0]?.message?.content;
+  if (!content) {
+    throw new Error("Grok API returned empty response");
+  }
+
+  return {
+    content,
+    model: data.model,
+    usage: data.usage,
+  };
+}

package/src/tools/code-review.ts

@@ -0,0 +1,68 @@
+import { callGrok } from "../lib/grok-client.js";
+
+interface CodeIssue {
+  severity: "critical" | "high" | "medium" | "low" | "info";
+  line?: number;
+  message: string;
+  suggestion: string;
+}
+
+/** Review code for security, quality, and performance issues */
+export async function reviewCode(
+  code: string,
+  language?: string,
+  focus?: string
+): Promise<{
+  language: string;
+  issues: CodeIssue[];
+  summary: string;
+  score: number;
+}> {
+  const focusArea = focus || "all";
+  const focusInstruction =
+    focusArea === "all"
+      ? "Review for security vulnerabilities, code quality, performance, and best practices."
+      : `Focus specifically on: ${focusArea}.`;
+
+  const response = await callGrok(
+    [
+      {
+        role: "system",
+        content: `You are an expert code reviewer. ${focusInstruction}
+
+Return ONLY valid JSON with this exact structure (no markdown, no code fences):
+{
+  "language": "detected language",
+  "issues": [
+    {
+      "severity": "critical|high|medium|low|info",
+      "line": null,
+      "message": "what's wrong",
+      "suggestion": "how to fix it"
+    }
+  ],
+  "summary": "brief overall assessment",
+  "score": 85
+}
+
+Score from 0-100 where 100 is perfect. Be thorough but fair. If the code is good, say so.`,
+      },
+      {
+        role: "user",
+        content: `Review this ${language || ""}code:\n\n${code}`,
+      },
+    ],
+    { temperature: 0.2, maxTokens: 4096 }
+  );
+
+  try {
+    return JSON.parse(response.content);
+  } catch {
+    return {
+      language: language || "unknown",
+      issues: [],
+      summary: response.content,
+      score: 0,
+    };
+  }
+}

package/src/tools/content.ts

@@ -0,0 +1,61 @@
+import { callGrok } from "../lib/grok-client.js";
+
+const SYSTEM_PROMPTS: Record<string, string> = {
+  blog_post:
+    "You are a skilled blog writer. Write engaging, well-structured blog posts with clear headings, intro, body, and conclusion. Use markdown formatting.",
+  product_description:
+    "You are a conversion-focused copywriter. Write compelling product descriptions that highlight benefits, features, and include a call to action.",
+  documentation:
+    "You are a technical writer. Write clear, precise documentation with examples. Use markdown with code blocks where appropriate.",
+  social_post:
+    "You are a social media expert. Write concise, engaging posts optimized for engagement. Include a hook, value, and CTA. No hashtag spam.",
+  email:
+    "You are an email copywriter. Write professional emails with clear subject line suggestions, compelling body, and strong CTA.",
+};
+
+const LENGTH_TOKENS: Record<string, number> = {
+  short: 1024,
+  medium: 2048,
+  long: 4096,
+};
+
+/** Generate content based on type, topic, and parameters */
+export async function generateContent(
+  type: string,
+  topic: string,
+  tone?: string,
+  length?: string,
+  keywords?: string
+): Promise<{
+  type: string;
+  content: string;
+  word_count: number;
+  model: string;
+}> {
+  const systemPrompt = SYSTEM_PROMPTS[type] || SYSTEM_PROMPTS.blog_post;
+  const toneStr = tone || "professional";
+  const maxTokens = LENGTH_TOKENS[length || "medium"] ?? 2048;
+
+  let userPrompt = `Write a ${type.replace(/_/g, " ")} about: ${topic}\n\nTone: ${toneStr}`;
+  if (keywords) {
+    userPrompt += `\nKeywords to include: ${keywords}`;
+  }
+  if (length) {
+    userPrompt += `\nTarget length: ${length}`;
+  }
+
+  const response = await callGrok(
+    [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ],
+    { temperature: 0.7, maxTokens }
+  );
+
+  return {
+    type,
+    content: response.content,
+    word_count: response.content.split(/\s+/).filter(Boolean).length,
+    model: response.model,
+  };
+}

package/src/tools/scraping.ts

@@ -0,0 +1,102 @@
+import { createPage, navigateTo, extractText } from "../lib/browser.js";
+import { callGrok } from "../lib/grok-client.js";
+
+/** Scrape a URL and return cleaned text content */
+export async function scrapeUrl(
+  url: string,
+  maxLength: number = 10_000
+): Promise<{
+  url: string;
+  title: string;
+  content: string;
+  word_count: number;
+  scraped_at: string;
+}> {
+  const page = await createPage({ blockMedia: true });
+  try {
+    await navigateTo(page, url);
+    const { title, content } = await extractText(page, maxLength);
+    return {
+      url,
+      title,
+      content,
+      word_count: content.split(/\s+/).filter(Boolean).length,
+      scraped_at: new Date().toISOString(),
+    };
+  } finally {
+    await page.close();
+  }
+}
+
+/** Take a screenshot of a URL and return base64 PNG */
+export async function screenshotUrl(
+  url: string,
+  fullPage: boolean = true,
+  width: number = 1280,
+  height: number = 720
+): Promise<{
+  url: string;
+  image_base64: string;
+  width: number;
+  height: number;
+  format: string;
+}> {
+  // Don't block images for screenshots
+  const page = await createPage({ blockMedia: false, width, height });
+  try {
+    await navigateTo(page, url);
+    const buffer = await page.screenshot({ fullPage, type: "png" });
+    return {
+      url,
+      image_base64: buffer.toString("base64"),
+      width,
+      height,
+      format: "png",
+    };
+  } finally {
+    await page.close();
+  }
+}
+
+/** Scrape URL then extract structured data via Grok */
+export async function extractStructuredData(
+  url: string,
+  schemaDescription: string
+): Promise<{
+  url: string;
+  data: unknown;
+  model: string;
+}> {
+  // Scrape the page first
+  const scraped = await scrapeUrl(url, 30_000);
+
+  // Send to Grok for structured extraction
+  const response = await callGrok(
+    [
+      {
+        role: "system",
+        content:
+          "You are a data extraction assistant. Extract structured data from the provided webpage content. Return ONLY valid JSON - no markdown, no explanation, no code fences. If you cannot extract the requested data, return an empty object {}.",
+      },
+      {
+        role: "user",
+        content: `Extract structured data from this webpage content matching this schema:\n\n${schemaDescription}\n\nWebpage title: ${scraped.title}\nWebpage content:\n${scraped.content}`,
+      },
+    ],
+    { temperature: 0.1, maxTokens: 4096 }
+  );
+
+  let data: unknown;
+  try {
+    data = JSON.parse(response.content);
+  } catch {
+    // If Grok didn't return valid JSON, wrap the raw text
+    data = { raw_response: response.content };
+  }
+
+  return {
+    url,
+    data,
+    model: response.model,
+  };
+}

package/src/tools/sentiment.ts

@@ -0,0 +1,53 @@
+import { callGrok } from "../lib/grok-client.js";
+
+interface Entity {
+  name: string;
+  type: string;
+  sentiment: "positive" | "negative" | "neutral";
+}
+
+/** Analyze sentiment of text with entity extraction */
+export async function analyzeSentiment(text: string): Promise<{
+  sentiment: "positive" | "negative" | "neutral" | "mixed";
+  confidence: number;
+  entities: Entity[];
+  summary: string;
+  key_phrases: string[];
+}> {
+  const response = await callGrok(
+    [
+      {
+        role: "system",
+        content: `You are a sentiment analysis expert. Analyze the provided text and return ONLY valid JSON with this exact structure (no markdown, no code fences):
+{
+  "sentiment": "positive|negative|neutral|mixed",
+  "confidence": 0.95,
+  "entities": [
+    { "name": "entity name", "type": "person|organization|product|location|other", "sentiment": "positive|negative|neutral" }
+  ],
+  "summary": "brief sentiment summary in one sentence",
+  "key_phrases": ["phrase1", "phrase2"]
+}
+
+Confidence is 0.0 to 1.0. Extract all named entities. Identify 3-5 key phrases.`,
+      },
+      {
+        role: "user",
+        content: `Analyze the sentiment of this text:\n\n${text}`,
+      },
+    ],
+    { temperature: 0.1, maxTokens: 2048 }
+  );
+
+  try {
+    return JSON.parse(response.content);
+  } catch {
+    return {
+      sentiment: "neutral",
+      confidence: 0,
+      entities: [],
+      summary: response.content,
+      key_phrases: [],
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}