@pagopa/dx-mcpserver 0.0.12 → 0.1.2

package/README.md

@@ -8,22 +8,88 @@ This package contains the implementation of a Model Context Protocol (MCP) serve
 
 The server currently exposes the following capabilities:
 
+### MCP Protocol
+
 - **Tools**:
   - `QueryPagoPADXDocumentation`: Queries Amazon Bedrock Knowledge Bases to retrieve relevant content from the [DX documentation](https://dx.pagopa.it/).
   - `SearchGitHubCode`: Searches for code snippets in specified GitHub organization (defaults to pagopa), allowing users to find real-world examples of code usage.
 - **Prompts**:
   - `GenerateTerraformConfiguration`: Guides the generation of Terraform configurations following PagoPA DX best practices.
 
-## Authentication
+### REST API Endpoints
+
+The server also exposes HTTP REST endpoints for direct documentation access:
+
+#### POST /ask
+
+AI-powered Q&A endpoint that generates contextual answers from the DX documentation.
+
+**Request**:
+
+```bash
+curl -X POST https://api.dx.pagopa.it/ask \
+  -H "Content-Type: application/json" \
+  -d '{"query": "How do I setup Terraform modules?"}'
+```
+
+**Response**:
+
+```json
+{
+  "answer": "To setup Terraform modules in PagoPA DX...",
+  "sources": [
+    "https://dx.pagopa.it/docs/terraform/modules/",
+    "https://dx.pagopa.it/docs/getting-started/"
+  ]
+}
+```
+
+**Features**:
+
+- Uses Amazon Bedrock RetrieveAndGenerate for AI-generated responses
+- Returns relevant source URLs from documentation
+- Automatically converts internal S3 URIs to public web URLs
+
+#### POST /search
+
+Semantic search endpoint that retrieves relevant documentation chunks.
+
+**Request**:
+
+```bash
+curl -X POST https://api.dx.pagopa.it/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "Azure naming conventions",
+    "number_of_results": 5
+  }'
+```
+
+**Response**:
+
+```json
+{
+  "query": "Azure naming conventions",
+  "results": [
+    {
+      "content": "Azure resources must follow...",
+      "score": 0.9542,
+      "source": "https://dx.pagopa.it/docs/azure/naming/"
+    }
+  ]
+}
+```
 
-The server requires a fine-grained [GitHub Personal Access Token](https://github.com/settings/personal-access-tokens) for authentication with the following settings:
+**Parameters**:
 
-- **Resource owner:**
-  - Choose the **pagopa** organization
-- **Repository access:**
-  - Public Repositories (read-only)
-- **Organization permissions:**
-  - Members: Read-only (to verify membership in the pagopa organization)
+- `query` (required): Natural language search query
+- `number_of_results` (optional): Number of results to return (1-20, default: 5)
+
+**Features**:
+
+- Uses Amazon Bedrock Retrieve API with optional reranking
+- Returns relevance scores for each result
+- Configurable result count
 
 ## Usage
 
@@ -31,37 +97,21 @@ This server can be used by any MCP-compliant client.
 
 ### VS Code
 
-[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_DX_MCP_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=ffffff)](vscode:mcp/install?%7B%22name%22%3A%22dx%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapi.dx.pagopa.it%2Fmcp%22%2C%22headers%22%3A%7B%22x-gh-pat%22%3A%22%24%7Binput%3Agithub_mcp_pat%7D%22%7D%7D)
-
-After installing the MCP server in VS Code, you need to configure the GitHub
-Personal Access Token (PAT) for authentication.
+[![Install in VS Code](https://img.shields.io/badge/VS_Code-Install_DX_MCP_Server-0098FF?style=flat-square&logo=visualstudiocode&logoColor=ffffff)](vscode:mcp/install?%7B%22name%22%3A%22dx%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapi.dx.pagopa.it%2Fmcp%22%7D)
 
-Update your MCP configuration file adding the `inputs` key to your MCP configuration as follows:
+After installing the MCP server in VS Code, update your MCP configuration file as follows:
 
 ```json
 {
   "servers": {
     "dx": {
       "url": "https://api.dx.pagopa.it/mcp",
-      "type": "http",
-      "headers": {
-        "x-gh-pat": "${input:github_mcp_pat}"
-      }
-    }
-  },
-  "inputs": [
-    {
-      "type": "promptString",
-      "id": "github_mcp_pat",
-      "description": "GitHub Personal Access Token",
-      "password": true
+      "type": "http"
     }
-  ]
+  }
 }
 ```
 
-You will be prompted to enter your GitHub PAT when you first use the server.
-
 See [VS Code MCP docs](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) for more info.
 
 ### GitHub Copilot Coding Agent
@@ -76,17 +126,12 @@ You need to configure it in the repository settings. See [GitHub Copilot MCP doc
     "pagopa-dx": {
       "url": "https://api.dx.pagopa.it/mcp",
       "type": "http",
-      "tools": ["*"],
-      "headers": {
-        "x-gh-pat": "$COPILOT_MCP_BOT_GH_PAT"
-      }
+      "tools": ["*"]
     }
   }
 }
 ```
 
-2.  **Configure Authentication**: Add any necessary tokens or secrets (e.g., `COPILOT_MCP_BOT_GH_PAT`) as secrets in the repository's Copilot configuration. This allows the coding agent to use them when querying the server.
-
 Once configured, Copilot can autonomously invoke the MCP server's tools during task execution, using it to access documentation context and improve the quality of its code generation.
 
 ### GitHub Copilot CLI
@@ -98,7 +143,7 @@ Follow the guided wizard to start using the DX MCP server:
 1. **Server Name**: `dx-docs`
 2. **Server Type**: `2` (HTTP)
 3. **URL**: `https://api.dx.pagopa.it/mcp`
-4. **HTTP Headers**: `{"x-gh-pat": "<your-gh-PAT>"}`
+4. **HTTP Headers**: leave as is (no headers needed)
 5. **Tools**: `*` (leave as is)
 
 Use `Tab` to navigate between fields and `Ctrl+S` to save.

package/dist/__tests__/__mocks__/handlers.js

@@ -0,0 +1,48 @@
+import { vi } from "vitest";
+import { z } from "zod";
+export const mockTool = {
+    annotations: {
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+        readOnlyHint: true,
+        title: "Test Tool",
+    },
+    description: "A test tool",
+    execute: vi.fn(async (args) => {
+        const parsedResult = z.object({ input: z.string() }).safeParse(args);
+        if (!parsedResult.success) {
+            return "Error: Invalid input";
+        }
+        return `Tool executed with: ${parsedResult.data.input}`;
+    }),
+    name: "TestTool",
+    parameters: z.object({
+        input: z.string().min(1, "Input cannot be empty"),
+    }),
+};
+export const mockCatalogEntry = {
+    category: "test",
+    enabled: true,
+    id: "test-prompt",
+    metadata: {
+        description: "A test prompt for unit testing",
+        title: "Test Prompt",
+    },
+    prompt: {
+        arguments: [
+            { description: "First argument", name: "arg1", required: true },
+            { description: "Second argument", name: "arg2", required: false },
+        ],
+        description: "A test prompt",
+        load: async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`,
+        name: "TestPrompt",
+    },
+    tags: ["test"],
+};
+export const mockPromptEntry = {
+    catalogEntry: mockCatalogEntry,
+    prompt: {
+        load: vi.fn(async (args) => `Prompt loaded with args: ${JSON.stringify(args)}`),
+    },
+};

package/dist/__tests__/http-endpoints.test.js

@@ -0,0 +1,246 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { loadConfig } from "../config.js";
+// Mock the prompts package to avoid Vite resolution issues in CI
+vi.mock("@pagopa/dx-mcpprompts", () => ({
+    getEnabledPrompts: vi.fn().mockResolvedValue([]),
+}));
+// Helper to create mock Bedrock responses
+function createMockBedrockResponse(command) {
+    if (command.constructor.name === "RetrieveAndGenerateCommand") {
+        return Promise.resolve({
+            citations: [
+                {
+                    retrievedReferences: [
+                        {
+                            content: { text: "Reference content", type: "TEXT" },
+                            location: {
+                                s3Location: {
+                                    uri: "s3://bucket/docs/terraform/setup.md",
+                                },
+                                type: "S3",
+                            },
+                        },
+                    ],
+                },
+            ],
+            output: { text: "This is how you setup Terraform." },
+            sessionId: "test-session",
+        });
+    }
+    else if (command.constructor.name === "RetrieveCommand") {
+        return Promise.resolve({
+            retrievalResults: [
+                {
+                    content: { text: "Azure naming conventions guide", type: "TEXT" },
+                    location: {
+                        s3Location: { uri: "s3://bucket/docs/azure/naming.md" },
+                        type: "S3",
+                    },
+                    score: 0.95,
+                },
+            ],
+        });
+    }
+    return Promise.resolve({});
+}
+// Mock AWS SDK to avoid external dependencies
+vi.mock("@aws-sdk/client-bedrock-agent-runtime", () => ({
+    BedrockAgentRuntimeClient: vi.fn().mockImplementation(() => ({
+        config: {
+            apiVersion: "2023-11-20",
+            region: async () => "eu-central-1",
+            requestHandler: { handle: vi.fn() },
+        },
+        destroy: vi.fn(),
+        middlewareStack: {},
+        send: vi.fn(),
+    })),
+    RetrieveAndGenerateCommand: vi.fn(),
+    RetrieveCommand: vi.fn(),
+}));
+vi.mock("../config/aws.js", () => ({
+    createBedrockRuntimeClient: vi.fn(() => ({
+        config: {
+            apiVersion: "2023-11-20",
+            region: async () => "eu-central-1",
+            requestHandler: { handle: vi.fn() },
+        },
+        destroy: vi.fn(),
+        middlewareStack: {},
+        send: vi.fn().mockImplementation(createMockBedrockResponse),
+    })),
+    rerankingSupportedRegions: ["us-east-1", "eu-central-1"],
+}));
+// Shared server instance
+let server;
+let baseUrl;
+async function closeTestServer() {
+    return new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+async function setupTestServer() {
+    const testEnv = {
+        AWS_BEDROCK_KNOWLEDGE_BASE_ID: "test-kb-id",
+        AWS_BEDROCK_MODEL_ARN: "arn:aws:bedrock:test",
+        AWS_REGION: "eu-central-1",
+        LOG_LEVEL: "error",
+        NODE_ENV: "test",
+    };
+    const config = loadConfig(testEnv);
+    const { startHttpServer } = await import("../index.js");
+    // Use empty prompts array since we mocked the module
+    server = await startHttpServer(config, []);
+    const address = server.address();
+    const port = typeof address === "object" ? address?.port : 8080;
+    baseUrl = `http://localhost:${port}`;
+}
+describe("HTTP Endpoints Integration Tests", () => {
+    beforeAll(setupTestServer);
+    afterAll(closeTestServer);
+    describe("POST /ask", () => {
+        it("should return 200 with answer and sources for valid request", async () => {
+            const response = await fetch(`${baseUrl}/ask`, {
+                body: JSON.stringify({ query: "How do I setup Terraform?" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(200);
+            expect(response.headers.get("content-type")).toContain("application/json");
+            const data = (await response.json());
+            expect(data).toHaveProperty("answer");
+            expect(data).toHaveProperty("sources");
+            expect(typeof data.answer).toBe("string");
+            expect(Array.isArray(data.sources)).toBe(true);
+        });
+        it("should return 400 for missing query field", async () => {
+            const response = await fetch(`${baseUrl}/ask`, {
+                body: JSON.stringify({}),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Missing required field: query");
+        });
+        it("should return 400 for empty query string", async () => {
+            const response = await fetch(`${baseUrl}/ask`, {
+                body: JSON.stringify({ query: "   " }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Missing required field: query");
+        });
+        it("should return 400 for invalid JSON", async () => {
+            const response = await fetch(`${baseUrl}/ask`, {
+                body: "not valid json{",
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Invalid JSON in request body");
+        });
+        it("should return 400 for non-string query", async () => {
+            const response = await fetch(`${baseUrl}/ask`, {
+                body: JSON.stringify({ query: 123 }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Missing required field: query");
+        });
+    });
+    describe("POST /search", () => {
+        it("should return 200 with results for valid request", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ query: "Azure naming conventions" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(200);
+            expect(response.headers.get("content-type")).toContain("application/json");
+            const data = (await response.json());
+            expect(data).toHaveProperty("query");
+            expect(data).toHaveProperty("results");
+            expect(Array.isArray(data.results)).toBe(true);
+            if (data.results.length > 0) {
+                const result = data.results[0];
+                expect(result).toHaveProperty("content");
+                expect(result).toHaveProperty("score");
+                expect(typeof result.score).toBe("number");
+            }
+        });
+        it("should use default number_of_results when not provided", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ query: "test query" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(200);
+            const data = (await response.json());
+            expect(data).toHaveProperty("results");
+        });
+        it("should accept custom number_of_results", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ number_of_results: 10, query: "test query" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(200);
+        });
+        it("should return 400 for missing query field", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({}),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Missing required field: query");
+        });
+        it("should return 400 for empty query string", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ query: "" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Missing required field: query");
+        });
+        it("should return 400 for invalid JSON", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: "{invalid json",
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("Invalid JSON in request body");
+        });
+        it("should return 400 for number_of_results out of range (too low)", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ number_of_results: 0, query: "test" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("number_of_results must be between 1 and 20");
+        });
+        it("should return 400 for number_of_results out of range (too high)", async () => {
+            const response = await fetch(`${baseUrl}/search`, {
+                body: JSON.stringify({ number_of_results: 21, query: "test" }),
+                headers: { "Content-Type": "application/json" },
+                method: "POST",
+            });
+            expect(response.status).toBe(400);
+            const data = (await response.json());
+            expect(data.error).toBe("number_of_results must be between 1 and 20");
+        });
+    });
+});

package/dist/__tests__/index.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from "vitest";
+import { mockCatalogEntry, mockPromptEntry, mockTool, } from "./__mocks__/handlers.js";
+describe("MCP Server Handlers", () => {
+    describe("Tool Handler Validation", () => {
+        it("should validate tool arguments against the Zod schema", async () => {
+            // Valid arguments should pass
+            const validArgs = { input: "test-value" };
+            const validationResult = mockTool.parameters.safeParse(validArgs);
+            expect(validationResult.success).toBe(true);
+            // Invalid arguments should fail
+            const invalidArgs = { input: "" };
+            const invalidationResult = mockTool.parameters.safeParse(invalidArgs);
+            expect(invalidationResult.success).toBe(false);
+            if (!invalidationResult.success) {
+                expect(invalidationResult.error.issues[0].message).toContain("cannot be empty");
+            }
+        });
+        it("should handle tool execution errors gracefully", async () => {
+            const errorTool = {
+                ...mockTool,
+                execute: vi.fn(async () => {
+                    throw new Error("Tool execution failed");
+                }),
+            };
+            await expect(errorTool.execute({ input: "test" }, undefined)).rejects.toThrow("Tool execution failed");
+        });
+        it("should pass context with session data to tool execute", async () => {
+            const context = { session: { id: "session-123" } };
+            await mockTool.execute({ input: "test" }, context);
+            expect(mockTool.execute).toHaveBeenCalledWith({ input: "test" }, context);
+        });
+    });
+    describe("Prompt Handler Validation", () => {
+        it("should validate required prompt arguments", () => {
+            const missingRequiredArg = { arg2: "value2" };
+            const hasAllRequired = mockCatalogEntry.prompt.arguments
+                .filter((arg) => arg.required)
+                .every((arg) => arg.name in missingRequiredArg);
+            expect(hasAllRequired).toBe(false);
+            const withAllRequired = { arg1: "value1", arg2: "value2" };
+            const hasAllRequired2 = mockCatalogEntry.prompt.arguments
+                .filter((arg) => arg.required)
+                .every((arg) => arg.name in withAllRequired);
+            expect(hasAllRequired2).toBe(true);
+        });
+        it("should handle missing required prompt arguments", () => {
+            const requiredArgs = mockCatalogEntry.prompt.arguments
+                .filter((arg) => arg.required)
+                .map((arg) => arg.name);
+            const providedArgs = { arg2: "value" };
+            const missingArgs = requiredArgs.filter((arg) => !(arg in providedArgs));
+            expect(missingArgs).toEqual(["arg1"]);
+        });
+        it("should handle optional prompt arguments", async () => {
+            const argsWithoutOptional = { arg1: "required-value" };
+            await mockPromptEntry.prompt.load(argsWithoutOptional);
+            expect(mockPromptEntry.prompt.load).toHaveBeenCalledWith(argsWithoutOptional);
+            const argsWithOptional = { arg1: "required-value", arg2: "optional" };
+            await mockPromptEntry.prompt.load(argsWithOptional);
+            expect(mockPromptEntry.prompt.load).toHaveBeenCalledWith(argsWithOptional);
+        });
+        it("should handle prompt loading errors gracefully", async () => {
+            const errorPrompt = {
+                ...mockPromptEntry,
+                prompt: {
+                    load: vi.fn(async () => {
+                        throw new Error("Prompt loading failed");
+                    }),
+                },
+            };
+            await expect(errorPrompt.prompt.load({ arg1: "test" })).rejects.toThrow("Prompt loading failed");
+        });
+    });
+    describe("Request Handler Integration", () => {
+        it("should handle valid tool requests", async () => {
+            const args = { input: "test-input" };
+            const result = await mockTool.execute(args, undefined);
+            expect(result).toContain("Tool executed with: test-input");
+            expect(mockTool.execute).toHaveBeenCalledWith(args, undefined);
+        });
+        it("should reject requests with invalid tool names", () => {
+            const toolRegistry = new Map();
+            toolRegistry.set("TestTool", mockTool);
+            const toolExists = toolRegistry.has("NonExistentTool");
+            expect(toolExists).toBe(false);
+        });
+        it("should handle tool execution with proper error context", async () => {
+            const toolWithErrorContext = {
+                ...mockTool,
+                execute: vi.fn(async (args, context) => {
+                    if (!context?.session) {
+                        throw new Error("Session context required");
+                    }
+                    return "Success with context";
+                }),
+            };
+            // Should fail without context
+            await expect(toolWithErrorContext.execute({ input: "test" }, undefined)).rejects.toThrow("Session context required");
+            // Should succeed with context
+            const result = await toolWithErrorContext.execute({ input: "test" }, { session: { id: "session-1" } });
+            expect(result).toBe("Success with context");
+        });
+        it("should handle batch tool and prompt registration", () => {
+            const toolRegistry = new Map();
+            const promptRegistry = new Map();
+            // Register multiple tools
+            toolRegistry.set(mockTool.name, mockTool);
+            toolRegistry.set("AnotherTool", { ...mockTool, name: "AnotherTool" });
+            // Register multiple prompts
+            promptRegistry.set(mockPromptEntry.catalogEntry.prompt.name, mockPromptEntry);
+            promptRegistry.set("AnotherPrompt", {
+                ...mockPromptEntry,
+                catalogEntry: {
+                    ...mockPromptEntry.catalogEntry,
+                    prompt: {
+                        ...mockPromptEntry.catalogEntry.prompt,
+                        name: "AnotherPrompt",
+                    },
+                },
+            });
+            expect(toolRegistry.size).toBe(2);
+            expect(promptRegistry.size).toBe(2);
+        });
+    });
+});

package/dist/__tests__/session.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { sessionStorage } from "../session.js";
+describe("Session Management", () => {
+    it("should maintain session isolation between concurrent contexts", async () => {
+        const session1 = { id: "session-1" };
+        const session2 = { id: "session-2" };
+        const results = [];
+        // Run two sessions concurrently
+        await Promise.all([
+            sessionStorage.run(session1, async () => {
+                // Wait a bit to ensure overlap
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                const stored = sessionStorage.getStore();
+                if (stored) {
+                    results.push(stored);
+                }
+            }),
+            sessionStorage.run(session2, async () => {
+                const stored = sessionStorage.getStore();
+                if (stored) {
+                    results.push(stored);
+                }
+            }),
+        ]);
+        // Both sessions should have completed and stored their data
+        expect(results).toHaveLength(2);
+        // Each session should have its own data
+        const ids = results.map((r) => r.id).sort();
+        expect(ids).toEqual(["session-1", "session-2"]);
+    });
+    it("should return undefined when accessed outside of run context", async () => {
+        const store = sessionStorage.getStore();
+        expect(store).toBeUndefined();
+    });
+    it("should provide correct session data within run context", async () => {
+        const session = {
+            id: "test-session-123",
+        };
+        await sessionStorage.run(session, async () => {
+            const stored = sessionStorage.getStore();
+            expect(stored).toBeDefined();
+            expect(stored?.id).toBe("test-session-123");
+        });
+    });
+    it("should properly clean up session data after run context completes", async () => {
+        const session = { id: "cleanup-456" };
+        await sessionStorage.run(session, async () => {
+            expect(sessionStorage.getStore()).toBeDefined();
+        });
+        // After the run completes, store should be undefined
+        expect(sessionStorage.getStore()).toBeUndefined();
+    });
+    it("should handle nested session contexts correctly", async () => {
+        const session1 = { id: "outer-1" };
+        const session2 = { id: "inner-2" };
+        await sessionStorage.run(session1, async () => {
+            expect(sessionStorage.getStore()?.id).toBe("outer-1");
+            await sessionStorage.run(session2, async () => {
+                // Inner context should override outer
+                expect(sessionStorage.getStore()?.id).toBe("inner-2");
+            });
+            // After inner context exits, outer context should be restored
+            expect(sessionStorage.getStore()?.id).toBe("outer-1");
+        });
+    });
+});

package/dist/cli.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for the MCP server.
+ *
+ * This file keeps runtime side effects limited to a single entrypoint and
+ * delegates all application logic to the main module.
+ */
+import { main } from "./index.js";
+main(process.env).catch((error) => {
+    console.error("Failed to start MCP server", error);
+    process.exitCode = 1;
+});

package/dist/config/__tests__/aws-config.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from "vitest";
+import { createBedrockRuntimeClient, rerankingSupportedRegions, } from "../aws.js";
+describe("aws config", () => {
+    it("should export rerankingSupportedRegions as array", () => {
+        expect(Array.isArray(rerankingSupportedRegions)).toBe(true);
+        expect(rerankingSupportedRegions.length).toBeGreaterThan(0);
+    });
+    it("should create a Bedrock runtime client", () => {
+        const logger = {
+            error: vi.fn(),
+        };
+        const client = createBedrockRuntimeClient("eu-central-1", logger);
+        expect(client).toHaveProperty("send");
+    });
+});