@gremlin/mcp-server 2.2.1 → 2.3.0

package/build/openapi/spec-loader.d.ts

@@ -0,0 +1,41 @@
+export interface OpenApiSpec {
+    paths: Record<string, PathItem>;
+}
+export interface PathItem {
+    [method: string]: Operation | undefined;
+}
+export interface Operation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: string[];
+    parameters?: Parameter[];
+    requestBody?: RequestBody;
+    security?: Array<Record<string, string[]>>;
+}
+export interface Parameter {
+    name: string;
+    in: 'path' | 'query' | 'header' | 'cookie';
+    required?: boolean;
+    description?: string;
+    schema?: Record<string, unknown>;
+}
+export interface RequestBody {
+    required?: boolean;
+    description?: string;
+    content?: Record<string, {
+        schema?: Record<string, unknown>;
+    }>;
+}
+export interface EndpointMatch {
+    method: string;
+    path: string;
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: string[];
+    parameters?: Parameter[];
+    requestBody?: RequestBody;
+}
+export declare function getSpec(): Promise<OpenApiSpec>;
+export declare function searchSpec(spec: OpenApiSpec, query: string, methodFilter?: string, tagFilter?: string, topN?: number): EndpointMatch[];

package/build/resources/index.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { GremlinClient } from "../client/interface";
+/**
+ * Register all resources with the MCP server
+ *
+ * @param server - The MCP server instance
+ * @param api - The Gremlin API client
+ */
+export declare function registerResources(server: McpServer, api: GremlinClient): void;

package/build/tools/company.d.ts

@@ -0,0 +1,49 @@
+import z from "zod";
+import type { GremlinClient } from "../client/interface";
+import type { ReportPeriod } from "../types";
+export declare function createGetPricingReportTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        startDate: z.ZodString;
+        endDate: z.ZodString;
+        trackingPeriod: z.ZodOptional<z.ZodEnum<["Daily", "Weekly", "Monthly"]>>;
+    };
+    handler: (args: {
+        startDate: string;
+        endDate: string;
+        trackingPeriod?: "Daily" | "Weekly" | "Monthly";
+    }) => Promise<import("../types").PricingReport>;
+};
+export declare function createGetClientSummaryTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        period: z.ZodEnum<["MONTHS", "WEEKS", "DAYS"]>;
+    };
+    handler: (args: {
+        teamId: string;
+        start: string;
+        end: string;
+        period: ReportPeriod;
+    }) => Promise<unknown>;
+};
+export declare function createGetAttackSummaryTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        period: z.ZodEnum<["MONTHS", "WEEKS", "DAYS"]>;
+    };
+    handler: (args: {
+        teamId: string;
+        start: string;
+        end: string;
+        period: ReportPeriod;
+    }) => Promise<unknown>;
+};

package/build/tools/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { GremlinClient } from "../client/interface";
+export declare function registerTools(server: McpServer, api: GremlinClient): void;

package/build/tools/openapi.d.ts

@@ -0,0 +1,49 @@
+import z from 'zod';
+import type { GremlinClient } from '../client/interface';
+import type { ElicitationClient } from '../elicitation';
+import { OpenApiSpec } from '../openapi/spec-loader';
+export declare function createSearchGremlinApiTool(_api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        query: z.ZodString;
+        method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>>;
+        tag: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    handler: (args: {
+        query: string;
+        method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        tag?: string;
+        limit?: number;
+    }) => Promise<{
+        message: string;
+        results: import("../openapi/spec-loader").EndpointMatch[];
+    }>;
+};
+export declare function getRunPrivileges(spec: OpenApiSpec, specPath: string, method: string): string[];
+export declare function createExecuteGremlinApiTool(api: GremlinClient, elicitation: ElicitationClient): {
+    name: string;
+    description: string;
+    schema: {
+        method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+        path: z.ZodString;
+        pathParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        queryParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        confirmExecution: z.ZodOptional<z.ZodBoolean>;
+    };
+    annotations: {
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    handler: (args: {
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        path: string;
+        pathParams?: Record<string, string>;
+        queryParams?: Record<string, string>;
+        body?: Record<string, unknown>;
+        confirmExecution?: boolean;
+    }) => Promise<unknown>;
+};

package/build/tools/reliability-management.d.ts

@@ -0,0 +1,98 @@
+import z from "zod";
+import type { GremlinClient } from "../client/interface";
+import type { ReliabilityTestRun } from "../types";
+export declare function createGetReliabilityExperimentTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+        dependencyId: z.ZodOptional<z.ZodString>;
+        testId: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        includeScenarioRun: z.ZodOptional<z.ZodBoolean>;
+    };
+    handler: (args: {
+        serviceId: string;
+        teamId: string;
+        dependencyId?: string;
+        testId?: string;
+        limit?: number;
+        includeScenarioRun?: boolean;
+    }) => Promise<ReliabilityTestRun | import("../types").Page<ReliabilityTestRun>>;
+};
+export declare function createGetReliabilityReportTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+        date: z.ZodOptional<z.ZodString>;
+    };
+    handler: (args: {
+        serviceId: string;
+        teamId: string;
+        date?: string;
+    }) => Promise<import("../types").ReliabilityReport>;
+};
+export declare function createGetCurrentTestSuiteTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodOptional<z.ZodString>;
+    };
+    handler: (args: {
+        teamId: string;
+    }) => Promise<import("../types").ReliabilityTestSuite[]>;
+};
+export declare function createRunReliabilityTestTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+        reliabilityTestId: z.ZodString;
+        dependencyId: z.ZodOptional<z.ZodString>;
+        failureFlagName: z.ZodOptional<z.ZodString>;
+        includeScenarioRun: z.ZodOptional<z.ZodBoolean>;
+    };
+    annotations: {
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+    handler: (args: {
+        teamId: string;
+        serviceId: string;
+        reliabilityTestId: string;
+        dependencyId?: string;
+        failureFlagName?: string;
+        includeScenarioRun?: boolean;
+    }) => Promise<ReliabilityTestRun>;
+};
+export declare function createGetPendingTestRunsTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+    };
+    handler: (args: {
+        teamId: string;
+        serviceId: string;
+    }) => Promise<import("../types").PendingReliabilityTestRun[]>;
+};
+export declare function createGetRecentReliabilityTestsTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        pageSize: z.ZodOptional<z.ZodNumber>;
+        pageToken: z.ZodOptional<z.ZodString>;
+    };
+    handler: (args: {
+        teamId: string;
+        pageSize?: number;
+        pageToken?: string;
+    }) => Promise<import("../types").Page<import("../types").RecentRunResponse>>;
+};

package/build/tools/services.d.ts

@@ -0,0 +1,55 @@
+import z from "zod";
+import type { GremlinClient } from "../client/interface";
+import type { Service } from "../types";
+export declare function createGetServiceDependenciesTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+    };
+    handler: (args: {
+        serviceId: string;
+        teamId: string;
+    }) => Promise<import("../types").ReliabilityReport>;
+};
+export declare function createListServiceRisksTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+    };
+    handler: (args: {
+        serviceId: string;
+        teamId: string;
+    }) => Promise<import("../types").ReliabilityReport>;
+};
+export declare function createGetServiceStatusChecksTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        teamId: z.ZodString;
+        serviceId: z.ZodString;
+    };
+    handler: (args: {
+        serviceId: string;
+        teamId: string;
+    }) => Promise<import("../types").ReliabilityReport>;
+};
+export declare function createListServicesTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {
+        $schema: string;
+        type: string;
+        properties: {};
+    };
+    /**
+     * Handles the list_services tool request with pagination and search
+     *
+     * @param params -  none currently, but will be extended for pagination
+     * @returns list of services with their details
+     */
+    handler: (params: {}) => Promise<Service[]>;
+};

package/build/tools/teams.d.ts

@@ -0,0 +1,7 @@
+import type { GremlinClient } from "../client/interface";
+export declare function createListTeamsTool(api: GremlinClient): {
+    name: string;
+    description: string;
+    schema: {};
+    handler: () => Promise<import("..").Team[]>;
+};

package/build/types.d.ts

@@ -0,0 +1,155 @@
+export interface Team {
+    identifier: string;
+    name: string;
+    companyId: string;
+    production: boolean;
+}
+export interface Service {
+    serviceId: string;
+    teamId: string;
+    name: string;
+    targetingStrategy?: string;
+    applicationSelector?: string;
+    description?: string;
+    schedulableTests?: string[];
+}
+export interface Self {
+    identifier: string;
+    user_id: string;
+    company_id: string;
+    team_memberships: string[];
+}
+export interface ReliabilityReport {
+    reliabilityScore: number;
+    testSuiteId: string;
+    reliability: Map<string, ReliabilityCategorySummary>;
+}
+export interface ReliabilityCategorySummary {
+    category: string;
+    score: number;
+    policyTarget: string;
+    policyStates: PolicyEvaluation[];
+}
+export interface PolicyEvaluation {
+    policyId: string;
+    reliabilityTestId: string;
+    serviceId: string;
+    dependencyId?: string;
+    failureFlagName?: string;
+    evaluationTime?: number;
+    staleness: number;
+    result: 'PASSED' | 'FAILED' | 'EXPIRED' | 'NEVER_RUN';
+}
+interface ScenarioRunResponse {
+    scenarioId: string;
+    runNumber: number;
+    orgId: string;
+    name: string;
+    description: string;
+    createdAt: Date;
+    updatedAt: Date;
+    endTime?: Date;
+    createSource: string;
+    triggerSource: string;
+    results: {
+        status: 'Passed' | 'Failed' | 'Unsure';
+    };
+    graph: ScenarioGraph;
+}
+interface ScenarioGraph {
+    nodesRecursive: never[];
+    expectedLength: number;
+    graph: Record<string, ScenarioGraphNode>;
+}
+interface ScenarioGraphNode {
+    id: string;
+    state: {
+        lifeCycle: 'NotStarted' | 'Running' | 'Completed' | 'Failed' | 'Halted' | 'HaltRequested' | 'Active' | 'Successful';
+    };
+}
+interface Suggestion {
+    markdown: string;
+    embeddings: {
+        serviceId: string;
+        key: string;
+    }[];
+}
+interface DiagnosisResponse {
+    summary: string;
+    suggestions: Suggestion[];
+}
+export interface PendingReliabilityTestRun {
+    reliabilityTestId: string;
+    reliabilityTestName: string;
+    dependencyId?: string;
+    dependencyName?: string;
+    failureFlagName?: string;
+    triggerSource: 'MANUAL' | 'RUN_ALL' | 'SCHEDULED' | 'RECURRING_SCHEDULE';
+    triggeredBy?: string;
+    expectedTriggerTime?: string;
+}
+export interface ReliabilityTestRunParameters {
+    serviceId: string;
+    dependencyId?: string;
+    failureFlagName?: string;
+}
+export interface ReliabilityTestRun {
+    guid: string;
+    serviceId: string;
+    dependencyId?: string;
+    dependencyName?: string;
+    failureFlagName?: string;
+    isDependencySpof?: boolean;
+    runNumber?: number;
+    run: ScenarioRunResponse;
+    diagnosis?: DiagnosisResponse;
+}
+export interface RecentRunResponse {
+    serviceId: string;
+    dependencyId?: string;
+    dependencyName?: string;
+    diagnosisAvailable: boolean;
+    createTime: Date;
+    endTime?: Date;
+    passCriteria: string;
+    reliabilityTestId: string;
+    reliabilityTestName: string;
+    runNumber: number;
+    status: 'Passed' | 'Failed' | 'Unsure';
+    triggerSource: string;
+    triggeredBy: string;
+}
+export interface Page<T> {
+    items: T[];
+    pageToken?: string;
+    pageSize?: number;
+}
+export interface ReliabilityTestSuite {
+    identifier: string;
+    name: string;
+    description?: string;
+    targetTeamIds: string[];
+    testResponses: any[];
+    excludedRiskIds?: string[];
+}
+export interface PricingUsage {
+    start: string;
+    end: string;
+    maxActiveAgents: number;
+    maxTargetableApplications: number;
+    uniqueTargetsApplication: number;
+    uniqueTargetsContainer: number;
+    uniqueTargetsHost: number;
+}
+export type TrackingPeriod = 'Daily' | 'Weekly' | 'Monthly';
+export interface PricingReport {
+    companyId: string;
+    startDate: string;
+    endDate: string;
+    trackingPeriod: TrackingPeriod;
+    usageByTrackingPeriod: PricingUsage[];
+}
+export type ReportPeriod = 'MONTHS' | 'WEEKS' | 'DAYS';
+export interface User {
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gremlin/mcp-server",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Gremlin MCP Server",
   "main": "build/main.mjs",
   "bin": "build/main.mjs",
@@ -21,9 +21,9 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "Apache-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.15.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@isaacs/ttlcache": "^1.1.1",
     "zod": "^3.25.75"
   },
@@ -32,5 +32,11 @@
     "esbuild": "^0.25.8",
     "typescript": "^5.8.3",
     "vitest": "^4.0.18"
+  },
+  "overrides": {
+    "vite": "7.3.3",
+    "rollup": "4.60.4",
+    "postcss": "8.5.14",
+    "picomatch": "4.0.4"
   }
 }