@secondlayer/mcp 0.2.0

package/dist/bin.js

@@ -0,0 +1,551 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/templates.ts
+import { z } from "zod";
+import { templates, getTemplateById, getTemplatesByCategory } from "@secondlayer/subgraphs/templates";
+
+// src/lib/tool.ts
+function defineTool(server, name, description, schema, handler) {
+  server.tool(name, description, schema, handler);
+}
+
+// src/tools/templates.ts
+function registerTemplateTools(server) {
+  defineTool(server, "templates_list", "List available subgraph templates. Returns metadata only — use templates_get for full code.", { category: z.enum(["defi", "nft", "token", "infrastructure"]).optional().describe("Filter by category") }, async ({ category }) => {
+    const list = category ? getTemplatesByCategory(category) : templates;
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(list.map((t) => ({
+          id: t.id,
+          name: t.name,
+          description: t.description,
+          category: t.category
+        })), null, 2)
+      }]
+    };
+  });
+  defineTool(server, "templates_get", "Get a template's full code and prompt by ID.", { id: z.string().describe("Template ID (e.g. 'dex-swaps')") }, async ({ id }) => {
+    const template = getTemplateById(id);
+    if (!template) {
+      return { content: [{ type: "text", text: `Template "${id}" not found. Use templates_list to see available templates.` }], isError: true };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ id: template.id, name: template.name, description: template.description, category: template.category, code: template.code, prompt: template.prompt }, null, 2)
+      }]
+    };
+  });
+}
+
+// src/tools/scaffold.ts
+import { z as z2 } from "zod";
+
+// src/lib/scaffold-generate.ts
+function isAbiBuffer(t) {
+  return typeof t === "object" && t !== null && "buff" in t;
+}
+function isAbiStringAscii(t) {
+  return typeof t === "object" && t !== null && "string-ascii" in t;
+}
+function isAbiStringUtf8(t) {
+  return typeof t === "object" && t !== null && "string-utf8" in t;
+}
+function isAbiOptional(t) {
+  return typeof t === "object" && t !== null && "optional" in t;
+}
+function isAbiTuple(t) {
+  return typeof t === "object" && t !== null && "tuple" in t;
+}
+function isAbiList(t) {
+  return typeof t === "object" && t !== null && "list" in t;
+}
+function isAbiResponse(t) {
+  return typeof t === "object" && t !== null && "response" in t;
+}
+function mapType(abiType, nullable) {
+  if (typeof abiType === "string") {
+    switch (abiType) {
+      case "uint128":
+        return { type: "uint", nullable };
+      case "int128":
+        return { type: "int", nullable };
+      case "principal":
+      case "trait_reference":
+        return { type: "principal", nullable };
+      case "bool":
+        return { type: "boolean", nullable };
+      default: {
+        const s = abiType;
+        if (s.includes("uint"))
+          return { type: "uint", nullable };
+        if (s.includes("int"))
+          return { type: "int", nullable };
+        if (s.includes("string") || s.includes("ascii") || s.includes("utf8")) {
+          return { type: "text", nullable };
+        }
+        if (s.includes("buff"))
+          return { type: "text", nullable };
+        return { type: "jsonb", nullable };
+      }
+    }
+  }
+  if (isAbiBuffer(abiType))
+    return { type: "text", nullable };
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    return { type: "text", nullable };
+  }
+  if (isAbiOptional(abiType))
+    return mapType(abiType.optional, true);
+  if (isAbiList(abiType) || isAbiTuple(abiType))
+    return { type: "jsonb", nullable };
+  if (isAbiResponse(abiType)) {
+    return mapType(abiType.response.ok, nullable);
+  }
+  return { type: "jsonb", nullable };
+}
+function clarityTypeToSubgraphColumn(abiType) {
+  return mapType(abiType, false);
+}
+function toSnake(name) {
+  return name.replace(/-/g, "_");
+}
+function toCamel(name) {
+  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function buildColumns(args) {
+  if (args.length === 0)
+    return "        _placeholder: { type: 'text' }";
+  return args.map((arg) => {
+    const mapped = clarityTypeToSubgraphColumn(arg.type);
+    const nullable = mapped.nullable ? ", nullable: true" : "";
+    return `        ${toSnake(arg.name)}: { type: '${mapped.type}'${nullable} }`;
+  }).join(`,
+`);
+}
+function buildInsertCall(tableName, args) {
+  if (args.length === 0) {
+    return `      ctx.insert('${tableName}', {
+        sender: ctx.tx.sender,
+      });`;
+  }
+  const mappings = args.map((arg) => {
+    return `        ${toSnake(arg.name)}: event.${toCamel(arg.name)}`;
+  });
+  return `      ctx.insert('${tableName}', {
+${mappings.join(`,
+`)},
+      });`;
+}
+function generateSubgraphCode(contractId, functions, subgraphName, events) {
+  const contractParts = contractId.split(".");
+  const contractName = contractParts[contractParts.length - 1] ?? contractId;
+  const name = subgraphName ?? contractName;
+  const publicFunctions = functions.filter((f) => f.access === "public");
+  const hasEvents = events && events.length > 0;
+  if (publicFunctions.length === 0 && !hasEvents) {
+    return `// No public functions or events selected for ${contractId}`;
+  }
+  const tableDefs = [];
+  if (hasEvents) {
+    for (const ev of events) {
+      const tableName = toSnake(ev.name);
+      let columns;
+      if (isAbiTuple(ev.value)) {
+        columns = buildColumns(ev.value.tuple);
+      } else {
+        columns = `        value: { type: '${clarityTypeToSubgraphColumn(ev.value).type}' }`;
+      }
+      tableDefs.push(`    ${tableName}: {
+      columns: {
+${columns}
+      }
+    }`);
+    }
+  }
+  for (const fn of publicFunctions) {
+    const tableName = toSnake(fn.name);
+    const columns = buildColumns(fn.args);
+    tableDefs.push(`    ${tableName}: {
+      columns: {
+${columns}
+      }
+    }`);
+  }
+  const schemaBlock = tableDefs.join(`,
+`);
+  const sourceEntries = [`{ contract: '${contractId}' }`];
+  const handlerEntries = [];
+  if (hasEvents) {
+    for (const ev of events) {
+      const tableName = toSnake(ev.name);
+      let insertCall;
+      if (isAbiTuple(ev.value)) {
+        insertCall = buildInsertCall(tableName, ev.value.tuple);
+      } else {
+        insertCall = `      ctx.insert('${tableName}', {
+        value: event.value,
+      });`;
+      }
+      handlerEntries.push(`    '${contractId}::${ev.name}': async (event, ctx) => {
+${insertCall}
+    }`);
+    }
+  }
+  for (const fn of publicFunctions) {
+    const tableName = toSnake(fn.name);
+    const insertCall = buildInsertCall(tableName, fn.args);
+    handlerEntries.push(`    '${contractId}::${fn.name}': async (event, ctx) => {
+${insertCall}
+    }`);
+  }
+  const handlersBlock = handlerEntries.join(`,
+
+`);
+  return `import { defineSubgraph } from '@secondlayer/subgraphs';
+
+export default defineSubgraph({
+  name: '${name}',
+  sources: [${sourceEntries.join(", ")}],
+  schema: {
+${schemaBlock}
+  },
+  handlers: {
+${handlersBlock}
+  }
+});
+`;
+}
+
+// src/tools/scaffold.ts
+var API_BASE = process.env.SECONDLAYER_API_URL || "https://api.secondlayer.tools";
+async function fetchAbi(contractId) {
+  const res = await fetch(`${API_BASE}/api/node/contracts/${contractId}/abi`);
+  if (!res.ok) {
+    if (res.status === 404)
+      throw new Error(`Contract not found: ${contractId}`);
+    throw new Error(`Failed to fetch ABI: HTTP ${res.status}`);
+  }
+  const abi = await res.json();
+  return {
+    functions: abi.functions ?? [],
+    maps: abi.maps ?? []
+  };
+}
+function registerScaffoldTools(server) {
+  defineTool(server, "scaffold_from_contract", "Generate a subgraph scaffold from a deployed Stacks contract. Fetches the ABI automatically.", {
+    contractId: z2.string().describe("Fully qualified contract ID (e.g. SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-pool-v2-01)"),
+    subgraphName: z2.string().optional().describe("Override the subgraph name (defaults to contract name)")
+  }, async ({ contractId, subgraphName }) => {
+    const { functions, maps } = await fetchAbi(contractId);
+    const code = generateSubgraphCode(contractId, functions, subgraphName, maps);
+    return { content: [{ type: "text", text: code }] };
+  });
+  defineTool(server, "scaffold_from_abi", "Generate a subgraph scaffold from a provided ABI JSON. Use when you already have the ABI.", {
+    abi: z2.string().describe("ABI JSON string (the full contract ABI object)"),
+    contractId: z2.string().describe("Fully qualified contract ID"),
+    subgraphName: z2.string().optional().describe("Override the subgraph name")
+  }, async ({ abi, contractId, subgraphName }) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(abi);
+    } catch {
+      return { content: [{ type: "text", text: "Invalid ABI JSON" }], isError: true };
+    }
+    const code = generateSubgraphCode(contractId, parsed.functions ?? [], subgraphName, parsed.maps ?? []);
+    return { content: [{ type: "text", text: code }] };
+  });
+}
+
+// src/tools/streams.ts
+import { z as z3 } from "zod";
+
+// src/lib/client.ts
+import { SecondLayer } from "@secondlayer/sdk";
+var instance = null;
+function getClient() {
+  if (!instance) {
+    const apiKey = process.env.SECONDLAYER_API_KEY;
+    if (!apiKey) {
+      throw new Error("SECONDLAYER_API_KEY environment variable is required. " + "Get your key at https://app.secondlayer.tools/settings/api-keys");
+    }
+    instance = new SecondLayer({ apiKey });
+  }
+  return instance;
+}
+
+// src/lib/format.ts
+function formatStreamSummary(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    status: s.status,
+    endpointUrl: s.endpointUrl,
+    totalDeliveries: s.totalDeliveries,
+    failedDeliveries: s.failedDeliveries
+  };
+}
+function formatSubgraphSummary(s) {
+  return {
+    name: s.name,
+    status: s.status,
+    tables: Array.isArray(s.tables) ? s.tables : Object.keys(s.tables),
+    lastProcessedBlock: s.lastProcessedBlock
+  };
+}
+function formatDeliverySummary(d) {
+  return {
+    id: d.id,
+    blockHeight: d.blockHeight,
+    status: d.status,
+    statusCode: d.statusCode,
+    attempts: d.attempts,
+    createdAt: d.createdAt
+  };
+}
+function withCap(items, cap) {
+  return {
+    items: items.slice(0, cap),
+    truncated: items.length > cap,
+    total: items.length
+  };
+}
+
+// src/tools/streams.ts
+var FilterSchema = z3.discriminatedUnion("type", [
+  z3.object({ type: z3.literal("stx_transfer"), sender: z3.string().optional(), recipient: z3.string().optional(), minAmount: z3.number().optional(), maxAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("stx_mint"), recipient: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("stx_burn"), sender: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("stx_lock"), lockedAddress: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("ft_transfer"), sender: z3.string().optional(), recipient: z3.string().optional(), assetIdentifier: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("ft_mint"), recipient: z3.string().optional(), assetIdentifier: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("ft_burn"), sender: z3.string().optional(), assetIdentifier: z3.string().optional(), minAmount: z3.number().optional() }),
+  z3.object({ type: z3.literal("nft_transfer"), sender: z3.string().optional(), recipient: z3.string().optional(), assetIdentifier: z3.string().optional(), tokenId: z3.string().optional() }),
+  z3.object({ type: z3.literal("nft_mint"), recipient: z3.string().optional(), assetIdentifier: z3.string().optional(), tokenId: z3.string().optional() }),
+  z3.object({ type: z3.literal("nft_burn"), sender: z3.string().optional(), assetIdentifier: z3.string().optional(), tokenId: z3.string().optional() }),
+  z3.object({ type: z3.literal("contract_call"), contractId: z3.string().optional(), functionName: z3.string().optional(), caller: z3.string().optional() }),
+  z3.object({ type: z3.literal("contract_deploy"), deployer: z3.string().optional(), contractName: z3.string().optional() }),
+  z3.object({ type: z3.literal("print_event"), contractId: z3.string().optional(), topic: z3.string().optional(), contains: z3.string().optional() })
+]);
+function registerStreamTools(server) {
+  defineTool(server, "streams_list", "List all webhook streams. Returns summary fields only.", { status: z3.enum(["active", "inactive", "paused", "failed"]).optional().describe("Filter by status") }, async ({ status }) => {
+    const { streams } = await getClient().streams.list(status ? { status } : undefined);
+    return {
+      content: [{ type: "text", text: JSON.stringify(streams.map(formatStreamSummary), null, 2) }]
+    };
+  });
+  defineTool(server, "streams_get", "Get full details of a stream by ID (accepts UUID prefix).", { id: z3.string().describe("Stream UUID or prefix") }, async ({ id }) => {
+    const stream = await getClient().streams.get(id);
+    return { content: [{ type: "text", text: JSON.stringify(stream, null, 2) }] };
+  });
+  defineTool(server, "streams_create", "Create a new webhook stream with filters.", {
+    name: z3.string().describe("Stream name"),
+    endpointUrl: z3.string().describe("Webhook endpoint URL"),
+    filters: z3.array(FilterSchema).min(1).describe("Event filters (at least one required)")
+  }, async ({ name, endpointUrl, filters }) => {
+    const result = await getClient().streams.create({ name, endpointUrl, filters });
+    return {
+      content: [{ type: "text", text: JSON.stringify({ id: result.stream.id, signingSecret: result.signingSecret }, null, 2) }]
+    };
+  });
+  defineTool(server, "streams_update", "Update a stream's name, endpoint, or filters.", {
+    id: z3.string().describe("Stream UUID or prefix"),
+    name: z3.string().optional().describe("New name"),
+    endpointUrl: z3.string().optional().describe("New endpoint URL"),
+    filters: z3.array(FilterSchema).min(1).optional().describe("New filters")
+  }, async ({ id, name, endpointUrl, filters }) => {
+    const data = {};
+    if (name !== undefined)
+      data.name = name;
+    if (endpointUrl !== undefined)
+      data.endpointUrl = endpointUrl;
+    if (filters !== undefined)
+      data.filters = filters;
+    const stream = await getClient().streams.update(id, data);
+    return { content: [{ type: "text", text: JSON.stringify(formatStreamSummary(stream), null, 2) }] };
+  });
+  defineTool(server, "streams_delete", "Delete a stream permanently.", { id: z3.string().describe("Stream UUID or prefix") }, async ({ id }) => {
+    await getClient().streams.delete(id);
+    return { content: [{ type: "text", text: `Stream ${id} deleted.` }] };
+  });
+  defineTool(server, "streams_toggle", "Enable or disable a stream.", {
+    id: z3.string().describe("Stream UUID or prefix"),
+    enabled: z3.boolean().describe("true to enable, false to disable")
+  }, async ({ id, enabled }) => {
+    const stream = enabled ? await getClient().streams.enable(id) : await getClient().streams.disable(id);
+    return { content: [{ type: "text", text: JSON.stringify({ id: stream.id, status: stream.status }, null, 2) }] };
+  });
+  defineTool(server, "streams_deliveries", "List recent deliveries for a stream (max 25).", {
+    id: z3.string().describe("Stream UUID or prefix"),
+    limit: z3.number().max(25).optional().describe("Max results (default 25)"),
+    status: z3.string().optional().describe("Filter by delivery status")
+  }, async ({ id, limit, status }) => {
+    const { deliveries } = await getClient().streams.listDeliveries(id, { limit: limit ?? 25, status });
+    const result = withCap(deliveries.map(formatDeliverySummary), 25);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  defineTool(server, "streams_pause_all", "Pause all active streams. Without confirm: true, returns a preview of streams that would be paused.", {
+    confirm: z3.boolean().optional().describe("Set to true to execute. Omit or false for preview only.")
+  }, async ({ confirm }) => {
+    if (!confirm) {
+      const { streams } = await getClient().streams.list({ status: "active" });
+      const names = streams.map((s) => s.name);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ preview: true, count: names.length, streams: names }, null, 2)
+        }]
+      };
+    }
+    const result = await getClient().streams.pauseAll();
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ paused: result.paused, streams: result.streams.map(formatStreamSummary) }, null, 2)
+      }]
+    };
+  });
+  defineTool(server, "streams_resume_all", "Resume all paused streams. Without confirm: true, returns a preview of streams that would be resumed.", {
+    confirm: z3.boolean().optional().describe("Set to true to execute. Omit or false for preview only.")
+  }, async ({ confirm }) => {
+    if (!confirm) {
+      const { streams } = await getClient().streams.list({ status: "paused" });
+      const names = streams.map((s) => s.name);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ preview: true, count: names.length, streams: names }, null, 2)
+        }]
+      };
+    }
+    const result = await getClient().streams.resumeAll();
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ resumed: result.resumed, streams: result.streams.map(formatStreamSummary) }, null, 2)
+      }]
+    };
+  });
+}
+
+// src/tools/subgraphs.ts
+import { z as z4 } from "zod";
+
+// src/lib/bundle.ts
+import esbuild from "esbuild";
+import { validateSubgraphDefinition } from "@secondlayer/subgraphs/validate";
+import { sourceKey } from "@secondlayer/subgraphs";
+async function bundleSubgraphCode(code) {
+  const result = await esbuild.build({
+    stdin: { contents: code, loader: "ts", resolveDir: process.cwd() },
+    bundle: true,
+    platform: "node",
+    format: "esm",
+    external: ["@secondlayer/subgraphs"],
+    write: false
+  });
+  const handlerCode = new TextDecoder().decode(result.outputFiles[0].contents);
+  const dataUri = `data:text/javascript;base64,${Buffer.from(handlerCode).toString("base64")}`;
+  const mod = await import(dataUri);
+  const def = mod.default ?? mod;
+  const validated = validateSubgraphDefinition(def);
+  return {
+    name: validated.name,
+    version: validated.version,
+    description: validated.description,
+    sources: validated.sources.map(sourceKey),
+    schema: validated.schema,
+    handlerCode
+  };
+}
+
+// src/tools/subgraphs.ts
+function registerSubgraphTools(server) {
+  defineTool(server, "subgraphs_list", "List all deployed subgraphs. Returns summary fields only.", {}, async () => {
+    const { data } = await getClient().subgraphs.list();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data.map(formatSubgraphSummary), null, 2) }]
+    };
+  });
+  defineTool(server, "subgraphs_get", "Get full details of a subgraph including schema, health, and table columns.", { name: z4.string().describe("Subgraph name") }, async ({ name }) => {
+    const detail = await getClient().subgraphs.get(name);
+    return { content: [{ type: "text", text: JSON.stringify(detail, null, 2) }] };
+  });
+  defineTool(server, "subgraphs_query", "Query rows from a subgraph table (max 50 rows).", {
+    name: z4.string().describe("Subgraph name"),
+    table: z4.string().describe("Table name"),
+    filters: z4.record(z4.string(), z4.string()).optional().describe('Column filters as key-value pairs (e.g. {"sender": "SP..."})'),
+    sort: z4.string().optional().describe("Column to sort by"),
+    order: z4.enum(["asc", "desc"]).optional().describe("Sort order"),
+    limit: z4.number().max(50).optional().describe("Max rows (default 50)"),
+    offset: z4.number().optional().describe("Offset for pagination")
+  }, async ({ name, table, filters, sort, order, limit, offset }) => {
+    const rows = await getClient().subgraphs.queryTable(name, table, {
+      filters,
+      sort,
+      order,
+      limit: limit ?? 50,
+      offset
+    });
+    const result = withCap(rows, 50);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  defineTool(server, "subgraphs_reindex", "Reindex a subgraph from a specific block range.", {
+    name: z4.string().describe("Subgraph name"),
+    fromBlock: z4.number().optional().describe("Start block (defaults to beginning)"),
+    toBlock: z4.number().optional().describe("End block (defaults to latest)")
+  }, async ({ name, fromBlock, toBlock }) => {
+    const result = await getClient().subgraphs.reindex(name, { fromBlock, toBlock });
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  });
+  defineTool(server, "subgraphs_delete", "Delete a subgraph permanently.", { name: z4.string().describe("Subgraph name") }, async ({ name }) => {
+    const result = await getClient().subgraphs.delete(name);
+    return { content: [{ type: "text", text: result.message }] };
+  });
+  defineTool(server, "subgraphs_deploy", "Deploy a subgraph from TypeScript code. Pass the full defineSubgraph() source — it will be bundled, validated, and deployed.", {
+    code: z4.string().describe("TypeScript source code containing a defineSubgraph() call"),
+    reindex: z4.boolean().optional().describe("Force reindex on breaking schema change (drops and rebuilds all data)")
+  }, async ({ code, reindex }) => {
+    const bundled = await bundleSubgraphCode(code);
+    const result = await getClient().subgraphs.deploy({
+      name: bundled.name,
+      version: bundled.version,
+      description: bundled.description,
+      sources: bundled.sources,
+      schema: bundled.schema,
+      handlerCode: bundled.handlerCode,
+      reindex
+    });
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  });
+}
+
+// src/server.ts
+function createServer() {
+  const server = new McpServer({
+    name: "secondlayer",
+    version: "0.1.0"
+  });
+  registerTemplateTools(server);
+  registerScaffoldTools(server);
+  registerStreamTools(server);
+  registerSubgraphTools(server);
+  return server;
+}
+
+// src/bin.ts
+var server = createServer();
+var transport = new StdioServerTransport;
+await server.connect(transport);
+
+//# debugId=6835CF0A8A97C86164756E2164756E21
+//# sourceMappingURL=bin.js.map