@muggleai/mcp-qa-gateway 1.0.1

package/dist/scripts/phase0-smoke.js

@@ -0,0 +1,1712 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPhase0SmokeAsync = runPhase0SmokeAsync;
+/**
+ * Phase 0 end-to-end smoke runner for the MCP QA Gateway.
+ *
+ * How to run (from mcp-gateway):
+ *   npx dotenv -e .env.staging -- tsx scripts/phase0-smoke.ts
+ *
+ * The script will automatically start the MCP Gateway server and run the tests.
+ *
+ * Optional env:
+ *   MCP_QA_ARCHIVE_UNAPPROVED=true,
+ *   MCP_QA_PRD_FILE_PATH (+ MCP_QA_PRD_CONTENT_TYPE),
+ *   MCP_QA_REPORT_CHANNELS=email,sms,webhook (+ MCP_QA_REPORT_EMAILS/PHONES/WEBHOOK_URL)
+ */
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const axios_1 = __importDefault(require("axios"));
+const TOOL_ENDPOINT_PATH = "/mcp";
+const JSON_RPC_VERSION = "2.0";
+const POLL_INTERVAL_MS = 5000;
+const MAX_POLL_ATTEMPTS = 6;
+const SERVER_STARTUP_TIMEOUT_MS = 30000;
+const SERVER_HEALTH_CHECK_INTERVAL_MS = 500;
+/** Delay after server health passes before first request (avoids ECONNRESET on back-to-back runs). */
+const SERVER_READY_SETTLE_MS = 1500;
+const SESSION_INIT_RETRY_ATTEMPTS = 3;
+const SESSION_INIT_RETRY_DELAY_MS = 1000;
+const PRD_PROCESS_POLL_INTERVAL_MS = 5000;
+const PRD_PROCESS_MAX_POLL_ATTEMPTS = 60;
+const TEST_CASE_DETECTION_POLL_INTERVAL_MS = 5000;
+const TEST_CASE_DETECTION_MAX_POLL_ATTEMPTS = 60;
+const TEST_SCRIPT_GENERATION_POLL_INTERVAL_MS = 5000;
+const TEST_SCRIPT_GENERATION_MAX_POLL_ATTEMPTS = 120;
+const WEBSITE_SCAN_POLL_INTERVAL_MS = 10000;
+const WEBSITE_SCAN_MAX_POLL_ATTEMPTS = 60;
+const DISCOVERY_MEMORY_POLL_INTERVAL_MS = 10000;
+const DISCOVERY_MEMORY_MAX_POLL_ATTEMPTS = 60;
+const CLIENT_NAME = "mcp-gateway-phase0-smoke";
+const CLIENT_VERSION = "1.0.0";
+let currentSessionId;
+const DEBUG_RAW_RESPONSES = process.env["MCP_SMOKE_DEBUG_RAW_RESPONSES"] === "true";
+/** Terminal workflow run statuses. */
+const TERMINAL_STATUSES = ["COMPLETED", "FAILED", "CANCELLED", "TIMEOUT"];
+/**
+ * Maximum use cases to approve in smoke test.
+ * Keeps within typical user quotas and is sufficient to validate the workflow.
+ */
+const MAX_USE_CASES_TO_APPROVE = 1;
+const TOOL_NAMES = {
+    projectCreate: "qa_project_create",
+    projectGet: "qa_project_get",
+    projectList: "qa_project_list",
+    projectDelete: "qa_project_delete",
+    prdUpload: "qa_prd_file_upload",
+    prdProcessStart: "qa_workflow_start_prd_file_process",
+    prdProcessLatestRun: "qa_workflow_get_prd_file_process_latest_run",
+    useCaseDiscovery: "qa_use_case_discovery_memory_get",
+    useCaseApprove: "qa_use_case_candidates_approve",
+    useCaseList: "qa_use_case_list",
+    workflowStartWebsiteScan: "qa_workflow_start_website_scan",
+    workflowGetWebsiteScanLatestRun: "qa_workflow_get_website_scan_latest_run",
+    workflowStartTestCaseDetection: "qa_workflow_start_test_case_detection",
+    workflowGetTestCaseDetectionLatestRun: "qa_workflow_get_test_case_detection_latest_run",
+    workflowStartTestScriptGeneration: "qa_workflow_start_test_script_generation",
+    workflowGetTestScriptGenerationLatestRun: "qa_workflow_get_test_script_generation_latest_run",
+    workflowStartTestScriptReplayBulk: "qa_workflow_start_test_script_replay_bulk",
+    testCaseList: "qa_test_case_list",
+    testCaseGet: "qa_test_case_get",
+    testCaseGenerateFromPrompt: "qa_test_case_generate_from_prompt",
+    testCaseCreate: "qa_test_case_create",
+    testScriptList: "qa_test_script_list",
+    reportFinalGenerate: "qa_report_final_generate",
+    reportPreferencesUpsert: "qa_report_preferences_upsert",
+};
+let sharedHttpClient = null;
+let serverProcess = null;
+/**
+ * Extract port number from a base URL.
+ */
+function extractPort(baseUrl) {
+    const url = new URL(baseUrl);
+    if (url.port) {
+        return parseInt(url.port, 10);
+    }
+    return url.protocol === "https:" ? 443 : 80;
+}
+/**
+ * Kill any process listening on the specified port.
+ * This is especially important on Windows where killed processes may leave the port bound.
+ */
+function killProcessOnPort(port) {
+    try {
+        if (process.platform === "win32") {
+            // Windows: use netstat to find PID, then taskkill
+            const netstatOutput = (0, node_child_process_1.execSync)(`netstat -ano | findstr :${port}`, {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            // Parse lines like "  TCP    0.0.0.0:6000  0.0.0.0:0  LISTENING  12345"
+            const lines = netstatOutput.split("\n").filter((line) => line.includes("LISTENING"));
+            const pids = new Set();
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parseInt(parts[parts.length - 1], 10);
+                if (!isNaN(pid) && pid > 0) {
+                    pids.add(pid);
+                }
+            }
+            for (const pid of pids) {
+                try {
+                    (0, node_child_process_1.execSync)(`taskkill /F /PID ${pid}`, {
+                        encoding: "utf8",
+                        windowsHide: true,
+                        stdio: "ignore",
+                    });
+                    console.log(`Killed process ${pid} on port ${port}`);
+                }
+                catch {
+                    // Process may have already exited
+                }
+            }
+        }
+        else {
+            // Unix: use lsof to find PID
+            const lsofOutput = (0, node_child_process_1.execSync)(`lsof -ti :${port}`, {
+                encoding: "utf8",
+            });
+            const pids = lsofOutput
+                .split("\n")
+                .map((s) => parseInt(s.trim(), 10))
+                .filter((p) => !isNaN(p) && p > 0);
+            for (const pid of pids) {
+                try {
+                    (0, node_child_process_1.execSync)(`kill -9 ${pid}`, { stdio: "ignore" });
+                    console.log(`Killed process ${pid} on port ${port}`);
+                }
+                catch {
+                    // Process may have already exited
+                }
+            }
+        }
+    }
+    catch {
+        // No process found on port - this is fine
+    }
+}
+/**
+ * Start the MCP Gateway server and wait for it to be ready.
+ * @returns Promise that resolves when server is ready.
+ */
+async function startServerAsync(baseUrl) {
+    console.log("Starting MCP Gateway server...");
+    // Kill any existing process on the port (handles stale processes from previous runs)
+    const port = extractPort(baseUrl);
+    killProcessOnPort(port);
+    // Give OS time to release the port after killing
+    await sleepAsync(500);
+    // Check if server is already running (shouldn't be after killProcessOnPort, but just in case)
+    const isAlreadyRunning = await checkServerHealthAsync(baseUrl);
+    if (isAlreadyRunning) {
+        console.log("MCP Gateway server is already running");
+        return;
+    }
+    // Start the server process from the current working directory
+    // The script should be run from the mcp-gateway folder
+    const gatewayDir = process.cwd();
+    // Use npx tsx to start the server directly
+    serverProcess = (0, node_child_process_1.spawn)("npx", ["tsx", "src/index.ts"], {
+        cwd: gatewayDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: true,
+        env: {
+            ...process.env,
+            // Ensure the server inherits the environment
+            FORCE_COLOR: "0",
+        },
+        windowsHide: true,
+    });
+    // Log server output for debugging
+    serverProcess.stdout?.on("data", (data) => {
+        const message = data.toString().trim();
+        if (message) {
+            // Always log first few messages to show startup
+            console.log(`[server] ${message}`);
+        }
+    });
+    serverProcess.stderr?.on("data", (data) => {
+        const message = data.toString().trim();
+        if (message) {
+            console.error(`[server:err] ${message}`);
+        }
+    });
+    serverProcess.on("error", (error) => {
+        console.error("Failed to start server process:", error.message);
+    });
+    serverProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+            console.error(`Server exited with code ${code}`);
+        }
+        serverProcess = null;
+    });
+    // Wait for server to be ready
+    const startTime = Date.now();
+    while (Date.now() - startTime < SERVER_STARTUP_TIMEOUT_MS) {
+        const isReady = await checkServerHealthAsync(baseUrl);
+        if (isReady) {
+            console.log("MCP Gateway server is ready");
+            await sleepAsync(SERVER_READY_SETTLE_MS);
+            return;
+        }
+        await sleepAsync(SERVER_HEALTH_CHECK_INTERVAL_MS);
+    }
+    // Timeout - kill the server and throw
+    stopServer();
+    throw new Error("Server failed to start within timeout");
+}
+/**
+ * Check if the server is healthy and responding.
+ */
+async function checkServerHealthAsync(baseUrl) {
+    try {
+        const response = await axios_1.default.get(`${baseUrl}/health`, {
+            timeout: 2000,
+            validateStatus: () => true,
+        });
+        return response.status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Stop the MCP Gateway server if it was started by this script.
+ * Waits for process to exit and cleans up HTTP client connections.
+ */
+async function stopServerAsync() {
+    // Reset HTTP client so next run doesn't reuse stale connections
+    if (sharedHttpClient) {
+        sharedHttpClient = null;
+    }
+    if (!serverProcess) {
+        return;
+    }
+    console.log("Stopping MCP Gateway server...");
+    const proc = serverProcess;
+    serverProcess = null;
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            // Force kill if graceful shutdown takes too long
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                // Ignore - process may already be dead
+            }
+            resolve();
+        }, 5000);
+        proc.on("exit", () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        // On Windows, SIGTERM may not work; try SIGKILL directly
+        if (process.platform === "win32") {
+            try {
+                proc.kill();
+            }
+            catch {
+                // Ignore
+            }
+        }
+        else {
+            proc.kill("SIGTERM");
+        }
+    });
+}
+/**
+ * Synchronous stop for signal handlers (best-effort).
+ */
+function stopServer() {
+    if (sharedHttpClient) {
+        sharedHttpClient = null;
+    }
+    if (serverProcess) {
+        console.log("Stopping MCP Gateway server...");
+        try {
+            if (process.platform === "win32") {
+                serverProcess.kill();
+            }
+            else {
+                serverProcess.kill("SIGTERM");
+            }
+        }
+        catch {
+            // Ignore
+        }
+        serverProcess = null;
+    }
+}
+/**
+ * Execute the Phase 0 MCP QA workflow end-to-end against the gateway.
+ * Returns a structured result instead of throwing errors.
+ */
+async function runPhase0SmokeAsync() {
+    const summary = {};
+    let currentStep = "initialization";
+    // These must be accessible in finally block for cleanup
+    const config = loadConfigFromEnv();
+    const httpClient = getHttpClient(config);
+    try {
+        console.log("Starting Phase 0 smoke with config", {
+            baseUrl: config.mcpGatewayBaseUrl,
+            hasAuthorizationHeader: Boolean(config.authorizationHeader),
+            hasApiKeyHeader: Boolean(config.apiKeyHeader),
+            projectId: config.projectId,
+        });
+        currentStep = "session_initialization";
+        const seededSessionId = (0, node_crypto_1.randomUUID)();
+        const sessionId = await initializeSessionAsync({
+            httpClient: httpClient,
+            sessionId: seededSessionId,
+        });
+        if (sessionId) {
+            currentSessionId = sessionId;
+            httpClient.defaults.headers.common["Mcp-Session-Id"] = sessionId;
+            console.log("MCP session initialized", { sessionId: sessionId });
+        }
+        currentStep = "project_resolution";
+        const projectId = await resolveProjectIdAsync({ config: config, httpClient: httpClient });
+        summary.projectId = projectId;
+        // Fast path: check if project already has approved use cases with test cases
+        currentStep = "existing_data_check";
+        const existingData = await checkExistingTestDataAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+        });
+        if (existingData.hasTestData) {
+            console.log("Fast path: using existing test data", {
+                useCaseId: existingData.useCaseId,
+                testCaseId: existingData.testCaseId,
+            });
+            // Skip directly to report generation
+            currentStep = "report_generation";
+            await generateReportAsync({
+                httpClient: httpClient,
+                projectId: projectId,
+            });
+            // Project deletion handled by finally block
+            return {
+                success: true,
+                summary: summary,
+            };
+        }
+        currentStep = "prd_upload";
+        await maybeUploadPrdAsync({
+            config: config,
+            httpClient: httpClient,
+            projectId: projectId,
+        });
+        currentStep = "website_scan_start";
+        const websiteScanRuntimeId = await startWebsiteScanAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            websiteUrl: config.websiteUrl,
+            scanDescription: config.scanDescription,
+            archiveUnapproved: config.archiveUnapproved,
+        });
+        summary.websiteScanRuntimeId = websiteScanRuntimeId;
+        currentStep = "website_scan_wait";
+        await waitForWebsiteScanCompletionAsync({
+            httpClient: httpClient,
+            workflowRuntimeId: websiteScanRuntimeId,
+        });
+        currentStep = "use_case_discovery";
+        const discoveryMemory = await waitForUseCaseDiscoveryAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+        });
+        currentStep = "use_case_approval";
+        const approvedUseCaseIds = await approveUseCaseCandidatesAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            useCaseCandidates: discoveryMemory.useCaseCandidates,
+        });
+        currentStep = "use_case_resolution";
+        const primaryUseCaseId = await resolveUseCaseIdAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            preferredUseCaseIds: approvedUseCaseIds,
+        });
+        currentStep = "test_case_detection_start";
+        const testCaseDetectionRuntimeId = await startTestCaseDetectionAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            useCaseId: primaryUseCaseId,
+            url: config.websiteUrl,
+        });
+        summary.testCaseDetectionRuntimeId = testCaseDetectionRuntimeId;
+        console.log("Started test case detection workflow", {
+            workflowRuntimeId: testCaseDetectionRuntimeId,
+        });
+        currentStep = "test_case_detection_wait";
+        await waitForTestCaseDetectionCompletionAsync({
+            httpClient: httpClient,
+            workflowRuntimeId: testCaseDetectionRuntimeId,
+        });
+        currentStep = "test_case_resolution";
+        const testCaseId = await resolveTestCaseIdAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            useCaseId: primaryUseCaseId,
+        });
+        currentStep = "test_script_generation_start";
+        const scriptGenerationRuntimeId = await startTestScriptGenerationAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            testCaseId: testCaseId,
+            useCaseId: primaryUseCaseId,
+        });
+        summary.scriptGenerationRuntimeId = scriptGenerationRuntimeId;
+        console.log("Started test script generation workflow", {
+            workflowRuntimeId: scriptGenerationRuntimeId,
+        });
+        currentStep = "test_script_generation_wait";
+        await waitForTestScriptGenerationCompletionAsync({
+            httpClient: httpClient,
+            workflowRuntimeId: scriptGenerationRuntimeId,
+        });
+        currentStep = "test_script_resolution";
+        const testScriptId = await resolveTestScriptIdAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+        });
+        summary.testScriptId = testScriptId;
+        currentStep = "test_script_replay";
+        await startTestScriptReplayBulkAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+            testCaseIds: [testCaseId],
+        });
+        currentStep = "report_generation";
+        console.log("Generating final report...");
+        await generateReportAsync({
+            httpClient: httpClient,
+            projectId: projectId,
+        });
+        currentStep = "report_preferences";
+        if (config.reportChannels && config.reportChannels.length > 0) {
+            await upsertReportPreferencesAsync({
+                httpClient: httpClient,
+                projectId: projectId,
+                channels: config.reportChannels,
+                emails: config.reportEmails,
+                phones: config.reportPhones,
+                webhookUrl: config.reportWebhookUrl,
+            });
+        }
+        else {
+            console.log("Report delivery preferences skipped: no channels provided");
+        }
+        console.log("Phase 0 smoke workflow completed", {
+            projectId: projectId,
+            websiteScanRuntimeId: websiteScanRuntimeId,
+            testCaseDetectionRuntimeId: testCaseDetectionRuntimeId,
+            scriptGenerationRuntimeId: scriptGenerationRuntimeId,
+            testScriptId: testScriptId,
+        });
+        return {
+            success: true,
+            summary: summary,
+        };
+    }
+    catch (error) {
+        const errorMessage = extractErrorMessage(error);
+        console.error(`Smoke test failed at step [${currentStep}]: ${errorMessage}`);
+        return {
+            success: false,
+            error: errorMessage,
+            failedStep: currentStep,
+            summary: summary,
+        };
+    }
+    finally {
+        // Always clean up: delete the project regardless of success or failure
+        if (summary.projectId) {
+            try {
+                console.log("Cleaning up: deleting project...");
+                await deleteProjectAsync({
+                    httpClient: httpClient,
+                    projectId: summary.projectId,
+                });
+                console.log("Project deleted successfully");
+            }
+            catch (cleanupError) {
+                console.warn(`Failed to delete project ${summary.projectId}: ${extractErrorMessage(cleanupError)}`);
+            }
+        }
+    }
+}
+/**
+ * Extract a clean error message from an unknown error.
+ */
+function extractErrorMessage(error) {
+    if (error instanceof Error) {
+        // Handle axios errors with code property
+        const axiosError = error;
+        if (axiosError.code === "ECONNREFUSED") {
+            return "Cannot connect to MCP Gateway - server may not be running";
+        }
+        if (axiosError.code === "ENOTFOUND") {
+            return "Cannot resolve MCP Gateway host - check the URL";
+        }
+        if (axiosError.code === "ETIMEDOUT") {
+            return "Connection to MCP Gateway timed out";
+        }
+        return error.message || "Unknown error";
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "object" && error !== null) {
+        const errorObj = error;
+        if (errorObj.code === "ECONNREFUSED") {
+            return "Cannot connect to MCP Gateway - server may not be running";
+        }
+        return errorObj.message || errorObj.error || "Unknown error";
+    }
+    return "Unknown error";
+}
+/**
+ * Entry point when invoked directly.
+ */
+async function main() {
+    const baseUrl = process.env["MCP_GATEWAY_BASE_URL"] || "http://localhost:6000";
+    let serverStartedByUs = false;
+    // Async cleanup for normal exit paths (waits for process to terminate)
+    const cleanupAsync = async () => {
+        if (serverStartedByUs) {
+            await stopServerAsync();
+        }
+    };
+    // Sync cleanup for signal handlers (best-effort)
+    const cleanupSync = () => {
+        if (serverStartedByUs) {
+            stopServer();
+        }
+    };
+    process.on("SIGINT", () => {
+        console.log("\nReceived SIGINT, cleaning up...");
+        cleanupSync();
+        process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+        console.log("\nReceived SIGTERM, cleaning up...");
+        cleanupSync();
+        process.exit(143);
+    });
+    try {
+        // Always kill any existing process on the port first to avoid stale/zombie processes
+        const port = extractPort(baseUrl);
+        killProcessOnPort(port);
+        await sleepAsync(500);
+        // Check if server is already running (shouldn't be after killing, but just in case)
+        const isRunning = await checkServerHealthAsync(baseUrl);
+        if (!isRunning) {
+            await startServerAsync(baseUrl);
+            serverStartedByUs = true;
+        }
+        else {
+            console.log("MCP Gateway server is already running (external)");
+        }
+        const result = await runPhase0SmokeAsync();
+        if (result.success) {
+            console.log("\n========================================");
+            console.log("SMOKE TEST PASSED");
+            console.log("========================================");
+            if (result.summary) {
+                console.log("Summary:", JSON.stringify(result.summary, null, 2));
+            }
+            await cleanupAsync();
+            process.exit(0);
+        }
+        else {
+            console.log("\n========================================");
+            console.log("SMOKE TEST FAILED");
+            console.log("========================================");
+            console.log(`Step: ${result.failedStep}`);
+            console.log(`Error: ${result.error}`);
+            if (result.summary && Object.keys(result.summary).length > 0) {
+                console.log("Partial progress:", JSON.stringify(result.summary, null, 2));
+            }
+            await cleanupAsync();
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error("Unexpected error:", extractErrorMessage(error));
+        await cleanupAsync();
+        process.exit(1);
+    }
+}
+void main();
+/**
+ * Load and validate configuration from environment variables.
+ */
+function loadConfigFromEnv() {
+    const baseUrl = process.env["MCP_GATEWAY_BASE_URL"];
+    const authorizationHeader = process.env["MCP_GATEWAY_AUTH_TOKEN"];
+    const apiKeyHeader = process.env["MCP_GATEWAY_API_KEY"];
+    const projectId = process.env["MCP_QA_PROJECT_ID"];
+    const projectName = process.env["MCP_QA_PROJECT_NAME"];
+    const projectDescription = process.env["MCP_QA_PROJECT_DESCRIPTION"];
+    const websiteUrl = process.env["MCP_QA_WEBSITE_URL"];
+    const scanDescription = process.env["MCP_QA_SCAN_DESCRIPTION"];
+    const archiveUnapproved = process.env["MCP_QA_ARCHIVE_UNAPPROVED"] === "true";
+    const prdFilePath = process.env["MCP_QA_PRD_FILE_PATH"];
+    const prdContentType = process.env["MCP_QA_PRD_CONTENT_TYPE"];
+    const reportChannelsRaw = process.env["MCP_QA_REPORT_CHANNELS"];
+    const reportEmailsRaw = process.env["MCP_QA_REPORT_EMAILS"];
+    const reportPhonesRaw = process.env["MCP_QA_REPORT_PHONES"];
+    const reportWebhookUrl = process.env["MCP_QA_REPORT_WEBHOOK_URL"];
+    if (!baseUrl) {
+        throw new Error("Missing MCP_GATEWAY_BASE_URL");
+    }
+    if (!authorizationHeader && !apiKeyHeader) {
+        throw new Error("Missing credentials: set MCP_GATEWAY_AUTH_TOKEN or MCP_GATEWAY_API_KEY");
+    }
+    if (!websiteUrl) {
+        throw new Error("Missing MCP_QA_WEBSITE_URL");
+    }
+    if (!scanDescription) {
+        throw new Error("Missing MCP_QA_SCAN_DESCRIPTION");
+    }
+    if (!projectId) {
+        if (!projectName) {
+            throw new Error("Missing MCP_QA_PROJECT_NAME for project creation");
+        }
+        if (!projectDescription) {
+            throw new Error("Missing MCP_QA_PROJECT_DESCRIPTION for project creation");
+        }
+    }
+    const reportChannels = reportChannelsRaw
+        ? reportChannelsRaw
+            .split(",")
+            .map((channel) => channel.trim())
+            .filter((channel) => channel.length > 0)
+        : undefined;
+    const reportEmails = reportEmailsRaw
+        ? reportEmailsRaw
+            .split(",")
+            .map((email) => email.trim())
+            .filter((email) => email.length > 0)
+        : undefined;
+    const reportPhones = reportPhonesRaw
+        ? reportPhonesRaw
+            .split(",")
+            .map((phone) => phone.trim())
+            .filter((phone) => phone.length > 0)
+        : undefined;
+    return {
+        mcpGatewayBaseUrl: baseUrl,
+        authorizationHeader: authorizationHeader,
+        apiKeyHeader: apiKeyHeader,
+        projectId: projectId,
+        projectName: projectName,
+        projectDescription: projectDescription,
+        scanDescription: scanDescription,
+        websiteUrl: websiteUrl,
+        archiveUnapproved: archiveUnapproved,
+        prdFilePath: prdFilePath,
+        prdContentType: prdContentType,
+        reportChannels: reportChannels,
+        reportEmails: reportEmails,
+        reportPhones: reportPhones,
+        reportWebhookUrl: reportWebhookUrl,
+    };
+}
+/**
+ * Get or create a shared Axios instance configured for the gateway.
+ */
+function getHttpClient(config) {
+    if (sharedHttpClient) {
+        return sharedHttpClient;
+    }
+    sharedHttpClient = axios_1.default.create({
+        baseURL: config.mcpGatewayBaseUrl,
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            Authorization: config.authorizationHeader,
+            "x-api-key": config.apiKeyHeader,
+        },
+        validateStatus: () => true,
+    });
+    return sharedHttpClient;
+}
+/**
+ * Initialize MCP session to obtain a session id for subsequent tool calls.
+ * Retries on connection errors (e.g. ECONNRESET on 2nd run when server was just started).
+ */
+async function initializeSessionAsync(params) {
+    const payload = {
+        jsonrpc: JSON_RPC_VERSION,
+        id: (0, node_crypto_1.randomUUID)(),
+        method: "initialize",
+        params: {
+            clientInfo: { name: CLIENT_NAME, version: CLIENT_VERSION },
+            capabilities: { tools: {} },
+            protocolVersion: "2024-12-17",
+        },
+    };
+    const requestConfig = {
+        headers: {
+            "Mcp-Session-Id": params.sessionId,
+        },
+    };
+    let lastError;
+    for (let attempt = 1; attempt <= SESSION_INIT_RETRY_ATTEMPTS; attempt++) {
+        try {
+            const response = await params.httpClient.post(TOOL_ENDPOINT_PATH, payload, requestConfig);
+            if (response.data.error) {
+                const errorData = response.data.error;
+                throw new Error(`MCP initialize error: code=${errorData.code} message=${errorData.message} data=${JSON.stringify(errorData.data)}`);
+            }
+            const sessionIdHeader = response.headers["mcp-session-id"] ||
+                response.headers["Mcp-Session-Id"] ||
+                response.data.result
+                    ?.sessionId;
+            if (!sessionIdHeader) {
+                console.warn("MCP initialize succeeded but no session id returned; proceeding without session pinning");
+            }
+            return sessionIdHeader;
+        }
+        catch (err) {
+            lastError = err;
+            const code = err.code;
+            const isConnectionError = code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT";
+            if (isConnectionError && attempt < SESSION_INIT_RETRY_ATTEMPTS) {
+                console.warn(`Session init attempt ${attempt}/${SESSION_INIT_RETRY_ATTEMPTS} failed (${code}), retrying in ${SESSION_INIT_RETRY_DELAY_MS}ms...`);
+                await sleepAsync(SESSION_INIT_RETRY_DELAY_MS);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Resolve the project id either by reusing an existing id or creating a new project.
+ */
+async function resolveProjectIdAsync(params) {
+    if (params.config.projectId) {
+        console.log("Using provided project id", { projectId: params.config.projectId });
+        await verifyProjectAsync({
+            httpClient: params.httpClient,
+            projectId: params.config.projectId,
+        });
+        return params.config.projectId;
+    }
+    console.log("Creating project", {
+        projectName: params.config.projectName,
+        websiteUrl: params.config.websiteUrl,
+    });
+    const createResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.projectCreate,
+            arguments: {
+                projectName: params.config.projectName,
+                description: params.config.projectDescription,
+                url: params.config.websiteUrl,
+            },
+        },
+    });
+    // Handle string response (may be JSON encoded)
+    const parsedResult = parseToolResult(createResult);
+    // Check if this is an error response (duplicate project)
+    const errorResponse = parsedResult;
+    if (errorResponse.error === "INVALID_ARGUMENT" &&
+        errorResponse.message?.includes("already exists")) {
+        console.log("Project already exists, looking up existing project...");
+        return await findProjectByNameAsync({
+            httpClient: params.httpClient,
+            projectName: params.config.projectName,
+        });
+    }
+    const projectId = parsedResult.id;
+    if (!projectId) {
+        throw new Error("Project creation failed: no project ID returned");
+    }
+    console.log("Created project", { projectId: projectId });
+    return projectId;
+}
+/**
+ * Parse tool result, handling string-encoded JSON responses.
+ */
+function parseToolResult(result) {
+    if (typeof result === "string") {
+        try {
+            return JSON.parse(result);
+        }
+        catch {
+            return result;
+        }
+    }
+    return result;
+}
+/**
+ * Delete a project by ID.
+ */
+async function deleteProjectAsync(params) {
+    console.log("Deleting smoke test project...", { projectId: params.projectId });
+    const rawResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.projectDelete,
+            arguments: {
+                projectId: params.projectId,
+            },
+        },
+    });
+    const result = parseToolResult(rawResult);
+    if (result.error) {
+        console.warn(`Project deletion returned error: ${result.error} - ${result.message || ""}`);
+        return;
+    }
+    console.log("Smoke test project deleted successfully", { projectId: params.projectId });
+}
+/**
+ * Find an existing project by name.
+ */
+async function findProjectByNameAsync(params) {
+    const projects = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.projectList,
+            arguments: {
+                page: 1,
+                pageSize: 100,
+            },
+        },
+    });
+    const parsedProjects = parseToolResult(projects);
+    const projectList = Array.isArray(parsedProjects) ? parsedProjects : [];
+    const matchingProject = projectList.find((p) => p.name === params.projectName);
+    if (!matchingProject?.id) {
+        throw new Error(`Could not find existing project with name: ${params.projectName}`);
+    }
+    console.log("Found existing project", {
+        projectId: matchingProject.id,
+        name: matchingProject.name,
+    });
+    return matchingProject.id;
+}
+/**
+ * Verify the provided project exists.
+ */
+async function verifyProjectAsync(params) {
+    const project = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.projectGet,
+            arguments: {
+                projectId: params.projectId,
+            },
+        },
+    });
+    console.log("Verified project", {
+        projectId: project.id,
+        projectName: project.projectName,
+    });
+}
+/**
+ * Upload a PRD file if configured, then start processing and wait for completion.
+ * Skips processing if use case candidates already exist from a previous run.
+ */
+async function maybeUploadPrdAsync(params) {
+    if (!params.config.prdFilePath) {
+        console.log("Skipping PRD upload: MCP_QA_PRD_FILE_PATH not set");
+        return;
+    }
+    // Check if use case candidates already exist from a previous run
+    console.log("Checking for existing use case candidates...");
+    const existingDiscovery = await checkExistingUseCaseCandidatesAsync({
+        httpClient: params.httpClient,
+        projectId: params.projectId,
+    });
+    if (existingDiscovery && existingDiscovery.useCaseCandidates.length > 0) {
+        console.log("Skipping PRD processing: use case candidates already exist", {
+            candidateCount: existingDiscovery.useCaseCandidates.length,
+        });
+        return;
+    }
+    const absolutePath = node_path_1.default.resolve(params.config.prdFilePath);
+    if (!node_fs_1.default.existsSync(absolutePath)) {
+        throw new Error(`PRD file not found at ${absolutePath}`);
+    }
+    const content = node_fs_1.default.readFileSync(absolutePath);
+    const base64Content = content.toString("base64");
+    const fileName = node_path_1.default.basename(absolutePath);
+    console.log("Uploading PRD file...", { fileName: fileName });
+    const uploadResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.prdUpload,
+            arguments: {
+                projectId: params.projectId,
+                fileName: fileName,
+                contentBase64: base64Content,
+                contentType: params.config.prdContentType,
+            },
+        },
+    });
+    // Parse upload result to get prdFilePath, contentChecksum, and fileSize
+    const parsedUploadResult = parseToolResult(uploadResult);
+    console.log("PRD file uploaded", parsedUploadResult);
+    if (!parsedUploadResult.prdFilePath) {
+        console.warn("PRD upload did not return prdFilePath; skipping processing");
+        return;
+    }
+    if (!parsedUploadResult.contentChecksum || !parsedUploadResult.fileSize) {
+        console.warn("PRD upload did not return contentChecksum or fileSize; skipping processing");
+        return;
+    }
+    // Start PRD processing workflow
+    console.log("Starting PRD file processing workflow...");
+    const rawProcessResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.prdProcessStart,
+            arguments: {
+                projectId: params.projectId,
+                name: `PRD-Process-${Date.now()}`,
+                description: `PRD file processing for ${fileName}`,
+                prdFilePath: parsedUploadResult.prdFilePath,
+                originalFileName: fileName,
+                url: params.config.websiteUrl,
+                contentChecksum: parsedUploadResult.contentChecksum,
+                fileSize: parsedUploadResult.fileSize,
+            },
+        },
+    });
+    const processResult = parseToolResult(rawProcessResult);
+    // Check for error response
+    if (processResult.error) {
+        console.warn(`PRD processing returned error: ${processResult.error}`);
+        console.warn(`PRD error details: ${processResult.message || ""}`);
+        if (processResult.details) {
+            console.warn(`PRD error full details:`, JSON.stringify(processResult.details, null, 2));
+        }
+        return;
+    }
+    // Extract workflow runtime ID - may be at top level or nested in workflowRuntime object
+    const workflowRuntimeId = processResult.workflowRuntimeId || processResult.id || processResult.workflowRuntime?.id;
+    if (!workflowRuntimeId) {
+        console.warn("PRD processing did not return a workflow runtime id; skipping wait");
+        console.log("PRD process response:", JSON.stringify(processResult, null, 2));
+        return;
+    }
+    console.log("PRD processing workflow started", { workflowRuntimeId: workflowRuntimeId });
+    // Poll for PRD processing completion
+    await waitForPrdProcessingCompletionAsync({
+        httpClient: params.httpClient,
+        workflowRuntimeId: workflowRuntimeId,
+    });
+}
+/**
+ * Wait for PRD processing workflow to complete.
+ */
+async function waitForPrdProcessingCompletionAsync(params) {
+    let lastProgress = -1;
+    for (let attempt = 1; attempt <= PRD_PROCESS_MAX_POLL_ATTEMPTS; attempt++) {
+        const rawStatus = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.prdProcessLatestRun,
+                arguments: {
+                    workflowRuntimeId: params.workflowRuntimeId,
+                },
+            },
+        });
+        const runStatus = parseToolResult(rawStatus);
+        const status = runStatus?.status;
+        const progress = runStatus?.progress ?? 0;
+        // Print progress if changed
+        if (progress !== lastProgress) {
+            console.log(`PRD processing progress: ${progress}% (status: ${status})`);
+            lastProgress = progress;
+        }
+        if (status && TERMINAL_STATUSES.includes(status)) {
+            if (status === "COMPLETED") {
+                console.log("PRD processing completed successfully");
+                return;
+            }
+            else {
+                const errorDetail = runStatus.error || "unknown reason";
+                throw new Error(`PRD processing failed: ${errorDetail}`);
+            }
+        }
+        await sleepAsync(PRD_PROCESS_POLL_INTERVAL_MS);
+    }
+    throw new Error("PRD processing timed out - workflow did not complete in time");
+}
+/**
+ * Start website scan workflow.
+ */
+async function startWebsiteScanAsync(params) {
+    const startResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.workflowStartWebsiteScan,
+            arguments: {
+                projectId: params.projectId,
+                url: params.websiteUrl,
+                description: params.scanDescription,
+                archiveUnapproved: params.archiveUnapproved,
+            },
+        },
+    });
+    const workflowRuntimeId = startResult.id ||
+        startResult.workflowRuntimeId;
+    if (!workflowRuntimeId) {
+        throw new Error("Website scan start returned no workflow runtime id");
+    }
+    console.log("Started website scan", {
+        workflowRuntimeId: workflowRuntimeId,
+    });
+    return workflowRuntimeId;
+}
+/**
+ * Wait for website scan workflow to complete (or fail).
+ * Prints progress updates and throws on failure.
+ */
+async function waitForWebsiteScanCompletionAsync(params) {
+    let lastProgress = -1;
+    let lastStatus = "";
+    for (let attempt = 1; attempt <= WEBSITE_SCAN_MAX_POLL_ATTEMPTS; attempt++) {
+        const rawStatus = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.workflowGetWebsiteScanLatestRun,
+                arguments: {
+                    workflowRuntimeId: params.workflowRuntimeId,
+                },
+            },
+        });
+        const runStatus = parseToolResult(rawStatus);
+        if (!runStatus || typeof runStatus !== "object" || !runStatus.status) {
+            console.log(`Waiting for website scan run to start (attempt ${attempt}/${WEBSITE_SCAN_MAX_POLL_ATTEMPTS})`);
+            await sleepAsync(WEBSITE_SCAN_POLL_INTERVAL_MS);
+            continue;
+        }
+        const status = runStatus.status || "UNKNOWN";
+        const progress = runStatus.progress ?? 0;
+        // Print progress if changed
+        if (progress !== lastProgress || status !== lastStatus) {
+            console.log(`Website scan progress: ${progress}% (status: ${status})`);
+            lastProgress = progress;
+            lastStatus = status;
+        }
+        if (TERMINAL_STATUSES.includes(status)) {
+            if (status === "COMPLETED") {
+                console.log("Website scan completed successfully", {
+                    runId: runStatus.id,
+                });
+                return;
+            }
+            else {
+                const errorDetail = runStatus.error || runStatus.errorMessage || "unknown reason";
+                throw new Error(`Website scan failed: ${errorDetail}`);
+            }
+        }
+        await sleepAsync(WEBSITE_SCAN_POLL_INTERVAL_MS);
+    }
+    throw new Error("Website scan timed out - workflow did not complete in time");
+}
+/**
+ * Wait for test case detection workflow to complete.
+ * Polls the latest run status and prints progress updates.
+ */
+async function waitForTestCaseDetectionCompletionAsync(params) {
+    let lastProgress = -1;
+    for (let attempt = 1; attempt <= TEST_CASE_DETECTION_MAX_POLL_ATTEMPTS; attempt++) {
+        const rawStatus = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.workflowGetTestCaseDetectionLatestRun,
+                arguments: {
+                    workflowRuntimeId: params.workflowRuntimeId,
+                },
+            },
+        });
+        const runStatus = parseToolResult(rawStatus);
+        const status = runStatus?.status;
+        const progress = runStatus?.progress ?? 0;
+        // Print progress if changed
+        if (progress !== lastProgress) {
+            console.log(`Test case detection progress: ${progress}% (status: ${status})`);
+            lastProgress = progress;
+        }
+        if (status && TERMINAL_STATUSES.includes(status)) {
+            if (status === "COMPLETED") {
+                console.log("Test case detection completed successfully");
+                return;
+            }
+            else {
+                const errorDetail = runStatus?.error || "unknown reason";
+                throw new Error(`Test case detection failed: ${errorDetail}`);
+            }
+        }
+        await sleepAsync(TEST_CASE_DETECTION_POLL_INTERVAL_MS);
+    }
+    throw new Error("Test case detection timed out - workflow did not complete in time");
+}
+/**
+ * Wait for test script generation workflow to complete.
+ * Polls the latest run status and prints progress updates.
+ */
+async function waitForTestScriptGenerationCompletionAsync(params) {
+    let lastProgress = -1;
+    for (let attempt = 1; attempt <= TEST_SCRIPT_GENERATION_MAX_POLL_ATTEMPTS; attempt++) {
+        const rawStatus = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.workflowGetTestScriptGenerationLatestRun,
+                arguments: {
+                    workflowRuntimeId: params.workflowRuntimeId,
+                },
+            },
+        });
+        const runStatus = parseToolResult(rawStatus);
+        const status = runStatus?.status;
+        const progress = runStatus?.progress ?? 0;
+        // Print progress if changed
+        if (progress !== lastProgress) {
+            console.log(`Test script generation progress: ${progress}% (status: ${status})`);
+            lastProgress = progress;
+        }
+        if (status && TERMINAL_STATUSES.includes(status)) {
+            if (status === "COMPLETED") {
+                console.log("Test script generation completed successfully");
+                return;
+            }
+            else {
+                const errorDetail = runStatus?.error || "unknown reason";
+                throw new Error(`Test script generation failed: ${errorDetail}`);
+            }
+        }
+        await sleepAsync(TEST_SCRIPT_GENERATION_POLL_INTERVAL_MS);
+    }
+    throw new Error("Test script generation timed out - workflow did not complete in time");
+}
+/**
+ * Check if the project has existing approved use cases with test cases.
+ * Used for the "fast path" to skip workflow-heavy steps on re-runs.
+ */
+async function checkExistingTestDataAsync(params) {
+    try {
+        console.log("Checking for existing approved use cases...");
+        // List use cases for this project
+        const useCasesRaw = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.useCaseList,
+                arguments: {
+                    projectId: params.projectId,
+                },
+            },
+        });
+        const useCasesResult = parseToolResult(useCasesRaw);
+        const approvedUseCases = (useCasesResult.useCases || []).filter((uc) => uc.status === "approved" || uc.status === "APPROVED");
+        if (approvedUseCases.length === 0) {
+            console.log("No approved use cases found, proceeding with full workflow");
+            return { hasTestData: false };
+        }
+        console.log("Found approved use cases", { count: approvedUseCases.length });
+        // Check if any approved use case has test cases
+        for (const useCase of approvedUseCases) {
+            const testCasesRaw = await callToolAsync({
+                httpClient: params.httpClient,
+                request: {
+                    toolName: TOOL_NAMES.testCaseList,
+                    arguments: {
+                        projectId: params.projectId,
+                        useCaseId: useCase.id,
+                    },
+                },
+            });
+            const testCasesResult = parseToolResult(testCasesRaw);
+            const testCases = testCasesResult.testCases || [];
+            if (testCases.length > 0) {
+                console.log("Found existing test cases for use case", {
+                    useCaseId: useCase.id,
+                    testCaseCount: testCases.length,
+                });
+                return {
+                    hasTestData: true,
+                    useCaseId: useCase.id,
+                    testCaseId: testCases[0].id,
+                };
+            }
+        }
+        console.log("No test cases found for approved use cases, proceeding with full workflow");
+        return { hasTestData: false };
+    }
+    catch (error) {
+        console.log("Error checking existing test data, proceeding with full workflow:", extractErrorMessage(error));
+        return { hasTestData: false };
+    }
+}
+/**
+ * Check if use case candidates already exist from a previous run (non-blocking).
+ * Returns the discovery memory if candidates exist, undefined otherwise.
+ * Unwraps prompt-service response (memory + useCaseQuotaStatus) when present.
+ */
+async function checkExistingUseCaseCandidatesAsync(params) {
+    try {
+        const rawResult = await callToolAsync({
+            httpClient: params.httpClient,
+            request: {
+                toolName: TOOL_NAMES.useCaseDiscovery,
+                arguments: {
+                    projectId: params.projectId,
+                },
+            },
+        });
+        const parsed = parseToolResult(rawResult);
+        const memory = parsed.memory ?? parsed;
+        if (memory?.useCaseCandidates && memory.useCaseCandidates.length > 0) {
+            return memory;
+        }
+        return undefined;
+    }
+    catch {
+        // If the call fails, return undefined to proceed with PRD processing
+        console.log("Could not check for existing use case candidates, proceeding with PRD processing");
+        return undefined;
+    }
+}
+/**
+ * Fetch use case discovery memory.
+ * Unwraps prompt-service response (memory + useCaseQuotaStatus) and returns memory when it has candidates.
+ */
+async function waitForUseCaseDiscoveryAsync(params) {
+    const memory = await pollForValueWithOptionsAsync({
+        action: async () => {
+            const value = await callToolAsync({
+                httpClient: params.httpClient,
+                request: {
+                    toolName: TOOL_NAMES.useCaseDiscovery,
+                    arguments: {
+                        projectId: params.projectId,
+                    },
+                },
+            });
+            const raw = value;
+            const mem = raw.memory ?? value;
+            const candidates = mem?.useCaseCandidates;
+            if (candidates && candidates.length > 0) {
+                return mem;
+            }
+            return undefined;
+        },
+        description: "use case discovery memory",
+        intervalMs: DISCOVERY_MEMORY_POLL_INTERVAL_MS,
+        maxAttempts: DISCOVERY_MEMORY_MAX_POLL_ATTEMPTS,
+    });
+    console.log("Discovered use case candidates", {
+        candidateCount: memory.useCaseCandidates.length,
+    });
+    return memory;
+}
+/**
+ * Approve all eligible use case candidates.
+ */
+async function approveUseCaseCandidatesAsync(params) {
+    const allCandidateIds = params.useCaseCandidates
+        .filter((candidate) => candidate.status === "candidate" || candidate.status === "draft")
+        .map((candidate) => candidate.id);
+    if (allCandidateIds.length === 0) {
+        throw new Error("No approvable use case candidates found");
+    }
+    // Limit to MAX_USE_CASES_TO_APPROVE to stay within typical user quotas
+    const candidateIds = allCandidateIds.slice(0, MAX_USE_CASES_TO_APPROVE);
+    console.log("Approving use case candidates", {
+        candidateIds: candidateIds,
+        totalAvailable: allCandidateIds.length,
+        limitedTo: MAX_USE_CASES_TO_APPROVE,
+    });
+    const rawApproveResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.useCaseApprove,
+            arguments: {
+                projectId: params.projectId,
+                approvedCandidateIds: candidateIds,
+            },
+        },
+    });
+    const approveResult = parseToolResult(rawApproveResult);
+    // Check for error response - handle quota exceeded gracefully
+    if (approveResult.error) {
+        const isQuotaExceeded = approveResult.message?.includes("limit exceeded") ||
+            approveResult.message?.includes("Remaining approvals: 0");
+        if (isQuotaExceeded) {
+            console.warn(`Use case approval quota exhausted: ${approveResult.message}. Will use existing approved use cases.`);
+            return [];
+        }
+        const errorDetail = approveResult.message || approveResult.error || "unknown reason";
+        throw new Error(`Use case approval failed: ${errorDetail}`);
+    }
+    let approvedUseCaseIds = (approveResult.approved || [])
+        .map((useCase) => useCase.id)
+        .filter(Boolean);
+    if (approvedUseCaseIds.length === 0) {
+        const memory = approveResult.memory;
+        const requestedSet = new Set(candidateIds);
+        const graduated = (memory?.useCaseCandidates ?? []).filter((c) => (c.status === "graduated" || c.status === "GRADUATED") && requestedSet.has(c.id));
+        approvedUseCaseIds = graduated
+            .map((c) => c.useCase?.id ?? c.useCaseId)
+            .filter(Boolean);
+    }
+    if (approvedUseCaseIds.length === 0) {
+        const quotaRemaining = approveResult.quotaInfo?.remaining;
+        if (typeof quotaRemaining === "number" && quotaRemaining <= 0) {
+            console.warn("Use case approval quota exhausted (remaining=0). Will use existing approved use cases.");
+            return [];
+        }
+        const keys = typeof approveResult === "object" && approveResult !== null
+            ? Object.keys(approveResult)
+            : [];
+        throw new Error(`Use case approval failed: no use cases were approved. ` +
+            `Response keys: ${keys.join(", ") || "none"}. ` +
+            `Set MCP_SMOKE_DEBUG_RAW_RESPONSES=true to log full response.`);
+    }
+    console.log(`Approved ${approvedUseCaseIds.length} use case(s)`);
+    return approvedUseCaseIds;
+}
+/**
+ * Resolve a use case id, preferring newly approved ids.
+ */
+async function resolveUseCaseIdAsync(params) {
+    if (params.preferredUseCaseIds && params.preferredUseCaseIds.length > 0) {
+        return params.preferredUseCaseIds[0];
+    }
+    const useCases = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.useCaseList,
+            arguments: {
+                projectId: params.projectId,
+                page: 1,
+                pageSize: 20,
+            },
+        },
+    });
+    const firstUseCaseId = useCases && useCases.length > 0 ? useCases[0].id : undefined;
+    if (!firstUseCaseId) {
+        throw new Error("No use cases available for test case detection");
+    }
+    return firstUseCaseId;
+}
+/**
+ * Start test case detection workflow.
+ */
+async function startTestCaseDetectionAsync(params) {
+    const startResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.workflowStartTestCaseDetection,
+            arguments: {
+                projectId: params.projectId,
+                useCaseId: params.useCaseId,
+                name: "phase0-smoke-test-case-detection",
+                description: "Generate test cases from approved use cases",
+                url: params.url,
+            },
+        },
+    });
+    const workflowRuntimeId = startResult.id ||
+        startResult.workflowRuntimeId;
+    if (!workflowRuntimeId) {
+        throw new Error("Test case detection start returned no workflow runtime id");
+    }
+    return workflowRuntimeId;
+}
+/**
+ * Resolve a test case id by polling the list endpoint.
+ */
+async function resolveTestCaseIdAsync(params) {
+    const testCaseId = await pollForValueAsync({
+        action: async () => {
+            const listResponse = await callToolAsync({
+                httpClient: params.httpClient,
+                request: {
+                    toolName: TOOL_NAMES.testCaseList,
+                    arguments: {
+                        projectId: params.projectId,
+                        page: 1,
+                        pageSize: 20,
+                    },
+                },
+            });
+            const match = (listResponse || []).find((entry) => entry.useCaseId === params.useCaseId);
+            return match ? match.id : undefined;
+        },
+        description: "test case list",
+    });
+    if (!testCaseId) {
+        throw new Error("No test case found after polling");
+    }
+    console.log("Resolved test case", { testCaseId: testCaseId });
+    return testCaseId;
+}
+/**
+ * Start test script generation workflow.
+ */
+async function startTestScriptGenerationAsync(params) {
+    const testCase = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.testCaseGet,
+            arguments: {
+                testCaseId: params.testCaseId,
+            },
+        },
+    });
+    const url = testCase.url;
+    const goal = testCase.goal;
+    const precondition = testCase.precondition;
+    const instructions = testCase.description;
+    const expectedResult = testCase.expectedResult;
+    if (!url || !goal || !precondition || !instructions || !expectedResult) {
+        throw new Error(`Missing required test case fields for script generation. testCaseId=${params.testCaseId} ` +
+            `url=${Boolean(url)} goal=${Boolean(goal)} precondition=${Boolean(precondition)} ` +
+            `description=${Boolean(instructions)} expectedResult=${Boolean(expectedResult)}`);
+    }
+    const startResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.workflowStartTestScriptGeneration,
+            arguments: {
+                projectId: params.projectId,
+                testCaseId: params.testCaseId,
+                useCaseId: params.useCaseId,
+                name: "phase0-smoke-script-generation",
+                url: url,
+                goal: goal,
+                precondition: precondition,
+                instructions: instructions,
+                expectedResult: expectedResult,
+            },
+        },
+    });
+    const workflowRuntimeId = startResult.id ||
+        startResult.workflowRuntimeId;
+    if (!workflowRuntimeId) {
+        throw new Error("Test script generation start returned no workflow runtime id");
+    }
+    return workflowRuntimeId;
+}
+/**
+ * Resolve a test script id by polling the list endpoint.
+ */
+async function resolveTestScriptIdAsync(params) {
+    const testScriptId = await pollForValueAsync({
+        action: async () => {
+            const listResponse = await callToolAsync({
+                httpClient: params.httpClient,
+                request: {
+                    toolName: TOOL_NAMES.testScriptList,
+                    arguments: {
+                        projectId: params.projectId,
+                        page: 1,
+                        pageSize: 20,
+                    },
+                },
+            });
+            const firstScript = listResponse && listResponse.length > 0 ? listResponse[0] : undefined;
+            return firstScript ? firstScript.id : undefined;
+        },
+        description: "test script list",
+    });
+    if (!testScriptId) {
+        throw new Error("No test script found after polling");
+    }
+    console.log("Resolved test script", { testScriptId: testScriptId });
+    return testScriptId;
+}
+/**
+ * Start bulk test script replay for the provided scripts.
+ */
+async function startTestScriptReplayBulkAsync(params) {
+    await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.workflowStartTestScriptReplayBulk,
+            arguments: {
+                projectId: params.projectId,
+                name: "phase0-smoke-replay",
+                intervalSec: -1,
+                testCaseIds: params.testCaseIds,
+            },
+        },
+    });
+    console.log("Started test script replay bulk", { testCaseIds: params.testCaseIds });
+}
+/**
+ * Default export format for reports.
+ */
+const DEFAULT_REPORT_EXPORT_FORMAT = "pdf";
+/**
+ * Trigger final report generation.
+ */
+async function generateReportAsync(params) {
+    const exportFormat = params.exportFormat ?? DEFAULT_REPORT_EXPORT_FORMAT;
+    const reportResult = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.reportFinalGenerate,
+            arguments: {
+                projectId: params.projectId,
+                exportFormat: exportFormat,
+            },
+        },
+    });
+    const workflowRuntimeId = reportResult.workflowRuntimeId;
+    if (!workflowRuntimeId) {
+        throw new Error(`Report generation failed: no workflowRuntimeId returned. ` +
+            `Response: ${JSON.stringify(reportResult)}`);
+    }
+    console.log("Triggered report generation", {
+        workflowRuntimeId: workflowRuntimeId,
+        exportFormat: exportFormat,
+    });
+    return workflowRuntimeId;
+}
+/**
+ * Upsert report delivery preferences.
+ */
+async function upsertReportPreferencesAsync(params) {
+    const result = await callToolAsync({
+        httpClient: params.httpClient,
+        request: {
+            toolName: TOOL_NAMES.reportPreferencesUpsert,
+            arguments: {
+                projectId: params.projectId,
+                channels: params.channels,
+                emails: params.emails,
+                phones: params.phones,
+                webhookUrl: params.webhookUrl,
+            },
+        },
+    });
+    console.log("Updated report delivery preferences", {
+        projectId: result.projectId,
+        channels: result.channels,
+    });
+}
+/**
+ * Generic JSON-RPC MCP tool caller with error handling.
+ */
+async function callToolAsync(params) {
+    const rpcEnvelope = {
+        jsonrpc: JSON_RPC_VERSION,
+        id: (0, node_crypto_1.randomUUID)(),
+        method: "tools/call",
+        params: {
+            name: params.request.toolName,
+            arguments: params.request.arguments,
+        },
+    };
+    let response;
+    try {
+        response = await params.httpClient.post(TOOL_ENDPOINT_PATH, rpcEnvelope, currentSessionId
+            ? {
+                headers: {
+                    "Mcp-Session-Id": currentSessionId,
+                },
+            }
+            : undefined);
+    }
+    catch (error) {
+        const axiosError = error;
+        if (axiosError.code === "ECONNREFUSED") {
+            throw new Error(`MCP Gateway server is not running or stopped responding. ` +
+                `Please ensure the server is running on the configured URL. ` +
+                `Tool: ${params.request.toolName}`);
+        }
+        throw error;
+    }
+    if (DEBUG_RAW_RESPONSES) {
+        console.log("tool response raw", params.request.toolName, JSON.stringify(response.data));
+    }
+    response = {
+        ...response,
+        data: normalizeStreamableHttpResponse(response.data),
+    };
+    // If server reports not initialized, try to re-init once and retry.
+    if (response.status === 400 &&
+        typeof response.data === "object" &&
+        response.data &&
+        response.data.error?.message?.includes("Server not initialized")) {
+        const newSessionId = (0, node_crypto_1.randomUUID)();
+        const initializedSession = await initializeSessionAsync({
+            httpClient: params.httpClient,
+            sessionId: newSessionId,
+        });
+        if (initializedSession) {
+            currentSessionId = initializedSession;
+        }
+        response = await params.httpClient.post(TOOL_ENDPOINT_PATH, rpcEnvelope, currentSessionId
+            ? {
+                headers: {
+                    "Mcp-Session-Id": currentSessionId,
+                },
+            }
+            : undefined);
+        response = {
+            ...response,
+            data: normalizeStreamableHttpResponse(response.data),
+        };
+    }
+    if (response.status >= 400) {
+        throw new Error(`HTTP error from gateway: status=${response.status} body=${JSON.stringify(response.data)}`);
+    }
+    const data = response.data;
+    if (data.error) {
+        const errorData = data.error;
+        throw new Error(`MCP tool error: name=${params.request.toolName} code=${errorData.code} message=${errorData.message}`);
+    }
+    const success = data;
+    const contentArray = success.result
+        ?.content || success.content;
+    if (contentArray && Array.isArray(contentArray) && contentArray.length > 0) {
+        const first = contentArray[0];
+        if (first.type === "text" && typeof first.text === "string") {
+            try {
+                const parsed = JSON.parse(first.text);
+                if (success.isError || parsed.error) {
+                    throw new Error(`MCP tool error: name=${params.request.toolName} message=${parsed.message || first.text}`);
+                }
+                return parsed;
+            }
+            catch {
+                // fallback to raw text
+                return first.text;
+            }
+        }
+    }
+    return success.result;
+}
+function normalizeStreamableHttpResponse(data) {
+    if (typeof data !== "string") {
+        return data;
+    }
+    const lines = data.split("\n");
+    const dataLine = lines.find((line) => line.startsWith("data: "));
+    if (!dataLine) {
+        return data;
+    }
+    const jsonText = dataLine.replace(/^data:\s*/, "").trim();
+    try {
+        return JSON.parse(jsonText);
+    }
+    catch {
+        return data;
+    }
+}
+/**
+ * Poll until a value is returned or attempts are exhausted.
+ */
+async function pollForValueAsync(params) {
+    for (let attempt = 1; attempt <= MAX_POLL_ATTEMPTS; attempt++) {
+        const value = await params.action();
+        if (value) {
+            return value;
+        }
+        console.log(`Waiting for ${params.description} (attempt ${attempt}/${MAX_POLL_ATTEMPTS})`);
+        await sleepAsync(POLL_INTERVAL_MS);
+    }
+    return undefined;
+}
+async function pollForValueWithOptionsAsync(params) {
+    for (let attempt = 1; attempt <= params.maxAttempts; attempt++) {
+        const value = await params.action();
+        if (value) {
+            return value;
+        }
+        console.log(`Waiting for ${params.description} (attempt ${attempt}/${params.maxAttempts})`);
+        await sleepAsync(params.intervalMs);
+    }
+    throw new Error(`Timed out waiting for ${params.description}`);
+}
+/**
+ * Sleep helper.
+ */
+function sleepAsync(durationMs) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, durationMs);
+    });
+}
+//# sourceMappingURL=phase0-smoke.js.map