taskfleet-mcp 0.1.0

package/README.md

@@ -0,0 +1,70 @@
+# taskfleet-mcp
+
+An [MCP](https://modelcontextprotocol.io) server that exposes **TaskFleet**'s
+pay-per-call AI task APIs as tools any MCP-capable agent can discover and call:
+web search, web scraping, structured extraction, translation, code review,
+summarization, and on-chain wallet intelligence.
+
+Payment is handled by the **x402** protocol (USDC on Base) — the caller brings
+the wallet; there are no accounts or API keys.
+
+## Why this exists
+
+It's a discovery channel. Agents that browse MCP registries or load MCP
+servers can find and use TaskFleet directly, in addition to the x402
+directories. The tool list is loaded live from the fleet's manifest, so new
+services appear automatically.
+
+## Use it (as an agent operator)
+
+Add to your MCP client config (e.g. Claude Desktop, or any MCP host):
+
+```json
+{
+  "mcpServers": {
+    "taskfleet": {
+      "command": "npx",
+      "args": ["-y", "taskfleet-mcp"],
+      "env": {
+        "BUYER_WALLET_PRIVATE_KEY": "0xYOUR_WALLET_KEY"
+      }
+    }
+  }
+}
+```
+
+- **With** `BUYER_WALLET_PRIVATE_KEY` (an EVM key holding a little USDC on Base):
+  tool calls auto-pay via x402 and return results.
+- **Without** it: tools still list (discovery works) and a call returns the
+  x402 payment instructions, so an x402-capable client can pay itself.
+- `TASKFLEET_URL` overrides the target (defaults to `https://taskfleet.net`).
+
+The wallet key stays on the operator's machine — it never reaches TaskFleet,
+which only ever sees the on-chain payment.
+
+## Tools
+
+One tool per TaskFleet service, named `taskfleet_<service>` (e.g.
+`taskfleet_search`, `taskfleet_scrape`, `taskfleet_wallet_intel`). Each tool's
+input schema and price come straight from the fleet manifest.
+
+## Publish it (as the fleet operator — discovery)
+
+```bash
+cd mcp
+npm install
+npm publish            # publishes taskfleet-mcp to npm
+```
+
+Once on npm it's installable via `npx taskfleet-mcp` and can be listed in MCP
+registries (the public MCP Registry, Smithery, PulseMCP, etc.) — each listing
+is another place agents discover TaskFleet. Submitting to those registries is
+free and generally just points at the npm package or this repo.
+
+## Local test
+
+```bash
+npm install
+TASKFLEET_URL=https://taskfleet.net node index.mjs
+# should print: taskfleet-mcp v0.1.0: 14 tools from https://taskfleet.net (payment: caller-pays)
+```

package/index.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// taskfleet-mcp — expose TaskFleet's paid services to any MCP-capable agent.
+//
+// Discovery: an agent that adds this server sees all TaskFleet services as
+// native MCP tools (names, descriptions, input schemas) — a discovery channel
+// entirely separate from the x402 directories.
+//
+// Payment: the *caller* brings the wallet. If BUYER_WALLET_PRIVATE_KEY is set,
+// calls auto-pay via x402 (USDC on Base) and return results. If not, tools
+// still list (discovery works) and a call returns the x402 payment
+// instructions so an x402-capable client can pay itself.
+//
+// The tool list is loaded LIVE from the fleet's own manifest, so new services
+// appear automatically — publish this once, it never goes stale.
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { toolName } from "./toolname.mjs";
+
+const BASE = (process.env.TASKFLEET_URL || "https://taskfleet.net").replace(/\/$/, "");
+const PK = process.env.BUYER_WALLET_PRIVATE_KEY || "";
+const VERSION = "0.1.0";
+
+async function loadServices() {
+  const res = await fetch(`${BASE}/.well-known/x402.json`);
+  if (!res.ok) throw new Error(`Cannot load TaskFleet manifest (${res.status}) from ${BASE}`);
+  const data = await res.json();
+  if (!Array.isArray(data.services)) throw new Error("Manifest missing services[]");
+  return data.services;
+}
+
+// Build a payment-capable fetch when a wallet is configured; else plain fetch.
+async function makeFetch() {
+  if (!PK) return { fetchImpl: fetch, paid: false };
+  const { privateKeyToAccount } = await import("viem/accounts");
+  const { createWalletClient, http } = await import("viem");
+  const { base } = await import("viem/chains");
+  const { wrapFetchWithPayment } = await import("x402-fetch");
+  const account = privateKeyToAccount(PK.startsWith("0x") ? PK : `0x${PK}`);
+  const wallet = createWalletClient({ account, chain: base, transport: http() });
+  return { fetchImpl: wrapFetchWithPayment(fetch, wallet), paid: true };
+}
+
+const server = new Server({ name: "taskfleet", version: VERSION }, { capabilities: { tools: {} } });
+
+let SERVICES = [];
+let FETCH = { fetchImpl: fetch, paid: false };
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: SERVICES.map((s) => ({
+    name: toolName(s.route),
+    description: `${s.description} Price: ${s.price} (USDC on Base via x402).`,
+    inputSchema: { type: "object", ...(s.input || {}) },
+  })),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const svc = SERVICES.find((s) => toolName(s.route) === req.params.name);
+  if (!svc) return { isError: true, content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }] };
+  const path = svc.route.split(" ")[1];
+  try {
+    const res = await FETCH.fetchImpl(`${BASE}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(req.params.arguments || {}),
+    });
+    const text = await res.text();
+
+    if (res.status === 402 && !FETCH.paid) {
+      const payHeader = res.headers.get("payment-required") || res.headers.get("PAYMENT-REQUIRED") || "";
+      return {
+        isError: true,
+        content: [{
+          type: "text",
+          text:
+            `Payment required (${svc.price}, USDC on Base). Set BUYER_WALLET_PRIVATE_KEY to auto-pay, ` +
+            `or handle x402 yourself with these instructions:\n${payHeader || text.slice(0, 600)}`,
+        }],
+      };
+    }
+    if (!res.ok) return { isError: true, content: [{ type: "text", text: `TaskFleet ${res.status}: ${text.slice(0, 600)}` }] };
+    return { content: [{ type: "text", text }] };
+  } catch (e) {
+    return { isError: true, content: [{ type: "text", text: `Call failed: ${e.message}` }] };
+  }
+});
+
+async function main() {
+  SERVICES = await loadServices();
+  FETCH = await makeFetch();
+  await server.connect(new StdioServerTransport());
+  // logs go to stderr so they don't corrupt the stdio protocol on stdout
+  console.error(`taskfleet-mcp v${VERSION}: ${SERVICES.length} tools from ${BASE} (payment: ${FETCH.paid ? "auto-pay" : "caller-pays"})`);
+}
+
+// Only run when executed directly (allows importing toolName for tests).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((e) => { console.error(e.message); process.exit(1); });
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "taskfleet-mcp",
+  "version": "0.1.0",
+  "description": "MCP server exposing TaskFleet's pay-per-call AI task APIs (web search, scrape, extract, translate, code review, on-chain wallet intel) as tools. Payment via x402 (USDC on Base).",
+  "type": "module",
+  "bin": { "taskfleet-mcp": "index.mjs" },
+  "main": "index.mjs",
+  "files": ["index.mjs", "toolname.mjs", "README.md"],
+  "engines": { "node": ">=20" },
+  "keywords": ["mcp", "model-context-protocol", "x402", "ai-agents", "web-search", "scraping", "web-scraper", "data-extraction", "translation", "code-review", "onchain", "base", "usdc", "agent-tools", "api"],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "viem": "^2.21.0",
+    "x402-fetch": "^0.6.0"
+  },
+  "license": "MIT"
+}

package/toolname.mjs

@@ -0,0 +1,4 @@
+// Pure helper: map a service route ("POST /wallet-intel") to a valid MCP tool
+// name ("taskfleet_wallet_intel"). Kept dependency-free so it's unit-testable.
+export const toolName = (route) =>
+  "taskfleet_" + route.split(" ")[1].replace(/^\//, "").replace(/-/g, "_");