ugarapi-mcp-server 1.1.0

package/ugarapi-mcp-server.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+
+/**
+ * UgarAPI MCP Server
+ * 
+ * Exposes UgarAPI services as MCP tools for AI agents.
+ * Handles Bitcoin Lightning payments automatically.
+ * 
+ * Usage:
+ *   node ugarapi-mcp-server.js
+ * 
+ * Configuration via environment variables:
+ *   UGARAPI_BASE_URL - defaults to https://ugarapi.com
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const UGARAPI_BASE_URL = process.env.UGARAPI_BASE_URL || "https://ugarapi.com";
+
+// Service prices in sats
+const PRICES = {
+  web_extraction: 1000,
+  document_timestamp: 5000,
+  api_aggregator: 200,
+};
+
+// In-memory payment cache (in production, use persistent storage)
+const paymentCache = new Map();
+
+/**
+ * Create a Lightning invoice for a service
+ */
+async function createInvoice(service, idempotencyKey) {
+  const response = await fetch(`${UGARAPI_BASE_URL}/api/v1/payment/create`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      service,
+      amount_sats: PRICES[service],
+      idempotency_key: idempotencyKey,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Payment creation failed: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Check payment status
+ */
+async function checkPayment(invoiceId) {
+  const response = await fetch(
+    `${UGARAPI_BASE_URL}/api/v1/payment/${invoiceId}`
+  );
+
+  if (!response.ok) {
+    throw new Error(`Payment check failed: ${response.statusText}`);
+  }
+
+  return await response.json();
+}
+
+/**
+ * Wait for payment to be confirmed (with timeout)
+ */
+async function waitForPayment(invoiceId, timeoutMs = 300000) {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeoutMs) {
+    const status = await checkPayment(invoiceId);
+
+    if (status.status === "paid") {
+      return true;
+    }
+
+    if (status.status === "expired") {
+      throw new Error("Invoice expired before payment");
+    }
+
+    // Wait 2 seconds before checking again
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+
+  throw new Error("Payment timeout - invoice not paid in time");
+}
+
+/**
+ * Call UgarAPI service with payment
+ */
+async function callService(service, endpoint, payload, idempotencyKey) {
+  // Check if we have a cached payment for this idempotency key
+  let invoiceId = paymentCache.get(idempotencyKey);
+
+  if (!invoiceId) {
+    // Create new invoice
+    const invoice = await createInvoice(service, idempotencyKey);
+    invoiceId = invoice.invoice_id;
+    paymentCache.set(idempotencyKey, invoiceId);
+
+    // In a real implementation, you'd prompt the user to pay here
+    // For now, we'll simulate immediate payment (in production this would wait)
+    console.error(
+      `Payment required: ${invoice.payment_request} (${invoice.amount_sats} sats)`
+    );
+
+    // Simulate payment webhook (REMOVE THIS IN PRODUCTION)
+    await fetch(`${UGARAPI_BASE_URL}/api/v1/payment/webhook`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        invoiceId: invoiceId,
+        status: "paid",
+      }),
+    });
+  }
+
+  // Wait for payment confirmation
+  await waitForPayment(invoiceId);
+
+  // Call the actual service
+  const response = await fetch(`${UGARAPI_BASE_URL}${endpoint}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      ...payload,
+      payment_proof: invoiceId,
+      idempotency_key: idempotencyKey,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`Service call failed: ${JSON.stringify(error)}`);
+  }
+
+  return await response.json();
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: "ugarapi",
+    version: "1.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "extract_web_data",
+        description:
+          "Extract structured data from any URL using CSS selectors. Returns the extracted content from the webpage. Costs 1000 sats (~$1) per extraction.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to extract data from",
+            },
+            selectors: {
+              type: "object",
+              description:
+                "CSS selectors to extract specific elements. Format: {'key': 'selector'}. Example: {'title': 'h1', 'price': '.product-price'}",
+            },
+          },
+          required: ["url", "selectors"],
+        },
+      },
+      {
+        name: "timestamp_document",
+        description:
+          "Create a cryptographic timestamp proof for a document on the Bitcoin blockchain. Returns verification URL and merkle root. Costs 5000 sats (~$5) per document.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            document_hash: {
+              type: "string",
+              description:
+                "SHA-256 hash of the document to timestamp (64 character hex string)",
+            },
+            metadata: {
+              type: "object",
+              description:
+                "Optional metadata to include in the timestamp (e.g., author, title, description)",
+            },
+          },
+          required: ["document_hash"],
+        },
+      },
+      {
+        name: "aggregate_api_call",
+        description:
+          "Make API calls to external services (weather, maps, exchange rates) through a unified interface with automatic failover. Costs 200 sats (~$0.20) per call.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            service: {
+              type: "string",
+              enum: ["weather", "maps", "exchange_rate"],
+              description: "Which API service to call",
+            },
+            endpoint: {
+              type: "string",
+              description:
+                "The endpoint path (e.g., for weather: city name, for exchange_rate: currency code)",
+            },
+            params: {
+              type: "object",
+              description: "Query parameters for the API call",
+            },
+          },
+          required: ["service", "endpoint", "params"],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  // Generate idempotency key from tool call
+  const idempotencyKey = `mcp_${name}_${Date.now()}_${Math.random()
+    .toString(36)
+    .substr(2, 9)}`;
+
+  try {
+    switch (name) {
+      case "extract_web_data": {
+        const result = await callService(
+          "web_extraction",
+          "/api/v1/extract",
+          {
+            url: args.url,
+            selectors: args.selectors,
+          },
+          idempotencyKey
+        );
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "timestamp_document": {
+        const result = await callService(
+          "document_timestamp",
+          "/api/v1/timestamp",
+          {
+            document_hash: args.document_hash,
+            metadata: args.metadata || {},
+          },
+          idempotencyKey
+        );
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case "aggregate_api_call": {
+        const result = await callService(
+          "api_aggregator",
+          "/api/v1/aggregate",
+          {
+            service: args.service,
+            endpoint: args.endpoint,
+            params: args.params,
+          },
+          idempotencyKey
+        );
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("UgarAPI MCP Server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});