@routedock/mcp-server 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RouteDock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,181 @@
+# @routedock/mcp-server
+
+Model Context Protocol (MCP) server for RouteDock Stellar payments. Exposes RouteDock's payment functionality as standardized tools that LLM agents can use directly.
+
+## Overview
+
+This MCP server implements the thesis that base payment infrastructure should be built for machines, not humans. Instead of requiring every LLM agent to implement the full RouteDock SDK, agents can simply connect to this MCP server and use standardized tools:
+
+- `pay_for_data(url, max_amount)` - Pay for a single data request
+- `open_session(url)` - Open a sustained MPP session for streaming
+- `stream_session(channel_id)` - Pull streamed data from an open session
+- `close_session(channel_id)` - Settle and close an open session
+- `check_balance()` - Check wallet balance
+- `list_providers(tags)` - Discover available providers
+
+## Installation
+
+```bash
+npm install -g @routedock/mcp-server
+```
+
+Or build from source:
+
+```bash
+cd packages/mcp-server
+pnpm install
+pnpm build
+```
+
+## Configuration
+
+For security, it is highly recommended to store your secrets in an external `.env` file rather than inline in the Claude Desktop configuration.
+
+Create a `.env` file (e.g., `~/.routedock/.env`):
+
+```bash
+# Required
+STELLAR_SECRET="SDU5..."  # Use a dedicated low-balance testnet key for safety
+STELLAR_NETWORK="testnet"  # or "mainnet"
+ROUTEDOCK_DAILY_CAP="1.00" # Required: Maximum daily spend in USDC
+
+# Optional (for session mode)
+COMMITMENT_SECRET="S..."  # Ed25519 secret for channel commitments
+
+# Optional (for provider registry)
+SUPABASE_URL="https://..."
+# Note: Use the anon key (anon + public_read_providers RLS is sufficient). Do NOT use the service-role key.
+SUPABASE_KEY="..."
+```
+
+## Available Tools
+
+### pay_for_data
+
+Pay for a single data request from a RouteDock provider. Automatically selects the best payment mode.
+
+**Parameters:**
+- `url` (required): Full URL of the provider endpoint
+- `max_amount` (required): Maximum USDC amount to pay
+- `preferred_mode` (optional): Preferred payment mode (`x402`, `mpp-charge`, `mpp-session`)
+
+**Returns:** Payment result with mode, amount, transaction hash, and response data
+
+### open_session
+
+Open a sustained MPP session for streaming data. Requires `COMMITMENT_SECRET`. RouteDock channels
+are pre-deployed and funded out-of-band before the agent runs, so `initial_deposit` is a safety
+check against the provider's `min_deposit`, not a fund transfer. Pass the returned `channel_id` to
+`stream_session` and `close_session` — the channel's collateral cannot be settled otherwise.
+
+**Parameters:**
+- `url` (required): Base URL of the provider
+- `initial_deposit` (optional): Amount in USDC you intend the channel to be funded with
+
+**Returns:** `channel_id` and open transaction hash
+
+### stream_session
+
+Pull the next batch of streamed responses from a session opened with `open_session`. Each message
+sends a voucher and waits for the provider's response.
+
+**Parameters:**
+- `channel_id` (required): The `channel_id` returned by `open_session`
+- `max_messages` (optional): Maximum number of messages to pull in this call (1 to 50, default 1)
+
+**Returns:** The pulled messages. If a voucher fails partway through the batch (local spend cap
+reached, provider 4xx/5xx), the call still returns `isError: true` with the messages that were
+already paid for, plus `count` and `stats`, instead of discarding the batch.
+
+### close_session
+
+Close a session opened with `open_session`, settling the channel on-chain with the highest signed
+voucher. Required to release the session's locked collateral.
+
+**Parameters:**
+- `channel_id` (required): The `channel_id` returned by `open_session`
+
+**Returns:** Close transaction hash, total amount paid, and vouchers issued
+
+### check_balance
+
+Check the Stellar wallet balance for the configured account.
+
+**Parameters:**
+- `asset_code` (optional): Asset code to check (e.g., "USDC")
+- `asset_issuer` (optional): Asset issuer address for non-native assets
+
+**Returns:** Balance information for the specified asset
+
+### list_providers
+
+List available RouteDock providers from the registry. Requires Supabase credentials.
+
+**Parameters:**
+- `tags` (optional): Comma-separated tags for filtering (e.g., "price,stellar,dex")
+- `network` (optional): Filter by network (`testnet` or `mainnet`)
+
+**Returns:** List of matching providers with their capabilities
+
+## Claude Desktop Configuration
+
+Add this to your Claude Desktop config file:
+
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "routedock": {
+      "command": "node",
+      "args": ["/path/to/@routedock/mcp-server/dist/index.js"],
+      "env": {
+        "ROUTEDOCK_ENV_FILE": "/absolute/path/to/your/.env"
+      }
+    }
+  }
+}
+```
+
+## Example Usage
+
+Once configured, you can ask Claude to:
+
+> "Check my Stellar balance"
+> "List providers that offer price data"
+> "Pay for data from https://api-a.routedock.xyz/price with a max of 0.01 USDC"
+> "Open a session with https://api-b.routedock.xyz for streaming orderbook data"
+> "Pull the next few messages from that session"
+> "Close the session and settle the channel"
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Watch mode
+pnpm dev
+
+# Type check
+pnpm typecheck
+
+# Run directly
+pnpm start
+```
+
+## Architecture
+
+The MCP server wraps the existing `@routedock/routedock` SDK and exposes its functionality through the Model Context Protocol. This allows any MCP-compatible LLM client (Claude Desktop, etc.) to interact with Stellar payments without implementing the SDK directly.
+
+```
+LLM Agent → MCP Protocol → @routedock/mcp-server → @routedock/routedock SDK → Stellar Network
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { config as loadDotenv } from "dotenv";
+import path from "path";
+import os from "os";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { RouteDockClient, FileSpendStore } from "@routedock/routedock";
+import { createClient } from "@supabase/supabase-js";
+
+// src/tools.ts
+var MAX_STREAM_MESSAGES = 50;
+var TOOLS = [
+  {
+    name: "pay_for_data",
+    description: "Pay for a single data request from a RouteDock provider. Automatically selects the best payment mode (x402, mpp-charge, mpp-session, or mpp-session-ws) based on the provider's manifest. Use mpp-session-ws for WebSocket-transport streaming providers (e.g. provider-b).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The full URL of the provider endpoint to pay for (e.g., https://api-a.routedock.xyz/price)"
+        },
+        max_amount: {
+          type: "string",
+          description: 'Maximum amount in USDC to pay for this request (e.g., "0.01")'
+        },
+        preferred_mode: {
+          type: "string",
+          enum: ["x402", "mpp-charge", "mpp-session", "mpp-session-ws"],
+          description: "Optional preferred payment mode. If not specified, the best mode is selected automatically. mpp-session-ws opens a WebSocket-transport MPP session instead of the default HTTP/SSE variant."
+        }
+      },
+      required: ["url", "max_amount"]
+    }
+  },
+  {
+    name: "open_session",
+    description: "Open a sustained MPP session with a provider for streaming data. Requires COMMITMENT_SECRET to be configured. Returns a channel_id \u2014 pass it to stream_session to pull data and to close_session when done, or the channel collateral can never be settled.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The base URL of the provider (e.g., https://api-b.routedock.xyz)"
+        },
+        initial_deposit: {
+          type: "string",
+          description: `Amount in USDC you intend the channel to be funded with (e.g., "1.0"). RouteDock channels are pre-deployed and funded out-of-band before the agent runs \u2014 this is checked against the provider's advertised min_deposit as a safety guard, it does not itself move funds.`
+        }
+      },
+      required: ["url"]
+    }
+  },
+  {
+    name: "stream_session",
+    description: "Pull the next batch of streamed responses from a session opened with open_session. Each message sends a voucher and waits for the provider to acknowledge it. Call repeatedly to keep streaming, then call close_session to settle and release the channel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel_id: {
+          type: "string",
+          description: "The channel_id returned by open_session"
+        },
+        max_messages: {
+          type: "integer",
+          minimum: 1,
+          maximum: MAX_STREAM_MESSAGES,
+          description: `Maximum number of messages to pull in this call (1 to ${MAX_STREAM_MESSAGES}, default 1)`
+        }
+      },
+      required: ["channel_id"]
+    }
+  },
+  {
+    name: "close_session",
+    description: "Close an MPP session opened with open_session, settling the channel on-chain with the highest signed voucher. This is required to release the session's locked collateral \u2014 an open session left unclosed keeps funds locked until the SDK's wall-clock auto-close guard fires.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        channel_id: {
+          type: "string",
+          description: "The channel_id returned by open_session"
+        }
+      },
+      required: ["channel_id"]
+    }
+  },
+  {
+    name: "check_balance",
+    description: "Check the Stellar wallet balance for the configured account",
+    inputSchema: {
+      type: "object",
+      properties: {
+        asset_code: {
+          type: "string",
+          description: 'Optional asset code to check (e.g., "USDC"). If not specified, returns native XLM balance.'
+        },
+        asset_issuer: {
+          type: "string",
+          description: "Optional asset issuer address for non-native assets"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "list_providers",
+    description: "List available RouteDock providers from the registry. Can filter by capability tags (returns providers matching any of the given tags) and by network.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        tags: {
+          type: "string",
+          description: 'Comma-separated tags to filter providers (e.g., "price,stellar,dex")'
+        },
+        network: {
+          type: "string",
+          enum: ["testnet", "mainnet"],
+          description: "Filter by Stellar network"
+        }
+      },
+      required: []
+    }
+  }
+];
+
+// src/handlers.ts
+import { Keypair, Horizon } from "@stellar/stellar-sdk";
+function ok(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+  };
+}
+function err(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ success: false, error: message }, null, 2) }],
+    isError: true
+  };
+}
+async function handlePayForData(args, deps2) {
+  const { url, max_amount, preferred_mode } = args;
+  const { client: client2 } = deps2;
+  const modeOptions = preferred_mode ? { forceMode: preferred_mode } : void 0;
+  const estimate = await client2.estimateCost(url, modeOptions);
+  if (estimate.amount === void 0 || isNaN(parseFloat(estimate.amount))) {
+    return err("Provider returned an undefined or invalid price");
+  }
+  if (parseFloat(estimate.amount) > parseFloat(max_amount)) {
+    return err(
+      `Provider cost ${estimate.amount} ${estimate.asset} exceeds max_amount ${max_amount} USDC`
+    );
+  }
+  const result = await client2.pay(url, modeOptions);
+  return ok({
+    success: true,
+    mode: result.mode,
+    amount: result.amount,
+    tx_hash: result.txHash,
+    timestamp: result.timestamp,
+    data: result.data
+  });
+}
+async function handleOpenSession(args, deps2, commitmentSecret) {
+  const { url, initial_deposit } = args;
+  const { client: client2, openSessions: openSessions2, fetchManifest } = deps2;
+  if (!commitmentSecret) {
+    return err("COMMITMENT_SECRET environment variable is required for session mode");
+  }
+  if (initial_deposit) {
+    const baseUrl = new URL(url).origin;
+    const manifestUrl = `${baseUrl}/.well-known/routedock.json`;
+    const fetcher = fetchManifest ?? ((u) => fetch(u));
+    const manifestResponse = await fetcher(manifestUrl);
+    const manifest = await manifestResponse.json();
+    const minDeposit = manifest?.pricing?.["mpp-session"]?.min_deposit ?? manifest?.pricing?.["mpp-session-ws"]?.min_deposit;
+    if (minDeposit && parseFloat(initial_deposit) < parseFloat(minDeposit)) {
+      return err(
+        `initial_deposit ${initial_deposit} is below this provider's min_deposit ${minDeposit}. RouteDock channels are pre-deployed and funded out-of-band before the agent runs \u2014 make sure the channel is funded with at least min_deposit before opening a session.`
+      );
+    }
+  }
+  const session = await client2.openSession(url);
+  openSessions2.set(session.channelId, session);
+  return ok({
+    success: true,
+    channel_id: session.channelId,
+    open_tx_hash: session.openTxHash,
+    message: "Session opened successfully. Use stream_session to pull data and close_session to settle and release the channel collateral."
+  });
+}
+async function handleStreamSession(args, deps2) {
+  const { channel_id, max_messages } = args;
+  const { openSessions: openSessions2 } = deps2;
+  const session = openSessions2.get(channel_id);
+  if (!session) {
+    return err(
+      `No open session found for channel_id ${channel_id}. It may have already been closed, auto-closed after its wall-clock lifetime guard, or opened by a different server process.`
+    );
+  }
+  if (max_messages !== void 0 && (!Number.isInteger(max_messages) || max_messages < 1 || max_messages > MAX_STREAM_MESSAGES)) {
+    return err(
+      `max_messages must be an integer between 1 and ${MAX_STREAM_MESSAGES} (received ${max_messages})`
+    );
+  }
+  const limit = max_messages ?? 1;
+  const messages = [];
+  const iterator = session.stream()[Symbol.asyncIterator]();
+  try {
+    for (let i = 0; i < limit; i++) {
+      const { value, done } = await iterator.next();
+      if (done) break;
+      messages.push(value);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: false,
+              error: error instanceof Error ? error.message : String(error),
+              channel_id,
+              count: messages.length,
+              messages,
+              stats: session.stats()
+            },
+            null,
+            2
+          )
+        }
+      ],
+      isError: true
+    };
+  } finally {
+    await iterator.return?.();
+  }
+  return ok({
+    success: true,
+    channel_id,
+    count: messages.length,
+    messages
+  });
+}
+async function handleCloseSession(args, deps2) {
+  const { channel_id } = args;
+  const { openSessions: openSessions2 } = deps2;
+  const session = openSessions2.get(channel_id);
+  if (!session) {
+    return err(
+      `No open session found for channel_id ${channel_id}. It may have already been closed or auto-closed after its wall-clock lifetime guard.`
+    );
+  }
+  const result = await session.close();
+  openSessions2.delete(channel_id);
+  return ok({
+    success: true,
+    channel_id,
+    close_tx_hash: result.closeTxHash,
+    total_paid: result.totalPaid,
+    vouchers_issued: result.vouchersIssued
+  });
+}
+var HORIZON_URLS = {
+  mainnet: "https://horizon.stellar.org",
+  testnet: "https://horizon-testnet.stellar.org"
+};
+function normalizeBalances(balances) {
+  return balances.map((b) => ({
+    asset_type: b.asset_type,
+    asset_code: "asset_code" in b ? b.asset_code : void 0,
+    asset_issuer: "asset_issuer" in b ? b.asset_issuer : void 0,
+    balance: b.balance
+  }));
+}
+async function handleCheckBalance(args, deps2) {
+  const { asset_code, asset_issuer } = args;
+  const { stellarSecret, stellarNetwork, createHorizonServer } = deps2;
+  const keypair = Keypair.fromSecret(stellarSecret);
+  const horizonUrl = HORIZON_URLS[stellarNetwork];
+  const horizonServer = createHorizonServer ? createHorizonServer(horizonUrl) : new Horizon.Server(horizonUrl);
+  const account = await horizonServer.loadAccount(keypair.publicKey());
+  const balances = normalizeBalances(account.balances);
+  if (asset_code && asset_issuer) {
+    const balance = balances.find(
+      (b) => b.asset_code === asset_code && b.asset_issuer === asset_issuer
+    );
+    return ok({
+      asset: asset_code,
+      issuer: asset_issuer,
+      balance: balance ? balance.balance : "0",
+      account: keypair.publicKey()
+    });
+  }
+  if (asset_code) {
+    const balance = balances.find((b) => b.asset_code === asset_code);
+    return ok({
+      asset: asset_code,
+      balance: balance ? balance.balance : "0",
+      account: keypair.publicKey()
+    });
+  }
+  const nativeBalance = balances.find((b) => b.asset_type === "native");
+  return ok({
+    asset: "XLM",
+    balance: nativeBalance ? nativeBalance.balance : "0",
+    account: keypair.publicKey()
+  });
+}
+async function handleListProviders(args, deps2) {
+  const { tags, network } = args;
+  const { supabase: supabase2 } = deps2;
+  if (!supabase2) {
+    return err(
+      "SUPABASE_URL and SUPABASE_KEY environment variables are required for provider registry access"
+    );
+  }
+  let query = supabase2.from("providers").select("*");
+  if (network && query.eq) {
+    query = query.eq("network", network);
+  }
+  if (tags) {
+    const tagList = tags.split(",").map((t) => t.trim()).filter(Boolean);
+    if (tagList.length > 0 && query.overlaps) {
+      query = query.overlaps("tags", tagList);
+    }
+  }
+  const { data, error } = await query;
+  if (error) {
+    return err(`Failed to fetch providers: ${error.message}`);
+  }
+  const rows = data ?? [];
+  return ok({
+    success: true,
+    count: rows.length,
+    providers: rows.map((p) => ({
+      name: p.name,
+      description: p.description,
+      network: p.network,
+      asset: p.asset,
+      modes: p.modes,
+      tags: p.tags,
+      base_url: p.base_url
+    }))
+  });
+}
+
+// src/index.ts
+var envPath = process.env.ROUTEDOCK_ENV_FILE;
+if (envPath) {
+  loadDotenv({ path: envPath });
+} else {
+  loadDotenv();
+}
+var STELLAR_SECRET = process.env.STELLAR_SECRET || process.env.ROUTEDOCK_WALLET_SECRET;
+var STELLAR_NETWORK = process.env.STELLAR_NETWORK || "testnet";
+var COMMITMENT_SECRET = process.env.COMMITMENT_SECRET;
+var SUPABASE_URL = process.env.SUPABASE_URL;
+var SUPABASE_KEY = process.env.SUPABASE_KEY || process.env.SUPABASE_SERVICE_KEY;
+if (process.env.SUPABASE_SERVICE_KEY) {
+  console.warn("WARNING: Using SUPABASE_SERVICE_KEY bypasses RLS. Use an anon key for list_providers (anon + public_read_providers RLS is sufficient).");
+}
+if (!STELLAR_SECRET) {
+  console.error("Error: STELLAR_SECRET or ROUTEDOCK_WALLET_SECRET environment variable is required");
+  process.exit(1);
+}
+var ROUTEDOCK_DAILY_CAP = process.env.ROUTEDOCK_DAILY_CAP;
+if (!ROUTEDOCK_DAILY_CAP) {
+  console.error("Error: ROUTEDOCK_DAILY_CAP environment variable is required to prevent unbounded spending");
+  process.exit(1);
+}
+var spendStorePath = process.env.ROUTEDOCK_SPEND_STORE_PATH || path.join(os.homedir(), ".routedock", "spend.json");
+var client = new RouteDockClient({
+  wallet: STELLAR_SECRET,
+  network: STELLAR_NETWORK,
+  commitmentSecret: COMMITMENT_SECRET,
+  spendCap: { daily: ROUTEDOCK_DAILY_CAP, asset: "USDC" },
+  spendStore: new FileSpendStore(spendStorePath)
+});
+var supabase = null;
+if (SUPABASE_URL && SUPABASE_KEY) {
+  supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+}
+var openSessions = /* @__PURE__ */ new Map();
+var deps = {
+  client,
+  openSessions,
+  supabase,
+  stellarSecret: STELLAR_SECRET,
+  stellarNetwork: STELLAR_NETWORK
+};
+var server = new Server(
+  {
+    name: "@routedock/mcp-server",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      case "pay_for_data":
+        return await handlePayForData(args, deps);
+      case "open_session":
+        return await handleOpenSession(args, deps, COMMITMENT_SECRET);
+      case "stream_session":
+        return await handleStreamSession(args, deps);
+      case "close_session":
+        return await handleCloseSession(args, deps);
+      case "check_balance":
+        return await handleCheckBalance(args, deps);
+      case "list_providers":
+        return await handleListProviders(args, deps);
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: error instanceof Error ? error.message : String(error)
+          }, null, 2)
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("@routedock/mcp-server running on stdio");
+}
+main().catch((error) => {
+  console.error("Server error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@routedock/mcp-server",
+  "version": "0.2.0",
+  "description": "MCP server for RouteDock Stellar payments - exposes payment tools to LLM agents",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/winsznx/routedock.git",
+    "directory": "packages/mcp-server"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "routedock-mcp-server": "dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@stellar/stellar-sdk": "^14.6.1",
+    "@supabase/supabase-js": "^2.47.0",
+    "dotenv": "^17.4.2",
+    "@routedock/routedock": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.22.3",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --experimental-test-module-mocks --test \"src/**/*.test.ts\"",
+    "start": "node dist/index.js"
+  }
+}