gitlab-mcp 0.1.4 → 1.0.0

package/tests/graphql-guard.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "vitest";
+
+import { containsGraphqlMutation, shouldDisableGraphqlTools } from "../src/tools/gitlab.js";
+
+describe("containsGraphqlMutation", () => {
+  it("detects mutation operations", () => {
+    expect(containsGraphqlMutation("mutation { createIssue(input: {}) { id } }")).toBeTruthy();
+  });
+
+  it("detects named mutation operations", () => {
+    expect(
+      containsGraphqlMutation("mutation CreateIssue { createIssue(input: {}) { id } }")
+    ).toBeTruthy();
+  });
+
+  it("detects mutation with variables", () => {
+    expect(
+      containsGraphqlMutation(
+        "mutation CreateIssue($input: CreateIssueInput!) { createIssue(input: $input) { id } }"
+      )
+    ).toBeTruthy();
+  });
+
+  it("detects mutation operations not at the beginning of a document", () => {
+    const document = `
+      fragment SharedFields on Issue {
+        id
+      }
+
+      mutation CreateIssue($title: String!) {
+        createIssue(input: { title: $title }) {
+          issue {
+            ...SharedFields
+          }
+        }
+      }
+    `;
+
+    expect(containsGraphqlMutation(document)).toBeTruthy();
+  });
+
+  it("does not flag query operations", () => {
+    expect(containsGraphqlMutation('query { project(fullPath: "group/app") { id } }')).toBeFalsy();
+  });
+
+  it("does not flag named query operations", () => {
+    expect(
+      containsGraphqlMutation('query GetProject { project(fullPath: "group/app") { id } }')
+    ).toBeFalsy();
+  });
+
+  it("ignores mutation keyword inside string literals", () => {
+    const document =
+      'query { search(query: "mutation { createIssue(input:{}) { id } }") { blobs { id } } }';
+    expect(containsGraphqlMutation(document)).toBeFalsy();
+  });
+
+  it("ignores mutation keyword inside triple-quoted strings", () => {
+    const document = `query {
+      search(query: """mutation { createIssue(input:{}) { id } }""") {
+        blobs { id }
+      }
+    }`;
+    expect(containsGraphqlMutation(document)).toBeFalsy();
+  });
+
+  it("ignores mutation keyword in comments", () => {
+    const document = `
+      # mutation CreateIssue { ... }
+      query { project { id } }
+    `;
+    expect(containsGraphqlMutation(document)).toBeFalsy();
+  });
+
+  it("returns false for empty string", () => {
+    expect(containsGraphqlMutation("")).toBeFalsy();
+  });
+
+  it("returns false for whitespace only", () => {
+    expect(containsGraphqlMutation("   \n  ")).toBeFalsy();
+  });
+
+  it("detects case-insensitive mutation keyword", () => {
+    expect(containsGraphqlMutation("MUTATION { createIssue { id } }")).toBeTruthy();
+    expect(containsGraphqlMutation("Mutation { createIssue { id } }")).toBeTruthy();
+  });
+
+  it("handles subscription operations (not mutation)", () => {
+    expect(containsGraphqlMutation("subscription { issueUpdated { id status } }")).toBeFalsy();
+  });
+
+  it("detects mutation with leading whitespace/newlines", () => {
+    expect(containsGraphqlMutation("\n\n  mutation { deleteIssue { id } }")).toBeTruthy();
+  });
+});
+
+describe("shouldDisableGraphqlTools", () => {
+  it("disables graphql tools by default when project scope restrictions are active", () => {
+    expect(shouldDisableGraphqlTools(["123"], false)).toBeTruthy();
+  });
+
+  it("keeps graphql tools enabled when explicit override is set", () => {
+    expect(shouldDisableGraphqlTools(["123"], true)).toBeFalsy();
+  });
+
+  it("keeps graphql tools enabled without project scope restrictions", () => {
+    expect(shouldDisableGraphqlTools([], false)).toBeFalsy();
+  });
+
+  it("keeps graphql tools enabled with empty project IDs and override", () => {
+    expect(shouldDisableGraphqlTools([], true)).toBeFalsy();
+  });
+
+  it("disables with multiple project IDs", () => {
+    expect(shouldDisableGraphqlTools(["1", "2", "3"], false)).toBeTruthy();
+  });
+
+  it("enables with multiple project IDs and override", () => {
+    expect(shouldDisableGraphqlTools(["1", "2", "3"], true)).toBeFalsy();
+  });
+});

package/tests/integration/agent-loop.integration.test.ts

@@ -0,0 +1,552 @@
+/**
+ * Integration tests simulating a full agent loop:
+ *   LLM (scripted) → MCP client → MCP server (InMemoryTransport)
+ *
+ * This validates the entire closed-loop flow:
+ *   1. Client calls tools/list to discover available tools
+ *   2. ScriptedLLM decides which tool to call
+ *   3. Client calls tools/call on the MCP server
+ *   4. Tool result is returned to the LLM
+ *   5. LLM produces final text output
+ *
+ * The GitLabClient is stubbed so no real network calls are made.
+ */
+import { describe, expect, it, vi } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+import { createMcpServer } from "../../src/server/build-server.js";
+import { OutputFormatter } from "../../src/lib/output.js";
+import { ToolPolicyEngine } from "../../src/lib/policy.js";
+import type { AppContext } from "../../src/types/context.js";
+
+/* ------------------------------------------------------------------ */
+/*  LLM abstraction                                                    */
+/* ------------------------------------------------------------------ */
+
+type LLMContent =
+  | { type: "text"; text: string }
+  | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> };
+
+interface LLMResponse {
+  content: LLMContent[];
+}
+
+interface LLM {
+  create(args: {
+    messages: unknown[];
+    tools: Array<{ name: string; description?: string; input_schema?: unknown }>;
+  }): Promise<LLMResponse>;
+}
+
+/**
+ * A scripted LLM that returns pre-defined responses in order.
+ * Each call to create() pops the next response from the script.
+ */
+class ScriptedLLM implements LLM {
+  private callIndex = 0;
+
+  constructor(private script: LLMResponse[]) {}
+
+  async create(): Promise<LLMResponse> {
+    if (this.callIndex >= this.script.length) {
+      throw new Error(`ScriptedLLM: script exhausted after ${this.callIndex} calls`);
+    }
+    return this.script[this.callIndex++];
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/*  Agent loop implementation                                          */
+/* ------------------------------------------------------------------ */
+
+interface AgentResult {
+  finalText: string[];
+  toolCalls: Array<{ name: string; arguments: Record<string, unknown> }>;
+  toolResults: unknown[];
+}
+
+async function runAgentLoop(params: {
+  client: Client;
+  llm: LLM;
+  query: string;
+  maxIterations?: number;
+}): Promise<AgentResult> {
+  const { client, llm, query, maxIterations = 10 } = params;
+
+  // 1. Discover tools
+  const toolsResponse = await client.listTools();
+  const tools = toolsResponse.tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.inputSchema
+  }));
+
+  // 2. Conversation loop
+  const messages: unknown[] = [{ role: "user", content: query }];
+  const finalText: string[] = [];
+  const toolCalls: AgentResult["toolCalls"] = [];
+  const toolResults: unknown[] = [];
+
+  for (let i = 0; i < maxIterations; i++) {
+    const response = await llm.create({ messages, tools });
+    let didToolCall = false;
+
+    for (const content of response.content) {
+      if (content.type === "text") {
+        finalText.push(content.text);
+        continue;
+      }
+
+      if (content.type === "tool_use") {
+        didToolCall = true;
+        toolCalls.push({ name: content.name, arguments: content.input });
+
+        // Call the actual MCP server tool
+        const toolResult = await client.callTool({
+          name: content.name,
+          arguments: content.input
+        });
+        toolResults.push(toolResult);
+
+        // Build conversation history (Anthropic-style)
+        messages.push({ role: "assistant", content: response.content });
+        messages.push({
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: content.id,
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify(toolResult.content)
+                }
+              ]
+            }
+          ]
+        });
+
+        break; // process next LLM turn
+      }
+    }
+
+    if (!didToolCall) break;
+  }
+
+  return { finalText, toolCalls, toolResults };
+}
+
+/* ------------------------------------------------------------------ */
+/*  Test helpers                                                       */
+/* ------------------------------------------------------------------ */
+
+function buildTestContext(gitlabStub?: Partial<AppContext["gitlab"]>): AppContext {
+  const defaultFeatures = {
+    wiki: true,
+    milestone: true,
+    pipeline: true,
+    release: true
+  };
+
+  return {
+    env: {
+      NODE_ENV: "test",
+      LOG_LEVEL: "silent",
+      MCP_SERVER_NAME: "agent-test-server",
+      MCP_SERVER_VERSION: "0.0.1",
+      GITLAB_API_URL: "https://gitlab.example.com/api/v4",
+      GITLAB_API_URLS: ["https://gitlab.example.com/api/v4"],
+      GITLAB_PERSONAL_ACCESS_TOKEN: "test-token",
+      GITLAB_USE_OAUTH: false,
+      GITLAB_OAUTH_AUTO_OPEN_BROWSER: false,
+      GITLAB_OAUTH_SCOPES: "api",
+      GITLAB_READ_ONLY_MODE: false,
+      GITLAB_ALLOWED_PROJECT_IDS: [],
+      GITLAB_ALLOWED_TOOLS: [],
+      GITLAB_ALLOW_GRAPHQL_WITH_PROJECT_SCOPE: false,
+      GITLAB_RESPONSE_MODE: "json",
+      GITLAB_MAX_RESPONSE_BYTES: 200_000,
+      GITLAB_HTTP_TIMEOUT_MS: 20_000,
+      GITLAB_ERROR_DETAIL_MODE: "full",
+      GITLAB_CLOUDFLARE_BYPASS: false,
+      GITLAB_ALLOW_INSECURE_TOKEN_FILE: false,
+      GITLAB_ALLOW_INSECURE_TLS: false,
+      GITLAB_COOKIE_WARMUP_PATH: "/user",
+      USE_GITLAB_WIKI: true,
+      USE_MILESTONE: true,
+      USE_PIPELINE: true,
+      USE_RELEASE: true,
+      REMOTE_AUTHORIZATION: false,
+      ENABLE_DYNAMIC_API_URL: false,
+      HTTP_JSON_ONLY: false,
+      SSE: false,
+      SESSION_TIMEOUT_SECONDS: 3600,
+      MAX_SESSIONS: 1000,
+      MAX_REQUESTS_PER_MINUTE: 300,
+      HTTP_HOST: "127.0.0.1",
+      HTTP_PORT: 3333,
+      GITLAB_TOKEN_CACHE_SECONDS: 300,
+      GITLAB_TOKEN_SCRIPT_TIMEOUT_MS: 10_000,
+      GITLAB_OAUTH_GITLAB_URL: undefined,
+      GITLAB_OAUTH_CLIENT_ID: undefined,
+      GITLAB_OAUTH_CLIENT_SECRET: undefined,
+      GITLAB_OAUTH_REDIRECT_URI: undefined,
+      GITLAB_OAUTH_TOKEN_PATH: undefined,
+      GITLAB_AUTH_COOKIE_PATH: undefined,
+      GITLAB_USER_AGENT: undefined,
+      GITLAB_ACCEPT_LANGUAGE: undefined,
+      GITLAB_TOKEN_SCRIPT: undefined,
+      GITLAB_TOKEN_FILE: undefined,
+      GITLAB_CA_CERT_PATH: undefined,
+      GITLAB_DENIED_TOOLS_REGEX: undefined,
+      NODE_TLS_REJECT_UNAUTHORIZED: undefined,
+      HTTP_PROXY: undefined,
+      HTTPS_PROXY: undefined
+    } as AppContext["env"],
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+      trace: vi.fn(),
+      fatal: vi.fn(),
+      child: () => ({}) as never
+    } as unknown as AppContext["logger"],
+    gitlab: {
+      listProjects: vi.fn().mockResolvedValue([
+        { id: 1, name: "project-alpha", path_with_namespace: "group/project-alpha" },
+        { id: 2, name: "project-beta", path_with_namespace: "group/project-beta" }
+      ]),
+      getProject: vi.fn().mockResolvedValue({
+        id: 1,
+        name: "project-alpha",
+        path_with_namespace: "group/project-alpha",
+        description: "Test project",
+        default_branch: "main",
+        web_url: "https://gitlab.example.com/group/project-alpha"
+      }),
+      listIssues: vi.fn().mockResolvedValue([
+        { iid: 1, title: "Fix bug", state: "opened" },
+        { iid: 2, title: "Add feature", state: "opened" }
+      ]),
+      ...gitlabStub
+    } as unknown as AppContext["gitlab"],
+    policy: new ToolPolicyEngine({
+      readOnlyMode: false,
+      allowedTools: [],
+      enabledFeatures: defaultFeatures
+    }),
+    formatter: new OutputFormatter({
+      responseMode: "json",
+      maxBytes: 200_000
+    })
+  };
+}
+
+async function createAgentTestPair(gitlabStub?: Partial<AppContext["gitlab"]>): Promise<{
+  client: Client;
+  server: McpServer;
+  clientTransport: InMemoryTransport;
+  serverTransport: InMemoryTransport;
+  context: AppContext;
+}> {
+  const context = buildTestContext(gitlabStub);
+  const server = createMcpServer(context);
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+  await server.connect(serverTransport);
+
+  const client = new Client({ name: "agent-test-client", version: "0.0.1" }, { capabilities: {} });
+  await client.connect(clientTransport);
+
+  return { client, server, clientTransport, serverTransport, context };
+}
+
+/* ------------------------------------------------------------------ */
+/*  Agent loop tests                                                   */
+/* ------------------------------------------------------------------ */
+
+describe("Agent Loop Integration (ScriptedLLM + MCP server)", () => {
+  describe("single tool call flow", () => {
+    it("completes a health_check tool call cycle", async () => {
+      const { client, clientTransport, serverTransport } = await createAgentTestPair();
+
+      try {
+        const llm = new ScriptedLLM([
+          // Turn 1: LLM decides to call health_check
+          {
+            content: [{ type: "tool_use", id: "call-1", name: "health_check", input: {} }]
+          },
+          // Turn 2: LLM sees tool result, produces final text
+          {
+            content: [{ type: "text", text: "Server is healthy!" }]
+          }
+        ]);
+
+        const result = await runAgentLoop({
+          client,
+          llm,
+          query: "Is the server healthy?"
+        });
+
+        // Verify tool was called
+        expect(result.toolCalls).toHaveLength(1);
+        expect(result.toolCalls[0].name).toBe("health_check");
+
+        // Verify tool result was successful
+        const toolResult = result.toolResults[0] as { isError?: boolean };
+        expect(toolResult.isError).toBeFalsy();
+
+        // Verify final output
+        expect(result.finalText).toContain("Server is healthy!");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+
+    it("completes a gitlab_list_projects tool call with mocked data", async () => {
+      const { client, clientTransport, serverTransport, context } = await createAgentTestPair();
+
+      try {
+        const llm = new ScriptedLLM([
+          {
+            content: [{ type: "tool_use", id: "call-1", name: "gitlab_list_projects", input: {} }]
+          },
+          {
+            content: [{ type: "text", text: "Found 2 projects." }]
+          }
+        ]);
+
+        const result = await runAgentLoop({
+          client,
+          llm,
+          query: "List all projects"
+        });
+
+        expect(result.toolCalls).toHaveLength(1);
+        expect(result.toolCalls[0].name).toBe("gitlab_list_projects");
+
+        // Verify the mocked gitlab client was called
+        expect(context.gitlab.listProjects).toHaveBeenCalled();
+
+        // Verify tool result contains data
+        const toolResult = result.toolResults[0] as {
+          isError?: boolean;
+          content: Array<{ type: string; text: string }>;
+        };
+        expect(toolResult.isError).toBeFalsy();
+
+        const text = toolResult.content.find((c) => c.type === "text")!.text;
+        expect(text).toContain("project-alpha");
+        expect(text).toContain("project-beta");
+
+        expect(result.finalText).toContain("Found 2 projects.");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+
+  describe("multi-turn tool call flow", () => {
+    it("handles sequential tool calls across multiple turns", async () => {
+      const { client, clientTransport, serverTransport, context } = await createAgentTestPair();
+
+      try {
+        const llm = new ScriptedLLM([
+          // Turn 1: List projects
+          {
+            content: [{ type: "tool_use", id: "call-1", name: "gitlab_list_projects", input: {} }]
+          },
+          // Turn 2: Get details on a specific project
+          {
+            content: [
+              {
+                type: "tool_use",
+                id: "call-2",
+                name: "gitlab_get_project",
+                input: { project_id: "group/project-alpha" }
+              }
+            ]
+          },
+          // Turn 3: Final answer
+          {
+            content: [
+              {
+                type: "text",
+                text: "project-alpha has default branch main."
+              }
+            ]
+          }
+        ]);
+
+        const result = await runAgentLoop({
+          client,
+          llm,
+          query: "Tell me about the first project"
+        });
+
+        expect(result.toolCalls).toHaveLength(2);
+        expect(result.toolCalls[0].name).toBe("gitlab_list_projects");
+        expect(result.toolCalls[1].name).toBe("gitlab_get_project");
+        expect(result.toolCalls[1].arguments).toEqual({ project_id: "group/project-alpha" });
+
+        expect(context.gitlab.listProjects).toHaveBeenCalled();
+        expect(context.gitlab.getProject).toHaveBeenCalledWith("group/project-alpha");
+
+        expect(result.finalText).toContain("project-alpha has default branch main.");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+
+  describe("text-only response (no tool call)", () => {
+    it("handles LLM responding with text only", async () => {
+      const { client, clientTransport, serverTransport } = await createAgentTestPair();
+
+      try {
+        const llm = new ScriptedLLM([
+          {
+            content: [{ type: "text", text: "I don't need any tools for this." }]
+          }
+        ]);
+
+        const result = await runAgentLoop({
+          client,
+          llm,
+          query: "Hello, how are you?"
+        });
+
+        expect(result.toolCalls).toHaveLength(0);
+        expect(result.toolResults).toHaveLength(0);
+        expect(result.finalText).toContain("I don't need any tools for this.");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+
+  describe("tool error handling in agent loop", () => {
+    it("propagates tool errors back to LLM gracefully", async () => {
+      const { client, clientTransport, serverTransport } = await createAgentTestPair({
+        getProject: vi.fn().mockRejectedValue(new Error("Network timeout"))
+      });
+
+      try {
+        const llm = new ScriptedLLM([
+          {
+            content: [
+              {
+                type: "tool_use",
+                id: "call-1",
+                name: "gitlab_get_project",
+                input: { project_id: "broken/project" }
+              }
+            ]
+          },
+          // LLM sees the error and produces a helpful message
+          {
+            content: [
+              {
+                type: "text",
+                text: "Sorry, I couldn't fetch the project due to a network error."
+              }
+            ]
+          }
+        ]);
+
+        const result = await runAgentLoop({
+          client,
+          llm,
+          query: "Get project details"
+        });
+
+        expect(result.toolCalls).toHaveLength(1);
+
+        // Tool result should be an error
+        const toolResult = result.toolResults[0] as { isError?: boolean };
+        expect(toolResult.isError).toBe(true);
+
+        // Agent still completes with final text from the scripted LLM
+        expect(result.finalText.join("\n")).toContain("couldn't fetch the project");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+
+  describe("tool discovery", () => {
+    it("agent discovers tools and LLM receives tool list", async () => {
+      const { client, clientTransport, serverTransport } = await createAgentTestPair();
+
+      try {
+        let receivedTools: Array<{ name: string }> = [];
+
+        const llm: LLM = {
+          async create({ tools }) {
+            receivedTools = tools;
+            return { content: [{ type: "text", text: "Done" }] };
+          }
+        };
+
+        await runAgentLoop({ client, llm, query: "test" });
+
+        expect(receivedTools.length).toBeGreaterThan(0);
+
+        const names = receivedTools.map((t) => t.name);
+        expect(names).toContain("health_check");
+        expect(names).toContain("gitlab_get_project");
+        expect(names).toContain("gitlab_list_projects");
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+
+  describe("iteration safety", () => {
+    it("respects maxIterations to prevent infinite loops", async () => {
+      const { client, clientTransport, serverTransport } = await createAgentTestPair();
+
+      try {
+        // LLM always requests another tool call, never stops
+        const infiniteLLM: LLM = {
+          callCount: 0,
+          async create() {
+            (this as { callCount: number }).callCount++;
+            return {
+              content: [
+                {
+                  type: "tool_use",
+                  id: `call-${(this as { callCount: number }).callCount}`,
+                  name: "health_check",
+                  input: {}
+                }
+              ]
+            };
+          }
+        } as LLM & { callCount: number };
+
+        const result = await runAgentLoop({
+          client,
+          llm: infiniteLLM,
+          query: "loop forever",
+          maxIterations: 3
+        });
+
+        // Should stop after maxIterations
+        expect(result.toolCalls).toHaveLength(3);
+      } finally {
+        await clientTransport.close();
+        await serverTransport.close();
+      }
+    });
+  });
+});