@stackwright-pro/mcp 0.1.0

package/dist/server.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server.js

@@ -0,0 +1,670 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/server.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/tools/data-explorer.ts
+var import_zod = require("zod");
+var import_cli_data_explorer = require("@stackwright-pro/cli-data-explorer");
+function registerDataExplorerTools(server2) {
+  server2.tool(
+    "stackwright_pro_list_entities",
+    "List all available API entities from OpenAPI specs or generated Zod schemas. Use this to discover what entities are available before generating endpoint filters. Returns entity names, endpoints, and field counts. Part of the Pro Otter Raft for building API-integrated Stackwright applications.",
+    {
+      specPath: import_zod.z.string().optional().describe("Path to OpenAPI spec file (YAML or JSON)"),
+      projectRoot: import_zod.z.string().optional().describe("Project root directory (auto-detected if omitted)")
+    },
+    async ({ specPath, projectRoot }) => {
+      const result = (0, import_cli_data_explorer.listEntities)({
+        specPath,
+        projectRoot
+      });
+      if (!result.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error discovering entities: ${(result.errors ?? []).join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const lines = [`\u{1F4E6} Found ${result.entities.length} API Entities:
+`];
+      for (const entity of result.entities) {
+        lines.push(`\u{1F4E6} ${entity.name} (${entity.slug})`);
+        lines.push(`   Endpoint: ${entity.endpoint}`);
+        lines.push(`   Fields: ${entity.fieldCount}`);
+        if (entity.fields.length > 0) {
+          const fieldTypes = entity.fields.slice(0, 3).map((f) => `${f.name}:${f.type}`).join(", ");
+          lines.push(`   Types: ${fieldTypes}${entity.fields.length > 3 ? "..." : ""}`);
+        }
+        lines.push("");
+      }
+      lines.push(
+        `
+\u{1F4A1} Use stackwright_pro_generate_filter with selected entity slugs to create endpoint filters.`
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: lines.join("\n")
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_generate_filter",
+    "Generate endpoint filter configuration from selected entities. Creates include/exclude patterns for stackwright.yml OpenAPI integration. Use this after stackwright_pro_list_entities to select which API endpoints the application needs. Only selected endpoints will generate client code, reducing bundle size and improving security.",
+    {
+      selectedEntities: import_zod.z.array(import_zod.z.string()).describe('Entity slugs to include (e.g., ["equipment", "supplies"])'),
+      excludePatterns: import_zod.z.array(import_zod.z.string()).optional().describe('Glob patterns to exclude (e.g., ["/admin/**", "/reports/**"])'),
+      projectRoot: import_zod.z.string().optional().describe("Project root directory")
+    },
+    async ({ selectedEntities, excludePatterns, projectRoot }) => {
+      const result = (0, import_cli_data_explorer.generateFilter)({
+        selectedEntities,
+        excludePatterns,
+        projectRoot: projectRoot || process.cwd()
+      });
+      if (!result.success) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error generating filter: ${result.warnings?.join(", ")}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const lines = ["\u{1F510} Generated Endpoint Filter:\n"];
+      lines.push("```yaml");
+      lines.push("integrations:");
+      lines.push("  - type: openapi");
+      lines.push("    endpoints:");
+      if (result.filter.include && result.filter.include.length > 0) {
+        lines.push("      include:");
+        for (const path2 of result.filter.include) {
+          lines.push(`        - ${path2}`);
+        }
+      }
+      if (result.filter.exclude && result.filter.exclude.length > 0) {
+        lines.push("      exclude:");
+        for (const pattern of result.filter.exclude) {
+          lines.push(`        - ${pattern}`);
+        }
+      }
+      lines.push("```");
+      if (result.warnings && result.warnings.length > 0) {
+        lines.push("\n\u26A0\uFE0F Warnings:");
+        for (const warning of result.warnings) {
+          lines.push(`  ${warning}`);
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: lines.join("\n")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/security.ts
+var import_zod2 = require("zod");
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+function registerSecurityTools(server2) {
+  server2.tool(
+    "stackwright_pro_validate_spec",
+    "Validate an OpenAPI spec against the enterprise approved-specs configuration. Checks if the spec URL is on the allowlist and verifies SHA-256 hash integrity. Use this in enterprise environments where only pre-approved API specs are allowed. Fails build if spec is not approved or has been modified.",
+    {
+      specPath: import_zod2.z.string().describe("URL or file path to the OpenAPI spec to validate"),
+      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml with prebuild.security config")
+    },
+    async ({ specPath, configPath }) => {
+      let securityEnabled = false;
+      let allowlist = [];
+      const configFile = configPath || import_path.default.join(process.cwd(), "stackwright.yml");
+      if (import_fs.default.existsSync(configFile)) {
+        try {
+          const content = import_fs.default.readFileSync(configFile, "utf8");
+          const securityMatch = content.match(
+            /prebuild:\s*\n\s*security:\s*\n\s*enabled:\s*(true|false)/
+          );
+          if (securityMatch && securityMatch[1] === "true") {
+            securityEnabled = true;
+            const specMatches = content.matchAll(
+              /- name:\s*(.+?)\n\s+url:\s*(.+?)\n\s+sha256:\s*(.+?)(?:\n|$)/g
+            );
+            for (const match of specMatches) {
+              allowlist.push({
+                name: match[1].trim(),
+                url: match[2].trim(),
+                sha256: match[3].trim()
+              });
+            }
+          }
+        } catch {
+        }
+      }
+      if (!securityEnabled) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u2705 Spec validation skipped (security not enabled)
+
+To enable approved-specs validation, add to stackwright.yml:
+
+prebuild:
+  security:
+    enabled: true
+    allowlist:
+      - name: My API
+        url: ${specPath}
+        sha256: <sha256-of-spec>`
+            }
+          ]
+        };
+      }
+      const matchingSpec = allowlist.find((s) => s.url === specPath);
+      if (!matchingSpec) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u274C Spec rejected!
+
+Error Code: SPEC_NOT_IN_ALLOWLIST
+
+URL: ${specPath}
+
+This spec is not on the approved-specs allowlist. Add it using stackwright_pro_add_approved_spec before proceeding.`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!specPath.startsWith("http://") && !specPath.startsWith("https://")) {
+        if (import_fs.default.existsSync(specPath)) {
+          const specContent = import_fs.default.readFileSync(specPath, "utf8");
+          const crypto = require("crypto");
+          const sha256 = crypto.createHash("sha256").update(specContent).digest("hex");
+          if (sha256 !== matchingSpec.sha256) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `\u274C Spec hash mismatch!
+
+Error Code: SPEC_HASH_MISMATCH
+
+Expected: ${matchingSpec.sha256.substring(0, 16)}...
+Actual:   ${sha256.substring(0, 16)}...
+
+The spec has been modified since it was approved. Re-approve the spec to continue.`
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2705 Spec approved!
+
+Name: ${matchingSpec.name}
+URL: ${specPath}
+Status: Valid (${allowlist.length} specs on allowlist)`
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_add_approved_spec",
+    "Add an OpenAPI spec to the approved-specs allowlist in stackwright.yml. Computes the SHA-256 hash of the spec and adds it to the security configuration. Use this when onboarding a new API in enterprise environments.",
+    {
+      name: import_zod2.z.string().describe("Human-readable name for the spec"),
+      url: import_zod2.z.string().describe("URL or file path to the OpenAPI spec"),
+      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml")
+    },
+    async ({ name, url, configPath }) => {
+      const configFile = configPath || import_path.default.join(process.cwd(), "stackwright.yml");
+      let sha256 = "<computed-at-build>";
+      try {
+        if (url.startsWith("http://") || url.startsWith("https://")) {
+          sha256 = "<computed-at-build>";
+        } else if (import_fs.default.existsSync(url)) {
+          const specContent = import_fs.default.readFileSync(url, "utf8");
+          const crypto = require("crypto");
+          sha256 = crypto.createHash("sha256").update(specContent).digest("hex");
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u274C Spec file not found: ${url}`
+              }
+            ],
+            isError: true
+          };
+        }
+      } catch (e) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u274C Failed to read spec: ${e}`
+            }
+          ],
+          isError: true
+        };
+      }
+      const yamlSnippet = `  - name: ${name}
+    url: ${url}
+    sha256: ${sha256}`;
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u{1F4DD} Add this to stackwright.yml under prebuild.security.allowlist:
+
+${yamlSnippet}
+
+SHA-256 computed: ${sha256}`
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_list_approved_specs",
+    "List all specs currently on the approved-specs allowlist. Shows spec names, URLs, and hash prefixes. Use this to audit what APIs are approved in the project.",
+    {
+      configPath: import_zod2.z.string().optional().describe("Path to stackwright.yml")
+    },
+    async ({ configPath }) => {
+      const configFile = configPath || import_path.default.join(process.cwd(), "stackwright.yml");
+      if (!import_fs.default.existsSync(configFile)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "\u274C stackwright.yml not found in project root."
+            }
+          ],
+          isError: true
+        };
+      }
+      const content = import_fs.default.readFileSync(configFile, "utf8");
+      const securityEnabled = content.includes("prebuild:") && content.includes("security:") && content.includes("enabled: true");
+      if (!securityEnabled) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "\u2139\uFE0F Approved-specs validation is not enabled.\n\nAdd to stackwright.yml to enable:\n\nprebuild:\n  security:\n    enabled: true\n    allowlist: []"
+            }
+          ]
+        };
+      }
+      const specs = [];
+      const specMatches = content.matchAll(
+        /- name:\s*(.+?)\n\s+url:\s*(.+?)\n\s+sha256:\s*(.+?)(?:\n|$)/g
+      );
+      for (const match of specMatches) {
+        specs.push({
+          name: match[1].trim(),
+          url: match[2].trim(),
+          sha256: match[3].trim().substring(0, 16) + "..."
+        });
+      }
+      if (specs.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "\u2139\uFE0F Security enabled but no specs on allowlist.\n\nAdd specs using stackwright_pro_add_approved_spec."
+            }
+          ]
+        };
+      }
+      const lines = [`\u{1F510} Approved Specs (${specs.length}):
+`];
+      for (const spec of specs) {
+        lines.push(`\u{1F4E6} ${spec.name}`);
+        lines.push(`   URL: ${spec.url}`);
+        lines.push(`   Hash: ${spec.sha256}`);
+        lines.push("");
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: lines.join("\n")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/isr.ts
+var import_zod3 = require("zod");
+function registerIsrTools(server2) {
+  server2.tool(
+    "stackwright_pro_configure_isr",
+    "Configure Incremental Static Regeneration (ISR) for an API-backed collection. ISR allows API data to be cached and refreshed on a schedule, providing real-time data with the performance of static generation. Use this after stackwright_pro_generate_filter to set revalidation intervals.",
+    {
+      collection: import_zod3.z.string().describe('Collection name (e.g., "equipment", "supplies")'),
+      revalidateSeconds: import_zod3.z.number().optional().describe("Revalidation interval in seconds (default: 60)"),
+      fallback: import_zod3.z.enum(["blocking", "true", "false"]).optional().describe("Fallback behavior for new pages"),
+      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
+    },
+    async ({ collection, revalidateSeconds = 60, fallback = "blocking", configPath }) => {
+      const revalidate = revalidateSeconds;
+      const yamlSnippet = `# Add to stackwright.yml under integrations:
+  - type: openapi
+    name: ${collection}
+    # ... other config
+    isr:
+      revalidate: ${revalidate}
+      fallback: ${fallback}`;
+      let description = "";
+      if (revalidate < 60) {
+        description = "\u26A1 Very fresh data (revalidate every " + revalidate + "s)";
+      } else if (revalidate < 300) {
+        description = "\u{1F4CA} Fresh data (revalidate every " + (revalidate / 60).toFixed(0) + " min)";
+      } else if (revalidate < 3600) {
+        description = "\u{1F4BE} Cached data (revalidate every " + (revalidate / 60).toFixed(0) + " min)";
+      } else {
+        description = "\u{1F5C4}\uFE0F Static data (revalidate every " + (revalidate / 3600).toFixed(0) + " hour)";
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u2699\uFE0F ISR Configuration for "${collection}":
+
+${description}
+
+Fallback: ${fallback === "blocking" ? "\u23F3 Show loading until cached" : fallback === "true" ? "\u{1F4C4} Generate on demand" : "\u274C 404 for new pages"}
+
+\`\`\`yaml
+${yamlSnippet}
+\`\`\``
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_configure_isr_batch",
+    "Configure ISR for multiple collections at once. More efficient than calling stackwright_pro_configure_isr multiple times. Provide different revalidation intervals based on data freshness requirements.",
+    {
+      collections: import_zod3.z.array(
+        import_zod3.z.object({
+          name: import_zod3.z.string().describe("Collection name"),
+          revalidateSeconds: import_zod3.z.number().optional().describe("Revalidation interval")
+        })
+      ).describe("Array of collection configurations"),
+      defaultFallback: import_zod3.z.enum(["blocking", "true", "false"]).optional().describe("Default fallback behavior"),
+      configPath: import_zod3.z.string().optional().describe("Path to stackwright.yml")
+    },
+    async ({ collections, defaultFallback = "blocking", configPath }) => {
+      const lines = [`\u2699\uFE0F Batch ISR Configuration:
+`];
+      for (const col of collections) {
+        const rev = col.revalidateSeconds || 60;
+        let freshness = "\u{1F4BE}";
+        if (rev < 60) freshness = "\u26A1";
+        else if (rev < 300) freshness = "\u{1F4CA}";
+        else if (rev >= 3600) freshness = "\u{1F5C4}\uFE0F";
+        lines.push(`${freshness} ${col.name}: revalidate=${rev}s`);
+      }
+      lines.push(`
+Fallback: ${defaultFallback}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: lines.join("\n")
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/dashboard.ts
+var import_zod4 = require("zod");
+var import_cli_data_explorer2 = require("@stackwright-pro/cli-data-explorer");
+function registerDashboardTools(server2) {
+  server2.tool(
+    "stackwright_pro_generate_dashboard",
+    "Generate a dashboard page configuration for displaying API data. Creates YAML content for a Stackwright page with collection_listing, data_table, or stats_grid content types. Use this after stackwright_pro_generate_filter to create pages for your API collections.",
+    {
+      entities: import_zod4.z.array(import_zod4.z.string()).describe("Entity slugs to include in dashboard"),
+      layout: import_zod4.z.enum(["grid", "table", "mixed"]).optional().describe("Dashboard layout style"),
+      pageTitle: import_zod4.z.string().optional().describe("Page title"),
+      specPath: import_zod4.z.string().optional().describe("Path to OpenAPI spec for entity details")
+    },
+    async ({ entities, layout = "mixed", pageTitle, specPath }) => {
+      let entityDetails = [];
+      if (specPath) {
+        const result = (0, import_cli_data_explorer2.listEntities)({ specPath });
+        if (result.success) {
+          entityDetails = result.entities.filter((e) => entities.includes(e.slug));
+        }
+      }
+      const title = pageTitle || entities.map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" & ");
+      const yamlLines = [
+        "# Dashboard page configuration",
+        "# Generated by Stackwright Pro MCP",
+        "",
+        "content:",
+        "  meta:",
+        `    title: "${title} | Dashboard"`,
+        `    description: "Live data from API"`,
+        "",
+        "  content_items:"
+      ];
+      if (layout === "grid" || layout === "mixed") {
+        for (const slug of entities) {
+          yamlLines.push(`    - stats_grid:`);
+          yamlLines.push(`        label: "${slug}-stats"`);
+          yamlLines.push(`        heading:`);
+          yamlLines.push(
+            `          text: "${slug.charAt(0).toUpperCase() + slug.slice(1)} Overview"`
+          );
+          yamlLines.push(`          textSize: "h2"`);
+          yamlLines.push(`        stats:`);
+          yamlLines.push(`          - label: "Total"`);
+          yamlLines.push(`            value: "{{ ${slug}.count }}"`);
+          yamlLines.push(`            icon: "Database"`);
+          yamlLines.push(`        source: "${slug}"`);
+          yamlLines.push(`        background: "surface"`);
+          yamlLines.push("");
+        }
+      }
+      yamlLines.push(`    - collection_listing:`);
+      yamlLines.push(`        label: "${entities[0]}-listing"`);
+      yamlLines.push(`        heading:`);
+      yamlLines.push(
+        `          text: "${entities.map((e) => e.charAt(0).toUpperCase() + e.slice(1)).join(" & ")}"`
+      );
+      yamlLines.push(`          textSize: "h2"`);
+      yamlLines.push(`        collection: "${entities[0]}"`);
+      yamlLines.push(`        showFilters: true`);
+      yamlLines.push(`        showSearch: true`);
+      const defaultCols = ['"id"', '"name"', '"status"', '"created_at"'];
+      yamlLines.push(
+        `        columns: ${entityDetails[0]?.fields?.slice(0, 4).map((f) => `"${f.name}"`).join(", ") || defaultCols.join(", ")}`
+      );
+      yamlLines.push(`        background: "background"`);
+      yamlLines.push("");
+      if (layout === "table") {
+        yamlLines.push(`    - data_table:`);
+        yamlLines.push(`        label: "${entities[0]}-table"`);
+        yamlLines.push(`        heading:`);
+        yamlLines.push(`          text: "Detailed View"`);
+        yamlLines.push(`          textSize: "h3"`);
+        yamlLines.push(`        collection: "${entities[0]}"`);
+        yamlLines.push(`        sortableColumns: true`);
+        yamlLines.push(`        exportable: true`);
+        yamlLines.push(`        background: "surface"`);
+      }
+      const yaml = yamlLines.join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u{1F4CA} Generated Dashboard for: ${entities.join(", ")}
+
+Layout: ${layout}
+
+\`\`\`yaml
+${yaml}
+\`\`\`
+
+\u{1F4A1} Add this to pages/dashboard/content.yml and validate with stackwright_validate_pages.`
+          }
+        ]
+      };
+    }
+  );
+  server2.tool(
+    "stackwright_pro_generate_detail_page",
+    "Generate a detail view page for a single API entity. Creates YAML content for displaying all fields of an individual record. Use this to create detail pages that complement collection listing pages.",
+    {
+      entity: import_zod4.z.string().describe('Entity slug (e.g., "equipment")'),
+      slugField: import_zod4.z.string().optional().describe('Field to use as URL slug (default: "id")'),
+      specPath: import_zod4.z.string().optional().describe("Path to OpenAPI spec for field details")
+    },
+    async ({ entity, slugField = "id", specPath }) => {
+      let fields = [];
+      if (specPath) {
+        const result = (0, import_cli_data_explorer2.listEntities)({ specPath });
+        if (result.success) {
+          const ent = result.entities.find((e) => e.slug === entity);
+          if (ent) {
+            fields = ent.fields;
+          }
+        }
+      }
+      const entityName = entity.charAt(0).toUpperCase() + entity.slice(1);
+      const yamlLines = [
+        `# Detail page for ${entityName}`,
+        "# Generated by Stackwright Pro MCP",
+        "",
+        "content:",
+        "  meta:",
+        `    title: "${entityName} Details | {{ ${entity}.${slugField} }}"`,
+        "",
+        "  content_items:",
+        "    - main:",
+        '        label: "detail-header"',
+        "        heading:",
+        `          text: "{{ ${entity}.${slugField} }}"`,
+        '          textSize: "h1"',
+        "        textBlocks:",
+        `          - text: "Details for this ${entity}"`,
+        '            textSize: "body1"',
+        '        background: "primary"',
+        '        color: "text"',
+        "",
+        "    - grid:",
+        '        label: "detail-fields"',
+        "        columns: 2",
+        "        items:"
+      ];
+      const displayFields = fields.length > 0 ? fields.slice(0, 8) : [
+        { name: slugField, type: "string" },
+        { name: "created_at", type: "datetime" },
+        { name: "updated_at", type: "datetime" }
+      ];
+      for (const field of displayFields) {
+        const label = field.name.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+        yamlLines.push(`          - card:`);
+        yamlLines.push(`              label: "${field.name}-field"`);
+        yamlLines.push(`              heading:`);
+        yamlLines.push(`                text: "${label}"`);
+        yamlLines.push(`                textSize: "h4"`);
+        yamlLines.push(`              content:`);
+        yamlLines.push(`                - text: "{{ ${entity}.${field.name} }}"`);
+        yamlLines.push(`                  textSize: "body1"`);
+      }
+      yamlLines.push('        background: "background"');
+      const yaml = yamlLines.join("\n");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u{1F4C4} Generated Detail Page for: ${entity}
+
+\`\`\`yaml
+${yaml}
+\`\`\`
+
+\u{1F4A1} Add this to pages/${entity}/[${slugField}]/content.yml and validate.`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/server.ts
+var server = new import_mcp.McpServer({
+  name: "stackwright-pro",
+  version: "0.1.0"
+});
+registerDataExplorerTools(server);
+registerSecurityTools(server);
+registerIsrTools(server);
+registerDashboardTools(server);
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("Stackwright Pro MCP server running on stdio");
+}
+main().catch((err) => {
+  console.error("Fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map