@arcisprotocol/mcp 0.1.0

package/README.md

@@ -0,0 +1,89 @@
+# @arcis/mcp
+
+Arcis Protocol MCP Server — connect any AI agent to DeFi vaults in one tool call.
+
+## What This Does
+
+Any LLM that supports MCP (Claude, GPT, etc.) can interact with Arcis Protocol's on-chain contracts through natural language. No SDK, no code, no ABI decoding. The agent says "deposit 1000 USDC into Arcis" and the MCP tool handles everything.
+
+## Tools
+
+### Read (no auth required)
+
+| Tool | Description |
+|---|---|
+| `arcis_vault_status` | TVL, exchange rate, supply, capacity, reserve/deployed |
+| `arcis_vault_balance` | Agent position: shares, value, USDC wallet |
+| `arcis_preview_deposit` | Preview shares received for a given deposit |
+| `arcis_credit_status` | Lending pool, total borrowed, utilization |
+| `arcis_credit_tiers` | ERC-8004 reputation tier table |
+| `arcis_credit_health` | Check if a loan is healthy |
+| `arcis_contracts` | All 7 deployed contract addresses |
+
+### Write (private key required)
+
+| Tool | Description |
+|---|---|
+| `arcis_deposit` | Deposit USDC → receive raUSDC (auto-approves) |
+| `arcis_withdraw` | Redeem raUSDC → receive USDC (supports withdraw_all) |
+
+### Resources
+
+| URI | Description |
+|---|---|
+| `arcis://protocol-info` | Protocol overview, ATI spec, product descriptions |
+
+## Setup
+
+```bash
+git clone https://github.com/Arcis-Protocol/mcp.git
+cd mcp && npm install
+npm run dev
+```
+
+## Connect to Claude
+
+Add to your Claude desktop config (`~/.claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "arcis": {
+      "command": "npx",
+      "args": ["tsx", "/path/to/arcis-mcp/src/index.ts"]
+    }
+  }
+}
+```
+
+## Example Interactions
+
+> "What's the TVL on Arcis?"
+> → Calls `arcis_vault_status`, returns $11,250.00
+
+> "Check agent 0xB390...57db's position"
+> → Calls `arcis_vault_balance`, returns shares + value + wallet
+
+> "Deposit 500 USDC"
+> → Calls `arcis_deposit`, handles approval, returns tx hash + explorer link
+
+> "What are the credit tiers?"
+> → Calls `arcis_credit_tiers`, returns 5-tier table with collateral ratios
+
+## Network
+
+Currently targets Base Sepolia testnet. Mainnet addresses will be updated after deployment.
+
+## Related Repos
+
+| Repo | Description |
+|---|---|
+| [`core`](https://github.com/Arcis-Protocol/core) | Smart contracts (Foundry) |
+| [`sdk`](https://github.com/Arcis-Protocol/sdk) | TypeScript SDK |
+| [`cli`](https://github.com/Arcis-Protocol/cli) | Terminal interface (TUI) |
+| [`app`](https://github.com/Arcis-Protocol/app) | arcis.money |
+| [`docs`](https://github.com/Arcis-Protocol/docs) | Protocol documentation |
+
+---
+
+*ARCIS · Of the Citadel · MMXXVI*

package/dist/index.js

@@ -0,0 +1,394 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { MCPServer, object, error, markdown } from "mcp-use/server";
+import { z } from "zod";
+import { createPublicClient, createWalletClient, http, defineChain, formatUnits } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var baseSepolia = defineChain({
+  id: 84532,
+  name: "Base Sepolia",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: { default: { http: ["https://sepolia.base.org"] } },
+  blockExplorers: { default: { name: "Blockscout", url: "https://base-sepolia.blockscout.com" } }
+});
+var ADDR = {
+  vault: "0xa8eF658E125C7f6D7aFa9B6b8035b66b32CBE98d",
+  credit: "0x019540E33a0292a9DDE36bD9Ef11774d5A1Ce6FC",
+  router: "0x0281e7D37683c585325004F84e0b94170c78d5B4",
+  usdc: "0x29440A12f15fe6bDf5F624f4eeEB298CCb782f05",
+  allocator: "0x9f101e1159AA530dC5Cb104decB32aBA1eAF2617",
+  strategy: "0x9d6FB397224141FD323096e95667d3Ae5D9FF9cC",
+  identity: "0x79E79629DB86CFb8feF9594621882b065EBC80A7"
+};
+var VAULT_ABI = [
+  { name: "deposit", type: "function", inputs: [{ name: "amount", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "nonpayable" },
+  { name: "withdraw", type: "function", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "nonpayable" },
+  { name: "balance", type: "function", inputs: [{ name: "agent", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "balanceOf", type: "function", inputs: [{ name: "account", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "totalAssets", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "totalSupply", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "exchangeRate", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "depositCap", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "remainingCapacity", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "reserveBalance", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "deployedBalance", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "paused", type: "function", inputs: [], outputs: [{ name: "", type: "bool" }], stateMutability: "view" },
+  { name: "previewDeposit", type: "function", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "previewWithdraw", type: "function", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" }
+];
+var CREDIT_ABI = [
+  { name: "lendingPool", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "totalBorrowed", type: "function", inputs: [], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "collateralRatios", type: "function", inputs: [{ name: "tier", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "totalOwed", type: "function", inputs: [{ name: "loanId", type: "uint256" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "isHealthy", type: "function", inputs: [{ name: "loanId", type: "uint256" }], outputs: [{ name: "", type: "bool" }], stateMutability: "view" }
+];
+var ERC20_ABI = [
+  { name: "approve", type: "function", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ name: "", type: "bool" }], stateMutability: "nonpayable" },
+  { name: "balanceOf", type: "function", inputs: [{ name: "account", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" },
+  { name: "allowance", type: "function", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ name: "", type: "uint256" }], stateMutability: "view" }
+];
+var client = createPublicClient({ chain: baseSepolia, transport: http() });
+var fmtUSDC = (raw) => formatUnits(raw, 6);
+var fmtRate = (raw) => {
+  const n = Number(raw) / 1e18;
+  return n > 1e3 || n < 1e-4 ? "1.000000" : n.toFixed(6);
+};
+var server = new MCPServer({
+  name: "arcis-protocol",
+  title: "Arcis Protocol",
+  description: "Financial infrastructure for autonomous AI agents \u2014 yield vaults, credit, and bonds on Base",
+  version: "0.1.0"
+});
+server.tool(
+  {
+    name: "arcis_vault_status",
+    description: "Get the current vault status: TVL, exchange rate, raUSDC supply, deposit cap, reserve/deployed split, and pause state. No parameters needed.",
+    schema: z.object({})
+  },
+  async () => {
+    try {
+      const [totalAssets, totalSupply, rate, cap, remaining, reserve, deployed, paused] = await Promise.all([
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "totalAssets" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "totalSupply" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "exchangeRate" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "depositCap" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "remainingCapacity" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "reserveBalance" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "deployedBalance" }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "paused" })
+      ]);
+      const utilPct = cap > 0n ? (Number(totalAssets * 10000n / cap) / 100).toFixed(2) : "0";
+      const resPct = totalAssets > 0n ? (Number(reserve * 10000n / totalAssets) / 100).toFixed(1) : "0";
+      return object({
+        network: "Base Sepolia (84532)",
+        contract: ADDR.vault,
+        status: paused ? "PAUSED" : "ACTIVE",
+        tvl_usdc: fmtUSDC(totalAssets),
+        rausdc_supply: fmtUSDC(totalSupply),
+        exchange_rate: totalSupply > 0n ? fmtRate(rate) : "1.000000",
+        reserve_usdc: fmtUSDC(reserve),
+        reserve_pct: resPct + "%",
+        deployed_usdc: fmtUSDC(deployed),
+        deposit_cap_usdc: cap > 0n ? fmtUSDC(cap) : "No cap set",
+        remaining_capacity: cap > 0n ? fmtUSDC(remaining) : "Unlimited",
+        utilization: utilPct + "%",
+        explorer: `https://base-sepolia.blockscout.com/address/${ADDR.vault}`
+      });
+    } catch (e) {
+      return error("Failed to fetch vault status: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_vault_balance",
+    description: "Check an agent's vault position: raUSDC shares held, position value in USDC, and USDC wallet balance.",
+    schema: z.object({
+      address: z.string().describe("The agent's Ethereum address (0x...)")
+    })
+  },
+  async ({ address }) => {
+    try {
+      const agent = address;
+      const [shares, value, usdcBal] = await Promise.all([
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "balanceOf", args: [agent] }),
+        client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "balance", args: [agent] }),
+        client.readContract({ address: ADDR.usdc, abi: ERC20_ABI, functionName: "balanceOf", args: [agent] })
+      ]);
+      return object({
+        agent: address,
+        rausdc_shares: fmtUSDC(shares),
+        position_value_usdc: fmtUSDC(value),
+        usdc_wallet_balance: fmtUSDC(usdcBal)
+      });
+    } catch (e) {
+      return error("Failed to fetch balance: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_preview_deposit",
+    description: "Preview how many raUSDC shares a given USDC deposit would yield, without executing the transaction.",
+    schema: z.object({
+      amount: z.number().positive().describe("Amount of USDC to deposit (e.g. 1000 for $1,000)")
+    })
+  },
+  async ({ amount }) => {
+    try {
+      const raw = BigInt(Math.floor(amount * 1e6));
+      const shares = await client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "previewDeposit", args: [raw] });
+      return object({
+        deposit_usdc: amount.toString(),
+        shares_received: fmtUSDC(shares),
+        exchange_rate: (amount * 1e6 / Number(shares)).toFixed(6)
+      });
+    } catch (e) {
+      return error("Preview failed: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_credit_status",
+    description: "Get the credit module status: lending pool size, total borrowed, and utilization rate.",
+    schema: z.object({})
+  },
+  async () => {
+    try {
+      const [pool, borrowed] = await Promise.all([
+        client.readContract({ address: ADDR.credit, abi: CREDIT_ABI, functionName: "lendingPool" }),
+        client.readContract({ address: ADDR.credit, abi: CREDIT_ABI, functionName: "totalBorrowed" })
+      ]);
+      const total = pool + borrowed;
+      const utilPct = total > 0n ? (Number(borrowed * 10000n / total) / 100).toFixed(1) : "0";
+      return object({
+        contract: ADDR.credit,
+        lending_pool_usdc: fmtUSDC(pool),
+        total_borrowed_usdc: fmtUSDC(borrowed),
+        utilization: utilPct + "%"
+      });
+    } catch (e) {
+      return error("Failed to fetch credit status: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_credit_tiers",
+    description: "List all 5 ERC-8004 reputation tiers with their collateral ratios and rate discounts.",
+    schema: z.object({})
+  },
+  async () => {
+    try {
+      const labels = ["No Identity", "Novice (1-25)", "Active (26-50)", "Established (51-75)", "Elite (76-100)"];
+      const discounts = [0, 100, 200, 350, 500];
+      const ratios = await Promise.all(
+        [0, 1, 2, 3, 4].map(
+          (i) => client.readContract({ address: ADDR.credit, abi: CREDIT_ABI, functionName: "collateralRatios", args: [BigInt(i)] })
+        )
+      );
+      return object({
+        tiers: ratios.map((r, i) => ({
+          tier: i,
+          label: labels[i],
+          collateral_ratio: (Number(r) / 100).toFixed(1) + "%",
+          rate_discount_bps: discounts[i]
+        }))
+      });
+    } catch (e) {
+      return error("Failed to fetch tiers: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_credit_health",
+    description: "Check whether a specific loan is healthy (sufficiently collateralized) and how much is owed.",
+    schema: z.object({
+      loan_id: z.number().int().positive().describe("The loan ID to check")
+    })
+  },
+  async ({ loan_id }) => {
+    try {
+      const [healthy, owed] = await Promise.all([
+        client.readContract({ address: ADDR.credit, abi: CREDIT_ABI, functionName: "isHealthy", args: [BigInt(loan_id)] }),
+        client.readContract({ address: ADDR.credit, abi: CREDIT_ABI, functionName: "totalOwed", args: [BigInt(loan_id)] })
+      ]);
+      return object({
+        loan_id,
+        healthy,
+        total_owed_usdc: fmtUSDC(owed),
+        status: healthy ? "HEALTHY" : "UNDERCOLLATERALIZED"
+      });
+    } catch (e) {
+      return error("Failed to check loan health: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_contracts",
+    description: "List all deployed Arcis Protocol contract addresses on Base Sepolia with their roles.",
+    schema: z.object({})
+  },
+  async () => {
+    return object({
+      network: "Base Sepolia (84532)",
+      explorer: "https://base-sepolia.blockscout.com",
+      contracts: {
+        ArcisVault: { address: ADDR.vault, role: "ERC-4626 yield vault (raUSDC)" },
+        AgentCredit: { address: ADDR.credit, role: "ERC-8004 identity-aware lending" },
+        ATIRouter: { address: ADDR.router, role: "Multi-vault entry point" },
+        StrategyAllocator: { address: ADDR.allocator, role: "Yield strategy weights" },
+        MockStrategy: { address: ADDR.strategy, role: "Testnet yield strategy" },
+        MockUSDC: { address: ADDR.usdc, role: "Testnet USDC" },
+        MockIdentityRegistry: { address: ADDR.identity, role: "ERC-8004 test registry" }
+      },
+      ati_standard: {
+        deposit: "deposit(uint256 amount) \u2192 uint256 shares",
+        withdraw: "withdraw(uint256 shares) \u2192 uint256 amount",
+        balance: "balance(address agent) \u2192 uint256 value"
+      }
+    });
+  }
+);
+server.tool(
+  {
+    name: "arcis_deposit",
+    description: "Deposit USDC into the Arcis vault and receive raUSDC shares. Handles USDC approval automatically. Requires an agent private key.",
+    schema: z.object({
+      amount: z.number().positive().describe("Amount of USDC to deposit (e.g. 1000 for $1,000)"),
+      private_key: z.string().describe("Agent's private key (0x...) for signing the transaction")
+    })
+  },
+  async ({ amount, private_key }) => {
+    try {
+      const amountRaw = BigInt(Math.floor(amount * 1e6));
+      const account = privateKeyToAccount(private_key);
+      const wallet = createWalletClient({ chain: baseSepolia, transport: http(), account });
+      const usdcBal = await client.readContract({ address: ADDR.usdc, abi: ERC20_ABI, functionName: "balanceOf", args: [account.address] });
+      if (usdcBal < amountRaw) {
+        return error(`Insufficient USDC. Have ${fmtUSDC(usdcBal)}, need ${fmtUSDC(amountRaw)}`);
+      }
+      const allowance = await client.readContract({ address: ADDR.usdc, abi: ERC20_ABI, functionName: "allowance", args: [account.address, ADDR.vault] });
+      if (allowance < amountRaw) {
+        const approveTx = await wallet.writeContract({
+          address: ADDR.usdc,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [ADDR.vault, 2n ** 256n - 1n],
+          chain: baseSepolia,
+          account
+        });
+        await client.waitForTransactionReceipt({ hash: approveTx });
+      }
+      const sharesPreview = await client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "previewDeposit", args: [amountRaw] });
+      const tx = await wallet.writeContract({
+        address: ADDR.vault,
+        abi: VAULT_ABI,
+        functionName: "deposit",
+        args: [amountRaw],
+        chain: baseSepolia,
+        account
+      });
+      const receipt = await client.waitForTransactionReceipt({ hash: tx });
+      return object({
+        status: "SUCCESS",
+        deposited_usdc: amount.toString(),
+        shares_received: fmtUSDC(sharesPreview),
+        tx_hash: tx,
+        block: Number(receipt.blockNumber),
+        gas_used: Number(receipt.gasUsed),
+        explorer: `https://base-sepolia.blockscout.com/tx/${tx}`
+      });
+    } catch (e) {
+      return error("Deposit failed: " + e.message);
+    }
+  }
+);
+server.tool(
+  {
+    name: "arcis_withdraw",
+    description: "Withdraw USDC from the Arcis vault by redeeming raUSDC shares. Use withdraw_all to redeem entire position.",
+    schema: z.object({
+      shares: z.number().positive().optional().describe("Amount of raUSDC shares to redeem (omit to withdraw all)"),
+      private_key: z.string().describe("Agent's private key (0x...) for signing the transaction"),
+      withdraw_all: z.boolean().optional().describe("Set to true to withdraw entire position")
+    })
+  },
+  async ({ shares, private_key, withdraw_all }) => {
+    try {
+      const account = privateKeyToAccount(private_key);
+      const wallet = createWalletClient({ chain: baseSepolia, transport: http(), account });
+      let sharesRaw;
+      if (withdraw_all) {
+        sharesRaw = await client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "balanceOf", args: [account.address] });
+        if (sharesRaw === 0n) return error("No shares to withdraw");
+      } else if (shares) {
+        sharesRaw = BigInt(Math.floor(shares * 1e6));
+      } else {
+        return error("Provide either shares amount or set withdraw_all to true");
+      }
+      const usdcPreview = await client.readContract({ address: ADDR.vault, abi: VAULT_ABI, functionName: "previewWithdraw", args: [sharesRaw] });
+      const tx = await wallet.writeContract({
+        address: ADDR.vault,
+        abi: VAULT_ABI,
+        functionName: "withdraw",
+        args: [sharesRaw],
+        chain: baseSepolia,
+        account
+      });
+      const receipt = await client.waitForTransactionReceipt({ hash: tx });
+      return object({
+        status: "SUCCESS",
+        shares_redeemed: fmtUSDC(sharesRaw),
+        usdc_received: fmtUSDC(usdcPreview),
+        tx_hash: tx,
+        block: Number(receipt.blockNumber),
+        explorer: `https://base-sepolia.blockscout.com/tx/${tx}`
+      });
+    } catch (e) {
+      return error("Withdraw failed: " + e.message);
+    }
+  }
+);
+server.resource(
+  {
+    uri: "arcis://protocol-info",
+    name: "Arcis Protocol Info",
+    description: "Overview of Arcis Protocol \u2014 what it is, how it works, and how agents interact with it",
+    mimeType: "text/markdown"
+  },
+  async () => markdown(`# Arcis Protocol
+
+**The citadel of agent capital.**
+
+Arcis builds financial infrastructure for autonomous AI agents: yield-bearing vaults, identity-aware credit lines, and revenue bonds. Deployed on Base.
+
+## ATI Standard (Agent Treasury Interface)
+
+Three functions. Any agent framework.
+
+- \`deposit(uint256 amount) \u2192 uint256 shares\` \u2014 Deposit USDC, receive yield-bearing raUSDC
+- \`withdraw(uint256 shares) \u2192 uint256 amount\` \u2014 Redeem raUSDC for USDC + accrued yield
+- \`balance(address agent) \u2192 uint256 value\` \u2014 Check position value in USDC
+
+## Products
+
+1. **Agent Vaults** \u2014 ERC-4626 vaults where agents park idle USDC. Yield via Aave/Morpho strategies. Management fee: 2% on yield.
+2. **Agent Credit** \u2014 ERC-8004 reputation-aware lending. 5 tiers from 200% to 115% collateral based on on-chain identity score.
+3. **Revenue Bonds** \u2014 Agents with consistent revenue issue tokenized bonds. Human investors buy fixed yield.
+
+## Links
+
+- Website: https://arcis.money
+- Dashboard: https://arcis.money/dashboard
+- GitHub: https://github.com/Arcis-Protocol
+- Telegram: https://t.me/arcisprotocol
+- X: https://x.com/ArcisProtocol
+`)
+);
+server.listen();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@arcisprotocol/mcp",
+  "version": "0.1.0",
+  "description": "Arcis Protocol MCP Server — connect any AI agent to DeFi vaults in one tool call",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "arcis-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["arcis", "mcp", "model-context-protocol", "defi", "ai-agents", "vault", "base"],
+  "author": "Arcis Protocol <dev@arcis.money>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Arcis-Protocol/mcp.git"
+  },
+  "homepage": "https://arcis.money",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "mcp-use": "^0.14.0",
+    "viem": "^2.21.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "tsup": "^8.3.0",
+    "tsx": "^4.19.0",
+    "@types/node": "^22.0.0"
+  }
+}