@secondlayer/mcp 1.0.0 → 1.0.2

package/dist/bin.js

@@ -10,17 +10,30 @@ import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
 // src/resources.ts
-import { templates as subgraphTemplates } from "@secondlayer/subgraphs/templates";
-import { templates as workflowTemplates } from "@secondlayer/workflows/templates";
 var FILTERS_REFERENCE = [
-  { type: "stx_transfer", fields: ["sender", "recipient", "minAmount", "maxAmount"] },
+  {
+    type: "stx_transfer",
+    fields: ["sender", "recipient", "minAmount", "maxAmount"]
+  },
   { type: "stx_mint", fields: ["recipient", "minAmount"] },
   { type: "stx_burn", fields: ["sender", "minAmount"] },
   { type: "stx_lock", fields: ["lockedAddress", "minAmount"] },
-  { type: "ft_transfer", fields: ["sender", "recipient", "assetIdentifier", "minAmount", "maxAmount"] },
+  {
+    type: "ft_transfer",
+    fields: [
+      "sender",
+      "recipient",
+      "assetIdentifier",
+      "minAmount",
+      "maxAmount"
+    ]
+  },
   { type: "ft_mint", fields: ["recipient", "assetIdentifier", "minAmount"] },
   { type: "ft_burn", fields: ["sender", "assetIdentifier", "minAmount"] },
-  { type: "nft_transfer", fields: ["sender", "recipient", "assetIdentifier", "tokenId"] },
+  {
+    type: "nft_transfer",
+    fields: ["sender", "recipient", "assetIdentifier", "tokenId"]
+  },
   { type: "nft_mint", fields: ["recipient", "assetIdentifier", "tokenId"] },
   { type: "nft_burn", fields: ["sender", "assetIdentifier", "tokenId"] },
   { type: "contract_call", fields: ["contract", "function"] },
@@ -70,33 +83,6 @@ function registerResources(server) {
       }
     ]
   }));
-  server.resource("templates", "secondlayer://templates", {
-    description: "Available subgraph and workflow templates with descriptions and categories"
-  }, async () => ({
-    contents: [
-      {
-        uri: "secondlayer://templates",
-        mimeType: "application/json",
-        text: JSON.stringify([
-          ...subgraphTemplates.map(({ id, name, description, category }) => ({
-            kind: "subgraph",
-            id,
-            name,
-            description,
-            category
-          })),
-          ...workflowTemplates.map(({ id, name, description, category, trigger }) => ({
-            kind: "workflow",
-            id,
-            name,
-            description,
-            category,
-            trigger
-          }))
-        ], null, 2)
-      }
-    ]
-  }));
 }
 
 // src/lib/client.ts
@@ -348,391 +334,6 @@ function registerSubgraphTools(server) {
   });
 }
 
-// src/tools/workflows.ts
-import { bundleWorkflowCode } from "@secondlayer/bundler";
-import {
-  generateWorkflowCode
-} from "@secondlayer/scaffold";
-import { VersionConflictError } from "@secondlayer/sdk";
-import {
-  getTemplateById as getWorkflowTemplateById,
-  templates as workflowTemplates2
-} from "@secondlayer/workflows/templates";
-import { createPatch } from "diff";
-import { z as z3 } from "zod/v4";
-function registerWorkflowTools(server) {
-  defineTool(server, "workflows_list", "List all workflows. Returns summary fields only.", {}, async () => {
-    const { workflows } = await getClient().workflows.list();
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(workflows, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "workflows_get", "Get full details of a workflow by name.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
-    const detail = await getClient().workflows.get(name);
-    return {
-      content: [{ type: "text", text: JSON.stringify(detail, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_get_definition", "Return the deployed TypeScript source of a workflow plus its stored version. Returns `sourceCode: null` + `readOnly: true` for workflows deployed before source capture.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
-    const source = await getClient().workflows.getSource(name);
-    return {
-      content: [{ type: "text", text: JSON.stringify(source, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_propose_edit", "Validate a proposed edit WITHOUT deploying. Fetches the current stored source, bundles the proposed source, computes a unified diff, and returns everything for review. Use this when you want to show the user a diff before committing — pair it with workflows_deploy(expectedVersion=...) to persist.", {
-    name: z3.string().describe("Workflow name"),
-    proposedCode: z3.string().describe("New TypeScript source — must compile and validate."),
-    expectedVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Version the proposer is editing from (for audit).")
-  }, async ({ name, proposedCode, expectedVersion }) => {
-    const current = await getClient().workflows.getSource(name);
-    if (current.sourceCode === null) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              error: "Workflow has no stored source. Redeploy via CLI first.",
-              readOnly: true,
-              version: current.version
-            }, null, 2)
-          }
-        ]
-      };
-    }
-    let bundleValid = false;
-    let validation;
-    let bundleSize = 0;
-    try {
-      const bundled = await bundleWorkflowCode(proposedCode);
-      bundleValid = true;
-      bundleSize = Buffer.byteLength(bundled.handlerCode, "utf8");
-      validation = {
-        name: bundled.name,
-        triggerType: bundled.trigger.type
-      };
-    } catch (err) {
-      validation = {
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }
-    const diffText = createPatch(`${name}.ts`, current.sourceCode, proposedCode, `v${current.version}`, "proposed");
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            currentVersion: current.version,
-            expectedVersion,
-            currentSource: current.sourceCode,
-            proposedSource: proposedCode,
-            diffText,
-            bundleValid,
-            validation,
-            bundleSize
-          }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "workflows_tail_run", "Tail a workflow run via SSE and return a compacted log. Resolves as soon as the run completes, `limit` events are collected, or `timeoutMs` elapses (default 60s). MCP is not streaming-first — use this for short-lived follow-ups, not long tails.", {
-    name: z3.string().describe("Workflow name"),
-    runId: z3.string().describe("Run id"),
-    limit: z3.number().int().positive().max(200).optional().describe("Max step events to collect (default 50)"),
-    timeoutMs: z3.number().int().positive().max(5 * 60 * 1000).optional().describe("Hard timeout in ms (default 60000, max 300000)")
-  }, async ({ name, runId, limit, timeoutMs }) => {
-    const cap = limit ?? 50;
-    const deadline = timeoutMs ?? 60000;
-    const events = [];
-    let finalStatus = null;
-    let stoppedBy = "timeout";
-    const controller = new AbortController;
-    const timer = setTimeout(() => {
-      stoppedBy = "timeout";
-      controller.abort();
-    }, deadline);
-    try {
-      await getClient().workflows.streamRun(name, runId, (event) => {
-        if (event.type === "step") {
-          events.push(event.step);
-          if (events.length >= cap) {
-            stoppedBy = "limit";
-            controller.abort();
-          }
-        } else if (event.type === "done") {
-          finalStatus = event.done.status;
-          stoppedBy = "done";
-        }
-      }, controller.signal);
-    } catch (err) {
-      if (!(err instanceof Error) || err.name !== "AbortError") {
-        throw err;
-      }
-    } finally {
-      clearTimeout(timer);
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            runId,
-            finalStatus,
-            stoppedBy,
-            eventCount: events.length,
-            events
-          }, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "workflows_pause_all", "Pause ALL active workflows for the authenticated account. Irreversible only by calling pause/resume per workflow. Returns the list of affected workflows.", {}, async () => {
-    const result = await getClient().workflows.pauseAll();
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_cancel_run", "Cancel an in-flight workflow run. Marks the run as cancelled and removes any pending queue entry. No-ops if the run is already terminal.", { runId: z3.string().describe("Run id to cancel") }, async ({ runId }) => {
-    const result = await getClient().workflows.cancelRun(runId);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_rollback", "Roll a workflow back to a prior version. The restored handler is re-published as a NEW version (audit trail), so no history is lost. Pass toVersion to pick a specific bundle; omit to roll back to the immediate previous version on disk. Last 3 versions are retained.", {
-    name: z3.string().describe("Workflow name"),
-    toVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Target version to restore. Must be one of the retained bundles on disk.")
-  }, async ({ name, toVersion }) => {
-    const result = await getClient().workflows.rollback(name, toVersion);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_delete", "Delete a workflow permanently.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
-    await getClient().workflows.delete(name);
-    return {
-      content: [{ type: "text", text: `Deleted workflow "${name}"` }]
-    };
-  });
-  defineTool(server, "workflows_trigger", "Trigger a workflow run. Optionally pass input as a JSON string.", {
-    name: z3.string().describe("Workflow name"),
-    input: z3.string().optional().describe("Input as JSON string")
-  }, async ({ name, input }) => {
-    const parsed = input ? JSON.parse(input) : undefined;
-    const result = await getClient().workflows.trigger(name, parsed);
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  });
-  defineTool(server, "workflows_pause", "Pause a running workflow.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
-    await getClient().workflows.pause(name);
-    return {
-      content: [{ type: "text", text: `Paused workflow "${name}"` }]
-    };
-  });
-  defineTool(server, "workflows_resume", "Resume a paused workflow.", { name: z3.string().describe("Workflow name") }, async ({ name }) => {
-    await getClient().workflows.resume(name);
-    return {
-      content: [{ type: "text", text: `Resumed workflow "${name}"` }]
-    };
-  });
-  defineTool(server, "workflows_template_list", "List available workflow templates. Returns metadata only — use workflows_template_get for the full source.", {}, async () => {
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(workflowTemplates2.map((t) => ({
-            id: t.id,
-            name: t.name,
-            description: t.description,
-            category: t.category,
-            trigger: t.trigger
-          })), null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "workflows_template_get", "Get a workflow template's full TypeScript source and prompt by id.", { id: z3.string().describe("Template id, e.g. 'whale-alert'") }, async ({ id }) => {
-    const template = getWorkflowTemplateById(id);
-    if (!template) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Template "${id}" not found. Use workflows_template_list to see available templates.`
-          }
-        ]
-      };
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(template, null, 2)
-        }
-      ]
-    };
-  });
-  defineTool(server, "workflows_scaffold", "Generate a compilable defineWorkflow() skeleton from a typed intent. Returns the TypeScript source; pass it to workflows_deploy to persist. Placeholders inside the source must be filled in before running a real workflow.", {
-    name: z3.string().regex(/^[a-z][a-z0-9-]*$/).describe("Workflow name (lowercase, hyphens)"),
-    trigger: z3.discriminatedUnion("type", [
-      z3.object({
-        type: z3.literal("event"),
-        filterType: z3.string().optional()
-      }),
-      z3.object({
-        type: z3.literal("schedule"),
-        cron: z3.string().min(1),
-        timezone: z3.string().optional()
-      }),
-      z3.object({ type: z3.literal("manual") })
-    ]).describe("Trigger shape"),
-    steps: z3.array(z3.enum(["run", "query", "ai", "deliver"])).describe("Ordered list of step kinds to include in the handler"),
-    deliveryTarget: z3.enum(["webhook", "slack", "email", "discord", "telegram"]).optional().describe("Delivery target used when steps includes `deliver`")
-  }, async ({ name, trigger, steps, deliveryTarget }) => {
-    const code = generateWorkflowCode({
-      name,
-      trigger,
-      steps,
-      deliveryTarget
-    });
-    return { content: [{ type: "text", text: code }] };
-  });
-  defineTool(server, "workflows_deploy", "Deploy a workflow from TypeScript source. Pass the full defineWorkflow() source — it will be bundled, validated, and deployed. Use expectedVersion for optimistic concurrency, or dryRun to validate without persisting.", {
-    code: z3.string().describe("TypeScript source code containing a defineWorkflow() call"),
-    expectedVersion: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Stored version the client expects (major.minor.patch). Server returns 409 on mismatch."),
-    dryRun: z3.boolean().optional().describe("If true, validate and bundle only — do not persist.")
-  }, async ({ code, expectedVersion, dryRun }) => {
-    let bundled;
-    try {
-      bundled = await bundleWorkflowCode(code);
-    } catch (err) {
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: err instanceof Error ? err.message : String(err)
-          }
-        ]
-      };
-    }
-    const base = {
-      name: bundled.name,
-      trigger: bundled.trigger,
-      handlerCode: bundled.handlerCode,
-      sourceCode: bundled.sourceCode,
-      retries: bundled.retries,
-      timeout: bundled.timeout,
-      expectedVersion
-    };
-    try {
-      const result = dryRun ? await getClient().workflows.deploy({ ...base, dryRun: true }) : await getClient().workflows.deploy(base);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-      };
-    } catch (err) {
-      if (err instanceof VersionConflictError) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: err.message,
-                code: "VERSION_CONFLICT",
-                currentVersion: err.currentVersion,
-                expectedVersion: err.expectedVersion
-              }, null, 2)
-            }
-          ]
-        };
-      }
-      throw err;
-    }
-  });
-  defineTool(server, "workflows_runs", "List runs for a workflow. Optionally filter by status and limit results.", {
-    name: z3.string().describe("Workflow name"),
-    status: z3.enum(["running", "completed", "failed", "cancelled"]).optional().describe("Filter by run status"),
-    limit: z3.number().optional().describe("Max runs to return (default 20)")
-  }, async ({ name, status, limit }) => {
-    const { runs } = await getClient().workflows.listRuns(name, {
-      status,
-      limit
-    });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(runs, null, 2)
-        }
-      ]
-    };
-  });
-}
-
-// src/tools/templates.ts
-import {
-  getTemplateById,
-  getTemplatesByCategory,
-  templates
-} from "@secondlayer/subgraphs/templates";
-import { z as z4 } from "zod/v4";
-function registerTemplateTools(server) {
-  defineTool(server, "templates_list", "List available subgraph templates. Returns metadata only — use templates_get for full code.", {
-    category: z4.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: z4.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/server.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(readFileSync(join(__dirname2, "../package.json"), "utf-8"));
@@ -741,11 +342,9 @@ function createServer() {
     name: "secondlayer",
     version: pkg.version
   });
-  registerTemplateTools(server);
   registerScaffoldTools(server);
   registerSubgraphTools(server);
   registerAccountTools(server);
-  registerWorkflowTools(server);
   registerResources(server);
   return server;
 }
@@ -755,5 +354,5 @@ var server = createServer();
 var transport = new StdioServerTransport;
 await server.connect(transport);
 
-//# debugId=683234D740089B7F64756E2164756E21
+//# debugId=B8287F0AD1E4E07664756E2164756E21
 //# sourceMappingURL=bin.js.map