gitlab-mcp 0.1.5 → 1.0.0

package/tests/request-runtime.test.ts

@@ -0,0 +1,252 @@
+/**
+ * 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 os from "node:os";
+import 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

@@ -0,0 +1,123 @@
+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/upload-reference.test.ts

@@ -0,0 +1,84 @@
+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("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

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

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "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

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

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Michael Lin
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.