@helm-protocol/ttt-mcp 0.1.6 → 0.1.7

package/dist/index.js

@@ -1,169 +1,169 @@
 #!/usr/bin/env node
 "use strict";
-// @helm-protocol/ttt-mcp — MCP Server for OpenTTT Proof of Time
-// Provides 5 tools for AI agents: pot_generate, pot_verify, pot_query, pot_stats, pot_health
-Object.defineProperty(exports, "__esModule", { value: true });
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-const http_1 = require("http");
-const zod_1 = require("zod");
-const tools_1 = require("./tools");
-const server = new mcp_js_1.McpServer({
-    name: "ttt-mcp",
-    version: "0.1.0",
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+var import_http = require("http");
+var import_zod = require("zod");
+var import_tools = require("./tools");
+const server = new import_mcp.McpServer({
+  name: "ttt-mcp",
+  version: "0.1.0"
 });
-// ---------- Tool 1: pot_generate ----------
-server.tool("pot_generate", "Generate a Proof of Time for a transaction. Returns potHash, timestamp, stratum, and GRG integrity shards.", {
-    txHash: zod_1.z.string().describe("Transaction hash (hex with 0x prefix)"),
-    chainId: zod_1.z.number().describe("Chain ID (e.g. 8453 for Base, 84532 for Base Sepolia)"),
-    poolAddress: zod_1.z.string().describe("DEX pool contract address"),
-}, async (args) => {
+server.tool(
+  "pot_generate",
+  "Generate a Proof of Time for a transaction. Returns potHash, timestamp, stratum, and GRG integrity shards.",
+  {
+    txHash: import_zod.z.string().describe("Transaction hash (hex with 0x prefix)"),
+    chainId: import_zod.z.number().describe("Chain ID (e.g. 8453 for Base, 84532 for Base Sepolia)"),
+    poolAddress: import_zod.z.string().describe("DEX pool contract address")
+  },
+  async (args) => {
     try {
-        const result = await (0, tools_1.potGenerate)(args);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
+      const result = await (0, import_tools.potGenerate)(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
-    }
-});
-// ---------- Tool 2: pot_verify ----------
-server.tool("pot_verify", "Verify a Proof of Time using its hash and GRG shards. Returns validity, mode (turbo/full), and timestamp.", {
-    potHash: zod_1.z.string().describe("PoT hash to verify (hex with 0x prefix)"),
-    grgShards: zod_1.z.array(zod_1.z.string()).describe("Array of hex-encoded GRG integrity shards"),
-    chainId: zod_1.z.number().describe("EVM chain ID (e.g. 84532 for Base Sepolia)"),
-    poolAddress: zod_1.z.string().describe("Uniswap V4 pool address (0x-prefixed)"),
-}, async (args) => {
+  }
+);
+server.tool(
+  "pot_verify",
+  "Verify a Proof of Time using its hash and GRG shards. Returns validity, mode (turbo/full), and timestamp.",
+  {
+    potHash: import_zod.z.string().describe("PoT hash to verify (hex with 0x prefix)"),
+    grgShards: import_zod.z.array(import_zod.z.string()).describe("Array of hex-encoded GRG integrity shards"),
+    chainId: import_zod.z.number().describe("EVM chain ID (e.g. 84532 for Base Sepolia)"),
+    poolAddress: import_zod.z.string().describe("Uniswap V4 pool address (0x-prefixed)")
+  },
+  async (args) => {
     try {
-        const result = await (0, tools_1.potVerify)(args);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
+      const result = await (0, import_tools.potVerify)(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-});
-// ---------- Tool 3: pot_query ----------
-server.tool("pot_query", "Query Proof of Time history from local log and on-chain subgraph.", {
-    startTime: zod_1.z.number().optional().describe("Start time (unix ms). Default: 24h ago"),
-    endTime: zod_1.z.number().optional().describe("End time (unix ms). Default: now"),
-    limit: zod_1.z.number().optional().describe("Max entries to return. Default: 100, max: 1000"),
-}, async (args) => {
+  }
+);
+server.tool(
+  "pot_query",
+  "Query Proof of Time history from local log and on-chain subgraph.",
+  {
+    startTime: import_zod.z.number().optional().describe("Start time (unix ms). Default: 24h ago"),
+    endTime: import_zod.z.number().optional().describe("End time (unix ms). Default: now"),
+    limit: import_zod.z.number().optional().describe("Max entries to return. Default: 100, max: 1000")
+  },
+  async (args) => {
     try {
-        const result = await (0, tools_1.potQuery)(args);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
+      const result = await (0, import_tools.potQuery)(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-});
-// ---------- Tool 4: pot_stats ----------
-server.tool("pot_stats", "Get PoT statistics: total swaps, turbo/full counts, and turbo ratio for a given period.", {
-    period: zod_1.z.enum(["day", "week", "month"]).describe("Time period for statistics"),
-}, async (args) => {
+  }
+);
+server.tool(
+  "pot_stats",
+  "Get PoT statistics: total swaps, turbo/full counts, and turbo ratio for a given period.",
+  {
+    period: import_zod.z.enum(["day", "week", "month"]).describe("Time period for statistics")
+  },
+  async (args) => {
     try {
-        const result = await (0, tools_1.potStats)(args);
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
+      const result = await (0, import_tools.potStats)(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
-    }
-});
-// ---------- Tool 5: pot_health ----------
-server.tool("pot_health", "Check PoT system health: time source status, subgraph sync, server uptime, and current mode.", {}, async () => {
+  }
+);
+server.tool(
+  "pot_health",
+  "Check PoT system health: time source status, subgraph sync, server uptime, and current mode.",
+  {},
+  async () => {
     try {
-        const result = await (0, tools_1.potHealth)();
-        return {
-            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-        };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        return {
-            content: [{ type: "text", text: `Error: ${message}` }],
-            isError: true,
-        };
+      const result = await (0, import_tools.potHealth)();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
     }
-});
-// ---------- Start Server ----------
+  }
+);
 async function main() {
-    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
-    if (port) {
-        // HTTP mode for Docker/Glama — StreamableHTTP transport
-        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
-            sessionIdGenerator: undefined,
-        });
-        await server.connect(transport);
-        const httpServer = (0, http_1.createServer)(async (req, res) => {
-            // Health check for Docker/Glama container probes
-            if (req.method === "GET" && (req.url === "/health" || req.url === "/ping")) {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.1.5" }));
-                return;
-            }
-            // SDK requires both application/json and text/event-stream in Accept.
-            // Glama sends only application/json — Hono reads rawHeaders (not headers),
-            // so we must patch rawHeaders directly.
-            const accept = req.headers["accept"] ?? "";
-            if (!accept.includes("text/event-stream")) {
-                const newAccept = accept
-                    ? `${accept}, text/event-stream`
-                    : "application/json, text/event-stream";
-                req.headers["accept"] = newAccept;
-                const raw = req.rawHeaders;
-                const idx = raw.findIndex((h, i) => i % 2 === 0 && h.toLowerCase() === "accept");
-                if (idx >= 0) {
-                    raw[idx + 1] = newAccept;
-                }
-                else {
-                    raw.push("Accept", newAccept);
-                }
-            }
-            try {
-                await transport.handleRequest(req, res);
-            }
-            catch (err) {
-                if (!res.headersSent) {
-                    res.writeHead(500, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ error: "Internal server error" }));
-                }
-            }
-        });
-        httpServer.listen(port, () => {
-            console.error(`[ttt-mcp] OpenTTT MCP Server (HTTP) on port ${port}`);
-        });
-    }
-    else {
-        // stdio mode for npx/Claude Desktop usage
-        const transport = new stdio_js_1.StdioServerTransport();
-        await server.connect(transport);
-        console.error("[ttt-mcp] OpenTTT MCP Server running on stdio");
-    }
+  const port = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
+  if (port) {
+    const transport = new import_streamableHttp.StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    await server.connect(transport);
+    const httpServer = (0, import_http.createServer)(async (req, res) => {
+      if (req.method === "GET" && (req.url === "/health" || req.url === "/ping")) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.1.5" }));
+        return;
+      }
+      const accept = req.headers["accept"] ?? "";
+      if (!accept.includes("text/event-stream")) {
+        const newAccept = accept ? `${accept}, text/event-stream` : "application/json, text/event-stream";
+        req.headers["accept"] = newAccept;
+        const raw = req.rawHeaders;
+        const idx = raw.findIndex((h, i) => i % 2 === 0 && h.toLowerCase() === "accept");
+        if (idx >= 0) {
+          raw[idx + 1] = newAccept;
+        } else {
+          raw.push("Accept", newAccept);
+        }
+      }
+      try {
+        await transport.handleRequest(req, res);
+      } catch (err) {
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+    });
+    httpServer.listen(port, () => {
+      console.error(`[ttt-mcp] OpenTTT MCP Server (HTTP) on port ${port}`);
+    });
+  } else {
+    const transport = new import_stdio.StdioServerTransport();
+    await server.connect(transport);
+    console.error("[ttt-mcp] OpenTTT MCP Server running on stdio");
+  }
 }
 main().catch((err) => {
-    console.error("[ttt-mcp] Fatal:", err);
-    process.exit(1);
+  console.error("[ttt-mcp] Fatal:", err);
+  process.exit(1);
 });

package/dist/telemetry.js

@@ -1,45 +1,59 @@
 "use strict";
-// @helm-protocol/ttt-mcp — Anonymous telemetry counter
-// Increments a simple counter on each tool call. Fire-and-forget, never blocks.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.telemetryIncrement = telemetryIncrement;
-exports.getTelemetryCounts = getTelemetryCounts;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  getTelemetryCounts: () => getTelemetryCounts,
+  telemetryIncrement: () => telemetryIncrement
+});
+module.exports = __toCommonJS(telemetry_exports);
 const counters = {};
 const TELEMETRY_ENDPOINT = "https://api.studio.thegraph.com/query/1744392/openttt-base-sepolia/v0.1.0";
-/**
- * Increment an anonymous tool-call counter.
- * Posts to subgraph endpoint as a best-effort ping. Never throws.
- */
 function telemetryIncrement(toolName) {
-    counters[toolName] = (counters[toolName] ?? 0) + 1;
-    // Fire-and-forget POST — no await, no error propagation
-    try {
-        const body = JSON.stringify({
-            query: `{ _meta { block { number } } }`,
-            extensions: {
-                telemetry: {
-                    tool: toolName,
-                    count: counters[toolName],
-                    ts: Date.now(),
-                    pkg: "@helm-protocol/ttt-mcp",
-                    v: "0.1.0",
-                },
-            },
-        });
-        fetch(TELEMETRY_ENDPOINT, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body,
-            signal: AbortSignal.timeout(3000),
-        }).catch(() => {
-            // silently ignore — telemetry is best-effort
-        });
-    }
-    catch {
-        // never block the tool call
-    }
+  counters[toolName] = (counters[toolName] ?? 0) + 1;
+  try {
+    const body = JSON.stringify({
+      query: `{ _meta { block { number } } }`,
+      extensions: {
+        telemetry: {
+          tool: toolName,
+          count: counters[toolName],
+          ts: Date.now(),
+          pkg: "@helm-protocol/ttt-mcp",
+          v: "0.1.0"
+        }
+      }
+    });
+    fetch(TELEMETRY_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      signal: AbortSignal.timeout(3e3)
+    }).catch(() => {
+    });
+  } catch {
+  }
 }
-/** Get current session counters (for debugging) */
 function getTelemetryCounts() {
-    return { ...counters };
+  return { ...counters };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTelemetryCounts,
+  telemetryIncrement
+});

package/dist/tools.js

@@ -1,114 +1,116 @@
 "use strict";
-// @helm-protocol/ttt-mcp — Tool implementations for Proof of Time MCP Server
-// Uses OpenTTT SDK: TimeSynthesis, IntegrityPipeline, PotSigner, AdaptiveSwitch
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.potGenerate = potGenerate;
-exports.potVerify = potVerify;
-exports.potQuery = potQuery;
-exports.potStats = potStats;
-exports.potHealth = potHealth;
-const openttt_1 = require("openttt");
-const telemetry_1 = require("./telemetry");
-// ---------- Shared Instances ----------
-const timeSynth = new openttt_1.TimeSynthesis();
-const adaptiveSwitch = new openttt_1.AdaptiveSwitch();
-const potSigner = new openttt_1.PotSigner(); // ephemeral Ed25519 keypair per server session
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tools_exports = {};
+__export(tools_exports, {
+  potGenerate: () => potGenerate,
+  potHealth: () => potHealth,
+  potQuery: () => potQuery,
+  potStats: () => potStats,
+  potVerify: () => potVerify
+});
+module.exports = __toCommonJS(tools_exports);
+var import_openttt = require("openttt");
+var import_telemetry = require("./telemetry");
+const timeSynth = new import_openttt.TimeSynthesis();
+const adaptiveSwitch = new import_openttt.AdaptiveSwitch();
+const potSigner = new import_openttt.PotSigner();
 const startedAt = Date.now();
-// In-memory PoT anchor log (bounded ring buffer)
-const POT_LOG_MAX = 10000;
+const POT_LOG_MAX = 1e4;
 const potLog = [];
-// ---------- Helpers ----------
 function bigintReplacer(_key, value) {
-    return typeof value === "bigint" ? value.toString() : value;
+  return typeof value === "bigint" ? value.toString() : value;
 }
 function serialize(obj) {
-    return JSON.parse(JSON.stringify(obj, bigintReplacer));
+  return JSON.parse(JSON.stringify(obj, bigintReplacer));
 }
 const SUBGRAPH_URL = "https://api.studio.thegraph.com/query/1744392/openttt-base-sepolia/v0.1.0";
-// ---------- Tool: pot_generate ----------
 async function potGenerate(args) {
-    (0, telemetry_1.telemetryIncrement)("pot_generate");
-    // 1. Synthesize time from multiple NTP/HTTPS sources
-    const pot = await timeSynth.generateProofOfTime();
-    const potHash = openttt_1.TimeSynthesis.getOnChainHash(pot);
-    // 2. GRG pipeline — encode tx data into integrity shards (black box)
-    const txData = new TextEncoder().encode(args.txHash);
-    const grgShards = openttt_1.GrgPipeline.processForward(txData, args.chainId, args.poolAddress);
-    // 3. Ed25519 sign the PoT hash for non-repudiation
-    const signature = potSigner.signPot(potHash);
-    // 4. Log the anchor
-    const entry = {
-        potHash,
-        timestamp: pot.timestamp.toString(),
-        stratum: pot.stratum,
-        mode: adaptiveSwitch.getCurrentMode(),
-        chainId: args.chainId,
-        poolAddress: args.poolAddress,
-        createdAt: Date.now(),
-    };
-    potLog.push(entry);
-    if (potLog.length > POT_LOG_MAX)
-        potLog.shift();
-    return serialize({
-        potHash,
-        timestamp: pot.timestamp.toString(),
-        stratum: pot.stratum,
-        uncertainty: pot.uncertainty,
-        confidence: pot.confidence,
-        sources: pot.sources,
-        nonce: pot.nonce,
-        expiresAt: pot.expiresAt.toString(),
-        grgShards: grgShards.map((s) => Buffer.from(s).toString("hex")),
-        signature: {
-            issuerPubKey: signature.issuerPubKey,
-            signature: signature.signature,
-            issuedAt: signature.issuedAt.toString(),
-        },
-    });
+  (0, import_telemetry.telemetryIncrement)("pot_generate");
+  const pot = await timeSynth.generateProofOfTime();
+  const potHash = import_openttt.TimeSynthesis.getOnChainHash(pot);
+  const txData = new TextEncoder().encode(args.txHash);
+  const grgShards = import_openttt.GrgPipeline.processForward(txData, args.chainId, args.poolAddress);
+  const signature = potSigner.signPot(potHash);
+  const entry = {
+    potHash,
+    timestamp: pot.timestamp.toString(),
+    stratum: pot.stratum,
+    mode: adaptiveSwitch.getCurrentMode(),
+    chainId: args.chainId,
+    poolAddress: args.poolAddress,
+    createdAt: Date.now()
+  };
+  potLog.push(entry);
+  if (potLog.length > POT_LOG_MAX) potLog.shift();
+  return serialize({
+    potHash,
+    timestamp: pot.timestamp.toString(),
+    stratum: pot.stratum,
+    uncertainty: pot.uncertainty,
+    confidence: pot.confidence,
+    sources: pot.sources,
+    nonce: pot.nonce,
+    expiresAt: pot.expiresAt.toString(),
+    grgShards: grgShards.map((s) => Buffer.from(s).toString("hex")),
+    signature: {
+      issuerPubKey: signature.issuerPubKey,
+      signature: signature.signature,
+      issuedAt: signature.issuedAt.toString()
+    }
+  });
 }
-// ---------- Tool: pot_verify ----------
 async function potVerify(args) {
-    (0, telemetry_1.telemetryIncrement)("pot_verify");
-    const shards = args.grgShards.map((hex) => new Uint8Array(Buffer.from(hex, "hex")));
-    let valid = false;
-    let reconstructedSize = 0;
-    try {
-        const recovered = openttt_1.GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
-        valid = recovered.length > 0;
-        reconstructedSize = recovered.length;
-    }
-    catch {
-        valid = false;
-    }
-    const mode = adaptiveSwitch.getCurrentMode() === openttt_1.AdaptiveMode.TURBO ? "turbo" : "full";
-    return serialize({
-        valid,
-        mode,
-        potHash: args.potHash,
-        reconstructedBytes: reconstructedSize,
-        verifiedAt: Date.now(),
-    });
+  (0, import_telemetry.telemetryIncrement)("pot_verify");
+  const shards = args.grgShards.map((hex) => new Uint8Array(Buffer.from(hex, "hex")));
+  let valid = false;
+  let reconstructedSize = 0;
+  try {
+    const recovered = import_openttt.GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
+    valid = recovered.length > 0;
+    reconstructedSize = recovered.length;
+  } catch {
+    valid = false;
+  }
+  const mode = adaptiveSwitch.getCurrentMode() === import_openttt.AdaptiveMode.TURBO ? "turbo" : "full";
+  return serialize({
+    valid,
+    mode,
+    potHash: args.potHash,
+    reconstructedBytes: reconstructedSize,
+    verifiedAt: Date.now()
+  });
 }
-// ---------- Tool: pot_query ----------
 async function potQuery(args) {
-    (0, telemetry_1.telemetryIncrement)("pot_query");
-    const limit = Math.min(args.limit ?? 100, 1000);
-    const now = Date.now();
-    const startTime = args.startTime ?? now - 86400_000;
-    const endTime = args.endTime ?? now;
-    // Filter from in-memory log
-    const filtered = potLog
-        .filter((e) => e.createdAt >= startTime && e.createdAt <= endTime)
-        .slice(-limit);
-    // Best-effort subgraph query
-    let subgraphEntries = [];
-    try {
-        const query = `{
+  (0, import_telemetry.telemetryIncrement)("pot_query");
+  const limit = Math.min(args.limit ?? 100, 1e3);
+  const now = Date.now();
+  const startTime = args.startTime ?? now - 864e5;
+  const endTime = args.endTime ?? now;
+  const filtered = potLog.filter((e) => e.createdAt >= startTime && e.createdAt <= endTime).slice(-limit);
+  let subgraphEntries = [];
+  try {
+    const query = `{
       potAnchors(
         first: ${limit},
         orderBy: blockTimestamp,
         orderDirection: desc,
-        where: { blockTimestamp_gte: "${Math.floor(startTime / 1000)}", blockTimestamp_lte: "${Math.floor(endTime / 1000)}" }
+        where: { blockTimestamp_gte: "${Math.floor(startTime / 1e3)}", blockTimestamp_lte: "${Math.floor(endTime / 1e3)}" }
       ) {
         id
         potHash
@@ -116,110 +118,113 @@ async function potQuery(args) {
         txHash
       }
     }`;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5000);
-        const resp = await fetch(SUBGRAPH_URL, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ query }),
-            signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        if (resp.ok) {
-            const json = (await resp.json());
-            subgraphEntries = json.data?.potAnchors ?? [];
-        }
-    }
-    catch {
-        // Subgraph unavailable — local log still returned
-    }
-    return serialize({
-        local: filtered,
-        subgraph: subgraphEntries,
-        totalLocal: potLog.length,
-        query: { startTime, endTime, limit },
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const resp = await fetch(SUBGRAPH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+      signal: controller.signal
     });
+    clearTimeout(timeout);
+    if (resp.ok) {
+      const json = await resp.json();
+      subgraphEntries = json.data?.potAnchors ?? [];
+    }
+  } catch {
+  }
+  return serialize({
+    local: filtered,
+    subgraph: subgraphEntries,
+    totalLocal: potLog.length,
+    query: { startTime, endTime, limit }
+  });
 }
-// ---------- Tool: pot_stats ----------
 async function potStats(args) {
-    (0, telemetry_1.telemetryIncrement)("pot_stats");
-    const now = Date.now();
-    const periodMs = {
-        day: 86400_000,
-        week: 604800_000,
-        month: 2592000_000,
-    };
-    const cutoff = now - (periodMs[args.period] ?? periodMs.day);
-    const entries = potLog.filter((e) => e.createdAt >= cutoff);
-    const turboCount = entries.filter((e) => e.mode === openttt_1.AdaptiveMode.TURBO).length;
-    const fullCount = entries.filter((e) => e.mode === openttt_1.AdaptiveMode.FULL).length;
-    const totalSwaps = entries.length;
-    return serialize({
-        period: args.period,
-        totalSwaps,
-        turboCount,
-        fullCount,
-        turboRatio: totalSwaps > 0 ? +(turboCount / totalSwaps).toFixed(4) : 0,
-        currentMode: adaptiveSwitch.getCurrentMode(),
-        windowStart: new Date(cutoff).toISOString(),
-        windowEnd: new Date(now).toISOString(),
-    });
+  (0, import_telemetry.telemetryIncrement)("pot_stats");
+  const now = Date.now();
+  const periodMs = {
+    day: 864e5,
+    week: 6048e5,
+    month: 2592e6
+  };
+  const cutoff = now - (periodMs[args.period] ?? periodMs.day);
+  const entries = potLog.filter((e) => e.createdAt >= cutoff);
+  const turboCount = entries.filter((e) => e.mode === import_openttt.AdaptiveMode.TURBO).length;
+  const fullCount = entries.filter((e) => e.mode === import_openttt.AdaptiveMode.FULL).length;
+  const totalSwaps = entries.length;
+  return serialize({
+    period: args.period,
+    totalSwaps,
+    turboCount,
+    fullCount,
+    turboRatio: totalSwaps > 0 ? +(turboCount / totalSwaps).toFixed(4) : 0,
+    currentMode: adaptiveSwitch.getCurrentMode(),
+    windowStart: new Date(cutoff).toISOString(),
+    windowEnd: new Date(now).toISOString()
+  });
 }
-// ---------- Tool: pot_health ----------
 async function potHealth() {
-    (0, telemetry_1.telemetryIncrement)("pot_health");
-    let timeStatus = "unknown";
-    let synthSources = 0;
-    try {
-        const synth = await Promise.race([
-            timeSynth.synthesize(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 5000)),
-        ]);
-        if (synth && synth.sources >= 2) {
-            timeStatus = "healthy";
-            synthSources = synth.sources;
-        }
-        else {
-            timeStatus = "degraded";
-            synthSources = synth?.sources ?? 0;
-        }
+  (0, import_telemetry.telemetryIncrement)("pot_health");
+  let timeStatus = "unknown";
+  let synthSources = 0;
+  try {
+    const synth = await Promise.race([
+      timeSynth.synthesize(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("timeout")), 5e3)
+      )
+    ]);
+    if (synth && synth.sources >= 2) {
+      timeStatus = "healthy";
+      synthSources = synth.sources;
+    } else {
+      timeStatus = "degraded";
+      synthSources = synth?.sources ?? 0;
     }
-    catch {
-        timeStatus = "unhealthy";
-    }
-    let latestBlock = 0;
-    let syncStatus = "unknown";
-    try {
-        const query = `{ _meta { block { number } hasIndexingErrors } }`;
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5000);
-        const resp = await fetch(SUBGRAPH_URL, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ query }),
-            signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        if (resp.ok) {
-            const json = (await resp.json());
-            latestBlock = json.data?._meta?.block?.number ?? 0;
-            syncStatus = json.data?._meta?.hasIndexingErrors ? "indexing_errors" : "synced";
-        }
+  } catch {
+    timeStatus = "unhealthy";
+  }
+  let latestBlock = 0;
+  let syncStatus = "unknown";
+  try {
+    const query = `{ _meta { block { number } hasIndexingErrors } }`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const resp = await fetch(SUBGRAPH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (resp.ok) {
+      const json = await resp.json();
+      latestBlock = json.data?._meta?.block?.number ?? 0;
+      syncStatus = json.data?._meta?.hasIndexingErrors ? "indexing_errors" : "synced";
     }
-    catch {
-        syncStatus = "unreachable";
+  } catch {
+    syncStatus = "unreachable";
+  }
+  const uptimeMs = Date.now() - startedAt;
+  return serialize({
+    status: timeStatus === "healthy" ? "ok" : timeStatus,
+    timeSources: { status: timeStatus, activeSources: synthSources },
+    subgraph: { latestBlock, syncStatus },
+    server: {
+      uptime: uptimeMs,
+      uptimeHuman: `${(uptimeMs / 36e5).toFixed(1)}h`,
+      potCount: potLog.length,
+      currentMode: adaptiveSwitch.getCurrentMode(),
+      signerPubKey: potSigner.getPubKeyHex()
     }
-    const uptimeMs = Date.now() - startedAt;
-    return serialize({
-        status: timeStatus === "healthy" ? "ok" : timeStatus,
-        timeSources: { status: timeStatus, activeSources: synthSources },
-        subgraph: { latestBlock, syncStatus },
-        server: {
-            uptime: uptimeMs,
-            uptimeHuman: `${(uptimeMs / 3600000).toFixed(1)}h`,
-            potCount: potLog.length,
-            currentMode: adaptiveSwitch.getCurrentMode(),
-            signerPubKey: potSigner.getPubKeyHex(),
-        },
-    });
+  });
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  potGenerate,
+  potHealth,
+  potQuery,
+  potStats,
+  potVerify
+});

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@helm-protocol/ttt-mcp",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "MCP Server for OpenTTT — Proof of Time tools for AI agents",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "bin": {
     "ttt-mcp": "./dist/index.js"
   },
@@ -12,7 +11,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "esbuild index.ts tools.ts telemetry.ts --platform=node --target=node18 --format=cjs --outdir=dist",
     "start": "node dist/index.js",
     "dev": "npx ts-node index.ts"
   },
@@ -42,6 +41,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.19",
+    "esbuild": "^0.27.4",
     "typescript": "^5.3.3"
   },
   "mcpName": "io.github.Helm-Protocol/openttt-pot"

package/dist/index.d.ts

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

package/dist/telemetry.d.ts

@@ -1,7 +0,0 @@
-/**
- * Increment an anonymous tool-call counter.
- * Posts to subgraph endpoint as a best-effort ping. Never throws.
- */
-export declare function telemetryIncrement(toolName: string): void;
-/** Get current session counters (for debugging) */
-export declare function getTelemetryCounts(): Record<string, number>;

package/dist/tools.d.ts

@@ -1,20 +0,0 @@
-export declare function potGenerate(args: {
-    txHash: string;
-    chainId: number;
-    poolAddress: string;
-}): Promise<unknown>;
-export declare function potVerify(args: {
-    potHash: string;
-    grgShards: string[];
-    chainId: number;
-    poolAddress: string;
-}): Promise<unknown>;
-export declare function potQuery(args: {
-    startTime?: number;
-    endTime?: number;
-    limit?: number;
-}): Promise<unknown>;
-export declare function potStats(args: {
-    period: "day" | "week" | "month";
-}): Promise<unknown>;
-export declare function potHealth(): Promise<unknown>;