@skyramp/mcp 0.3.2-rc.pom-3 → 0.3.2

package/build/services/AnalyticsService.test.js

@@ -1,86 +0,0 @@
-// @ts-nocheck - Jest ESM type inference issues
-import { jest } from "@jest/globals";
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-// AnalyticsService resolves the MCP version with
-// `fileURLToPath(import.meta.url)` at module scope. Under ts-jest's old
-// CommonJS transform that top-level import.meta failed to compile with TS1343,
-// so this module — and therefore this test — could not exist. The native-ESM
-// Jest config (SKYR-3799) is what makes it loadable.
-// pushToolEvent lives in @skyramp/skyramp, which pulls the native dylib. Mock
-// it so we can assert on the event payload without loading the binary. Under
-// native ESM jest.mock is not hoisted — use unstable_mockModule + dynamic
-// import of the subject below.
-const pushToolEvent = jest.fn();
-jest.unstable_mockModule("@skyramp/skyramp", () => ({ pushToolEvent }));
-jest.unstable_mockModule("../utils/telemetry.js", () => ({
-    getEntryPoint: jest.fn(() => "mcp"),
-    getCIPlatform: jest.fn(() => undefined),
-    getRepositoryInfo: jest.fn(async () => ({})),
-}));
-jest.unstable_mockModule("../utils/logger.js", () => ({
-    logger: { info: jest.fn(), error: jest.fn(), debug: jest.fn(), warn: jest.fn() },
-}));
-const { AnalyticsService } = await import("./AnalyticsService.js");
-const telemetry = await import("../utils/telemetry.js");
-// The version the production code should resolve: package.json two levels up
-// from this module's own location — the same lookup getMCPPackageVersion does
-// via import.meta.url. Computing it the same way here proves the test harness
-// itself supports import.meta now.
-const expectedVersion = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8")).version;
-describe("AnalyticsService — import.meta-based version resolution", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        telemetry.getEntryPoint.mockReturnValue("mcp");
-        telemetry.getCIPlatform.mockReturnValue(undefined);
-        telemetry.getRepositoryInfo.mockResolvedValue({});
-    });
-    it("stamps the package.json version (resolved via import.meta.url) into the event params", async () => {
-        const params = {};
-        await AnalyticsService.pushMCPToolEvent("skyramp_smoke_test_generation", undefined, params);
-        expect(pushToolEvent).toHaveBeenCalledTimes(1);
-        const [, toolName, , sentParams] = pushToolEvent.mock.calls[0];
-        expect(toolName).toBe("skyramp_smoke_test_generation");
-        expect(sentParams.mcpServerVersion).toBe(expectedVersion);
-        // Sanity: a real semver-ish string, not an empty/undefined fallback.
-        expect(sentParams.mcpServerVersion).toMatch(/^\d+\.\d+\.\d+/);
-    });
-    it("concatenates error text from an isError result into the event error message", async () => {
-        const result = {
-            isError: true,
-            content: [
-                { type: "text", text: "first failure" },
-                { type: "text", text: "second failure" },
-            ],
-        };
-        await AnalyticsService.pushMCPToolEvent("skyramp_execute_test", result, {});
-        const [, , errorMessage] = pushToolEvent.mock.calls[0];
-        expect(errorMessage).toBe("first failure, second failure");
-    });
-    it("sends an empty error message for a successful result", async () => {
-        const result = { isError: false, content: [{ type: "text", text: "ok" }] };
-        await AnalyticsService.pushMCPToolEvent("skyramp_execute_test", result, {});
-        const [, , errorMessage] = pushToolEvent.mock.calls[0];
-        expect(errorMessage).toBe("");
-    });
-    it("includes ciPlatform in the params when running in CI", async () => {
-        telemetry.getCIPlatform.mockReturnValue("github_actions");
-        const params = {};
-        await AnalyticsService.pushMCPToolEvent("skyramp_init_workspace", undefined, params);
-        const [, , , sentParams] = pushToolEvent.mock.calls[0];
-        expect(sentParams.ciPlatform).toBe("github_actions");
-    });
-    it("merges repository info into the params", async () => {
-        telemetry.getRepositoryInfo.mockResolvedValue({ repoName: "letsramp/mcp", repoOwner: "letsramp" });
-        const params = { repositoryPath: "/repo" };
-        await AnalyticsService.pushMCPToolEvent("skyramp_analyze_changes", undefined, params);
-        expect(telemetry.getRepositoryInfo).toHaveBeenCalledWith("/repo");
-        const [, , , sentParams] = pushToolEvent.mock.calls[0];
-        expect(sentParams.repoName).toBe("letsramp/mcp");
-    });
-    it("swallows errors from pushToolEvent (telemetry must never break a tool call)", async () => {
-        pushToolEvent.mockRejectedValueOnce(new Error("network down"));
-        await expect(AnalyticsService.pushMCPToolEvent("skyramp_smoke_test_generation", undefined, {})).resolves.toBeUndefined();
-    });
-});

package/build/services/ScenarioGenerationService.integration.test.d.ts

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

package/build/services/ScenarioGenerationService.integration.test.js

@@ -1,162 +0,0 @@
-/**
- * Integration test: verifies query params survive the full pipeline
- * TS (ScenarioGenerationService) → JSON file → Go binary → generated test code
- *
- * Requires: @skyramp/skyramp native dylib (skips if not available)
- */
-import { jest } from "@jest/globals";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { createRequire } from "module";
-import { ScenarioGenerationService } from "./ScenarioGenerationService.js";
-// Native dylib is a CommonJS addon — load it via createRequire under ESM.
-const require = createRequire(import.meta.url);
-let SkyrampClient;
-try {
-    SkyrampClient = require("@skyramp/skyramp").SkyrampClient;
-}
-catch {
-    SkyrampClient = null;
-}
-// These tests require the native Go binary which is platform-specific.
-// Skip in CI or when the binary isn't available for this OS/arch.
-const isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS);
-const describeIfBinary = SkyrampClient && !isCI ? describe : describe.skip;
-function buildTrace(overrides) {
-    const service = new ScenarioGenerationService();
-    return service.generateTraceRequestFromInput({
-        scenarioName: "integration-qp-test",
-        destination: "localhost",
-        baseURL: "http://localhost:8080",
-        method: "GET",
-        path: "/api/v1/items",
-        outputDir: os.tmpdir(),
-        authHeader: "",
-        authScheme: "",
-        ...overrides,
-    });
-}
-describeIfBinary("QueryParams integration: TS → JSON → Go binary → generated code", () => {
-    let tmpDir;
-    let outputDir;
-    let client;
-    // Go dylib cold-starts can take a few seconds
-    jest.setTimeout(15000);
-    beforeAll(() => {
-        client = new SkyrampClient();
-    });
-    afterAll(() => {
-        client?.close?.();
-    });
-    beforeEach(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-qp-integration-"));
-        outputDir = path.join(tmpDir, "output");
-        fs.mkdirSync(outputDir);
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    async function generateFromTrace(trace) {
-        const traceFile = path.join(tmpDir, "scenario.json");
-        fs.writeFileSync(traceFile, JSON.stringify([trace], null, 2));
-        await client.generateRestTest({
-            testType: "integration",
-            language: "python",
-            framework: "pytest",
-            outputDir,
-            force: true,
-            traceFilePath: traceFile,
-        });
-        const files = fs.readdirSync(outputDir).filter((f) => f.endsWith(".py"));
-        if (files.length === 0)
-            throw new Error("No generated test file found");
-        return fs.readFileSync(path.join(outputDir, files[0]), "utf8");
-    }
-    it("bracket-notation keys pass through to generated test code", async () => {
-        // Simulates: GET /api/v1/items?filter[status][_eq]=published&limit=25
-        const trace = buildTrace({
-            queryParams: '{"filter[status][_eq]":"published","limit":25}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            "filter[status][_eq]": ["published"],
-            "limit": ["25"],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("filter[status][_eq]");
-        expect(code).toContain("published");
-        expect(code).toContain("limit");
-        expect(code).toContain("25");
-    });
-    it("simple flat params pass through to generated test code", async () => {
-        // Simulates: GET /api/v1/items?page=2&status=active
-        const trace = buildTrace({
-            queryParams: '{"page":2,"status":"active"}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            page: ["2"],
-            status: ["active"],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("page");
-        expect(code).toContain("2");
-        expect(code).toContain("status");
-        expect(code).toContain("active");
-    });
-    it("JSON-encoded string value (Elasticsearch-style) passes through intact", async () => {
-        // Simulates: GET /search?source={"query":{"match":{"name":"bear"}}}
-        const trace = buildTrace({
-            queryParams: '{"source":"{\\"query\\":{\\"match\\":{\\"name\\":\\"bear\\"}}}"}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            source: ['{"query":{"match":{"name":"bear"}}}'],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("source");
-        expect(code).toMatch(/query.*match.*name.*bear/);
-    });
-    it("array params are comma-joined into a single value in generated code", async () => {
-        // Simulates: GET /products?tags=sale,new
-        const trace = buildTrace({
-            queryParams: '{"tags":["sale","new"]}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            tags: ["sale,new"],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("tags");
-        expect(code).toContain("sale,new");
-    });
-    it("null params are omitted — not present in generated code", async () => {
-        // null means "don't include this param" — same as axios/fetch omitting undefined
-        const trace = buildTrace({
-            queryParams: '{"limit":10,"cursor":null}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            limit: ["10"],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("limit");
-        expect(code).toContain("10");
-        expect(code).not.toContain("cursor");
-    });
-    it("nested object fallback produces valid JSON string in generated code", async () => {
-        // LLM mistakenly sends nested object — service JSON-stringifies it
-        const trace = buildTrace({
-            queryParams: '{"filter":{"status":"active"}}',
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({
-            filter: ['{"status":"active"}'],
-        });
-        const code = await generateFromTrace(trace);
-        expect(code).toContain("filter");
-        expect(code).not.toContain("[object Object]");
-        expect(code).not.toContain("map[");
-    });
-});

package/build/services/ScenarioGenerationService.test.d.ts

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

package/build/services/ScenarioGenerationService.test.js

@@ -1,414 +0,0 @@
-import { ScenarioGenerationService } from "./ScenarioGenerationService.js";
-import { AUTH_PLACEHOLDER_TOKEN } from "../types/TestTypes.js";
-const BASE_PARAMS = {
-    scenarioName: "test-scenario",
-    destination: "api.example.com",
-    method: "GET",
-    path: "/api/v1/items",
-    outputDir: "/tmp/skyramp-test",
-    baseURL: "http://localhost:8000",
-};
-function generateTrace(overrides = {}) {
-    const service = new ScenarioGenerationService();
-    return service["generateTraceRequestFromInput"]({
-        ...BASE_PARAMS,
-        ...overrides,
-    });
-}
-function getAuthHeaders(trace) {
-    const { "Content-Type": _, ...rest } = trace.RequestHeaders;
-    return rest;
-}
-describe("ScenarioGenerationService — auth header flavors", () => {
-    // 1. Public API — no auth (explicit empty string)
-    it("skips auth header when authHeader is empty string", () => {
-        const trace = generateTrace({ authHeader: "" });
-        expect(trace).not.toBeNull();
-        const auth = getAuthHeaders(trace);
-        expect(auth).toEqual({});
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-    // 2. Public API — no auth params at all (undefined)
-    it("skips auth header when authHeader is undefined", () => {
-        const trace = generateTrace({ authHeader: undefined });
-        expect(trace).not.toBeNull();
-        const auth = getAuthHeaders(trace);
-        expect(auth).toEqual({});
-    });
-    // 3. Bearer token — Authorization with scheme embedded in trace for CLI compatibility
-    it("generates Authorization: Bearer <token> header in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            `Bearer ${AUTH_PLACEHOLDER_TOKEN}`,
-        ]);
-    });
-    // 4. DRF Token — Authorization with Token scheme embedded in trace
-    it("generates Authorization: Token <token> header in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "Token",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            `Token ${AUTH_PLACEHOLDER_TOKEN}`,
-        ]);
-    });
-    // 5. Basic auth — Authorization with Basic scheme embedded in trace
-    it("generates Authorization: Basic <token> header in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "Basic",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            `Basic ${AUTH_PLACEHOLDER_TOKEN}`,
-        ]);
-    });
-    // 6. Raw token — Authorization with no scheme, placeholder only
-    it("generates Authorization with raw placeholder when authScheme is empty", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            AUTH_PLACEHOLDER_TOKEN,
-        ]);
-    });
-    // 7. X-API-Key header with explicit token
-    it("includes X-API-Key with explicit token in trace", () => {
-        const trace = generateTrace({
-            authHeader: "X-API-Key",
-            authToken: AUTH_PLACEHOLDER_TOKEN,
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["X-API-Key"]).toEqual([
-            AUTH_PLACEHOLDER_TOKEN,
-        ]);
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-    // 8. Cookie-based auth (e.g. NextAuth)
-    it("includes Cookie with session token in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Cookie",
-            authToken: `session=${AUTH_PLACEHOLDER_TOKEN}`,
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Cookie"]).toEqual([
-            `session=${AUTH_PLACEHOLDER_TOKEN}`,
-        ]);
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-    // 9. Custom header (e.g. internal microservice)
-    it("includes custom auth header with token in trace", () => {
-        const trace = generateTrace({
-            authHeader: "X-Internal-Service-Key",
-            authToken: AUTH_PLACEHOLDER_TOKEN,
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["X-Internal-Service-Key"]).toEqual([
-            AUTH_PLACEHOLDER_TOKEN,
-        ]);
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-    // 10. OAuth — Authorization with OAuth scheme embedded in trace
-    it("generates Authorization: OAuth <token> header in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "OAuth",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            `OAuth ${AUTH_PLACEHOLDER_TOKEN}`,
-        ]);
-    });
-    // 11. Explicit token overrides scheme auto-generation
-    it("uses explicit authToken and ignores authScheme when both provided", () => {
-        const trace = generateTrace({
-            authHeader: "Authorization",
-            authScheme: "Bearer",
-            authToken: "my-hardcoded-token-123",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Authorization"]).toEqual([
-            "my-hardcoded-token-123",
-        ]);
-    });
-    // 12. Non-Authorization header without token — placeholder in trace (CLI parameterizes it)
-    it("includes X-API-Key with placeholder when authToken is missing", () => {
-        const trace = generateTrace({
-            authHeader: "X-API-Key",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["X-API-Key"]).toEqual([AUTH_PLACEHOLDER_TOKEN]);
-    });
-    // 16. Cookie header without explicit token — placeholder in trace (CLI parameterizes it)
-    it("includes Cookie with placeholder when authToken is missing", () => {
-        const trace = generateTrace({
-            authHeader: "Cookie",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Cookie"]).toEqual([AUTH_PLACEHOLDER_TOKEN]);
-    });
-    // 17. Custom header without explicit token — placeholder in trace (CLI parameterizes it)
-    it("includes custom auth header with placeholder when authToken is missing", () => {
-        const trace = generateTrace({
-            authHeader: "X-Internal-Service-Key",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["X-Internal-Service-Key"]).toEqual([AUTH_PLACEHOLDER_TOKEN]);
-    });
-    // 13. Content-Type always present regardless of auth
-    it("always includes Content-Type regardless of auth config", () => {
-        const noAuth = generateTrace({ authHeader: "" });
-        const bearer = generateTrace({ authHeader: "Authorization", authScheme: "Bearer" });
-        const apiKey = generateTrace({ authHeader: "X-API-Key", authToken: "key123" });
-        expect(noAuth.RequestHeaders["Content-Type"]).toEqual(["application/json"]);
-        expect(bearer.RequestHeaders["Content-Type"]).toEqual(["application/json"]);
-        expect(apiKey.RequestHeaders["Content-Type"]).toEqual(["application/json"]);
-    });
-    // 14. Firebase AppCheck custom header
-    it("includes X-Firebase-AppCheck with token in trace", () => {
-        const trace = generateTrace({
-            authHeader: "X-Firebase-AppCheck",
-            authToken: AUTH_PLACEHOLDER_TOKEN,
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["X-Firebase-AppCheck"]).toEqual([
-            AUTH_PLACEHOLDER_TOKEN,
-        ]);
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-    // 15. Proxy-Authorization header with explicit token
-    it("includes Proxy-Authorization with explicit token in trace", () => {
-        const trace = generateTrace({
-            authHeader: "Proxy-Authorization",
-            authToken: "Bearer proxy-token-abc",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.RequestHeaders["Proxy-Authorization"]).toEqual([
-            "Bearer proxy-token-abc",
-        ]);
-        expect(trace.RequestHeaders["Authorization"]).toBeUndefined();
-    });
-});
-describe("ScenarioGenerationService — queryParams handling", () => {
-    // --- Primitive values (strings, numbers, booleans) ---
-    it("coerces string values into single-element arrays", () => {
-        const trace = generateTrace({ queryParams: '{"status":"active"}' });
-        expect(trace.QueryParams).toEqual({ status: ["active"] });
-    });
-    it("coerces numeric values to string", () => {
-        const trace = generateTrace({ queryParams: '{"limit":10,"offset":0}' });
-        expect(trace.QueryParams).toEqual({ limit: ["10"], offset: ["0"] });
-    });
-    it("coerces boolean values to string", () => {
-        const trace = generateTrace({ queryParams: '{"active":true,"deleted":false}' });
-        expect(trace.QueryParams).toEqual({ active: ["true"], deleted: ["false"] });
-    });
-    it("coerces empty string to single-element array", () => {
-        const trace = generateTrace({ queryParams: '{"q":""}' });
-        expect(trace.QueryParams).toEqual({ q: [""] });
-    });
-    it("passes bracket-notation keys through verbatim (Directus regression)", () => {
-        // Root cause of the original P0: filter[title][_neq] must reach the Go backend
-        // as the literal key string, not as a nested object or [object Object].
-        const trace = generateTrace({
-            queryParams: '{"filter[status][_eq]":"published","filter[date_created][_gte]":"2024-01-01","limit":25}',
-        });
-        expect(trace.QueryParams["filter[status][_eq]"]).toEqual(["published"]);
-        expect(trace.QueryParams["filter[date_created][_gte]"]).toEqual(["2024-01-01"]);
-        expect(trace.QueryParams["limit"]).toEqual(["25"]);
-    });
-    // --- Null omission ---
-    it("omits null values entirely (prevents ?status=null in URL)", () => {
-        // null means "omit this param" — same convention as axios/fetch omitting undefined params
-        const trace = generateTrace({ queryParams: '{"cursor":null,"limit":20}' });
-        expect(trace.QueryParams["cursor"]).toBeUndefined();
-        expect(trace.QueryParams["limit"]).toEqual(["20"]);
-    });
-    it("omits all-null object leaving only non-null keys", () => {
-        const trace = generateTrace({ queryParams: '{"a":null,"b":null,"c":"keep"}' });
-        expect(trace.QueryParams).toEqual({ c: ["keep"] });
-    });
-    // --- Array values: filter nulls, comma-join into single element ---
-    it("array of strings joins into single comma-separated value", () => {
-        const trace = generateTrace({ queryParams: '{"tags":["sale","new","featured"]}' });
-        expect(trace.QueryParams["tags"]).toEqual(["sale,new,featured"]);
-    });
-    it("array of mixed primitives coerces each to string then joins", () => {
-        const trace = generateTrace({ queryParams: '{"ids":[1,2,"three",true,0,false]}' });
-        expect(trace.QueryParams["ids"]).toEqual(["1,2,three,true,0,false"]);
-    });
-    it("array with null items filters nulls before joining", () => {
-        const trace = generateTrace({ queryParams: '{"tags":[null,"active",null,"pending"]}' });
-        expect(trace.QueryParams["tags"]).toEqual(["active,pending"]);
-    });
-    it("array with all-null items omits the key entirely", () => {
-        const trace = generateTrace({ queryParams: '{"tags":[null,null],"limit":5}' });
-        expect(trace.QueryParams["tags"]).toBeUndefined();
-        expect(trace.QueryParams["limit"]).toEqual(["5"]);
-    });
-    it("empty array omits the key (no items after filtering)", () => {
-        const trace = generateTrace({ queryParams: '{"ids":[],"limit":10}' });
-        expect(trace.QueryParams["ids"]).toBeUndefined();
-        expect(trace.QueryParams["limit"]).toEqual(["10"]);
-    });
-    it("array containing objects JSON-stringifies each then joins", () => {
-        const trace = generateTrace({
-            queryParams: '{"filters":[{"field":"status","value":"active"},{"field":"price","op":"gte","value":"10"}]}',
-        });
-        expect(trace.QueryParams["filters"]).toEqual([
-            '{"field":"status","value":"active"},{"field":"price","op":"gte","value":"10"}',
-        ]);
-    });
-    it("array mixing objects, primitives, and nulls: filters nulls, stringifies objects, joins all", () => {
-        const trace = generateTrace({
-            queryParams: '{"mixed":[null,{"nested":true},"plain",42,null]}',
-        });
-        expect(trace.QueryParams["mixed"]).toEqual(['{"nested":true},plain,42']);
-    });
-    // --- Nested object fallback: JSON.stringify ---
-    it("nested object is JSON-stringified as fallback", () => {
-        const trace = generateTrace({
-            queryParams: '{"filter":{"status":"active","min_price":10}}',
-        });
-        expect(trace.QueryParams["filter"]).toEqual(['{"status":"active","min_price":10}']);
-    });
-    it("deeply nested object is fully JSON-stringified", () => {
-        const trace = generateTrace({
-            queryParams: '{"filter":{"title":{"_neq":"not-a-number"}}}',
-        });
-        expect(trace.QueryParams["filter"]).toEqual(['{"title":{"_neq":"not-a-number"}}']);
-    });
-    it("empty nested object is JSON-stringified to '{}'", () => {
-        const trace = generateTrace({ queryParams: '{"filter":{}}' });
-        expect(trace.QueryParams["filter"]).toEqual(["{}"]);
-    });
-    // --- JSON parsing and object validation ---
-    it("omitted queryParams produces empty QueryParams", () => {
-        const trace = generateTrace({});
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("invalid JSON produces empty QueryParams without throwing", () => {
-        const trace = generateTrace({ queryParams: "not-valid-json{" });
-        expect(trace).not.toBeNull();
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("JSON array (not object) produces empty QueryParams", () => {
-        const trace = generateTrace({ queryParams: '["limit","10"]' });
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("JSON null produces empty QueryParams", () => {
-        const trace = generateTrace({ queryParams: "null" });
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("JSON number produces empty QueryParams", () => {
-        const trace = generateTrace({ queryParams: "42" });
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("JSON string produces empty QueryParams", () => {
-        const trace = generateTrace({ queryParams: '"just a string"' });
-        expect(trace.QueryParams).toEqual({});
-    });
-    it("empty object produces empty QueryParams", () => {
-        const trace = generateTrace({ queryParams: '{}' });
-        expect(trace.QueryParams).toEqual({});
-    });
-    // --- Security: PROTO_KEYS guard ---
-    it("skips __proto__ key to prevent prototype pollution via setter", () => {
-        const trace = generateTrace({
-            queryParams: '{"__proto__":{"polluted":true},"limit":10}',
-        });
-        expect(Object.hasOwn(trace.QueryParams, "__proto__")).toBe(false);
-        expect(Object.getPrototypeOf(trace.QueryParams)).toBe(Object.prototype);
-        expect(trace.QueryParams["limit"]).toEqual(["10"]);
-    });
-    it("skips constructor and prototype keys", () => {
-        const trace = generateTrace({
-            queryParams: '{"constructor":"pwned","prototype":"evil","valid":"yes"}',
-        });
-        expect(Object.hasOwn(trace.QueryParams, "constructor")).toBe(false);
-        expect(Object.hasOwn(trace.QueryParams, "prototype")).toBe(false);
-        expect(trace.QueryParams["valid"]).toEqual(["yes"]);
-    });
-});
-describe("ScenarioGenerationService — baseURL parsing", () => {
-    it("parses http baseURL correctly", () => {
-        const trace = generateTrace({
-            baseURL: "http://localhost:3000",
-            authHeader: "",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.Scheme).toBe("http");
-        expect(trace.Destination).toBe("localhost");
-        expect(trace.Port).toBe(3000);
-    });
-    it("parses https baseURL with default port", () => {
-        const trace = generateTrace({
-            baseURL: "https://api.example.com",
-            authHeader: "",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.Scheme).toBe("https");
-        expect(trace.Destination).toBe("api.example.com");
-        expect(trace.Port).toBe(443);
-    });
-    it("parses http baseURL with default port", () => {
-        const trace = generateTrace({
-            baseURL: "http://api.example.com",
-            authHeader: "",
-        });
-        expect(trace).not.toBeNull();
-        expect(trace.Scheme).toBe("http");
-        expect(trace.Port).toBe(80);
-    });
-});
-describe("ScenarioGenerationService — unique fields (SKYR-3882)", () => {
-    it("carries uniqueFields onto the trace request", () => {
-        const trace = generateTrace({ uniqueFields: ["name", "slug"] });
-        expect(trace).not.toBeNull();
-        expect(trace.UniqueFields).toEqual(["name", "slug"]);
-    });
-    it("omits UniqueFields when none are provided", () => {
-        const trace = generateTrace({});
-        expect(trace).not.toBeNull();
-        expect(trace.UniqueFields).toBeUndefined();
-    });
-});
-describe("ScenarioGenerationService — step timestamps (SKYR-3884)", () => {
-    it("stamps consecutive traces from one instance with strictly increasing timestamps", () => {
-        // All steps of a batch are generated within the same millisecond, so a bare
-        // new Date().toISOString() gives every step the identical timestamp. The Go
-        // codegen treats "earlier timestamp" as "prior step" when chaining FKs and
-        // path params from create responses — equal stamps break every chain. The
-        // service owns the invariant, so callers cannot forget to thread an index.
-        const service = new ScenarioGenerationService();
-        const traces = [0, 1, 2].map(() => service.generateTraceRequestFromInput(BASE_PARAMS));
-        for (let i = 1; i < traces.length; i++) {
-            expect(new Date(traces[i].Timestamp).getTime()).toBeGreaterThan(new Date(traces[i - 1].Timestamp).getTime());
-        }
-    });
-    it("stamps the first trace of a fresh instance at the current time", () => {
-        const before = Date.now();
-        const trace = generateTrace({});
-        const after = Date.now();
-        const ts = new Date(trace.Timestamp).getTime();
-        expect(ts).toBeGreaterThanOrEqual(before);
-        expect(ts).toBeLessThanOrEqual(after);
-    });
-});
-describe("ScenarioGenerationService — scenarioName embedding (SKYR-3884)", () => {
-    it("writes scenarioName into each trace request so the plan guard can identify the file", () => {
-        // readScenarioNameFromFile (generateIntegrationRestTool) reads
-        // parsed[0].scenarioName to match the file against the approved plan.
-        // Without this field every scenarioFile-mode generation is rejected
-        // fail-closed whenever a plan is active.
-        const trace = generateTrace({});
-        expect(trace.scenarioName).toBe("test-scenario");
-    });
-});

package/build/services/TestDiscoveryService.test.d.ts

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