gitlab-mcp 1.1.0 → 1.2.0

package/tests/request-runtime.test.ts

@@ -1,252 +0,0 @@
-/**
- * Tests for helper functions exported or used internally by request-runtime.ts.
- * Since some functions are private, we test them indirectly or test the module-level
- * exported utilities that are accessible.
- *
- * For deeper testing we extract testable logic patterns.
- */
-import { describe, expect, it } from "vitest";
-import * as os from "node:os";
-import * as path from "node:path";
-
-/**
- * Replicate the parseTokenOutput logic for testing.
- * This matches the private function in request-runtime.ts.
- */
-function parseTokenOutput(rawOutput: string): string | undefined {
-  const output = rawOutput.trim();
-  if (!output) {
-    return undefined;
-  }
-
-  try {
-    const parsed = JSON.parse(output) as Record<string, unknown>;
-    const token =
-      getStringField(parsed, "token") ||
-      getStringField(parsed, "access_token") ||
-      getStringField(parsed, "private_token");
-    if (token) {
-      return token;
-    }
-  } catch {
-    // Plain string output is valid.
-  }
-
-  return output.split(/\r?\n/, 1)[0]?.trim() || undefined;
-}
-
-function getStringField(record: Record<string, unknown>, key: string): string | undefined {
-  const value = record[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-
-/**
- * Replicate resolveHomePath for testing.
- */
-function resolveHomePath(input?: string): string | undefined {
-  if (!input) {
-    return undefined;
-  }
-
-  if (input.startsWith("~/")) {
-    return path.join(os.homedir(), input.slice(2));
-  }
-
-  return input;
-}
-
-/**
- * Replicate normalizeWarmupPath for testing.
- */
-function normalizeWarmupPath(value: string): string {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return "/user";
-  }
-
-  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
-}
-
-/**
- * Replicate resolveApiRoot for testing.
- */
-function resolveApiRoot(url: URL): string | undefined {
-  const match = url.pathname.match(/^(.*\/api\/v4)(?:\/|$)/);
-  return match?.[1];
-}
-
-/**
- * Replicate parseOauthScopes for testing.
- */
-function parseOauthScopes(rawScopes: string): string[] {
-  return rawScopes
-    .split(/[,\s]+/)
-    .map((scope) => scope.trim())
-    .filter((scope) => scope.length > 0);
-}
-
-describe("parseTokenOutput", () => {
-  it("returns undefined for empty string", () => {
-    expect(parseTokenOutput("")).toBeUndefined();
-  });
-
-  it("returns undefined for whitespace-only string", () => {
-    expect(parseTokenOutput("   \n  ")).toBeUndefined();
-  });
-
-  it("parses plain text token", () => {
-    expect(parseTokenOutput("glpat-abc123")).toBe("glpat-abc123");
-  });
-
-  it("parses plain text with trailing newline", () => {
-    expect(parseTokenOutput("glpat-abc123\n")).toBe("glpat-abc123");
-  });
-
-  it("takes first line of multi-line output", () => {
-    expect(parseTokenOutput("glpat-abc123\nsome debug info\nmore stuff")).toBe("glpat-abc123");
-  });
-
-  it("parses JSON with token field", () => {
-    expect(parseTokenOutput('{"token": "glpat-from-json"}')).toBe("glpat-from-json");
-  });
-
-  it("parses JSON with access_token field", () => {
-    expect(parseTokenOutput('{"access_token": "oauth-token-123"}')).toBe("oauth-token-123");
-  });
-
-  it("parses JSON with private_token field", () => {
-    expect(parseTokenOutput('{"private_token": "private-123"}')).toBe("private-123");
-  });
-
-  it("prefers token field over access_token", () => {
-    expect(parseTokenOutput('{"token": "primary", "access_token": "secondary"}')).toBe("primary");
-  });
-
-  it("ignores JSON with empty token fields", () => {
-    expect(parseTokenOutput('{"token": "", "other": "value"}')).toBe(
-      '{"token": "", "other": "value"}'
-    );
-  });
-
-  it("ignores JSON with whitespace-only token fields", () => {
-    expect(parseTokenOutput('{"token": "   "}')).toBe('{"token": "   "}');
-  });
-
-  it("trims whitespace from parsed token values", () => {
-    expect(parseTokenOutput('{"token": "  trimmed  "}')).toBe("trimmed");
-  });
-
-  it("handles JSON with no recognized token fields", () => {
-    const input = '{"unknown_field": "some-value"}';
-    // Falls back to first line
-    expect(parseTokenOutput(input)).toBe(input);
-  });
-});
-
-describe("resolveHomePath", () => {
-  it("returns undefined for empty input", () => {
-    expect(resolveHomePath("")).toBeUndefined();
-    expect(resolveHomePath(undefined)).toBeUndefined();
-  });
-
-  it("expands ~ to home directory", () => {
-    const result = resolveHomePath("~/some/path");
-    expect(result).toBeDefined();
-    expect(result).not.toContain("~/");
-    expect(result).toContain("some/path");
-  });
-
-  it("returns absolute paths unchanged", () => {
-    expect(resolveHomePath("/absolute/path")).toBe("/absolute/path");
-  });
-
-  it("returns relative paths unchanged", () => {
-    expect(resolveHomePath("relative/path")).toBe("relative/path");
-  });
-});
-
-describe("normalizeWarmupPath", () => {
-  it("returns /user for empty string", () => {
-    expect(normalizeWarmupPath("")).toBe("/user");
-  });
-
-  it("returns /user for whitespace-only string", () => {
-    expect(normalizeWarmupPath("   ")).toBe("/user");
-  });
-
-  it("preserves leading slash", () => {
-    expect(normalizeWarmupPath("/custom")).toBe("/custom");
-  });
-
-  it("adds leading slash when missing", () => {
-    expect(normalizeWarmupPath("custom")).toBe("/custom");
-  });
-
-  it("trims whitespace", () => {
-    expect(normalizeWarmupPath("  /user  ")).toBe("/user");
-  });
-});
-
-describe("resolveApiRoot", () => {
-  it("extracts /api/v4 from standard URL", () => {
-    const url = new URL("https://gitlab.example.com/api/v4/projects/1");
-    expect(resolveApiRoot(url)).toBe("/api/v4");
-  });
-
-  it("extracts subpath /api/v4", () => {
-    const url = new URL("https://example.com/gitlab/api/v4/projects");
-    expect(resolveApiRoot(url)).toBe("/gitlab/api/v4");
-  });
-
-  it("returns undefined for non-API URLs", () => {
-    const url = new URL("https://gitlab.example.com/group/project");
-    expect(resolveApiRoot(url)).toBeUndefined();
-  });
-
-  it("matches when path ends with /api/v4", () => {
-    const url = new URL("https://gitlab.example.com/api/v4/");
-    expect(resolveApiRoot(url)).toBe("/api/v4");
-  });
-});
-
-describe("parseOauthScopes", () => {
-  it("parses space-separated scopes", () => {
-    expect(parseOauthScopes("api read_user")).toEqual(["api", "read_user"]);
-  });
-
-  it("parses comma-separated scopes", () => {
-    expect(parseOauthScopes("api,read_user,write_repository")).toEqual([
-      "api",
-      "read_user",
-      "write_repository"
-    ]);
-  });
-
-  it("handles mixed separators", () => {
-    expect(parseOauthScopes("api, read_user write_repository")).toEqual([
-      "api",
-      "read_user",
-      "write_repository"
-    ]);
-  });
-
-  it("filters empty entries", () => {
-    expect(parseOauthScopes("api,,read_user, ,write_repository")).toEqual([
-      "api",
-      "read_user",
-      "write_repository"
-    ]);
-  });
-
-  it("handles single scope", () => {
-    expect(parseOauthScopes("api")).toEqual(["api"]);
-  });
-
-  it("handles empty string", () => {
-    expect(parseOauthScopes("")).toEqual([]);
-  });
-
-  it("trims whitespace from scopes", () => {
-    expect(parseOauthScopes("  api  ,  read_user  ")).toEqual(["api", "read_user"]);
-  });
-});

package/tests/sanitize.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { stripNullsDeep } from "../src/lib/sanitize.js";
-
-describe("stripNullsDeep", () => {
-  it("removes null values recursively from objects", () => {
-    const input = {
-      title: "demo",
-      description: null,
-      nested: {
-        keep: 1,
-        drop: null,
-        arr: [1, null, 2, null, 3]
-      }
-    };
-
-    expect(stripNullsDeep(input)).toEqual({
-      title: "demo",
-      nested: {
-        keep: 1,
-        arr: [1, 2, 3]
-      }
-    });
-  });
-
-  it("returns undefined for top-level null", () => {
-    expect(stripNullsDeep(null)).toBeUndefined();
-  });
-
-  it("preserves primitive string values", () => {
-    expect(stripNullsDeep("hello")).toBe("hello");
-  });
-
-  it("preserves primitive number values", () => {
-    expect(stripNullsDeep(42)).toBe(42);
-    expect(stripNullsDeep(0)).toBe(0);
-    expect(stripNullsDeep(-1)).toBe(-1);
-  });
-
-  it("preserves boolean values", () => {
-    expect(stripNullsDeep(true)).toBe(true);
-    expect(stripNullsDeep(false)).toBe(false);
-  });
-
-  it("preserves undefined as-is", () => {
-    expect(stripNullsDeep(undefined)).toBeUndefined();
-  });
-
-  it("handles empty object", () => {
-    expect(stripNullsDeep({})).toEqual({});
-  });
-
-  it("handles empty array", () => {
-    expect(stripNullsDeep([])).toEqual([]);
-  });
-
-  it("handles object with all null values", () => {
-    expect(stripNullsDeep({ a: null, b: null, c: null })).toEqual({});
-  });
-
-  it("handles array with all null values", () => {
-    expect(stripNullsDeep([null, null, null])).toEqual([]);
-  });
-
-  it("handles deeply nested null removal", () => {
-    const input = {
-      level1: {
-        level2: {
-          level3: {
-            keep: "value",
-            drop: null
-          }
-        }
-      }
-    };
-
-    expect(stripNullsDeep(input)).toEqual({
-      level1: {
-        level2: {
-          level3: {
-            keep: "value"
-          }
-        }
-      }
-    });
-  });
-
-  it("handles mixed array contents", () => {
-    const input = [1, "hello", null, true, null, { key: null, keep: "yes" }];
-
-    expect(stripNullsDeep(input)).toEqual([1, "hello", true, { keep: "yes" }]);
-  });
-
-  it("handles nested arrays within objects", () => {
-    const input = {
-      items: [{ name: "a", value: null }, null, { name: "b", value: 1 }]
-    };
-
-    expect(stripNullsDeep(input)).toEqual({
-      items: [{ name: "a" }, { name: "b", value: 1 }]
-    });
-  });
-
-  it("preserves zero, empty string, and false values", () => {
-    const input = {
-      zero: 0,
-      emptyStr: "",
-      falsy: false,
-      nullValue: null
-    };
-
-    expect(stripNullsDeep(input)).toEqual({
-      zero: 0,
-      emptyStr: "",
-      falsy: false
-    });
-  });
-
-  it("handles arrays nested within arrays", () => {
-    const input = [[null, 1], [2, null], null];
-    expect(stripNullsDeep(input)).toEqual([[1], [2]]);
-  });
-});

package/tests/session-capacity.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { getTotalSessions, hasReachedSessionCapacity } from "../src/lib/session-capacity.js";
-
-describe("session capacity helpers", () => {
-  it("counts streamable, pending, and SSE sessions together", () => {
-    expect(
-      getTotalSessions({
-        streamableSessions: 2,
-        pendingSessions: 1,
-        sseSessions: 3,
-        maxSessions: 10
-      })
-    ).toBe(6);
-  });
-
-  it("treats capacity as reached when total equals max", () => {
-    expect(
-      hasReachedSessionCapacity({
-        streamableSessions: 1,
-        pendingSessions: 1,
-        sseSessions: 1,
-        maxSessions: 3
-      })
-    ).toBe(true);
-  });
-
-  it("treats capacity as reached when total exceeds max", () => {
-    expect(
-      hasReachedSessionCapacity({
-        streamableSessions: 2,
-        pendingSessions: 1,
-        sseSessions: 2,
-        maxSessions: 4
-      })
-    ).toBe(true);
-  });
-
-  it("does not reach capacity when total is below max", () => {
-    expect(
-      hasReachedSessionCapacity({
-        streamableSessions: 1,
-        pendingSessions: 0,
-        sseSessions: 1,
-        maxSessions: 3
-      })
-    ).toBe(false);
-  });
-});

package/tests/upload-reference.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { parseProjectUploadReference } from "../src/tools/gitlab.js";
-
-describe("parseProjectUploadReference", () => {
-  it("parses absolute upload URL", () => {
-    expect(
-      parseProjectUploadReference("https://gitlab.example.com/group/repo/uploads/abc123/file.txt")
-    ).toEqual({
-      secret: "abc123",
-      filename: "file.txt"
-    });
-  });
-
-  it("parses relative upload path", () => {
-    expect(parseProjectUploadReference("/uploads/abc123/file.txt")).toEqual({
-      secret: "abc123",
-      filename: "file.txt"
-    });
-  });
-
-  it("parses relative upload path with encoded filename", () => {
-    expect(parseProjectUploadReference("/uploads/abc123/%E6%B5%8B%E8%AF%95.txt")).toEqual({
-      secret: "abc123",
-      filename: "测试.txt"
-    });
-  });
-
-  it("returns undefined for non-upload paths", () => {
-    expect(parseProjectUploadReference("/api/v4/projects/1/issues")).toBeUndefined();
-  });
-
-  it("returns undefined for empty string", () => {
-    expect(parseProjectUploadReference("")).toBeUndefined();
-  });
-
-  it("returns undefined for whitespace-only string", () => {
-    expect(parseProjectUploadReference("   ")).toBeUndefined();
-  });
-
-  it("handles URL with query parameters", () => {
-    const result = parseProjectUploadReference(
-      "https://gitlab.example.com/group/repo/uploads/abc123/file.txt?inline=true"
-    );
-    expect(result).toEqual({
-      secret: "abc123",
-      filename: "file.txt"
-    });
-  });
-
-  it("handles URL with fragment", () => {
-    const result = parseProjectUploadReference(
-      "https://gitlab.example.com/group/repo/uploads/abc123/file.txt#section"
-    );
-    expect(result).toEqual({
-      secret: "abc123",
-      filename: "file.txt"
-    });
-  });
-
-  it("handles URL with nested group paths", () => {
-    const result = parseProjectUploadReference(
-      "https://gitlab.example.com/group/subgroup/repo/uploads/secret123/document.pdf"
-    );
-    expect(result).toEqual({
-      secret: "secret123",
-      filename: "document.pdf"
-    });
-  });
-
-  it("returns undefined for invalid URL", () => {
-    expect(parseProjectUploadReference("not a url at all")).toBeUndefined();
-  });
-
-  it("returns undefined for malformed percent-encoding", () => {
-    expect(parseProjectUploadReference("/uploads/abc123/%E0%A4%A")).toBeUndefined();
-  });
-
-  it("handles upload path without leading slash", () => {
-    // This depends on implementation, but should handle gracefully
-    const result = parseProjectUploadReference("uploads/abc123/file.txt");
-    // May or may not match depending on implementation
-    if (result) {
-      expect(result.secret).toBe("abc123");
-      expect(result.filename).toBe("file.txt");
-    }
-  });
-});

package/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "sourceMap": true,
-    "types": ["node"]
-  },
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022", "DOM"],
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "useUnknownInCatchVariables": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": false,
-    "forceConsistentCasingInFileNames": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "types": ["node", "vitest/globals"]
-  },
-  "include": ["src", "tests", "eslint.config.js", "vitest.config.ts"],
-  "exclude": ["dist", "node_modules"]
-}

package/vitest.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    include: ["tests/**/*.test.ts"],
-    coverage: {
-      reporter: ["text", "html"],
-      include: ["src/**/*.ts"]
-    }
-  }
-});