@pagopa/dx-mcpserver 0.0.12 → 0.1.1

package/dist/tools/__tests__/registry.test.js

@@ -0,0 +1,81 @@
+import { BedrockAgentRuntimeClient } from "@aws-sdk/client-bedrock-agent-runtime";
+import { describe, expect, it } from "vitest";
+import { createToolDefinitions } from "../registry.js";
+const toolDefinitions = createToolDefinitions({
+    aws: {
+        knowledgeBaseId: "kb-id",
+        modelArn: "arn:aws:bedrock:eu-central-1:123456789012:model/model-id",
+        region: "eu-central-1",
+        rerankingEnabled: false,
+    },
+    githubSearchOrg: "pagopa",
+    kbRuntimeClient: new BedrockAgentRuntimeClient({ region: "eu-central-1" }),
+});
+describe("Tool Registry", () => {
+    describe("registry structure", () => {
+        it("should contain expected tools", () => {
+            expect(toolDefinitions).toHaveLength(1);
+            const toolIds = toolDefinitions.map((entry) => entry.id);
+            expect(toolIds).toContain("pagopa_query_documentation");
+        });
+        it("should have unique tool IDs", () => {
+            const toolIds = toolDefinitions.map((entry) => entry.id);
+            const uniqueIds = new Set(toolIds);
+            expect(uniqueIds.size).toBe(toolIds.length);
+        });
+        it("should follow snake_case naming convention with pagopa prefix", () => {
+            for (const entry of toolDefinitions) {
+                expect(entry.id).toMatch(/^pagopa_[a-z_]+$/);
+            }
+        });
+    });
+    describe("tool entries", () => {
+        it("should have valid tool definitions", () => {
+            for (const entry of toolDefinitions) {
+                expect(entry.tool).toBeDefined();
+                expect(entry.tool.name).toBeTruthy();
+                expect(entry.tool.description).toBeTruthy();
+                expect(entry.tool.execute).toBeTypeOf("function");
+                expect(entry.tool.parameters).toBeDefined();
+            }
+        });
+        it("should have proper annotations", () => {
+            for (const entry of toolDefinitions) {
+                expect(entry.tool.annotations).toBeDefined();
+                expect(entry.tool.annotations.title).toBeTruthy();
+            }
+        });
+        it("should have boolean values for hint annotations when defined", () => {
+            for (const entry of toolDefinitions) {
+                const { annotations } = entry.tool;
+                if (annotations.readOnlyHint !== undefined) {
+                    expect(annotations.readOnlyHint).toBeTypeOf("boolean");
+                }
+                if (annotations.destructiveHint !== undefined) {
+                    expect(annotations.destructiveHint).toBeTypeOf("boolean");
+                }
+                if (annotations.idempotentHint !== undefined) {
+                    expect(annotations.idempotentHint).toBeTypeOf("boolean");
+                }
+                if (annotations.openWorldHint !== undefined) {
+                    expect(annotations.openWorldHint).toBeTypeOf("boolean");
+                }
+            }
+        });
+    });
+    describe("session requirements", () => {
+        it("should mark documentation tool as not requiring session", () => {
+            const docTool = toolDefinitions.find((entry) => entry.id === "pagopa_query_documentation");
+            expect(docTool?.requiresSession).toBe(false);
+        });
+    });
+    describe("pagopa_query_documentation", () => {
+        const docTool = toolDefinitions.find((entry) => entry.id === "pagopa_query_documentation");
+        it("should have correct metadata", () => {
+            expect(docTool?.tool.name).toBe("pagopa_query_documentation");
+            expect(docTool?.tool.annotations.readOnlyHint).toBe(true);
+            expect(docTool?.tool.annotations.destructiveHint).toBe(false);
+            expect(docTool?.tool.annotations.idempotentHint).toBe(true);
+        });
+    });
+});

package/dist/tools/query-pagopa-dx-documentation.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { queryKnowledgeBase } from "../services/bedrock.js";
+import { handleApiError } from "../utils/error-handling.js";
+/**
+ * Response format options for documentation queries
+ */
+var ResponseFormat;
+(function (ResponseFormat) {
+    ResponseFormat["JSON"] = "json";
+    ResponseFormat["MARKDOWN"] = "markdown";
+})(ResponseFormat || (ResponseFormat = {}));
+/**
+ * Pagination constants
+ */
+const DEFAULT_NUMBER_OF_RESULTS = 5;
+const MIN_RESULTS = 1;
+const MAX_RESULTS = 20;
+/**
+ * Zod schema for QueryPagoPADXDocumentation input validation
+ */
+export const QueryPagoPADXDocumentationInputSchema = z
+    .object({
+    format: z
+        .nativeEnum(ResponseFormat)
+        .default(ResponseFormat.MARKDOWN)
+        .describe("Output format: 'markdown' for human-readable or 'json' for machine-readable"),
+    number_of_results: z
+        .number()
+        .int()
+        .min(MIN_RESULTS, `Must return at least ${MIN_RESULTS} result`)
+        .max(MAX_RESULTS, `Cannot exceed ${MAX_RESULTS} results`)
+        .default(DEFAULT_NUMBER_OF_RESULTS)
+        .describe(`Number of documentation chunks to retrieve (${MIN_RESULTS}-${MAX_RESULTS}, default: ${DEFAULT_NUMBER_OF_RESULTS}). Use more for comprehensive answers, fewer for quick lookups.`),
+    query: z
+        .string()
+        .min(3, "Query must be at least 3 characters")
+        .max(500, "Query must not exceed 500 characters")
+        .describe("A natural language query in English used to search the DX documentation for relevant information."),
+})
+    .strict();
+/**
+ * A tool that provides access to the complete PagoPA DX documentation.
+ * It uses a Bedrock knowledge base to answer queries about DX tools, patterns, and best practices.
+ */
+export function createQueryPagoPADXDocumentationTool(config) {
+    return {
+        annotations: {
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+            readOnlyHint: true,
+            title: "Query PagoPA DX Documentation",
+        },
+        description: `Query the PagoPA DX documentation knowledge base for information about developer tools, patterns, and best practices.
+
+This tool provides access to the complete PagoPA DX documentation covering:
+- Getting started, monorepo setup, dev containers, and GitHub collaboration
+- Git workflows and pull requests
+- DX pipelines setup and management
+- TypeScript development (npm scripts, ESLint, code review)
+- Terraform (folder structure, DX modules, Azure provider, pre-commit hooks, validation, deployment, drift detection)
+- Azure development (naming conventions, policies, IAM, API Management, monitoring, networking, deployments, static websites, Service Bus, data archiving)
+- Container development (Docker images)
+- Contributing to DX (Azure provider, Terraform modules, documentation)
+
+Args:
+  - query (string, required): Natural language query in English (3-500 characters)
+  - format ('markdown' | 'json', optional): Output format (default: 'markdown')
+  - number_of_results (number, optional): Number of documentation chunks to retrieve (1-20, default: 5)
+
+Returns:
+  For JSON format:
+  {
+    "query": string,           // The original query
+    "result": string,          // Documentation content matching the query
+    "number_of_results": number // How many chunks were requested
+  }
+
+  For Markdown format:
+  Human-readable documentation content with proper formatting.
+
+Examples:
+  - "How do I set up a new Terraform module?" -> Returns step-by-step guide
+  - "What are the Azure naming conventions?" -> Returns naming standards
+  - "How to configure ESLint for TypeScript?" -> Returns configuration guide
+
+Notes:
+  - All queries should be written in English
+  - Use \`number_of_results: 1-3\` for quick lookups, \`10-20\` for comprehensive research
+  - For Terraform module examples and code patterns, use the \`search_code\` tool from GitHub's MCP server
+
+Error Handling:
+  - Returns "Error: Query must be at least 3 characters" for queries too short
+  - Returns "Error: Query must not exceed 500 characters" for queries too long
+  - Returns "Error: ..." for API or network errors`,
+        execute: async (args) => {
+            const parsedArgsResult = QueryPagoPADXDocumentationInputSchema.safeParse(args);
+            if (!parsedArgsResult.success) {
+                return handleApiError(parsedArgsResult.error);
+            }
+            const parsedArgs = parsedArgsResult.data;
+            const numberOfResults = parsedArgs.number_of_results;
+            try {
+                const result = await queryKnowledgeBase(config.knowledgeBaseId, parsedArgs.query, config.kbRuntimeClient, numberOfResults, config.rerankingEnabled);
+                const format = parsedArgs.format;
+                if (format === ResponseFormat.JSON) {
+                    return JSON.stringify({
+                        number_of_results: numberOfResults,
+                        query: parsedArgs.query,
+                        result,
+                    }, null, 2);
+                }
+                return result;
+            }
+            catch (error) {
+                return handleApiError(error);
+            }
+        },
+        name: "pagopa_query_documentation",
+        parameters: QueryPagoPADXDocumentationInputSchema,
+    };
+}

package/dist/tools/registry.js

@@ -0,0 +1,20 @@
+/**
+ * Tool registry for dynamic tool registration
+ *
+ * This file provides a centralized, scalable way to manage MCP tools.
+ * Adding a new tool only requires adding it to the createToolDefinitions return array.
+ */
+import { createQueryPagoPADXDocumentationTool } from "./query-pagopa-dx-documentation.js";
+export function createToolDefinitions(config) {
+    return [
+        {
+            id: "pagopa_query_documentation",
+            requiresSession: false,
+            tool: createQueryPagoPADXDocumentationTool({
+                kbRuntimeClient: config.kbRuntimeClient,
+                knowledgeBaseId: config.aws.knowledgeBaseId,
+                rerankingEnabled: config.aws.rerankingEnabled,
+            }),
+        },
+    ];
+}

package/dist/types.js

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

package/dist/utils/__tests__/error-handling.test.js

@@ -0,0 +1,168 @@
+import { AxiosError, AxiosHeaders } from "axios";
+import { describe, expect, it } from "vitest";
+import { ZodError } from "zod";
+import { handleApiError, isAxiosError, isZodError } from "../error-handling.js";
+/**
+ * Helper to create an AxiosError with a response
+ */
+const createAxiosResponseError = (status, statusText) => {
+    const config = { headers: new AxiosHeaders() };
+    return new AxiosError(statusText, "ERR_BAD_REQUEST", config, undefined, {
+        config,
+        data: {},
+        headers: {},
+        status,
+        statusText,
+    });
+};
+describe("handleApiError - Axios HTTP status codes", () => {
+    it("should handle 400 Bad Request", () => {
+        const error = createAxiosResponseError(400, "Bad Request");
+        expect(handleApiError(error)).toBe("Error: Bad request. Please check your input parameters.");
+    });
+    it("should handle 401 Unauthorized", () => {
+        const error = createAxiosResponseError(401, "Unauthorized");
+        expect(handleApiError(error)).toBe("Error: Authentication failed. Please check your credentials.");
+    });
+    it("should handle 403 Forbidden", () => {
+        const error = createAxiosResponseError(403, "Forbidden");
+        expect(handleApiError(error)).toBe("Error: Permission denied. You don't have access to this resource.");
+    });
+    it("should handle 404 Not Found", () => {
+        const error = createAxiosResponseError(404, "Not Found");
+        expect(handleApiError(error)).toBe("Error: Resource not found. Please check the ID is correct.");
+    });
+    it("should handle 429 Rate Limit", () => {
+        const error = createAxiosResponseError(429, "Too Many Requests");
+        expect(handleApiError(error)).toBe("Error: Rate limit exceeded. Please wait before making more requests.");
+    });
+    it("should handle 500 Internal Server Error", () => {
+        const error = createAxiosResponseError(500, "Internal Server Error");
+        expect(handleApiError(error)).toBe("Error: Server error. The service is temporarily unavailable.");
+    });
+    it("should handle 502 Bad Gateway", () => {
+        const error = createAxiosResponseError(502, "Bad Gateway");
+        expect(handleApiError(error)).toBe("Error: Bad gateway. The service is temporarily unavailable.");
+    });
+    it("should handle 503 Service Unavailable", () => {
+        const error = createAxiosResponseError(503, "Service Unavailable");
+        expect(handleApiError(error)).toBe("Error: Service unavailable. Please try again later.");
+    });
+    it("should handle unknown status codes", () => {
+        const error = createAxiosResponseError(418, "I'm a teapot");
+        expect(handleApiError(error)).toBe("Error: API request failed with status 418");
+    });
+});
+describe("handleApiError - Axios network errors", () => {
+    it("should handle ECONNABORTED timeout errors", () => {
+        const error = new AxiosError("Timeout", "ECONNABORTED");
+        expect(handleApiError(error)).toBe("Error: Request timed out. Please try again.");
+    });
+    it("should handle ENOTFOUND errors", () => {
+        const error = new AxiosError("Not Found", "ENOTFOUND");
+        expect(handleApiError(error)).toBe("Error: Could not connect to the server. Please check your network.");
+    });
+    it("should handle ECONNREFUSED errors", () => {
+        const error = new AxiosError("Connection Refused", "ECONNREFUSED");
+        expect(handleApiError(error)).toBe("Error: Connection refused. The server may be down.");
+    });
+    it("should handle other network errors", () => {
+        const error = new AxiosError("Unknown network error");
+        expect(handleApiError(error)).toBe("Error: Network error occurred: Unknown network error");
+    });
+});
+describe("handleApiError - Zod validation errors", () => {
+    it("should format single validation error", () => {
+        const error = new ZodError([
+            {
+                code: "too_small",
+                inclusive: true,
+                message: "String must contain at least 3 character(s)",
+                minimum: 3,
+                path: ["query"],
+                type: "string",
+            },
+        ]);
+        expect(handleApiError(error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s)");
+    });
+    it("should format multiple validation errors", () => {
+        const error = new ZodError([
+            {
+                code: "too_small",
+                inclusive: true,
+                message: "String must contain at least 3 character(s)",
+                minimum: 3,
+                path: ["query"],
+                type: "string",
+            },
+            {
+                code: "invalid_type",
+                expected: "number",
+                message: "Expected number, received string",
+                path: ["page"],
+                received: "string",
+            },
+        ]);
+        expect(handleApiError(error)).toBe("Error: Invalid input - query: String must contain at least 3 character(s); page: Expected number, received string");
+    });
+    it("should handle nested path errors", () => {
+        const error = new ZodError([
+            {
+                code: "invalid_type",
+                expected: "string",
+                message: "Required",
+                path: ["data", "nested", "field"],
+                received: "undefined",
+            },
+        ]);
+        expect(handleApiError(error)).toBe("Error: Invalid input - data.nested.field: Required");
+    });
+});
+describe("handleApiError - generic errors", () => {
+    it("should handle Error instances", () => {
+        const error = new Error("Something went wrong");
+        expect(handleApiError(error)).toBe("Error: Something went wrong");
+    });
+    it("should handle string errors", () => {
+        expect(handleApiError("Raw string error")).toBe("Error: Unexpected error occurred: Raw string error");
+    });
+    it("should handle null", () => {
+        expect(handleApiError(null)).toBe("Error: Unexpected error occurred: null");
+    });
+    it("should handle undefined", () => {
+        expect(handleApiError(undefined)).toBe("Error: Unexpected error occurred: undefined");
+    });
+    it("should handle objects", () => {
+        expect(handleApiError({ custom: "error" })).toBe("Error: Unexpected error occurred: [object Object]");
+    });
+});
+describe("isAxiosError", () => {
+    it("should return true for AxiosError instances", () => {
+        const error = new AxiosError("Test error");
+        expect(isAxiosError(error)).toBe(true);
+    });
+    it("should return false for regular Error instances", () => {
+        const error = new Error("Test error");
+        expect(isAxiosError(error)).toBe(false);
+    });
+    it("should return false for non-errors", () => {
+        expect(isAxiosError("string")).toBe(false);
+        expect(isAxiosError(null)).toBe(false);
+        expect(isAxiosError(undefined)).toBe(false);
+    });
+});
+describe("isZodError", () => {
+    it("should return true for ZodError instances", () => {
+        const error = new ZodError([]);
+        expect(isZodError(error)).toBe(true);
+    });
+    it("should return false for regular Error instances", () => {
+        const error = new Error("Test error");
+        expect(isZodError(error)).toBe(false);
+    });
+    it("should return false for non-errors", () => {
+        expect(isZodError("string")).toBe(false);
+        expect(isZodError(null)).toBe(false);
+        expect(isZodError(undefined)).toBe(false);
+    });
+});

package/dist/utils/error-handling.js

@@ -0,0 +1,74 @@
+/**
+ * Centralized error handling utilities for the MCP server.
+ * Provides consistent error messages across all tools.
+ */
+import { AxiosError } from "axios";
+import { ZodError } from "zod";
+/**
+ * Handles API errors and returns user-friendly error messages.
+ * Supports Axios errors, Zod validation errors, and generic errors.
+ *
+ * @param error - The error to handle
+ * @returns A formatted error message string
+ */
+export function handleApiError(error) {
+    // Handle Axios HTTP errors
+    if (error instanceof AxiosError) {
+        if (error.response) {
+            switch (error.response.status) {
+                case 400:
+                    return "Error: Bad request. Please check your input parameters.";
+                case 401:
+                    return "Error: Authentication failed. Please check your credentials.";
+                case 403:
+                    return "Error: Permission denied. You don't have access to this resource.";
+                case 404:
+                    return "Error: Resource not found. Please check the ID is correct.";
+                case 429:
+                    return "Error: Rate limit exceeded. Please wait before making more requests.";
+                case 500:
+                    return "Error: Server error. The service is temporarily unavailable.";
+                case 502:
+                    return "Error: Bad gateway. The service is temporarily unavailable.";
+                case 503:
+                    return "Error: Service unavailable. Please try again later.";
+                default:
+                    return `Error: API request failed with status ${error.response.status}`;
+            }
+        }
+        else if (error.code === "ECONNABORTED") {
+            return "Error: Request timed out. Please try again.";
+        }
+        else if (error.code === "ENOTFOUND") {
+            return "Error: Could not connect to the server. Please check your network.";
+        }
+        else if (error.code === "ECONNREFUSED") {
+            return "Error: Connection refused. The server may be down.";
+        }
+        return `Error: Network error occurred: ${error.message}`;
+    }
+    // Handle Zod validation errors
+    if (error instanceof ZodError) {
+        const issues = error.issues
+            .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+            .join("; ");
+        return `Error: Invalid input - ${issues}`;
+    }
+    // Handle generic errors
+    if (error instanceof Error) {
+        return `Error: ${error.message}`;
+    }
+    return `Error: Unexpected error occurred: ${String(error)}`;
+}
+/**
+ * Type guard to check if an error is an Axios error
+ */
+export function isAxiosError(error) {
+    return error instanceof AxiosError;
+}
+/**
+ * Type guard to check if an error is a Zod validation error
+ */
+export function isZodError(error) {
+    return error instanceof ZodError;
+}

package/dist/utils/errors.js

@@ -0,0 +1,12 @@
+/**
+ * Formats a list of Zod issues into a single, human-readable string.
+ * This is useful for error messages when configuration or input validation fails.
+ *
+ * @param issues - The array of Zod issues to format
+ * @returns A semicolon-separated string of formatted issues
+ */
+export function formatZodIssues(issues) {
+    return issues
+        .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+        .join("; ");
+}

package/dist/utils/filter-undefined.js

@@ -0,0 +1,6 @@
+/**
+ * Filter out undefined values from an object to match emitCustomEvent expectations
+ */
+export function filterUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}

package/dist/utils/http.js

@@ -0,0 +1,36 @@
+/**
+ * Parses JSON body from an incoming HTTP request.
+ */
+export async function parseJsonBody(req) {
+    let body = "";
+    for await (const chunk of req) {
+        body += chunk;
+    }
+    if (!body)
+        return undefined;
+    return JSON.parse(body);
+}
+/**
+ * Sends an error response in a standard format.
+ */
+export function sendErrorResponse(res, statusCode, message, details) {
+    sendJsonResponse(res, statusCode, {
+        error: message,
+        ...(details ? { details } : {}),
+    });
+}
+/**
+ * Sends a JSON response with the specified status code.
+ */
+export function sendJsonResponse(res, statusCode, data) {
+    res.writeHead(statusCode, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+/**
+ * Sets standard CORS headers for the response.
+ */
+export function setCorsHeaders(res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS, DELETE");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+}

package/dist/utils/normalize-boolean.js

@@ -0,0 +1,13 @@
+/**
+ * Normalizes a string or undefined value into a boolean.
+ *
+ * @param value - The string value to normalize (e.g., from an environment variable)
+ * @param defaultValue - The default boolean value to return if the input is undefined or empty
+ * @returns The boolean representation of the string, or the default value
+ */
+export function normalizeBoolean(value, defaultValue) {
+    if (!value) {
+        return defaultValue;
+    }
+    return value.trim().toLowerCase() === "true";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagopa/dx-mcpserver",
-  "version": "0.0.12",
+  "version": "0.1.1",
   "type": "module",
   "description": "An MCP server that supports developers using DX tools.",
   "repository": {
@@ -16,17 +16,17 @@
     "dist"
   ],
   "bin": {
-    "dx": "./dist/index.js"
+    "dx": "./dist/cli.js"
   },
   "dependencies": {
     "@aws-sdk/client-bedrock-agent-runtime": "^3.583.0",
     "@logtape/logtape": "^1.3.4",
+    "@modelcontextprotocol/sdk": "^1.25.2",
     "@octokit/rest": "^22.0.0",
     "axios": "^1.12.2",
-    "fastmcp": "^3.19.1",
     "zod": "^3.25.76",
-    "@pagopa/azure-tracing": "^0.4.10",
-    "@pagopa/dx-mcpprompts": "^0.2.0"
+    "@pagopa/dx-mcpprompts": "^0.2.2",
+    "@pagopa/azure-tracing": "^0.4.11"
   },
   "devDependencies": {
     "@types/node": "^22.19.1",
@@ -36,10 +36,10 @@
     "tsx": "^4.20.6",
     "typescript": "~5.8.3",
     "vitest": "^3.2.4",
-    "@pagopa/eslint-config": "^5.1.1"
+    "@pagopa/eslint-config": "^5.1.2"
   },
   "scripts": {
-    "start": "tsx src/index.ts",
+    "start": "tsx src/cli.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "typecheck": "tsc --noEmit",

package/dist/auth/__tests__/githubAuth.test.js

@@ -1,65 +0,0 @@
-import { getLogger } from "@logtape/logtape";
-import { Octokit } from "@octokit/rest";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import * as githubAuth from "../github.js";
-vi.mock("@octokit/rest");
-describe("verifyGithubUser", () => {
-    let loggerSpy;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        process.env.REQUIRED_ORGANIZATIONS = "pagopa";
-        // Get logger and spy on its methods - no need for special configuration
-        const logger = getLogger(["mcpserver", "github-auth"]);
-        loggerSpy = {
-            debug: vi.spyOn(logger, "debug"),
-            error: vi.spyOn(logger, "error"),
-            warn: vi.spyOn(logger, "warn"),
-        };
-    });
-    it("returns false if no token is provided", async () => {
-        const result = await githubAuth.verifyGithubUser("");
-        expect(result).toBe(false);
-    });
-    it("returns false if Octokit throws", async () => {
-        vi.mocked(Octokit).mockImplementation(() => ({
-            rest: {
-                orgs: {
-                    listForAuthenticatedUser: vi
-                        .fn()
-                        .mockRejectedValue(new Error("fail")),
-                },
-            },
-        }));
-        const result = await githubAuth.verifyGithubUser("token");
-        expect(result).toBe(false);
-        expect(loggerSpy.error).toHaveBeenCalledWith("Error verifying GitHub organization membership", { error: expect.any(Error) });
-    });
-    it("returns false if user is not member of required org", async () => {
-        vi.mocked(Octokit).mockImplementation(() => ({
-            rest: {
-                orgs: {
-                    listForAuthenticatedUser: vi.fn().mockResolvedValue({
-                        data: [{ login: "otherorg" }],
-                    }),
-                },
-            },
-        }));
-        const result = await githubAuth.verifyGithubUser("token");
-        expect(result).toBe(false);
-        expect(loggerSpy.warn).toHaveBeenCalledWith("User is not a member of any of the required organizations: pagopa");
-    });
-    it("returns true if user is member of required org", async () => {
-        vi.mocked(Octokit).mockImplementation(() => ({
-            rest: {
-                orgs: {
-                    listForAuthenticatedUser: vi.fn().mockResolvedValue({
-                        data: [{ login: "pagopa" }],
-                    }),
-                },
-            },
-        }));
-        const result = await githubAuth.verifyGithubUser("token");
-        expect(result).toBe(true);
-        expect(loggerSpy.debug).toHaveBeenCalledWith("User is a member of one of the required organizations: pagopa");
-    });
-});