@kylewadegrove/cutline-mcp-cli 0.4.2 → 0.5.1

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,121 @@
+#!/usr/bin/env node
+import {
+  isWriteTool
+} from "./chunk-KMUSQOTJ.js";
+import {
+  createLinearIssues,
+  processStripeEvent
+} from "./chunk-IVWF7VYZ.js";
+import {
+  guardBoundary,
+  guardOutput,
+  initFirebase,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  validateAuth,
+  validateRequestSize,
+  withPerfTracking
+} from "./chunk-PD2HN2R5.js";
+import "./chunk-7FHM2GD3.js";
+import "./chunk-JBJYSV4P.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";
+import Stripe from "stripe";
+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);
+    initFirebase();
+    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 createLinearIssues(schema_json, limit);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }]
+          };
+        }
+        case "stripe_webhook_dispatch": {
+          const { event, auth_token } = args;
+          await requirePremiumWithAutoAuth(auth_token);
+          const stripe = new Stripe(process.env.STRIPE_SECRET_KEY || "", {
+            apiVersion: "2023-10-16"
+          });
+          await processStripeEvent(event, stripe);
+          return {
+            content: [{ type: "text", text: JSON.stringify({ dispatched: true }) }]
+          };
+        }
+        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,120 @@
+#!/usr/bin/env node
+import {
+  buildPdfBuffer,
+  generateAnswer,
+  uploadAndSign
+} from "./chunk-IVWF7VYZ.js";
+import {
+  guardBoundary,
+  guardOutput,
+  initFirebase,
+  mapErrorToMcp,
+  requirePremiumWithAutoAuth,
+  validateRequestSize,
+  withPerfTracking
+} from "./chunk-PD2HN2R5.js";
+import {
+  PMJsonSchema
+} from "./chunk-7FHM2GD3.js";
+import "./chunk-JBJYSV4P.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);
+    initFirebase();
+    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 bytes = await buildPdfBuffer(parsedDoc);
+          if (store) {
+            const uploaded = await uploadAndSign(bytes, parsedDoc?.project?.name || "premortem");
+            if (uploaded?.url) {
+              return {
+                content: [{ type: "text", text: JSON.stringify({ ok: true, url: uploaded.url }) }]
+              };
+            }
+          }
+          const base64 = Buffer.from(bytes).toString("base64");
+          return {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, dataUrl: `data:application/pdf;base64,${base64}` }) }]
+          };
+        }
+        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 generateAnswer(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);
+});

package/dist/servers/pipeline-O5GJPNR4.js

@@ -0,0 +1,20 @@
+import {
+  regenerateAssumptions,
+  regenerateExperiments,
+  regenerateFeaturePriorities,
+  regenerateFeatures,
+  regenerateFeaturesOnly,
+  regenerateGraphAndVerdict,
+  runRolesAndSummarize,
+  runRolesAndSummarizeIncremental
+} from "./chunk-7FHM2GD3.js";
+export {
+  regenerateAssumptions,
+  regenerateExperiments,
+  regenerateFeaturePriorities,
+  regenerateFeatures,
+  regenerateFeaturesOnly,
+  regenerateGraphAndVerdict,
+  runRolesAndSummarize,
+  runRolesAndSummarizeIncremental
+};

package/dist/servers/premortem-handoff-XT4K3YDJ.js

@@ -0,0 +1,10 @@
+import {
+  buildGraduationMetadata,
+  buildRunInput,
+  validateForGraduation
+} from "./chunk-JBJYSV4P.js";
+export {
+  buildGraduationMetadata,
+  buildRunInput,
+  validateForGraduation
+};