@cloakely/mcp 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bob Labs
+
+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

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# @cloakely/mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Cloak's MCP server.** It lets an AI agent launch tokens with sealed bids and trade them privately on Kinetiq's Elysium, from Claude, Cursor or any MCP client.
+
+An agent that trades on chain leaks its strategy with every transaction, and anyone can copy or front-run it. With Cloak, its bids stay sealed until bidding closes, and its trades come from a private balance: each one is proven on the agent's machine and sent by a relayer, so the agent's wallet never appears on them.
+
+**Testnet only for now** (Elysium testnet, chain `99801`). Play money only.
+
+There are two ways in:
+
+| | Hosted link | Local server (this package) |
+|---|---|---|
+| Install | Nothing: paste `https://cloak.boblabs.tech/mcp` | `npx -y @cloakely/mcp` |
+| Can do | Read and plan: launches, quotes, vault totals, launch plans | Everything: launch, bid, claim, shield, private swaps, batch orders, private sends, withdrawals |
+| Keys | None. It never signs and refuses calls that look like they carry a key | Your agent's wallet, on your machine only |
+
+## Connect by link
+
+- **Claude** (claude.ai or Desktop): Settings, Connectors, Add custom connector, then paste `https://cloak.boblabs.tech/mcp`.
+- **ChatGPT**: turn on developer mode under Apps and connectors, then add a connector with the link and no authentication.
+- **Claude Code**: `claude mcp add --transport http cloak https://cloak.boblabs.tech/mcp`
+- **Cursor, VS Code and others**: `{ "mcpServers": { "cloak": { "url": "https://cloak.boblabs.tech/mcp" } } }`
+
+Its tools: `cloak_info`, `list_launches`, `get_launch`, `quote_bid`, `quote_swap`, `vault_stats`, `plan_launch` and `connect_full_agent`. It's stateless (each request gets a fresh server and nothing is kept) and rate limited. You can serve it yourself from any runtime that speaks web `Request`/`Response`: `import { handleMcpRequest } from "@cloakely/mcp/http"`.
+
+## Set up the local server
+
+Create a fresh wallet for the agent, fund it from the [Elysium faucet](https://elysium.kinetiq.xyz/testnet-faucet), and put its private key in a file only you can read:
+
+```sh
+umask 077 && echo 0xYOUR_AGENT_KEY > ~/.cloak-agent-key
+```
+
+**Claude Code:**
+
+```sh
+claude mcp add cloak --env CLOAK_KEY_FILE=$HOME/.cloak-agent-key -- npx -y @cloakely/mcp
+```
+
+**Claude Desktop, Cursor and other clients** (`claude_desktop_config.json`, `.cursor/mcp.json`, and so on):
+
+```json
+{
+  "mcpServers": {
+    "cloak": {
+      "command": "npx",
+      "args": ["-y", "@cloakely/mcp"],
+      "env": { "CLOAK_KEY_FILE": "/Users/you/.cloak-agent-key" }
+    }
+  }
+}
+```
+
+Without a key, the server is **read only**: the agent can browse launches and quote bids and swaps, but can't sign anything.
+
+Then ask, for example:
+- "What Cloak launches are open right now?"
+- "Launch a token called Ember, 1M for sale, starting at 0.000001 HYPE, bidding open for an hour."
+- "Bid on EMBR up to 0.00002 HYPE for 50,000 tokens. Dry run first."
+- "Shield 0.5 HYPE, then buy CLOAK privately with 0.1 of it."
+- "Send 0.05 private HYPE to cloak:…, then withdraw the rest to 0x…"
+
+## Tools
+
+| Group | Tool | What it does |
+|---|---|---|
+| Read | `cloak_info` | Network, contracts, the wallet and its public balances, spending limits with what's left today |
+| | `list_launches` | Launches, newest first, with phase, timing, prices and whether private trading is on |
+| | `get_launch` | One launch in full: timing, prices, caps, results, revealed demand once bids open |
+| | `quote_bid` | The price tick, cost and rounded deposit for a bid |
+| | `quote_swap` | Expected output of a private buy or sell, with the fees |
+| | `vault_stats` | How much sits in each private vault (totals only) |
+| Launch | `create_launch` | Start a sealed-bid launch |
+| | `place_sealed_bid` | Commit a sealed bid. It opens by itself after bidding closes |
+| | `my_bids` | The wallet's bids: opened, claimed, tokens won, refund |
+| | `claim` | Settle if nobody has, then claim tokens and refunds |
+| | `enable_private_trading` | Open a private vault for a settled launch's token |
+| Private | `unlock` | Derive the private account from one local signature and return its `cloak:` address |
+| | `private_balance` | HYPE, USDC and launch tokens held privately |
+| | `shield` | HYPE or USDC from the wallet into the private balance (the one public step) |
+| | `private_swap` | Buy or sell a launch token from the private balance |
+| | `batch_order` | Trade in standard sizes inside a batch round, which hides the trade's size |
+| | `private_send` | Pay a `cloak:` address. Sender, recipient and amount stay hidden |
+| | `withdraw` | Private balance to a normal address (ideally a fresh one) |
+
+Amounts are in whole units (`"0.5"` HYPE). `private_send`, `withdraw` and a `private_swap` sell accept `"max"`.
+
+## Safety
+
+- **Spending limits.** Every action that moves value is checked first: bids, shields, swaps (either side, valued in HYPE at the pool price), batch orders, sends and withdrawals. There's a cap per transaction and per UTC day for HYPE value, a separate one for USDC, and a number of launches per day. The day's totals are kept in `~/.cloak-mcp`, so restarting the server doesn't reset them.
+- **Dry run.** Every write tool takes `dry_run: true` and returns exactly what it would do, without signing or sending anything. `CLOAK_DRY_RUN=1` makes every write a dry run.
+- **Testnet by default.** Mainnet needs `CLOAK_NETWORK=mainnet` and `CLOAK_ALLOW_MAINNET=1`, and isn't live yet.
+- **The key stays on your machine.** It signs locally and is never sent anywhere. The private account is derived from a local signature, and proofs are generated locally (the circuit files are downloaded once and checked against the hashes pinned in `@cloakely/sdk`). The relayer only sees proofs, which it can submit but can't change.
+- **One write at a time**, so two calls never spend the same private notes.
+- Give the agent a **dedicated wallet** with only what you're willing to let it spend.
+
+## Configuration
+
+| Variable | Default | |
+|---|---|---|
+| `CLOAK_KEY_FILE` | | File holding the agent wallet's private key (preferred) |
+| `CLOAK_PRIVATE_KEY` | | The key itself, if a file isn't practical |
+| `CLOAK_NETWORK` | `testnet` | `testnet`, or `custom` with `CLOAK_DEPLOYMENT_FILE` |
+| `CLOAK_MAX_HYPE_PER_TX` | `1` | HYPE value per transaction |
+| `CLOAK_MAX_HYPE_PER_DAY` | `10` | HYPE value per UTC day |
+| `CLOAK_MAX_USDC_PER_TX` | `100` | USDC per transaction |
+| `CLOAK_MAX_USDC_PER_DAY` | `1000` | USDC per UTC day |
+| `CLOAK_MAX_LAUNCHES_PER_DAY` | `3` | Launches per UTC day |
+| `CLOAK_DRY_RUN` | | `1` turns every write into a dry run |
+| `CLOAK_STATE_DIR` | `~/.cloak-mcp` | Daily spend totals and bid receipts |
+| `CLOAK_RPC_URL` | Elysium testnet RPC | |
+| `CLOAK_RELAYER_URL` | Cloak's hosted relayer | |
+| `CLOAK_CIRCUITS_DIR` | download | Folder with `transaction2x2.wasm` and `transaction2x2_final.zkey` |
+
+Built on [`@cloakely/sdk`](https://www.npmjs.com/package/@cloakely/sdk). Source: [NECOKIZZ/Cloak](https://github.com/NECOKIZZ/Cloak/tree/main/packages/mcp). MIT.

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+import { type Chain, type Hex } from "viem";
+import { type CloakDeployment } from "@cloakely/sdk";
+/** Where the server points, and what it may do. Everything comes from environment variables (see README). */
+export interface Settings {
+    network: string;
+    chain: Chain;
+    rpcUrl: string;
+    deployment: CloakDeployment;
+    /** First block to scan for a launch's bids (the factory's deploy block). */
+    launchesFromBlock: bigint;
+    /** Local circuit files instead of downloading them (hash-checked) from `deployment.circuitsUrl`. */
+    circuitsDir?: string;
+    privateKey?: Hex;
+    dryRun: boolean;
+    stateDir: string;
+    limits: Limits;
+}
+export interface Limits {
+    hypePerTx: bigint;
+    hypePerDay: bigint;
+    usdcPerTx: bigint;
+    usdcPerDay: bigint;
+    launchesPerDay: number;
+}
+export declare function loadSettings(env?: NodeJS.ProcessEnv): Settings;

package/dist/config.js

@@ -0,0 +1,73 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { defineChain, parseEther, parseUnits } from "viem";
+import { deploymentFor, elysiumTestnet } from "@cloakely/sdk";
+const NETWORKS = {
+    testnet: { chain: elysiumTestnet, launchesFromBlock: 15855986n },
+};
+export function loadSettings(env = process.env) {
+    const network = env.CLOAK_NETWORK ?? (env.CLOAK_DEPLOYMENT_FILE ? "custom" : "testnet");
+    let chain;
+    let deployment;
+    let launchesFromBlock;
+    let rpcUrl;
+    if (network === "mainnet") {
+        if (env.CLOAK_ALLOW_MAINNET !== "1")
+            throw new Error("CLOAK_NETWORK=mainnet needs CLOAK_ALLOW_MAINNET=1 as well. Mainnet moves real money.");
+        throw new Error("Cloak mainnet isn't live yet. Use CLOAK_NETWORK=testnet.");
+    }
+    else if (network === "custom") {
+        if (!env.CLOAK_DEPLOYMENT_FILE)
+            throw new Error("CLOAK_NETWORK=custom needs CLOAK_DEPLOYMENT_FILE");
+        const f = JSON.parse(readFileSync(env.CLOAK_DEPLOYMENT_FILE, "utf8"));
+        rpcUrl = f.rpcUrl;
+        chain = defineChain({ id: f.chainId, name: `Cloak custom (${f.chainId})`, nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 }, rpcUrls: { default: { http: [rpcUrl] } }, testnet: true });
+        deployment = { ...f, routerBlock: BigInt(f.routerBlock), assets: f.assets?.map((a) => ({ ...a, fromBlock: BigInt(a.fromBlock) })) };
+        launchesFromBlock = BigInt(f.launchesFromBlock ?? 0);
+    }
+    else {
+        const n = NETWORKS[network];
+        if (!n)
+            throw new Error(`unknown CLOAK_NETWORK "${network}" (use testnet)`);
+        chain = n.chain;
+        deployment = deploymentFor(chain.id);
+        launchesFromBlock = n.launchesFromBlock;
+        rpcUrl = chain.rpcUrls.default.http[0];
+    }
+    if (env.CLOAK_RPC_URL)
+        rpcUrl = env.CLOAK_RPC_URL;
+    if (env.CLOAK_RELAYER_URL)
+        deployment = { ...deployment, relayerUrl: env.CLOAK_RELAYER_URL };
+    let key = env.CLOAK_PRIVATE_KEY?.trim();
+    if (!key && env.CLOAK_KEY_FILE)
+        key = readFileSync(env.CLOAK_KEY_FILE, "utf8").trim();
+    if (key && !key.startsWith("0x"))
+        key = `0x${key}`;
+    if (key && !/^0x[0-9a-fA-F]{64}$/.test(key))
+        throw new Error("the private key must be 32 bytes of hex");
+    const num = (name, fallback) => {
+        const v = env[name] ?? fallback;
+        if (!/^\d+(\.\d+)?$/.test(v))
+            throw new Error(`${name} must be a number, got "${v}"`);
+        return v;
+    };
+    return {
+        network,
+        chain,
+        rpcUrl,
+        deployment,
+        launchesFromBlock,
+        circuitsDir: env.CLOAK_CIRCUITS_DIR,
+        privateKey: key,
+        dryRun: env.CLOAK_DRY_RUN === "1",
+        stateDir: env.CLOAK_STATE_DIR ?? join(homedir(), ".cloak-mcp"),
+        limits: {
+            hypePerTx: parseEther(num("CLOAK_MAX_HYPE_PER_TX", "1")),
+            hypePerDay: parseEther(num("CLOAK_MAX_HYPE_PER_DAY", "10")),
+            usdcPerTx: parseUnits(num("CLOAK_MAX_USDC_PER_TX", "100"), 6),
+            usdcPerDay: parseUnits(num("CLOAK_MAX_USDC_PER_DAY", "1000"), 6),
+            launchesPerDay: Number(num("CLOAK_MAX_LAUNCHES_PER_DAY", "3")),
+        },
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,5 @@
+import { type Settings } from "./config.js";
+/** `settings` defaults to Elysium testnet, without a key (tests pass their own). */
+export declare function handleMcpRequest(req: Request, opts?: {
+    settings?: Settings;
+}): Promise<Response>;

package/dist/http.js

@@ -0,0 +1,92 @@
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { loadSettings } from "./config.js";
+import { createCloakServer } from "./server.js";
+/**
+ * The hosted MCP endpoint as a web-standard handler (Request in, Response out), for any serverless runtime.
+ * Streamable HTTP, stateless: every POST gets a fresh read-and-plan server, the answer is plain JSON, and nothing is
+ * kept. With no sessions, GET (an event stream) and DELETE (ending a session) answer 405, as the spec allows; a
+ * browser opening the URL is sent to the setup docs instead.
+ */
+const REQUESTS_PER_MINUTE = 60;
+const MAX_BODY_BYTES = 64_000;
+const DOCS = "https://cloak.boblabs.tech/docs#agents";
+const CORS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Accept, Authorization, Mcp-Session-Id, Mcp-Protocol-Version, Last-Event-ID",
+    "Access-Control-Expose-Headers": "Mcp-Session-Id, Mcp-Protocol-Version, Retry-After",
+    "Access-Control-Max-Age": "86400",
+};
+function withHeaders(res, extra = {}) {
+    const headers = new Headers(res.headers);
+    for (const [k, v] of Object.entries({ ...CORS, "Cache-Control": "no-store", ...extra }))
+        headers.set(k, v);
+    return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+}
+const rpcError = (status, code, message, extra) => withHeaders(Response.json({ jsonrpc: "2.0", error: { code, message }, id: null }, { status }), extra);
+// Best effort, per instance: a serverless platform may run several, so this caps bursts rather than guaranteeing a rate.
+const hits = new Map();
+function limited(ip) {
+    const now = Date.now();
+    const h = hits.get(ip);
+    if (!h || now - h.start > 60_000) {
+        if (hits.size > 10_000)
+            hits.clear();
+        hits.set(ip, { start: now, n: 1 });
+        return 0;
+    }
+    h.n++;
+    return h.n > REQUESTS_PER_MINUTE ? Math.ceil((h.start + 60_000 - now) / 1000) : 0;
+}
+let settings;
+/** `settings` defaults to Elysium testnet, without a key (tests pass their own). */
+export async function handleMcpRequest(req, opts = {}) {
+    if (req.method === "OPTIONS")
+        return withHeaders(new Response(null, { status: 204 }));
+    if (req.method === "GET") {
+        const accept = req.headers.get("accept") ?? "";
+        if (accept.includes("text/html") && !accept.includes("text/event-stream"))
+            return withHeaders(Response.redirect(DOCS, 307));
+        return rpcError(405, -32000, "Method not allowed. This server is stateless: POST JSON-RPC messages to this URL.", { Allow: "POST, OPTIONS" });
+    }
+    if (req.method !== "POST")
+        return rpcError(405, -32000, "Method not allowed. This server keeps no sessions.", { Allow: "POST, OPTIONS" });
+    const ip = (req.headers.get("x-forwarded-for") ?? "").split(",")[0].trim() || req.headers.get("x-real-ip") || "unknown";
+    const wait = limited(ip);
+    if (wait)
+        return rpcError(429, -32000, `Too many requests. Try again in ${wait} seconds.`, { "Retry-After": String(wait) });
+    if (Number(req.headers.get("content-length") ?? "0") > MAX_BODY_BYTES)
+        return rpcError(413, -32600, "Request too large.");
+    let body;
+    try {
+        const text = await req.text();
+        if (text.length > MAX_BODY_BYTES)
+            return rpcError(413, -32600, "Request too large.");
+        body = JSON.parse(text);
+    }
+    catch {
+        return rpcError(400, -32700, "Parse error: send a JSON-RPC message as JSON.");
+    }
+    // the body is already parsed, so be lenient about the headers: the answer is always JSON
+    const headers = new Headers(req.headers);
+    headers.set("accept", "application/json, text/event-stream");
+    headers.set("content-type", "application/json");
+    headers.delete("content-length");
+    headers.delete("transfer-encoding");
+    const forward = new Request(req.url, { method: "POST", headers });
+    // never a key here, whatever the environment says
+    const s = opts.settings ?? (settings ??= loadSettings({ CLOAK_NETWORK: "testnet", CLOAK_RPC_URL: process.env.CLOAK_RPC_URL, CLOAK_RELAYER_URL: process.env.CLOAK_RELAYER_URL }));
+    const server = createCloakServer(s, { hosted: true });
+    const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+    try {
+        await server.connect(transport);
+        return withHeaders(await transport.handleRequest(forward, { parsedBody: body }));
+    }
+    catch (e) {
+        console.error("cloak-mcp hosted:", e?.name ?? "error");
+        return rpcError(500, -32603, "Internal error.");
+    }
+    finally {
+        await server.close().catch(() => { });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// Cloak's MCP server over stdio: `npx @cloakely/mcp`. Configuration is environment variables only (see README).
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createCloakServer, loadSettings, VERSION } from "./server.js";
+try {
+    const settings = loadSettings();
+    const server = createCloakServer(settings);
+    await server.connect(new StdioServerTransport());
+    // stdout carries the protocol, so anything for humans goes to stderr
+    console.error(`cloak-mcp ${VERSION} on ${settings.network} (chain ${settings.chain.id}), ${settings.privateKey ? "wallet configured" : "read only"}${settings.dryRun ? ", dry run" : ""}`);
+}
+catch (e) {
+    console.error(`cloak-mcp: ${e.message}`);
+    process.exit(1);
+}

package/dist/limits.d.ts

@@ -0,0 +1,48 @@
+import type { Limits } from "./config.js";
+export type Budget = "hype" | "usdc" | "launches";
+/**
+ * Spending limits for one wallet: a cap per transaction and per UTC day for HYPE value and for USDC, and a number of
+ * launches per day. The day's totals live in a file under the state directory, so restarting the server doesn't reset
+ * them. Only actions that succeed are counted.
+ */
+export declare class Spending {
+    readonly limits: Limits;
+    private now;
+    private file;
+    session: {
+        hype: bigint;
+        usdc: bigint;
+        launches: bigint;
+    };
+    constructor(limits: Limits, stateDir: string, account: string, now?: () => Date);
+    private today;
+    private caps;
+    /** Throws a plain sentence if `amount` would break a limit. */
+    check(b: Budget, amount: bigint): void;
+    record(b: Budget, amount: bigint): void;
+    summary(): {
+        day: string;
+        hype: {
+            perTransaction: string;
+            perDay: string;
+            usedToday: string;
+            leftToday: string;
+            usedThisSession: string;
+        };
+        usdc: {
+            perTransaction: string;
+            perDay: string;
+            usedToday: string;
+            leftToday: string;
+            usedThisSession: string;
+        };
+        launches: {
+            perTransaction: string;
+            perDay: string;
+            usedToday: string;
+            leftToday: string;
+            usedThisSession: string;
+        };
+    };
+}
+export declare function show(b: Budget, x: bigint): string;

package/dist/limits.js

@@ -0,0 +1,72 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { formatEther, formatUnits } from "viem";
+/**
+ * Spending limits for one wallet: a cap per transaction and per UTC day for HYPE value and for USDC, and a number of
+ * launches per day. The day's totals live in a file under the state directory, so restarting the server doesn't reset
+ * them. Only actions that succeed are counted.
+ */
+export class Spending {
+    limits;
+    now;
+    file;
+    session = { hype: 0n, usdc: 0n, launches: 0n };
+    constructor(limits, stateDir, account, now = () => new Date()) {
+        this.limits = limits;
+        this.now = now;
+        mkdirSync(stateDir, { recursive: true });
+        this.file = join(stateDir, `spend-${account.toLowerCase()}.json`);
+    }
+    today() {
+        const day = this.now().toISOString().slice(0, 10);
+        try {
+            const j = JSON.parse(readFileSync(this.file, "utf8"));
+            if (j.day === day)
+                return { day, hype: BigInt(j.hype), usdc: BigInt(j.usdc), launches: BigInt(j.launches ?? 0) };
+        }
+        catch {
+            // no file yet, or unreadable: start the day at zero
+        }
+        return { day, hype: 0n, usdc: 0n, launches: 0n };
+    }
+    caps(b) {
+        if (b === "hype")
+            return { perTx: this.limits.hypePerTx, perDay: this.limits.hypePerDay };
+        if (b === "usdc")
+            return { perTx: this.limits.usdcPerTx, perDay: this.limits.usdcPerDay };
+        return { perTx: 1n, perDay: BigInt(this.limits.launchesPerDay) };
+    }
+    /** Throws a plain sentence if `amount` would break a limit. */
+    check(b, amount) {
+        const { perTx, perDay } = this.caps(b);
+        const used = this.today()[b];
+        const f = (x) => show(b, x);
+        if (amount > perTx)
+            throw new Error(`Spending limit: ${f(amount)} is over the ${f(perTx)} allowed per transaction. Raise CLOAK_MAX_${b === "hype" ? "HYPE" : "USDC"}_PER_TX to allow it.`);
+        if (used + amount > perDay)
+            throw new Error(`Spending limit: ${f(amount)} would bring today's total to ${f(used + amount)}, over the ${f(perDay)} daily limit (${f(perDay > used ? perDay - used : 0n)} left today).`);
+    }
+    record(b, amount) {
+        const d = this.today();
+        d[b] += amount;
+        this.session[b] += amount;
+        const tmp = `${this.file}.tmp`;
+        writeFileSync(tmp, JSON.stringify({ day: d.day, hype: d.hype.toString(), usdc: d.usdc.toString(), launches: d.launches.toString() }));
+        renameSync(tmp, this.file);
+    }
+    summary() {
+        const d = this.today();
+        const row = (b) => {
+            const { perTx, perDay } = this.caps(b);
+            return { perTransaction: show(b, perTx), perDay: show(b, perDay), usedToday: show(b, d[b]), leftToday: show(b, perDay > d[b] ? perDay - d[b] : 0n), usedThisSession: show(b, this.session[b]) };
+        };
+        return { day: d.day, hype: row("hype"), usdc: row("usdc"), launches: row("launches") };
+    }
+}
+export function show(b, x) {
+    if (b === "hype")
+        return `${formatEther(x)} HYPE`;
+    if (b === "usdc")
+        return `${formatUnits(x, 6)} USDC`;
+    return `${x} launch${x === 1n ? "" : "es"}`;
+}

package/dist/server.d.ts

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type Prover } from "@cloakely/sdk";
+import type { Settings } from "./config.js";
+export { loadSettings, type Settings, type Limits } from "./config.js";
+export { Spending } from "./limits.js";
+export declare const VERSION = "0.1.0";
+export declare const HOSTED_URL = "https://cloak.boblabs.tech/mcp";
+/** Turn an SDK or chain error into one plain sentence an agent can act on. */
+export declare function explain(e: unknown): string;
+/** A tool argument that looks like a private key, a note secret or a recovery phrase. */
+export declare function looksSecret(args: unknown): boolean;
+/**
+ * The Cloak MCP server. `hosted` is the public read-and-plan server (https://cloak.boblabs.tech/mcp): it never has a
+ * key, never signs, and refuses any call that looks like it carries a secret. Without `hosted`, it's the local server
+ * that signs for one agent wallet under spending limits.
+ */
+export declare function createCloakServer(settings: Settings, opts?: {
+    prover?: () => Promise<Prover>;
+    hosted?: boolean;
+}): McpServer;

package/dist/server.js

@@ -0,0 +1,682 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { createPublicClient, createWalletClient, erc20Abi, formatEther, formatUnits, http, isAddress, parseEther, parseUnits, zeroAddress, } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { Cloak, CloakPrivate, cloakPairAbi, createProver, loadProver, privateRouterAbi, relayerSubmitter, shieldedPoolAbi, } from "@cloakely/sdk";
+import { Spending } from "./limits.js";
+export { loadSettings } from "./config.js";
+export { Spending } from "./limits.js";
+export const VERSION = "0.1.0";
+export const HOSTED_URL = "https://cloak.boblabs.tech/mcp";
+const INSTRUCTIONS = `Cloak: sealed-bid token launches and private trading on Kinetiq's Elysium (HYPE is the gas and base currency).
+
+Launches: create_launch starts a sealed-bid auction. place_sealed_bid commits a bid that nobody can read until bidding closes; bids then open by themselves (the keeper reveals them from the drand beacon), so there is nothing to come back for. Everyone who wins pays one clearing price. After settlement, claim pays out tokens and refunds (the keeper usually pushes claims already), and enable_private_trading opens a private vault for the token if nobody has yet.
+
+Private balances: shield moves HYPE or USDC from the wallet into a private balance (the one public step). private_swap, batch_order, private_send and withdraw then run from that balance: each is proven on this machine and sent by a relayer, so the wallet never appears on chain. batch_order also hides trade size. withdraw lands funds at a normal address, ideally a fresh one. Amounts are in whole units ("0.5" HYPE), and send, sell and withdraw accept "max".
+
+Safety: every action that moves value is checked against per-transaction and daily spending limits (see cloak_info), and any write tool takes dry_run: true to see exactly what would happen without signing anything. Use dry_run first when unsure.`;
+const HOSTED_INSTRUCTIONS = `Cloak's hosted MCP server: read and plan for Cloak, sealed-bid token launches and private trading on Kinetiq's Elysium testnet (HYPE is the gas and base currency).
+
+It never signs and never holds keys. Use it to find launches (list_launches, get_launch), price a sealed bid (quote_bid) or a private swap (quote_swap), see vault totals (vault_stats) and plan a launch (plan_launch). Bids stay sealed until bidding closes, so demand only shows after that. To actually launch, bid or trade, the agent needs the local server: connect_full_agent explains it. Never send a private key, note secret or recovery phrase here; calls that look like they carry one are refused.`;
+const j = (x) => JSON.stringify(x, (_k, v) => (typeof v === "bigint" ? v.toString() : v), 2);
+const reply = (x) => ({ content: [{ type: "text", text: j(x) }] });
+const fail = (msg) => ({ isError: true, content: [{ type: "text", text: msg }] });
+const iso = (t) => new Date(t * 1000).toISOString();
+const hype = (x) => `${formatEther(x)} HYPE`;
+/** Turn an SDK or chain error into one plain sentence an agent can act on. */
+export function explain(e) {
+    const m = String(e?.shortMessage ?? e?.message ?? e);
+    if (/insufficient private balance/.test(m))
+        return "Not enough private balance for this, counting the relayer's fee. Check private_balance, try a smaller amount, or use amount \"max\".";
+    if (/insufficient token balance in wallet/.test(m))
+        return "The wallet doesn't hold that many tokens. Check cloak_info for the wallet's public balances.";
+    if (/insufficient funds|exceeds the balance|gas required exceeds allowance/i.test(m))
+        return "The wallet doesn't have enough HYPE for this and its gas. Get testnet HYPE from https://elysium.kinetiq.xyz/testnet-faucet.";
+    if (/OverDepositLimit/.test(m))
+        return "That's over the vault's deposit cap during the beta. Try a smaller amount.";
+    if (/BidOverCap|DepositOverCap|over cap/i.test(m))
+        return "That bid is over the auction's cap (100 HYPE per bid, 10,000 in total during the beta).";
+    if (/commit phase is over/.test(m))
+        return "Bidding has closed for this launch.";
+    if (/below the auction's minimum price/.test(m))
+        return m;
+    return m.replace(/\s*\n\s*/g, " ").slice(0, 400);
+}
+/** Parse a whole-unit amount ("1.5") into base units, or null for "max". */
+function amountOf(s, decimals) {
+    if (s.trim().toLowerCase() === "max")
+        return null;
+    if (!/^\d+(\.\d+)?$/.test(s.trim()))
+        throw new Error(`"${s}" isn't an amount: use a number like 0.5, or "max"`);
+    const a = parseUnits(s.trim(), decimals);
+    if (a <= 0n)
+        throw new Error("the amount must be above zero");
+    return a;
+}
+/** A tool argument that looks like a private key, a note secret or a recovery phrase. */
+export function looksSecret(args) {
+    const text = JSON.stringify(args ?? {});
+    return /(0x)?[0-9a-fA-F]{64}(?![0-9a-fA-F])/.test(text) || /\b([a-z]{3,8}\s+){11,23}[a-z]{3,8}\b/.test(text);
+}
+/**
+ * The Cloak MCP server. `hosted` is the public read-and-plan server (https://cloak.boblabs.tech/mcp): it never has a
+ * key, never signs, and refuses any call that looks like it carries a secret. Without `hosted`, it's the local server
+ * that signs for one agent wallet under spending limits.
+ */
+export function createCloakServer(settings, opts = {}) {
+    if (opts.hosted)
+        settings = { ...settings, privateKey: undefined };
+    const d = settings.deployment;
+    // reads in the same tick go out as one multicall where the chain has Multicall3 (a launch list is ~20 reads per
+    // launch, more than a public RPC takes at once), and failed requests are retried
+    const pub = createPublicClient({
+        chain: settings.chain,
+        transport: http(settings.rpcUrl, { retryCount: 4, retryDelay: 400, timeout: 20_000 }),
+        batch: settings.chain.contracts?.multicall3 ? { multicall: true } : undefined,
+    });
+    const account = settings.privateKey ? privateKeyToAccount(settings.privateKey) : undefined;
+    const wallet = account ? createWalletClient({ chain: settings.chain, transport: http(settings.rpcUrl), account }) : undefined;
+    const cloak = new Cloak(pub, wallet, d.factory);
+    const spending = account ? new Spending(settings.limits, settings.stateDir, account.address) : undefined;
+    const submit = relayerSubmitter(d.relayerUrl);
+    const explorer = settings.chain.blockExplorers?.default.url;
+    const link = (h) => (explorer ? `${explorer}/tx/${h}` : h);
+    let proverP;
+    const prover = opts.prover ??
+        (() => (proverP ??= settings.circuitsDir
+            ? Promise.resolve(createProver(readFileSync(join(settings.circuitsDir, "transaction2x2.wasm")), readFileSync(join(settings.circuitsDir, "transaction2x2_final.zkey"))))
+            : loadProver(d.circuitsUrl)));
+    let privP;
+    async function priv() {
+        if (!wallet)
+            throw new Error("No wallet configured: set CLOAK_KEY_FILE (or CLOAK_PRIVATE_KEY) to use private balances.");
+        privP ??= (async () => {
+            const keys = await CloakPrivate.keysFromWallet(wallet, { chainId: settings.chain.id, router: d.router, verify: true });
+            const p = new CloakPrivate(pub, d.router, keys, prover, submit, d.routerBlock, d.batcher, d.migrator);
+            for (const a of d.assets ?? [])
+                p.addAsset(a);
+            return p;
+        })().catch((e) => {
+            privP = undefined;
+            throw e;
+        });
+        const p = await privP;
+        await p.loadMarkets(); // new private markets appear as launches settle
+        return p;
+    }
+    // one write at a time: two private calls must not pick the same notes, and nonces stay in order
+    let queue = Promise.resolve();
+    const exclusive = (fn) => {
+        const run = queue.then(fn, fn);
+        queue = run.catch(() => { });
+        return run;
+    };
+    const needWallet = () => {
+        if (!wallet || !account || !spending)
+            throw new Error("No wallet configured: set CLOAK_KEY_FILE (or CLOAK_PRIVATE_KEY). Read tools work without one.");
+        return { wallet, account, spending };
+    };
+    const symbols = new Map();
+    async function symbolOf(token) {
+        const k = token.toLowerCase();
+        if (!symbols.has(k))
+            symbols.set(k, await pub.readContract({ address: token, abi: erc20Abi, functionName: "symbol" }).catch(() => "?"));
+        return symbols.get(k);
+    }
+    /** Every asset with a private vault: HYPE, USDC-like assets, and every launch token with a private market. */
+    async function vaults() {
+        const c = { address: d.router, abi: privateRouterAbi };
+        const n = await pub.readContract({ ...c, functionName: "tokensCount" });
+        const out = [{ kind: "hype", symbol: "HYPE", token: d.whype, pool: d.hypePool, decimals: 18 }];
+        for (const a of d.assets ?? [])
+            out.push({ kind: "asset", symbol: a.symbol, token: a.token, pool: a.pool, decimals: a.decimals });
+        const toks = await Promise.all(Array.from({ length: Number(n) - 1 }, (_, i) => pub.readContract({ ...c, functionName: "tokens", args: [BigInt(i + 1)] })));
+        for (const token of toks) {
+            const [pool, pair, symbol] = await Promise.all([
+                pub.readContract({ ...c, functionName: "poolOf", args: [token] }),
+                pub.readContract({ ...c, functionName: "pairOf", args: [token] }),
+                symbolOf(token),
+            ]);
+            out.push({ kind: "token", symbol, token, pool, pair, decimals: 18 });
+        }
+        return out;
+    }
+    /** "HYPE", "USDC", a launch token's symbol, or any of their addresses. */
+    async function resolve(ref) {
+        const all = await vaults();
+        const r = ref.trim();
+        if (isAddress(r)) {
+            const hit = all.find((a) => a.token.toLowerCase() === r.toLowerCase() || a.pool.toLowerCase() === r.toLowerCase());
+            if (hit)
+                return hit;
+            throw new Error(`${r} has no private vault yet. If it's a settled Cloak launch, enable_private_trading opens one.`);
+        }
+        const hits = all.filter((a) => a.symbol.toLowerCase() === r.replace(/^\$/, "").toLowerCase());
+        if (hits.length === 1)
+            return hits[0];
+        if (hits.length > 1)
+            throw new Error(`Several tokens are called ${r}: ${hits.map((h) => h.token).join(", ")}. Pass the token address instead.`);
+        throw new Error(`No private vault for "${r}". Private vaults: ${[...new Set(all.map((a) => a.symbol))].join(", ")}.`);
+    }
+    /** Expected output of a private swap of `amountIn` (after the vault's withdrawal fee), and the relayer's fee. */
+    async function quoteSwap(t, side, amountIn) {
+        const poolIn = side === "buy" ? d.hypePool : t.pool;
+        const net = await pub.readContract({ address: poolIn, abi: shieldedPoolAbi, functionName: "afterFee", args: [amountIn] });
+        const [rH, rT] = await Promise.all([
+            pub.readContract({ address: t.pair, abi: cloakPairAbi, functionName: "reserveHype" }),
+            pub.readContract({ address: t.pair, abi: cloakPairAbi, functionName: "reserveToken" }),
+        ]);
+        const out = await pub.readContract({ address: t.pair, abi: cloakPairAbi, functionName: "getAmountOut", args: side === "buy" ? [net, rH, rT] : [net, rT, rH] });
+        const fee = await submit.quote("privateSwap", poolIn).then((q) => q.fee, () => 0n);
+        return { out, net, fee };
+    }
+    /** What an amount of an asset counts against: HYPE value (launch tokens at the pool's price), or USDC. */
+    async function cost(a, amount) {
+        if (a.kind === "hype")
+            return { budget: "hype", value: amount };
+        if (a.kind === "asset")
+            return { budget: "usdc", value: (amount * 10n ** 6n) / 10n ** BigInt(a.decimals) };
+        const [rH, rT] = await Promise.all([
+            pub.readContract({ address: a.pair, abi: cloakPairAbi, functionName: "reserveHype" }),
+            pub.readContract({ address: a.pair, abi: cloakPairAbi, functionName: "reserveToken" }),
+        ]);
+        return { budget: "hype", value: rT === 0n ? 0n : (amount * rH) / rT }; // at the pool's spot price, before impact
+    }
+    const fmtAmt = (a, x) => `${formatUnits(x, a.decimals)} ${a.symbol}`;
+    async function receipt(h) {
+        const r = await pub.waitForTransactionReceipt({ hash: h });
+        if (r.status !== "success")
+            throw new Error(`transaction reverted: ${link(h)}`);
+        return r;
+    }
+    function launchView(s) {
+        const now = Math.floor(Date.now() / 1000);
+        return {
+            auction: s.address,
+            token: s.token,
+            name: s.tokenName,
+            symbol: s.tokenSymbol,
+            phase: s.failed ? "failed (every bid refunded)" : s.phase,
+            biddingEnds: iso(s.commitEnd),
+            revealsEnd: iso(s.revealEnd),
+            ...(s.phase === "commit" ? { biddingClosesInMinutes: Math.max(0, Math.round((s.commitEnd - now) / 6) / 10) } : {}),
+            tokensForSale: formatEther(s.saleSupply),
+            minPrice: `${formatEther(s.minPrice)} HYPE per token`,
+            tickSize: `${formatEther(s.tickSize)} HYPE`,
+            priceTicks: s.numTicks,
+            bids: s.commits,
+            bidsOpened: s.reveals,
+            ...(s.settled
+                ? { clearingPrice: `${formatEther(s.clearingPrice)} HYPE per token`, sold: formatEther(s.sold), raised: hype(s.raised), pool: s.pair }
+                : {}),
+            liquidity: `${s.lpBps / 100}% of the raise seeds the pool at the clearing price; LP ${s.lpLockUntil === 0 ? "burned" : `locked until ${iso(s.lpLockUntil)}`}`,
+            noRevealPenalty: `${s.noRevealPenaltyBps / 100}%`,
+            launchFee: `${s.launchFeeBps / 100}% of a successful raise`,
+            caps: { perBid: s.bidCap ? hype(s.bidCap) : "none", total: s.depositCap ? hype(s.depositCap) : "none" },
+        };
+    }
+    async function privateTradingOn(token) {
+        return (await pub.readContract({ address: d.router, abi: privateRouterAbi, functionName: "poolOf", args: [token] })) !== zeroAddress;
+    }
+    const bidsFile = (a) => join(settings.stateDir, `bids-${a.toLowerCase()}.json`);
+    function saveBid(a, secret) {
+        mkdirSync(settings.stateDir, { recursive: true });
+        let all = [];
+        try {
+            all = JSON.parse(readFileSync(bidsFile(a), "utf8"));
+        }
+        catch {
+            // first bid
+        }
+        all.push(secret);
+        writeFileSync(bidsFile(a), j(all));
+    }
+    const server = new McpServer({ name: opts.hosted ? "cloak-hosted" : "cloak", version: VERSION }, { instructions: opts.hosted ? HOSTED_INSTRUCTIONS : INSTRUCTIONS });
+    const dry = z.boolean().optional().describe("Return what would happen without signing or sending anything.");
+    const addr = z.string().describe("0x address");
+    const amt = (what) => z.string().describe(`${what}, in whole units (e.g. "0.5")`);
+    const isDry = (x) => settings.dryRun || x === true;
+    const READ = { readOnlyHint: true, openWorldHint: true };
+    const WRITE = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
+    /** Wrap a handler: plain-sentence errors instead of stack traces. */
+    const safe = (fn) => async (a) => {
+        if (opts.hosted && looksSecret(a))
+            return fail("This hosted server never takes private keys, note secrets or recovery phrases, and refused the call. Nothing was stored. If that was a real key, treat it as exposed and move its funds to a new wallet.");
+        try {
+            return reply(await fn(a));
+        }
+        catch (e) {
+            return fail(explain(e));
+        }
+    };
+    // ───────────── read ─────────────
+    server.registerTool("cloak_info", { title: "Cloak setup and limits", description: "Network, contract addresses, the configured wallet and its public balances, dry-run mode, and spending limits with what's left today.", inputSchema: {}, annotations: READ }, safe(async () => {
+        const usdc = d.assets?.[0];
+        const wallet = account
+            ? {
+                address: account.address,
+                publicBalances: {
+                    HYPE: formatEther(await pub.getBalance({ address: account.address })),
+                    ...(usdc ? { [usdc.symbol]: formatUnits(await pub.readContract({ address: usdc.token, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }), usdc.decimals) } : {}),
+                },
+            }
+            : null;
+        return {
+            server: opts.hosted ? `Cloak hosted MCP ${VERSION} (${HOSTED_URL})` : `@cloakely/mcp ${VERSION}`,
+            network: settings.network,
+            chainId: settings.chain.id,
+            mode: opts.hosted ? "hosted: read and plan only, never signs (connect_full_agent explains how to launch, bid and trade)" : account ? "read and write" : "read only (no wallet configured)",
+            ...(opts.hosted
+                ? {}
+                : { dryRun: settings.dryRun ? "on for every write (CLOAK_DRY_RUN=1)" : "off (pass dry_run: true on any write to preview it)", wallet, limits: spending?.summary() ?? null }),
+            contracts: { factory: d.factory, router: d.router, batcher: d.batcher, hypeVault: d.hypePool, ...(usdc ? { [`${usdc.symbol.toLowerCase()}Vault`]: usdc.pool } : {}) },
+            relayer: d.relayerUrl,
+            ...(settings.network === "testnet" ? { faucet: "https://elysium.kinetiq.xyz/testnet-faucet", note: "Testnet: play money only." } : {}),
+        };
+    }));
+    server.registerTool("list_launches", {
+        title: "List launches",
+        description: "Cloak launches, newest first, with phase, timing, prices and whether private trading is on.",
+        inputSchema: { limit: z.number().int().min(1).max(50).optional().describe("How many (default 10)"), phase: z.enum(["commit", "reveal", "settle", "settled"]).optional().describe("Only launches in this phase") },
+        annotations: READ,
+    }, safe(async ({ limit, phase }) => {
+        const all = (await cloak.listLaunches()).reverse();
+        const out = [];
+        for (let i = 0; i < all.length && out.length < (limit ?? 10); i += 10) {
+            const states = await Promise.all(all.slice(i, i + 10).map((l) => cloak.getAuction(l.auction)));
+            for (const s of states) {
+                if (phase && s.phase !== phase)
+                    continue;
+                if (out.length >= (limit ?? 10))
+                    break;
+                const v = launchView(s);
+                out.push({ symbol: v.symbol, name: v.name, auction: v.auction, token: v.token, phase: v.phase, biddingEnds: v.biddingEnds, bids: v.bids, minPrice: v.minPrice, ...(s.settled ? { clearingPrice: v.clearingPrice, raised: v.raised, privateTrading: await privateTradingOn(s.token) } : {}) });
+            }
+        }
+        return { total: all.length, launches: out };
+    }));
+    server.registerTool("get_launch", { title: "Launch details", description: "Everything about one launch: phase, timing, prices, caps, results once settled, revealed demand once bids open, and whether private trading is on.", inputSchema: { auction: addr }, annotations: READ }, safe(async ({ auction }) => {
+        const s = await cloak.getAuction(auction);
+        const v = launchView(s);
+        const demand = s.phase === "commit" ? [] : (await cloak.demandCurve(s.address)).filter((x) => x.demand > 0n).map((x) => ({ price: formatEther(x.price), tokensWanted: formatEther(x.demand) }));
+        return {
+            ...v,
+            ...(s.phase === "commit" ? { demand: "hidden until bidding closes: every bid is sealed" } : { revealedDemand: demand }),
+            ...(s.settled && !s.failed ? { poolPrice: `${formatEther(await cloak.pairPrice(s.pair))} HYPE per token`, privateTrading: await privateTradingOn(s.token) } : {}),
+        };
+    }));
+    server.registerTool("quote_bid", {
+        title: "Quote a sealed bid",
+        description: "What a bid would cost: the price tick it lands on, its cost, and the rounded deposit that hides its size (the unused part is refunded).",
+        inputSchema: { auction: addr, max_price: amt("Highest price you'd pay, in HYPE per token"), quantity: amt("Tokens wanted") },
+        annotations: READ,
+    }, safe(async ({ auction, max_price, quantity }) => {
+        const s = await cloak.getAuction(auction);
+        const q = cloak.quoteBid(s, parseEther(max_price), parseEther(quantity));
+        return { phase: s.phase, tick: q.tick, price: `${formatEther(q.price)} HYPE per token`, cost: hype(q.cost), deposit: hype(q.deposit), note: "The deposit is rounded up to 1, 2 or 5 × 10ⁿ so it doesn't reveal the bid's size. Whatever isn't used at the clearing price is refunded." };
+    }));
+    server.registerTool("quote_swap", {
+        title: "Quote a private swap",
+        description: "Expected output of a private buy (HYPE in) or sell (tokens in), after the vault's withdrawal fee, plus the relayer's fee.",
+        inputSchema: { token: z.string().describe("Launch token symbol or address"), side: z.enum(["buy", "sell"]), amount: amt("HYPE to spend (buy) or tokens to sell (sell)") },
+        annotations: READ,
+    }, safe(async ({ token, side, amount }) => {
+        const t = await resolve(token);
+        if (t.kind !== "token")
+            throw new Error(`${t.symbol} isn't a launch token: private swaps trade launch tokens against HYPE.`);
+        const a = parseEther(amount);
+        const q = await quoteSwap(t, side, a);
+        const outSym = side === "buy" ? t.symbol : "HYPE";
+        return { side, in: side === "buy" ? hype(a) : `${amount} ${t.symbol}`, expectedOut: `${formatEther(q.out)} ${outSym}`, relayerFee: `${formatEther(q.fee)} ${side === "buy" ? "HYPE" : t.symbol}`, withdrawalFee: `${formatEther(a - q.net)} ${side === "buy" ? "HYPE" : t.symbol}` };
+    }));
+    server.registerTool("vault_stats", { title: "Private vault totals", description: "How much sits in each private vault (HYPE, USDC and every launch token). Totals are public; who owns what isn't.", inputSchema: {}, annotations: READ }, safe(async () => {
+        const out = [];
+        for (const a of await vaults()) {
+            const held = await pub.readContract({ address: a.pool, abi: shieldedPoolAbi, functionName: "deposited" });
+            if (held === 0n && a.kind === "token")
+                continue;
+            out.push({ asset: a.symbol, token: a.token, vault: a.pool, held: fmtAmt(a, held) });
+        }
+        return { vaults: out, note: "Each vault is one shared pool of encrypted notes. The chain shows the total, not the owners or their balances." };
+    }));
+    if (opts.hosted) {
+        server.registerTool("plan_launch", {
+            title: "Plan a launch",
+            description: "Check a launch's settings and see its schedule, price range and what it raises at the lowest and highest price, before creating it on the site or with the local server.",
+            inputSchema: {
+                sale_supply: amt("Tokens sold in the auction"),
+                min_price: amt("Lowest price, in HYPE per token"),
+                tick_size: amt("Price step between ticks, in HYPE").optional(),
+                price_ticks: z.number().int().min(1).max(256).optional().describe("Number of price ticks (default 100)"),
+                bidding_minutes: z.number().positive().max(60 * 24 * 14).optional().describe("How long bidding stays open (default 60)"),
+                reveal_minutes: z.number().min(1).max(60 * 24).optional().describe("Time for bids to open after bidding closes (default 10)"),
+                lp_percent: z.number().min(0).max(100).optional().describe("Share of the raise that seeds the pool (default 50)"),
+            },
+            annotations: READ,
+        }, safe(async (p) => {
+            const supply = parseEther(p.sale_supply);
+            const min = parseEther(p.min_price);
+            const tick = parseEther(p.tick_size ?? p.min_price);
+            const ticks = p.price_ticks ?? 100;
+            const top = min + BigInt(ticks - 1) * tick;
+            const now = Number((await pub.getBlock()).timestamp);
+            const commitEnd = now + Math.round((p.bidding_minutes ?? 60) * 60);
+            const revealEnd = commitEnd + Math.round((p.reveal_minutes ?? 10) * 60);
+            const raise = (price) => (price * supply) / 10n ** 18n;
+            const lp = p.lp_percent ?? 50;
+            return {
+                ifCreatedNow: { biddingEnds: iso(commitEnd), revealsEnd: iso(revealEnd) },
+                priceRange: `${formatEther(min)} to ${formatEther(top)} HYPE per token, ${ticks} ticks`,
+                raiseIfFullySold: { atLowestPrice: hype(raise(min)), atHighestPrice: hype(raise(top)) },
+                toPool: `${lp}% of the raise, paired with tokens at the clearing price; the LP is burned unless you lock it`,
+                launchFee: "1.5% of a successful raise; nothing if the launch doesn't fill",
+                caps: "During the beta a bid can be at most 100 HYPE and an auction can take at most 10,000 HYPE.",
+                create: { onTheSite: "https://cloak.boblabs.tech/app/create", withAnAgent: "the local server's create_launch tool (see connect_full_agent)" },
+            };
+        }));
+        server.registerTool("connect_full_agent", { title: "Connect a full agent", description: "How to let an agent launch, bid and trade privately: the local Cloak MCP server, which signs on your own machine under spending limits.", inputSchema: {}, annotations: READ }, safe(async () => ({
+            why: "This hosted server never holds keys, so it can read and plan but not sign. Launching, bidding and private trading run in the local server, on the machine that holds the agent's wallet. Its proofs are made there too, so nobody else, Cloak included, can see or move the funds.",
+            steps: [
+                "Make a fresh wallet just for the agent and fund it with testnet HYPE from https://elysium.kinetiq.xyz/testnet-faucet",
+                "Save its private key to a file only you can read, for example ~/.cloak-agent-key",
+                "Claude Code: claude mcp add cloak --env CLOAK_KEY_FILE=$HOME/.cloak-agent-key -- npx -y @cloakely/mcp",
+                'Other clients: { "mcpServers": { "cloak": { "command": "npx", "args": ["-y", "@cloakely/mcp"], "env": { "CLOAK_KEY_FILE": "/path/to/key" } } } }',
+            ],
+            safety: "Spending limits per transaction and per day (1 HYPE and 10 HYPE by default, set with CLOAK_MAX_HYPE_PER_TX and CLOAK_MAX_HYPE_PER_DAY), dry_run on every action, testnet by default. Never paste a key into a chat or into this hosted server.",
+            docs: "https://github.com/NECOKIZZ/Cloak/tree/main/packages/mcp",
+        })));
+        return server;
+    }
+    // ───────────── launches ─────────────
+    server.registerTool("create_launch", {
+        title: "Create a sealed-bid launch",
+        description: "Start a token launch: a sealed-bid auction that ends in one clearing price, with liquidity seeded at that price. Counts against the daily launch limit.",
+        inputSchema: {
+            name: z.string().min(1).max(40),
+            symbol: z.string().min(1).max(12),
+            sale_supply: amt("Tokens sold in the auction"),
+            min_price: amt("Lowest price, in HYPE per token"),
+            tick_size: amt("Price step between ticks, in HYPE").optional(),
+            price_ticks: z.number().int().min(1).max(256).optional().describe("Number of price ticks (default 100)"),
+            bidding_minutes: z.number().positive().max(60 * 24 * 14).optional().describe("How long bidding stays open (default 60)"),
+            reveal_minutes: z.number().min(1).max(60 * 24).optional().describe("Time for bids to open after bidding closes (default 10)"),
+            lp_percent: z.number().min(0).max(100).optional().describe("Share of the raise that seeds the pool (default 50)"),
+            lp_tokens: amt("Tokens paired with that HYPE (default: same as sale_supply)").optional(),
+            lp_lock_days: z.number().min(0).optional().describe("Lock the LP for this many days instead of burning it (default: burn)"),
+            creator_share: amt("Tokens for the creator, at most 20% of supply, vesting linearly").optional(),
+            vest_days: z.number().min(30).optional().describe("Vesting length for the creator share (default 90)"),
+            metadata_uri: z.string().optional(),
+            dry_run: dry,
+        },
+        annotations: WRITE,
+    }, safe(async (p) => {
+        const { account, spending } = needWallet();
+        const now = Number((await pub.getBlock()).timestamp);
+        const commitEnd = now + Math.round((p.bidding_minutes ?? 60) * 60);
+        const revealEnd = commitEnd + Math.round((p.reveal_minutes ?? 10) * 60);
+        const params = {
+            name: p.name,
+            symbol: p.symbol,
+            saleSupply: parseEther(p.sale_supply),
+            lpReserve: p.lp_tokens ? parseEther(p.lp_tokens) : undefined,
+            creatorAlloc: p.creator_share ? parseEther(p.creator_share) : undefined,
+            creatorVestSecs: Math.round((p.vest_days ?? 90) * 86400),
+            minPrice: parseEther(p.min_price),
+            tickSize: parseEther(p.tick_size ?? p.min_price),
+            numTicks: p.price_ticks ?? 100,
+            commitEnd,
+            revealEnd,
+            lpBps: Math.round((p.lp_percent ?? 50) * 100),
+            lpLockUntil: p.lp_lock_days ? now + Math.round(p.lp_lock_days * 86400) : "burn",
+            metadataURI: p.metadata_uri,
+        };
+        spending.check("launches", 1n);
+        const plan = { creator: account.address, ...p, biddingEnds: iso(commitEnd), revealsEnd: iso(revealEnd), topPrice: `${formatEther(params.minPrice + BigInt(params.numTicks - 1) * params.tickSize)} HYPE per token` };
+        if (isDry(p.dry_run))
+            return { dryRun: true, wouldCreate: plan };
+        return exclusive(async () => {
+            const l = await cloak.createLaunch(params);
+            spending.record("launches", 1n);
+            return { created: true, auction: l.auction, token: l.token, tx: link(l.txHash), biddingEnds: plan.biddingEnds, revealsEnd: plan.revealsEnd, next: "Share the auction address. Bids open by themselves after bidding closes, and the keeper settles the launch." };
+        });
+    }));
+    server.registerTool("place_sealed_bid", {
+        title: "Place a sealed bid",
+        description: "Commit a sealed bid: only a hash and a timelocked ciphertext go on chain, so nobody (other bidders, bots, the sequencer) sees price or size until bidding closes. It opens by itself afterwards. Spends the rounded deposit from the wallet; the unused part is refunded at settlement.",
+        inputSchema: { auction: addr, max_price: amt("Highest price you'd pay, in HYPE per token"), quantity: amt("Tokens wanted"), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ auction, max_price, quantity, dry_run }) => {
+        const { account, spending } = needWallet();
+        const s = await cloak.getAuction(auction);
+        if (s.phase !== "commit")
+            throw new Error(`Bidding has closed for ${s.tokenSymbol} (phase: ${s.phase}).`);
+        const q = cloak.quoteBid(s, parseEther(max_price), parseEther(quantity));
+        spending.check("hype", q.deposit);
+        const plan = { launch: s.tokenSymbol, price: `${formatEther(q.price)} HYPE per token`, quantity, cost: hype(q.cost), deposit: hype(q.deposit), biddingEnds: iso(s.commitEnd) };
+        if (isDry(dry_run))
+            return { dryRun: true, wouldBid: plan };
+        return exclusive(async () => {
+            const b = await cloak.bid(s.address, { maxPrice: parseEther(max_price), quantity: parseEther(quantity) });
+            spending.record("hype", b.deposit);
+            saveBid(account.address, b);
+            return { placed: true, bidId: b.id, ...plan, tx: link(b.txHash), next: "Nothing else to do: the bid opens by itself after bidding closes. Check my_bids after settlement." };
+        });
+    }));
+    server.registerTool("my_bids", { title: "My bids", description: "The wallet's bids on a launch: deposit, whether each has opened, and once settled the tokens won, refund and any penalty.", inputSchema: { auction: addr }, annotations: READ }, safe(async ({ auction }) => {
+        const { account } = needWallet();
+        const s = await cloak.getAuction(auction);
+        const bids = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+        return {
+            launch: s.tokenSymbol,
+            phase: s.phase,
+            bids: bids.map((b) => ({ id: b.id, deposit: hype(b.deposit), opened: b.revealed, claimed: b.claimed, ...(s.settled ? { tokensWon: formatEther(b.tokens), refund: hype(b.refund), penalty: hype(b.penalty) } : {}) })),
+        };
+    }));
+    server.registerTool("claim", { title: "Claim tokens and refunds", description: "After bids open, settle the launch if nobody has yet, then claim the wallet's tokens and refunds. Cloak's keeper usually pushes claims already.", inputSchema: { auction: addr, dry_run: dry }, annotations: WRITE }, safe(async ({ auction, dry_run }) => {
+        const { account } = needWallet();
+        let s = await cloak.getAuction(auction);
+        if (s.phase === "commit" || s.phase === "reveal")
+            throw new Error(`${s.tokenSymbol} can't settle yet: bids are ${s.phase === "commit" ? "still being placed" : "still opening"} until ${iso(s.phase === "commit" ? s.commitEnd : s.revealEnd)}.`);
+        const bids = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+        const open = bids.filter((b) => !b.claimed);
+        if (isDry(dry_run))
+            return { dryRun: true, wouldSettle: !s.settled, wouldClaim: open.map((b) => b.id) };
+        return exclusive(async () => {
+            const txs = [];
+            if (!s.settled) {
+                txs.push(link(await cloak.settle(s.address)));
+                s = await cloak.getAuction(s.address);
+            }
+            if (open.length)
+                txs.push(link(await cloak.claim(s.address, open.map((b) => b.id))));
+            const after = await cloak.bidsOf(s.address, account.address, settings.launchesFromBlock);
+            return {
+                launch: s.tokenSymbol,
+                settled: s.settled,
+                ...(s.failed ? { failed: "No demand was revealed, so every bid was refunded in full." } : { clearingPrice: `${formatEther(s.clearingPrice)} HYPE per token` }),
+                claimed: open.length ? open.map((b) => b.id) : "nothing left to claim (already paid out)",
+                tokensWon: formatEther(after.reduce((a, b) => a + b.tokens, 0n)),
+                refunds: hype(after.reduce((a, b) => a + b.refund, 0n)),
+                txs,
+            };
+        });
+    }));
+    server.registerTool("enable_private_trading", { title: "Enable private trading", description: "Open a private vault for a settled launch's token so it can be traded from private balances. Anyone can do this once per token; it costs only gas.", inputSchema: { auction: addr, dry_run: dry }, annotations: WRITE }, safe(async ({ auction, dry_run }) => {
+        const { wallet } = needWallet();
+        const s = await cloak.getAuction(auction);
+        if (!s.settled || s.failed)
+            throw new Error(`${s.tokenSymbol} needs to settle successfully first (phase: ${s.phase}).`);
+        if (await privateTradingOn(s.token))
+            return { alreadyOn: true, token: s.token };
+        const idx = (await cloak.listLaunches()).findIndex((l) => l.auction.toLowerCase() === s.address.toLowerCase());
+        if (idx < 0)
+            throw new Error("This launch isn't from the current Cloak factory, so it can't get a private vault.");
+        if (isDry(dry_run))
+            return { dryRun: true, wouldEnable: s.tokenSymbol, launchIndex: idx };
+        return exclusive(async () => {
+            const h = await wallet.writeContract({ address: d.router, abi: privateRouterAbi, functionName: "createPool", args: [BigInt(idx)] });
+            await receipt(h);
+            return { enabled: true, token: s.token, vault: await pub.readContract({ address: d.router, abi: privateRouterAbi, functionName: "poolOf", args: [s.token] }), tx: link(h) };
+        });
+    }));
+    // ───────────── private balances ─────────────
+    server.registerTool("unlock", { title: "Unlock the private account", description: "Derive the private account from one local signature (no transaction, nothing sent anywhere) and return its cloak: address, which others use to pay it privately.", inputSchema: {}, annotations: READ }, safe(async () => {
+        const p = await priv();
+        return { cloakAddress: await p.address(), note: "Share the cloak: address to receive private payments. It doesn't reveal the wallet." };
+    }));
+    server.registerTool("private_balance", { title: "Private balances", description: "Balances only this account can see: HYPE, USDC and every launch token held privately.", inputSchema: { include_zero: z.boolean().optional() }, annotations: READ }, safe(async ({ include_zero }) => {
+        const p = await priv();
+        const out = {};
+        const tokens = {};
+        for (const a of await vaults()) {
+            const b = await p.balance(a.pool);
+            if (b === 0n && !include_zero && a.kind === "token")
+                continue;
+            if (a.kind === "token")
+                tokens[`${a.symbol} ${a.token.slice(0, 8)}`] = { token: a.token, balance: formatUnits(b, a.decimals) };
+            else
+                out[a.symbol] = formatUnits(b, a.decimals);
+        }
+        return { cloakAddress: await p.address(), balances: out, launchTokens: tokens };
+    }));
+    server.registerTool("shield", {
+        title: "Shield into a private balance",
+        description: "Deposit HYPE or USDC from the wallet into the private balance. This is the one public step: it lands on a one-time key, so it can't be linked to what comes next.",
+        inputSchema: { asset: z.string().describe('"HYPE" or "USDC"'), amount: amt("Amount"), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ asset, amount, dry_run }) => {
+        const { wallet, spending } = needWallet();
+        const a = await resolve(asset);
+        if (a.kind === "token")
+            throw new Error("Launch tokens enter a private balance by buying privately (private_swap), not by shielding.");
+        const x = amountOf(amount, a.decimals);
+        if (x === null)
+            throw new Error("Give an exact amount to shield.");
+        const c = await cost(a, x);
+        spending.check(c.budget, c.value);
+        if (isDry(dry_run))
+            return { dryRun: true, wouldShield: fmtAmt(a, x), ...(a.kind === "asset" ? { note: "The first time takes two transactions: an approval, then the deposit." } : {}) };
+        return exclusive(async () => {
+            const p = await priv();
+            const h = a.kind === "hype" ? await p.shieldHype(wallet, x) : await p.shieldToken(wallet, a.token, x);
+            spending.record(c.budget, c.value);
+            return { shielded: fmtAmt(a, x), privateBalance: fmtAmt(a, await p.balance(a.pool)), tx: link(h) };
+        });
+    }));
+    server.registerTool("private_swap", {
+        title: "Private swap",
+        description: "Buy a launch token with private HYPE, or sell it for private HYPE. Proven on this machine and sent by a relayer, so the wallet never appears on the trade. The output lands back in the private balance.",
+        inputSchema: { token: z.string().describe("Launch token symbol or address"), side: z.enum(["buy", "sell"]), amount: amt('HYPE to spend (buy) or tokens to sell (sell); "max" for the whole balance'), slippage_bps: z.number().int().min(1).max(5000).optional().describe("Max slippage in basis points (default 100 = 1%)"), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ token, side, amount, slippage_bps, dry_run }) => {
+        const { spending } = needWallet();
+        const t = await resolve(token);
+        if (t.kind !== "token")
+            throw new Error(`${t.symbol} isn't a launch token: private swaps trade launch tokens against HYPE.`);
+        const p = await priv();
+        const poolIn = side === "buy" ? d.hypePool : t.pool;
+        const x = amountOf(amount, 18) ?? (await p.maxSpendable(poolIn, "privateSwap"));
+        if (x <= 0n)
+            throw new Error("Not enough private balance for this, counting the relayer's fee.");
+        const c = await cost(side === "buy" ? (await vaults())[0] : t, x);
+        spending.check(c.budget, c.value);
+        const q = await quoteSwap(t, side, x);
+        const inSym = side === "buy" ? "HYPE" : t.symbol;
+        const outSym = side === "buy" ? t.symbol : "HYPE";
+        if (isDry(dry_run))
+            return { dryRun: true, wouldSwap: `${formatEther(x)} ${inSym} for about ${formatEther(q.out)} ${outSym}`, relayerFee: `${formatEther(q.fee)} ${inSym}`, slippage: `${(slippage_bps ?? 100) / 100}%` };
+        return exclusive(async () => {
+            const r = await (side === "buy" ? p.buy(t.token, x, { slippageBps: slippage_bps }) : p.sell(t.token, x, { slippageBps: slippage_bps }));
+            await receipt(r.txHash);
+            spending.record(c.budget, c.value);
+            const outPool = side === "buy" ? t.pool : d.hypePool;
+            return { swapped: `${formatEther(x)} ${inSym}`, expected: `${formatEther(r.expectedOut)} ${outSym}`, minimum: `${formatEther(r.minOut)} ${outSym}`, relayerFee: `${formatEther(r.relayerFee)} ${inSym}`, privateBalance: { [inSym]: formatEther(await p.balance(poolIn)), [outSym]: formatEther(await p.balance(outPool)) }, tx: link(r.txHash), sentBy: "the relayer, not this wallet" };
+        });
+    }));
+    server.registerTool("batch_order", {
+        title: "Batch order (hides size)",
+        description: "Trade in the next batch round: the amount is split into standard sizes everyone uses, buys and sells cross at the round's average price, and only the net hits the pool. Observers can't tell how much any one trader moved. Fills when the round settles (about 30 s on testnet). A round only settles if its net trade moves the pool less than 5%, so keep orders small next to the pool; a round that can't settle is refunded after a delay.",
+        inputSchema: { token: z.string().describe("Launch token symbol or address"), side: z.enum(["buy", "sell"]), amount: amt("HYPE to spend (buy) or tokens to sell (sell)"), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ token, side, amount, dry_run }) => {
+        const { spending } = needWallet();
+        const t = await resolve(token);
+        if (t.kind !== "token")
+            throw new Error(`${t.symbol} isn't a launch token: batch orders trade launch tokens against HYPE.`);
+        const x = amountOf(amount, 18);
+        if (x === null)
+            throw new Error('Give an exact amount for a batch order ("max" works for private_swap).');
+        const c = await cost(side === "buy" ? (await vaults())[0] : t, x);
+        spending.check(c.budget, c.value);
+        const p = await priv();
+        const round = await p.roundInfo();
+        if (isDry(dry_run))
+            return { dryRun: true, wouldPlace: `${formatEther(x)} ${side === "buy" ? "HYPE" : t.symbol} as standard-size ${side} orders`, roundEndsAt: iso(round.endsAt) };
+        return exclusive(async () => {
+            const r = await p.batch(t.token, side, x);
+            const placed = r.orders.reduce((a, o) => a + o.size, 0n);
+            const pc = await cost(side === "buy" ? (await vaults())[0] : t, placed);
+            spending.record(pc.budget, pc.value);
+            return {
+                placed: r.orders.map((o) => ({ size: formatEther(o.size), round: o.round, tx: link(o.txHash) })),
+                leftInBalance: formatEther(r.rest),
+                next: "The output arrives in the private balance when the round settles. Check private_balance in a minute.",
+            };
+        });
+    }));
+    server.registerTool("private_send", {
+        title: "Send privately",
+        description: "Pay someone's cloak: address from the private balance. The chain sees that a private transaction happened, but not who sent it, who got it or how much.",
+        inputSchema: { asset: z.string().describe('"HYPE", "USDC" or a launch token'), to: z.string().describe("Recipient cloak: address"), amount: amt('Amount, or "max"'), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ asset, to, amount, dry_run }) => {
+        const { spending } = needWallet();
+        if (!to.startsWith("cloak:"))
+            throw new Error("The recipient must be a cloak: address (the receiver gets it from unlock or the Portfolio page).");
+        const a = await resolve(asset);
+        const p = await priv();
+        const x = amountOf(amount, a.decimals) ?? (await p.maxSpendable(a.pool, "transact"));
+        if (x <= 0n)
+            throw new Error("Not enough private balance for this, counting the relayer's fee.");
+        const c = await cost(a, x);
+        spending.check(c.budget, c.value);
+        if (isDry(dry_run))
+            return { dryRun: true, wouldSend: fmtAmt(a, x), to };
+        return exclusive(async () => {
+            const h = await p.send(a.kind === "hype" ? p.hypeMarket.token : a.token, to, x);
+            await receipt(h);
+            spending.record(c.budget, c.value);
+            return { sent: fmtAmt(a, x), to, privateBalance: fmtAmt(a, await p.balance(a.pool)), tx: link(h), visibleOnChain: "a private transaction happened; no sender, recipient or amount" };
+        });
+    }));
+    server.registerTool("withdraw", {
+        title: "Withdraw to an address",
+        description: "Move funds from the private balance to a normal 0x address (public on purpose). A brand-new address keeps the most privacy. Cloak keeps 0.25%, and the relayer takes a small fee for gas.",
+        inputSchema: { asset: z.string().describe('"HYPE", "USDC" or a launch token'), to: addr, amount: amt('Amount, or "max"'), dry_run: dry },
+        annotations: WRITE,
+    }, safe(async ({ asset, to, amount, dry_run }) => {
+        const { spending } = needWallet();
+        if (!isAddress(to))
+            throw new Error("`to` must be a 0x address.");
+        const a = await resolve(asset);
+        const p = await priv();
+        const kind = a.kind === "hype" ? "unshieldHype" : "transact";
+        const x = amountOf(amount, a.decimals) ?? (await p.maxSpendable(a.pool, kind));
+        if (x <= 0n)
+            throw new Error("Not enough private balance for this, counting the relayer's fee.");
+        const c = await cost(a, x);
+        spending.check(c.budget, c.value);
+        const arrives = await pub.readContract({ address: a.pool, abi: shieldedPoolAbi, functionName: "afterFee", args: [x] });
+        if (isDry(dry_run))
+            return { dryRun: true, wouldWithdraw: fmtAmt(a, x), arrives: fmtAmt(a, arrives), to };
+        return exclusive(async () => {
+            const h = a.kind === "hype" ? await p.unshieldHype(to, x) : await p.unshieldToken(a.token, to, x);
+            await receipt(h);
+            spending.record(c.budget, c.value);
+            return { withdrew: fmtAmt(a, x), arrived: fmtAmt(a, arrives), to, privateBalance: fmtAmt(a, await p.balance(a.pool)), tx: link(h) };
+        });
+    }));
+    return server;
+}

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@cloakely/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Cloak's MCP server: let an AI agent launch tokens with sealed bids and trade them privately on Elysium, with spending limits, testnet by default and a local signer.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-agent",
+    "cloak",
+    "elysium",
+    "kinetiq",
+    "hype",
+    "sealed-bid",
+    "privacy",
+    "zero-knowledge"
+  ],
+  "homepage": "https://cloak.boblabs.tech/sdk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NECOKIZZ/Cloak.git",
+    "directory": "packages/mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/NECOKIZZ/cloak/issues"
+  },
+  "author": "Bob Labs",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cloak-mcp": "dist/index.js"
+  },
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.1",
+    "viem": "2.21.54",
+    "zod": "4.6.7",
+    "@cloakely/sdk": "^0.2.6"
+  },
+  "devDependencies": {
+    "@types/node": "22.10.2",
+    "typescript": "5.6.3"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./http": {
+      "types": "./dist/http.d.ts",
+      "default": "./dist/http.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "test": "node --test test/*.test.mjs"
+  }
 }