@skyramp/mcp 0.0.59 → 0.0.60-rc.2

package/build/utils/scenarioDrafting.js

@@ -0,0 +1,119 @@
+const ACTION_PATTERN = /^(me|merge|archive|search|login|logout|verify|forgot|reset|config|dashboard|webhook|migration|favicon|payment|health|status|ping|metrics|callback|confirm|activate|deactivate|subscribe|unsubscribe)$/i;
+const ACTION_VERB_HYPHEN = /^(forgot-|reset-|verify-|confirm-|send-|check-|get-|set-|update-|delete-|create-|trigger-|start-|stop-)/i;
+export function isRealResource(r) {
+    return !ACTION_PATTERN.test(r) && !ACTION_VERB_HYPHEN.test(r);
+}
+export function draftScenariosFromEndpoints(endpoints) {
+    const scenarios = [];
+    const resourceGroups = new Map();
+    for (const ep of endpoints) {
+        const segments = ep.path.split("/").filter(Boolean);
+        const skipSet = new Set(["api", "v1", "v2", "v3", "public"]);
+        const nonParamSegs = segments.filter(s => !s.startsWith("{") && !skipSet.has(s));
+        const resource = nonParamSegs[nonParamSegs.length - 1] || "unknown";
+        const hasParam = /\{/.test(ep.path);
+        const resourceSegIdx = segments.lastIndexOf(resource);
+        const basePath = "/" + segments.slice(0, resourceSegIdx + 1).join("/");
+        let paramPath;
+        if (hasParam && resourceSegIdx + 1 < segments.length && segments[resourceSegIdx + 1].startsWith("{")) {
+            paramPath = basePath + "/" + segments[resourceSegIdx + 1];
+        }
+        const existing = resourceGroups.get(resource);
+        if (existing) {
+            for (const m of ep.methods)
+                existing.methods.add(typeof m === "string" ? m : m.method);
+            if (basePath.split("/").length < existing.basePath.split("/").length) {
+                existing.basePath = basePath;
+            }
+            if (paramPath && (!existing.paramPath || paramPath.split("/").length < existing.paramPath.split("/").length)) {
+                existing.paramPath = paramPath;
+            }
+        }
+        else {
+            resourceGroups.set(resource, {
+                basePath,
+                methods: new Set(ep.methods.map((m) => typeof m === "string" ? m : m.method)),
+                paramPath,
+            });
+        }
+    }
+    const creatableResources = Array.from(resourceGroups.keys()).filter(r => isRealResource(r) && resourceGroups.get(r).methods.has("POST"));
+    const MAX_CROSS_RESOURCE = Math.min(Math.max(3, Math.floor(creatableResources.length / 2)), 8);
+    let crossCount = 0;
+    for (let i = 0; i < creatableResources.length && crossCount < MAX_CROSS_RESOURCE; i++) {
+        for (let j = i + 1; j < creatableResources.length && crossCount < MAX_CROSS_RESOURCE; j++) {
+            const r1 = creatableResources[i];
+            const r2 = creatableResources[j];
+            const g1 = resourceGroups.get(r1);
+            const g2 = resourceGroups.get(r2);
+            const steps = [];
+            let order = 1;
+            const singular1 = r1.replace(/s$/, "");
+            const singular2 = r2.replace(/s$/, "");
+            steps.push({
+                order: order++, method: "POST", path: g1.basePath,
+                description: `Create a ${singular1}`,
+                interactionType: "success", expectedStatusCode: 201,
+            });
+            steps.push({
+                order: order++, method: "POST", path: g2.basePath,
+                description: `Create a ${singular2} referencing the ${singular1}`,
+                interactionType: "success", expectedStatusCode: 201,
+                chainsFrom: { sourceStep: 1, sourceField: `${singular1}_id`, sourceLocation: "body", targetParam: `${singular1}_id`, targetLocation: "body" },
+            });
+            if (g2.paramPath && g2.methods.has("GET")) {
+                steps.push({
+                    order: order++, method: "GET", path: g2.paramPath,
+                    description: `Verify the ${singular2} references the correct ${singular1}`,
+                    interactionType: "success", expectedStatusCode: 200,
+                });
+            }
+            if (g2.paramPath && g2.methods.has("DELETE")) {
+                steps.push({
+                    order: order++, method: "DELETE", path: g2.paramPath,
+                    description: `Clean up: delete the ${singular2}`,
+                    interactionType: "success", expectedStatusCode: 204,
+                });
+            }
+            scenarios.push({
+                scenarioName: `${r1}-${r2}-integration`,
+                description: `Multi-resource integration: create ${singular1}, create ${singular2} linked to it, verify, clean up`,
+                category: "workflow",
+                priority: "high",
+                steps,
+                chainingKeys: [`${singular1}_id`, `${singular2}_id`, "id"],
+                requiresAuth: true,
+                estimatedComplexity: "complex",
+                source: "code-inferred",
+            });
+            crossCount++;
+        }
+    }
+    for (const [resource, group] of resourceGroups) {
+        const m = group.methods;
+        if (!m.has("POST") || !m.has("GET") || !isRealResource(resource))
+            continue;
+        const steps = [];
+        let order = 1;
+        const singular = resource.replace(/s$/, "");
+        steps.push({ order: order++, method: "POST", path: group.basePath, description: `Create a new ${singular}`, interactionType: "success", expectedStatusCode: 201 });
+        if (group.paramPath)
+            steps.push({ order: order++, method: "GET", path: group.paramPath, description: `Get the created ${singular} by ID`, interactionType: "success", expectedStatusCode: 200 });
+        if ((m.has("PUT") || m.has("PATCH")) && group.paramPath)
+            steps.push({ order: order++, method: m.has("PUT") ? "PUT" : "PATCH", path: group.paramPath, description: `Update the ${singular}`, interactionType: "success", expectedStatusCode: 200 });
+        if (m.has("DELETE") && group.paramPath)
+            steps.push({ order: order++, method: "DELETE", path: group.paramPath, description: `Delete the ${singular}`, interactionType: "success", expectedStatusCode: 204 });
+        scenarios.push({
+            scenarioName: `${resource}-crud-lifecycle`,
+            description: `CRUD lifecycle for ${resource}: create, read, update, delete`,
+            category: "crud",
+            priority: "medium",
+            steps,
+            chainingKeys: ["id", `${singular}_id`],
+            requiresAuth: true,
+            estimatedComplexity: "moderate",
+            source: "code-inferred",
+        });
+    }
+    return scenarios;
+}

package/build/utils/scenarioDrafting.test.js

@@ -0,0 +1,66 @@
+// @ts-ignore
+import { isRealResource, draftScenariosFromEndpoints } from "./scenarioDrafting.js";
+describe("isRealResource", () => {
+    it("accepts normal resource names", () => {
+        expect(isRealResource("users")).toBe(true);
+        expect(isRealResource("products")).toBe(true);
+        expect(isRealResource("orders")).toBe(true);
+    });
+    it("accepts hyphenated resource names (not action verbs)", () => {
+        expect(isRealResource("saved-searches")).toBe(true);
+        expect(isRealResource("order-items")).toBe(true);
+        expect(isRealResource("user-profiles")).toBe(true);
+        expect(isRealResource("api-keys")).toBe(true);
+    });
+    it("rejects action-like single words", () => {
+        expect(isRealResource("login")).toBe(false);
+        expect(isRealResource("logout")).toBe(false);
+        expect(isRealResource("verify")).toBe(false);
+        expect(isRealResource("health")).toBe(false);
+        expect(isRealResource("ping")).toBe(false);
+        expect(isRealResource("dashboard")).toBe(false);
+        expect(isRealResource("webhook")).toBe(false);
+    });
+    it("rejects action-verb-hyphenated patterns", () => {
+        expect(isRealResource("forgot-password")).toBe(false);
+        expect(isRealResource("reset-password")).toBe(false);
+        expect(isRealResource("verify-email")).toBe(false);
+        expect(isRealResource("confirm-order")).toBe(false);
+        expect(isRealResource("send-notification")).toBe(false);
+        expect(isRealResource("create-session")).toBe(false);
+        expect(isRealResource("delete-cache")).toBe(false);
+    });
+    it("is case-insensitive", () => {
+        expect(isRealResource("Login")).toBe(false);
+        expect(isRealResource("VERIFY")).toBe(false);
+        expect(isRealResource("Forgot-Password")).toBe(false);
+    });
+});
+describe("draftScenariosFromEndpoints", () => {
+    it("returns empty array for no endpoints", () => {
+        expect(draftScenariosFromEndpoints([])).toEqual([]);
+    });
+    it("generates CRUD scenario for resource with multiple methods", () => {
+        const endpoints = [
+            { path: "/api/products", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/products/{id}", methods: [{ method: "GET" }, { method: "PUT" }, { method: "DELETE" }] },
+        ];
+        const scenarios = draftScenariosFromEndpoints(endpoints);
+        expect(scenarios.length).toBeGreaterThan(0);
+        const crudScenario = scenarios.find((s) => /crud/i.test(s.scenarioName) || /products/i.test(s.scenarioName));
+        expect(crudScenario).toBeDefined();
+    });
+    it("generates cross-resource scenario when multiple resources exist", () => {
+        const endpoints = [
+            { path: "/api/users", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/users/{id}", methods: [{ method: "GET" }] },
+            { path: "/api/products", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/products/{id}", methods: [{ method: "GET" }] },
+            { path: "/api/orders", methods: [{ method: "GET" }, { method: "POST" }] },
+            { path: "/api/orders/{id}", methods: [{ method: "GET" }] },
+        ];
+        const scenarios = draftScenariosFromEndpoints(endpoints);
+        const crossResource = scenarios.find((s) => /integration/i.test(s.scenarioName) && s.category === "workflow");
+        expect(crossResource).toBeDefined();
+    });
+});

package/build/utils/trace-parser.js

@@ -0,0 +1,166 @@
+/**
+ * Trace Parser — parses Skyramp trace format and HAR files into
+ * structured entries for analysis enrichment.
+ */
+import * as fs from "fs";
+const FLOW_GAP_MS = 30_000;
+const SENSITIVE_HEADER = /^(authorization|cookie|x-api-key|x-auth-token|set-cookie)/i;
+function groupIntoFlows(entries) {
+    if (entries.length === 0)
+        return [];
+    const sorted = [...entries].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const flows = [];
+    let current = [sorted[0]];
+    let flowIdx = 1;
+    for (let i = 1; i < sorted.length; i++) {
+        const prev = new Date(sorted[i - 1].timestamp).getTime();
+        const curr = new Date(sorted[i].timestamp).getTime();
+        if (curr - prev > FLOW_GAP_MS) {
+            const first = new Date(current[0].timestamp).getTime();
+            const last = new Date(current[current.length - 1].timestamp).getTime();
+            flows.push({ flowId: `flow-${flowIdx++}`, entries: current, durationMs: last - first });
+            current = [];
+        }
+        current.push(sorted[i]);
+    }
+    if (current.length > 0) {
+        const first = new Date(current[0].timestamp).getTime();
+        const last = new Date(current[current.length - 1].timestamp).getTime();
+        flows.push({ flowId: `flow-${flowIdx}`, entries: current, durationMs: last - first });
+    }
+    return flows;
+}
+function sanitizeHeaders(headers) {
+    const result = {};
+    for (const [k, v] of Object.entries(headers)) {
+        result[k] = SENSITIVE_HEADER.test(k) ? "<redacted>" : v;
+    }
+    return result;
+}
+function parseSkyrampTrace(data) {
+    return data.map((entry) => ({
+        method: (entry.method || entry.request?.method || "GET").toUpperCase(),
+        path: entry.path || entry.url || entry.request?.url || "/",
+        statusCode: entry.statusCode || entry.status || entry.response?.status || 0,
+        requestHeaders: entry.request?.headers ? sanitizeHeaders(entry.request.headers) : undefined,
+        requestBody: entry.request?.body || entry.requestBody,
+        responseHeaders: entry.response?.headers ? sanitizeHeaders(entry.response.headers) : undefined,
+        responseBody: summarizeBody(entry.response?.body || entry.responseBody),
+        timestamp: entry.timestamp || entry.request?.timestamp || "",
+    }));
+}
+function parseHarTrace(harData) {
+    const entries = harData?.log?.entries || [];
+    return entries.map((entry) => {
+        const req = entry.request || {};
+        const res = entry.response || {};
+        const url = new URL(req.url || "http://localhost/");
+        const reqHeaders = {};
+        for (const h of req.headers || [])
+            reqHeaders[h.name] = h.value;
+        const resHeaders = {};
+        for (const h of res.headers || [])
+            resHeaders[h.name] = h.value;
+        let reqBody;
+        if (req.postData?.text) {
+            try {
+                reqBody = JSON.parse(req.postData.text);
+            }
+            catch {
+                reqBody = req.postData.text;
+            }
+        }
+        let resBody;
+        if (res.content?.text) {
+            try {
+                resBody = JSON.parse(res.content.text);
+            }
+            catch {
+                resBody = res.content.text;
+            }
+        }
+        return {
+            method: (req.method || "GET").toUpperCase(),
+            path: url.pathname + (url.search || ""),
+            statusCode: res.status || 0,
+            requestHeaders: sanitizeHeaders(reqHeaders),
+            requestBody: reqBody,
+            responseHeaders: sanitizeHeaders(resHeaders),
+            responseBody: summarizeBody(resBody),
+            timestamp: entry.startedDateTime || "",
+        };
+    });
+}
+function summarizeBody(body) {
+    if (!body)
+        return undefined;
+    const str = typeof body === "string" ? body : JSON.stringify(body);
+    if (str.length > 2000) {
+        if (typeof body === "object" && body !== null) {
+            const keys = Object.keys(body);
+            return { _summarized: true, keys, _truncatedAt: 2000 };
+        }
+        return str.slice(0, 2000) + "...<truncated>";
+    }
+    return body;
+}
+export async function parseTraceFile(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return { entries: [], userFlows: [], format: "unknown" };
+    }
+    let entries;
+    let format;
+    if (data?.log?.entries) {
+        entries = parseHarTrace(data);
+        format = "har";
+    }
+    else if (Array.isArray(data)) {
+        entries = parseSkyrampTrace(data);
+        format = "skyramp";
+    }
+    else if (data?.traces && Array.isArray(data.traces)) {
+        entries = parseSkyrampTrace(data.traces);
+        format = "skyramp";
+    }
+    else {
+        return { entries: [], userFlows: [], format: "unknown" };
+    }
+    const userFlows = groupIntoFlows(entries);
+    return { entries, userFlows, format };
+}
+/**
+ * Discover trace files in a repository path.
+ */
+export function discoverTraceFiles(repositoryPath) {
+    const candidates = [
+        "skyramp_traces.json",
+        "traces.json",
+        "trace.json",
+        "traces.har",
+        "trace.har",
+    ];
+    const found = [];
+    for (const name of candidates) {
+        const full = `${repositoryPath}/${name}`;
+        if (fs.existsSync(full))
+            found.push(full);
+    }
+    const skyrampDir = `${repositoryPath}/.skyramp`;
+    if (fs.existsSync(skyrampDir)) {
+        try {
+            const files = fs.readdirSync(skyrampDir);
+            for (const f of files) {
+                if (/\.(json|har)$/i.test(f) && /trace/i.test(f)) {
+                    found.push(`${skyrampDir}/${f}`);
+                }
+            }
+        }
+        catch { /* dir not readable */ }
+    }
+    return found;
+}

package/build/utils/workspaceAuth.js

@@ -0,0 +1,16 @@
+import { WorkspaceConfigManager } from "@skyramp/skyramp";
+export async function getWorkspaceAuthHeader(repositoryPath) {
+    try {
+        const wsMgr = new WorkspaceConfigManager(repositoryPath);
+        if (await wsMgr.exists()) {
+            const wsConfig = await wsMgr.read();
+            const firstServiceAuth = wsConfig.services?.find((s) => s.api?.authHeader)?.api?.authHeader;
+            if (firstServiceAuth)
+                return firstServiceAuth;
+        }
+    }
+    catch {
+        // Workspace config not available
+    }
+    return undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.0.59",
+  "version": "0.0.60-rc.2",
   "main": "build/index.js",
   "type": "module",
   "bin": {