@skyramp/mcp 0.0.61 → 0.0.62

package/build/resources/analysisResources.js

@@ -0,0 +1,248 @@
+import * as fs from "fs";
+import { ResourceTemplate, } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StateManager, getSessionFilePath, getRegisteredSessions, hasSessionData, getSessionData, normalizeRecommendationState, } from "../utils/AnalysisStateManager.js";
+import { logger } from "../utils/logger.js";
+export const ANALYSIS_URI_PREFIX = "skyramp://analysis";
+/**
+ * Register MCP Resources for analysis data access.
+ *
+ * Resources provide read-only, token-efficient access to analysis data
+ * via sessionId. The state file is an internal backing store.
+ *
+ * URI scheme:
+ *   skyramp://analysis/{sessionId}/summary
+ *   skyramp://analysis/{sessionId}/endpoints
+ *   skyramp://analysis/{sessionId}/endpoints/{+path}
+ *   skyramp://analysis/{sessionId}/endpoints/{+path}/{method}
+ *   skyramp://analysis/{sessionId}/scenarios
+ *   skyramp://analysis/{sessionId}/diff
+ */
+export function registerAnalysisResources(server) {
+    logger.info("Registering analysis resources");
+    async function loadAnalysis(sessionId) {
+        // Try process memory first (new flow — no state file needed)
+        if (hasSessionData(sessionId)) {
+            const memData = getSessionData(sessionId);
+            if (memData?.analysis) {
+                logger.debug("Loaded analysis from process memory for resource", { sessionId });
+                return memData;
+            }
+        }
+        // Fall back to state file for backward compatibility
+        const registeredPath = getSessionFilePath(sessionId);
+        const mgr = registeredPath
+            ? StateManager.fromStatePath(registeredPath)
+            : StateManager.fromSessionId(sessionId);
+        if (!mgr.exists()) {
+            throw new Error(`Analysis session "${sessionId}" not found or expired.`);
+        }
+        const data = await mgr.readData();
+        if (!data) {
+            throw new Error(`Analysis session "${sessionId}" has no data.`);
+        }
+        const normalized = normalizeRecommendationState(data);
+        if (!normalized.analysis) {
+            throw new Error(`Analysis session "${sessionId}" has no analysis data.`);
+        }
+        return normalized;
+    }
+    /**
+     * Shared list callback: returns resource URIs for sessions created by
+     * this process only (via the in-memory registry). No filesystem scan —
+     * eliminates cross-process leakage when multiple clients share /tmp.
+     */
+    function makeListCallback(suffix) {
+        return async () => {
+            const sessions = getRegisteredSessions();
+            const available = Array.from(sessions.entries()).filter(([sessionId, filePath]) => hasSessionData(sessionId) || fs.existsSync(filePath));
+            return {
+                resources: available.map(([sessionId]) => ({
+                    uri: `${ANALYSIS_URI_PREFIX}/${sessionId}/${suffix}`,
+                    name: `Analysis ${suffix} (${sessionId})`,
+                    mimeType: "application/json",
+                })),
+            };
+        };
+    }
+    // ── Summary ──
+    server.registerResource("analysis_summary", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/summary`, {
+        list: makeListCallback("summary"),
+    }), {
+        title: "Analysis Summary",
+        description: "High-level overview: project type, tech stack, endpoint/scenario counts, coverage gaps.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis, repositoryPath, analysisScope } = await loadAnalysis(sessionId);
+        const summary = {
+            sessionId,
+            repositoryPath,
+            analysisScope: analysisScope || "full_repo",
+            metadata: analysis.metadata,
+            projectClassification: analysis.projectClassification,
+            technologyStack: {
+                languages: analysis.technologyStack.languages,
+                frameworks: analysis.technologyStack.frameworks,
+                runtime: analysis.technologyStack.runtime,
+            },
+            authentication: analysis.authentication,
+            infrastructure: analysis.infrastructure,
+            endpointStats: {
+                totalPaths: analysis.apiEndpoints.endpoints.length,
+                totalMethods: analysis.apiEndpoints.endpoints.reduce((sum, ep) => sum + ep.methods.length, 0),
+                totalInteractions: analysis.apiEndpoints.endpoints.reduce((sum, ep) => sum +
+                    ep.methods.reduce((msum, m) => msum + m.interactions.length, 0), 0),
+                baseUrl: analysis.apiEndpoints.baseUrl,
+            },
+            scenarioCount: analysis.businessContext.draftedScenarios.length,
+            existingTests: analysis.existingTests,
+        };
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(summary, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Endpoints (compact listing) ──
+    server.registerResource("analysis_endpoints", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/endpoints`, {
+        list: makeListCallback("endpoints"),
+    }), {
+        title: "Endpoint Listing",
+        description: "Compact listing of all endpoints (path, methods, interaction counts). Use path-specific resources for full detail.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        const compact = analysis.apiEndpoints.endpoints.map((ep) => ({
+            path: ep.path,
+            resourceGroup: ep.resourceGroup,
+            pathParams: ep.pathParams.map((p) => p.name),
+            methods: ep.methods.map((m) => ({
+                method: m.method,
+                authRequired: m.authRequired,
+                interactionCount: m.interactions.length,
+                interactionTypes: m.interactions.map((i) => i.type),
+                hasCookies: m.interactions.some((i) => (i.response.cookies?.length ?? 0) > 0),
+                hasResponseHeaders: m.interactions.some((i) => Object.keys(i.response.headers ?? {}).length > 0),
+                createsResource: m.createsResource,
+            })),
+        }));
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ baseUrl: analysis.apiEndpoints.baseUrl, endpoints: compact }, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Single Path Detail ──
+    // No list callback — these are parameterized drilldowns, not top-level resources.
+    server.registerResource("analysis_endpoint_path", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/endpoints/{+path}`, { list: undefined }), {
+        title: "Endpoint Path Detail",
+        description: "Full detail for a specific path: all methods, interactions, params.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const endpointPath = "/" + params.path;
+        const { analysis } = await loadAnalysis(sessionId);
+        const ep = analysis.apiEndpoints.endpoints.find((e) => e.path === endpointPath);
+        if (!ep) {
+            throw new Error(`Endpoint path "${endpointPath}" not found in session "${sessionId}".`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(ep, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Single Method Detail ──
+    server.registerResource("analysis_endpoint_method", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/endpoints/{+path}/{method}`, { list: undefined }), {
+        title: "Endpoint Method Detail",
+        description: "Full detail for a specific method on a path: interactions, params, auth.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const endpointPath = "/" + params.path;
+        const method = params.method.toUpperCase();
+        const { analysis } = await loadAnalysis(sessionId);
+        const ep = analysis.apiEndpoints.endpoints.find((e) => e.path === endpointPath);
+        if (!ep) {
+            throw new Error(`Endpoint path "${endpointPath}" not found in session "${sessionId}".`);
+        }
+        const m = ep.methods.find((em) => em.method.toUpperCase() === method);
+        if (!m) {
+            throw new Error(`Method "${method}" not found on "${endpointPath}" in session "${sessionId}".`);
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ path: ep.path, resourceGroup: ep.resourceGroup, pathParams: ep.pathParams, ...m }, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Scenarios ──
+    server.registerResource("analysis_scenarios", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/scenarios`, {
+        list: makeListCallback("scenarios"),
+    }), {
+        title: "Drafted Scenarios",
+        description: "All drafted user-flow scenarios with steps, chaining, and priority.",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(analysis.businessContext.draftedScenarios, null, 2),
+                },
+            ],
+        };
+    });
+    // ── Branch Diff ──
+    server.registerResource("analysis_diff", new ResourceTemplate(`${ANALYSIS_URI_PREFIX}/{sessionId}/diff`, {
+        list: makeListCallback("diff"),
+    }), {
+        title: "Branch Diff Context",
+        description: "Branch diff context with new/modified endpoints (only present for current_branch_diff scope).",
+        mimeType: "application/json",
+    }, async (uri, params) => {
+        const sessionId = params.sessionId;
+        const { analysis } = await loadAnalysis(sessionId);
+        if (!analysis.branchDiffContext) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: "application/json",
+                        text: JSON.stringify({ message: "No branch diff context (analysis scope was full_repo)." }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text: JSON.stringify(analysis.branchDiffContext, null, 2),
+                },
+            ],
+        };
+    });
+    logger.info("Analysis resources registered successfully");
+}

package/build/services/ScenarioGenerationService.js

@@ -7,19 +7,6 @@ export class ScenarioGenerationService {
             logger.info("Parsing scenario into API requests", {
                 scenarioName: params.scenarioName,
             });
-            // Check if we have API schema to work with
-            if (!params.apiSchema) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Please provide an API schema so that I can parse the scenario and map it to specific API endpoints.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Generate a single trace request from the scenario
             const traceRequest = this.generateTraceRequestFromInput(params);
             if (!traceRequest) {
                 return {
@@ -32,14 +19,10 @@ export class ScenarioGenerationService {
                     isError: true,
                 };
             }
-            // Handle file writing
-            //add hyphen to the scenario name
-            //make file in tmp directory
             const scenarioName = params.scenarioName.replace(/ /g, "-").toLowerCase();
             const fileName = `scenario_${scenarioName}.json`;
             const filePath = path.join(params.outputDir, fileName);
             try {
-                // Check if file exists to determine if we should append or create new
                 let existingRequests = [];
                 if (fs.existsSync(filePath)) {
                     try {
@@ -49,14 +32,11 @@ export class ScenarioGenerationService {
                             existingRequests = [];
                         }
                     }
-                    catch (parseError) {
-                        // If file exists but can't be parsed, start fresh
+                    catch {
                         existingRequests = [];
                     }
                 }
-                // Add the new request to the array
                 existingRequests.push(traceRequest);
-                // Write the updated array to the file
                 fs.writeFileSync(filePath, JSON.stringify(existingRequests, null, 2), "utf8");
                 logger.info("Trace request added to file", {
                     filePath,
@@ -118,37 +98,55 @@ ${JSON.stringify(traceRequest, null, 2)}
         }
     }
     generateTraceRequestFromInput(params) {
-        const destination = params.destination;
-        // Use AI-provided parameters instead of parsing
+        let destination = params.destination;
+        let scheme = "https";
+        let port = 443;
+        if (params.baseURL) {
+            try {
+                const parsed = new URL(params.baseURL);
+                scheme = parsed.protocol.replace(":", "");
+                destination = parsed.hostname;
+                port = parsed.port
+                    ? parseInt(parsed.port, 10)
+                    : scheme === "https"
+                        ? 443
+                        : 80;
+            }
+            catch {
+                logger.warning("Could not parse baseURL, using destination param", {
+                    baseURL: params.baseURL,
+                });
+            }
+        }
         const timestamp = new Date().toISOString();
         const method = params.method;
-        const path = params.path;
-        const statusCode = params.statusCode ||
-            (method === "POST" ? 201 : method === "DELETE" ? 204 : 200);
+        const statusCode = params.statusCode ?? (method === "POST" ? 201 : method === "DELETE" ? 204 : 200);
         const requestBody = params.requestBody ||
             (method === "GET" || method === "DELETE" ? "" : "{}");
-        const responseBody = params.responseBody || (method === "DELETE" ? "" : "{}");
-        // Hardcode source IP and port for NLP consistency
-        const source = "192.168.65.1:39998";
+        const responseHeaders = params.responseHeaders
+            || { "Content-Type": ["application/json"] };
+        const isJsonResponse = (responseHeaders["Content-Type"] || [])
+            .some(v => v.includes("application/json"));
+        const responseBody = params.responseBody || (isJsonResponse ? "{}" : "");
+        const authHeaderName = params.authHeader || "Authorization";
+        const requestHeaders = {
+            "Content-Type": ["application/json"],
+            [authHeaderName]: [params.authToken ?? ""],
+        };
         return {
-            Source: source,
+            Source: "192.168.65.1:39998",
             Destination: destination,
             RequestBody: requestBody,
             ResponseBody: responseBody,
-            RequestHeaders: {
-                "Content-Type": ["application/json"],
-                Authorization: ["Bearer demo-token"],
-            },
-            ResponseHeaders: {
-                "Content-Type": ["application/json"],
-            },
+            RequestHeaders: requestHeaders,
+            ResponseHeaders: responseHeaders,
             Method: method,
-            Path: path,
+            Path: params.path,
             QueryParams: {},
             StatusCode: statusCode,
-            Port: 443,
+            Port: port,
             Timestamp: timestamp,
-            Scheme: "https",
+            Scheme: scheme,
         };
     }
 }

package/build/services/TestExecutionService.js

@@ -6,7 +6,7 @@ import { stripVTControlCharacters } from "util";
 import { logger } from "../utils/logger.js";
 const DEFAULT_TIMEOUT = 300000; // 5 minutes
 const MAX_CONCURRENT_EXECUTIONS = 5;
-export const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.12";
+export const EXECUTOR_DOCKER_IMAGE = "skyramp/executor:v1.3.13";
 const DOCKER_PLATFORM = "linux/amd64";
 const EXECUTION_PROGRESS_INTERVAL = 10000; // 10 seconds between progress updates during execution
 // Files and directories to exclude when mounting workspace to Docker container
@@ -384,6 +384,15 @@ export class TestExecutionService {
             `SKYRAMP_TEST_TOKEN=${options.token || ""}`,
             "SKYRAMP_IN_DOCKER=true",
         ];
+        // Skyramp-generated tests are standalone HTTP tests that never need host repo
+        // conftest.py files or pytest configuration. --noconftest prevents loading any
+        // conftest in the test directory tree (avoids missing deps like boto3, django).
+        // -c /dev/null overrides all config file discovery (pyproject.toml, pytest.ini,
+        // setup.cfg, tox.ini) so user-repo plugins (e.g. pytest-timeout) not installed
+        // in the executor container don't cause INTERNALERROR at collection time.
+        if (options.language === "python") {
+            env.push(`PYTEST_ADDOPTS=--noconftest -c /dev/null`);
+        }
         // Add save storage path to environment if provided
         if (saveStorageTargetPath) {
             env.push(`PLAYWRIGHT_SAVE_STORAGE_PATH=${saveStorageTargetPath}`);

package/build/tools/generate-tests/generateScenarioRestTool.js

@@ -11,7 +11,8 @@ const scenarioTestSchema = {
         .describe("Destination hostname or IP address for the test (e.g., api.example.com, localhost, 192.168.1.1). Do NOT include port numbers."),
     apiSchema: z
         .string()
-        .describe("MUST be absolute path (/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL to the OpenAPI/Swagger schema file (e.g. https://demoshop.skyramp.dev/openapi.json). Required for accurate API mapping."),
+        .optional()
+        .describe("Optional. Absolute path (/path/to/openapi.json) to the OpenAPI/Swagger schema file or a URL (e.g., https://demoshop.skyramp.dev/openapi.json). DO NOT TRY TO ASSUME THE OPENAPI SCHEMA IF NOT PROVIDED. NOTE TO AI ASSISTANTS: You do not need to read the contents of this file - simply pass the file path as the backend will handle reading and processing it."),
     baseURL: z
         .string()
         .optional()
@@ -23,7 +24,7 @@ const scenarioTestSchema = {
         .describe("HTTP method (GET, POST, PUT, DELETE, etc.) parsed by AI from the scenario"),
     path: z
         .string()
-        .describe("API path (e.g., /api/v1/products, /api/v1/orders/{product_id}) parsed by AI from the scenario"),
+        .describe("API path parsed by AI from the scenario. CRITICAL: For requests that reference an ID created by a prior step (e.g. GET/PUT/DELETE after a POST), use the ACTUAL ID value from the prior step's responseBody in the path, NOT a template variable. Example: use '/api/v1/products/70885' instead of '/api/v1/products/{product_id}'. The CLI detects chaining by matching concrete values across requests."),
     // AI-parsed parameters (optional)
     requestBody: z
         .string()
@@ -36,8 +37,21 @@ const scenarioTestSchema = {
     statusCode: z
         .number()
         .optional()
-        .describe("HTTP status code (e.g., 200, 201, 204) parsed by AI from the scenario"),
+        .describe("Expected HTTP status code. Defaults: POST→201, DELETE→204, GET/PUT/PATCH→200. Only override for non-standard codes."),
     outputDir: baseSchema.shape.outputDir,
+    authHeader: z
+        .string()
+        .optional()
+        .default("Authorization")
+        .describe("Name of the HTTP header to use for authorization. Use 'Cookie' for cookie-based auth (e.g., NextAuth), 'Authorization' for Bearer tokens, 'X-API-Key' for API keys. Defaults to 'Authorization'."),
+    authToken: z
+        .string()
+        .optional()
+        .describe("Full auth token value to include in the request header. For Authorization headers, include the scheme prefix (e.g., 'Bearer my-token'). For Cookie headers, use the cookie string (e.g., 'session=abc123'). For API key headers, use the raw key. If omitted, the header value is left empty (the CLI injects the real token at runtime)."),
+    responseHeaders: z
+        .record(z.array(z.string()))
+        .optional()
+        .describe('Response headers as a JSON object (e.g., {"Content-Type": ["application/json"]}). Defaults to Content-Type: application/json.'),
 };
 const TOOL_NAME = "skyramp_scenario_test_generation";
 export function registerScenarioTestTool(server) {
@@ -65,7 +79,7 @@ Returns a single TraceRequest object with:
 **AI Responsibilities:**
 The AI should parse the natural language scenario and provide:
 - HTTP method (POST, GET, PUT, DELETE)
-- API path (e.g., /api/v1/products, /api/v1/products/{product_id})
+- API path with CONCRETE ID values, not templates (e.g., /api/v1/products/70885, NOT /api/v1/products/{product_id})
 - Request body (JSON string, if applicable)
 - Response body (JSON string, if applicable)
 - Status code (optional, defaults based on method)
@@ -77,8 +91,6 @@ The AI should parse the natural language scenario and provide:
 - AI-parsed HTTP method and path (required)
 - AI-parsed request/response bodies (optional)
 
-**IMPORTANT: If an apiSchema parameter (OpenAPI/Swagger file path or URL) is provided, DO NOT attempt to read or analyze the file contents. These files can be very large. Simply pass the path/URL to the tool - the backend will handle reading and processing the schema file.**
-
 **Note:** This tool generates one request at a time. Call multiple times for multi-step scenarios.
 
 **CRITICAL - Integration Test Generation After Scenario Creation:**

package/build/tools/submitReportTool.js

@@ -15,10 +15,32 @@ const newTestSchema = z.object({
     testType: z.string().describe("Type of test created: Smoke, Contract, Integration, etc."),
     endpoint: z.string().describe("HTTP verb and path, e.g. 'GET /api/v1/products'"),
     fileName: z.string().describe("Name of the generated test file"),
+    description: z.string().optional().describe("What the test scenario covers, e.g. 'Creates a collection, adds a link, then verifies the link exists'"),
+    scenarioFile: z.string().optional().describe("Path to the scenario JSON file if one was generated (e.g. 'tests/scenario_collections-links.json')"),
+    traceFile: z.string().optional().describe("Path to the backend trace file if used or created"),
+    frontendTrace: z.string().optional().describe("Path to the Playwright/UI trace file if used or created"),
 });
 const descriptionSchema = z.object({
     description: z.string().describe("One-line description"),
 });
+const scenarioStepSchema = z.object({
+    method: z.string().optional().describe("HTTP method (e.g. 'POST', 'GET'). Required for API steps, omit for UI/E2E actions."),
+    path: z.string().optional().describe("Endpoint or page path (e.g. '/api/v1/products' or '/products'). Required for API steps, omit for UI actions."),
+    description: z.string().describe("What this step does, e.g. 'Create a product' or 'Click checkout button and verify confirmation'"),
+    expectedStatusCode: z.number().optional().describe("Expected HTTP status code, e.g. 200, 201, 404"),
+    requestBody: z.record(z.any()).optional().describe("Example request body with realistic field values"),
+    responseBody: z.record(z.any()).optional().describe("Key response fields to verify, e.g. { id: 'number', name: 'string', in_stock: 'boolean?' }"),
+});
+const additionalRecommendationSchema = z.object({
+    testType: z.string().describe("Type of test: Integration, E2E, Fuzz, Contract, UI, etc."),
+    scenarioName: z.string().describe("Name of the scenario, e.g. 'products_orders_workflow'"),
+    steps: z.array(scenarioStepSchema).describe("Ordered sequence of API/UI steps in this test scenario"),
+    description: z.string().describe("Why this test is valuable and what it would cover"),
+    priority: z.string().describe("Priority level: high, medium, or low"),
+    openApiSpec: z.string().optional().describe("Path to OpenAPI/Swagger spec file if available, e.g. 'openapi.yaml'"),
+    backendTrace: z.string().optional().describe("Path to backend trace file if available, e.g. 'tests/skyramp-traces.json'. Used by integration and E2E tests."),
+    frontendTrace: z.string().optional().describe("Path to Playwright/UI trace file if available, e.g. 'tests/skyramp-playwright.zip'. UI tests need this; E2E tests need both frontend and backend traces."),
+});
 const testMaintenanceSchema = z.object({
     fileName: z.string().describe("Test file that was maintained, e.g. 'products_smoke_test.py'"),
     description: z.string().describe("What was changed and why"),
@@ -47,6 +69,11 @@ export function registerSubmitReportTool(server) {
             testResults: z
                 .array(testResultSchema)
                 .describe("List of ALL test execution results. One entry per test executed."),
+            additionalRecommendations: z
+                .array(additionalRecommendationSchema)
+                .optional()
+                .default([])
+                .describe("Recommended tests that were not generated (lower priority). Include the remaining recommendations from skyramp_recommend_tests that were not implemented."),
             issuesFound: z
                 .array(descriptionSchema)
                 .describe("List of issues, failures, or bugs found. Use empty array [] if none."),
@@ -68,6 +95,7 @@ export function registerSubmitReportTool(server) {
             newTestsCreated: params.newTestsCreated,
             testMaintenance: params.testMaintenance,
             testResults: params.testResults,
+            additionalRecommendations: params.additionalRecommendations ?? [],
             issuesFound: params.issuesFound,
             commitMessage: (params.commitMessage ?? "").replace(/[\r\n]+/g, " ").trim().slice(0, 72) || DEFAULT_COMMIT_MESSAGE,
         }, null, 2);

package/build/tools/test-maintenance/stateCleanupTool.js

@@ -105,6 +105,14 @@ Information about state files and cleanup results.`,
                 const maxAgeHours = args.maxAgeHours || 24;
                 const deletedCount = await StateManager.cleanupOldStateFiles(maxAgeHours);
                 logger.info(`Cleaned up ${deletedCount} state files older than ${maxAgeHours} hours`);
+                if (deletedCount > 0) {
+                    try {
+                        await server.sendResourceListChanged();
+                    }
+                    catch {
+                        logger.warning("Unable to update MCP clients with new resource list");
+                    }
+                }
                 // Get remaining files
                 const remainingFiles = await StateManager.listStateFiles();
                 return {