@vibekiln/cutline-mcp-cli 0.1.0

package/dist/servers/graph-metrics-DCNR7JZN.js

@@ -0,0 +1,12 @@
+import {
+  applyGenericPrior,
+  computeGenericGraphMetrics,
+  computeGraphMetrics,
+  computeMetricsFromGraph
+} from "./chunk-UBBAYTW3.js";
+export {
+  applyGenericPrior,
+  computeGenericGraphMetrics,
+  computeGraphMetrics,
+  computeMetricsFromGraph
+};

package/dist/servers/integrations-server.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import {
+  isWriteTool
+} from "./chunk-KMUSQOTJ.js";
+import {
+  guardBoundary,
+  guardOutput,
+  withPerfTracking
+} from "./chunk-OP4EO6FV.js";
+import {
+  cfCreateLinearIssues,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  validateAuth,
+  validateRequestSize
+} from "./chunk-ZVWDXO6M.js";
+
+// ../mcp/dist/mcp/src/integrations-server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+var server = new Server({
+  name: "cutline-integrations",
+  version: "0.1.0"
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "integrations_create_issues",
+        description: "Create issues in issue tracker (stub)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            schema_json: { type: "object" },
+            limit: { type: "number" },
+            auth_token: { type: "string" }
+          },
+          required: ["schema_json"]
+        }
+      },
+      {
+        name: "stripe_webhook_dispatch",
+        description: "Manually dispatch a Stripe webhook event",
+        inputSchema: {
+          type: "object",
+          properties: {
+            event: { type: "object" },
+            auth_token: { type: "string" }
+          },
+          required: ["event"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: rawArgs } = request.params;
+    if (!rawArgs)
+      throw new McpError(ErrorCode.InvalidParams, "Missing arguments");
+    validateRequestSize(rawArgs);
+    const { args } = guardBoundary(name, rawArgs);
+    const rawResponse = await withPerfTracking(name, async () => {
+      if (isWriteTool(name)) {
+        const peekToken = args.auth_token;
+        if (peekToken) {
+          const peekDecoded = await validateAuth(peekToken).catch(() => null);
+          if (peekDecoded && peekDecoded.accountType === "agent") {
+            throw new McpError(ErrorCode.InvalidRequest, "This is a read-only agent account. Write operations require the owner account.");
+          }
+        }
+      }
+      switch (name) {
+        case "integrations_create_issues": {
+          const { schema_json, limit, auth_token } = args;
+          await requirePremiumWithAutoAuth(auth_token);
+          const result = await cfCreateLinearIssues(schema_json, limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }]
+          };
+        }
+        case "stripe_webhook_dispatch": {
+          throw new McpError(ErrorCode.InvalidRequest, "Stripe webhook dispatch is not available from local MCP. Webhooks are handled server-side.");
+        }
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+    });
+    return guardOutput(name, rawResponse);
+  } catch (error) {
+    throw mapErrorToMcp(error, { tool: request.params.name });
+  }
+});
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Cutline Integrations MCP Server running on stdio");
+}
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});

package/dist/servers/output-server.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import {
+  PMJsonSchema
+} from "./chunk-DE7R7WKY.js";
+import {
+  guardBoundary,
+  guardOutput,
+  withPerfTracking
+} from "./chunk-OP4EO6FV.js";
+import {
+  cfBuildAndUploadPdf,
+  cfGenerateAnswer,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  validateRequestSize
+} from "./chunk-ZVWDXO6M.js";
+
+// ../mcp/dist/mcp/src/output-server.js
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+var server = new Server({
+  name: "cutline-output",
+  version: "0.1.0"
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "premortem_render_pdf",
+        description: "Generate PDF and signed URL",
+        inputSchema: {
+          type: "object",
+          properties: {
+            doc: { type: "object" },
+            auth_token: { type: "string" },
+            store: { type: "boolean" }
+          },
+          required: ["doc"]
+        }
+      },
+      {
+        name: "premortem_qa_answer",
+        description: "Answer questions against a premortem doc",
+        inputSchema: {
+          type: "object",
+          properties: {
+            question: { type: "string" },
+            doc: { type: "object" }
+          },
+          required: ["question"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const { name, arguments: rawArgs } = request.params;
+    if (!rawArgs)
+      throw new McpError(ErrorCode.InvalidParams, "Missing arguments");
+    validateRequestSize(rawArgs);
+    const { args } = guardBoundary(name, rawArgs);
+    const rawResponse = await withPerfTracking(name, async () => {
+      switch (name) {
+        case "premortem_render_pdf": {
+          const { doc, auth_token, store = true } = args;
+          await requirePremiumWithAutoAuth(auth_token);
+          const parsedDoc = PMJsonSchema.parse(doc);
+          const result = await cfBuildAndUploadPdf(parsedDoc);
+          return {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, ...result }) }]
+          };
+        }
+        case "premortem_qa_answer": {
+          const { question, doc, auth_token } = args;
+          const allowPublic = process.env.ALLOW_PUBLIC_PREMORTEM === "true";
+          if (!allowPublic) {
+            await requirePremiumWithAutoAuth(auth_token);
+          }
+          const result = await cfGenerateAnswer(question, doc);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }]
+          };
+        }
+        default:
+          throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+      }
+    });
+    return guardOutput(name, rawResponse);
+  } catch (error) {
+    throw mapErrorToMcp(error, { tool: request.params.name });
+  }
+});
+async function run() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Cutline Output MCP Server running on stdio");
+}
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});