retestkit 1.4.1 → 1.5.0

package/src/tools/webtest/start-analysis.test.ts

@@ -1,151 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createStartAnalysisTool } from "./start-analysis.js";
-import {
-  createMockContext,
-  type MockContext,
-} from "../../test-utils/index.js";
-
-describe("webtest_init", () => {
-  let context: MockContext;
-  let tool: ReturnType<typeof createStartAnalysisTool>;
-
-  beforeEach(() => {
-    context = createMockContext();
-    tool = createStartAnalysisTool(() => context as any);
-  });
-
-  describe("tool metadata", () => {
-    it("has correct name", () => {
-      expect(tool.name).toBe("webtest_init");
-    });
-
-    it("has a description", () => {
-      expect(tool.description).toBeDefined();
-      expect(tool.description.length).toBeGreaterThan(0);
-    });
-
-    it("has an input schema", () => {
-      expect(tool.inputSchema).toBeDefined();
-    });
-  });
-
-  describe("handler", () => {
-    it("creates workspace for valid URL", async () => {
-      const result = await tool.handler({
-        url: "https://example.com",
-        focus: "Test the login flow",
-      });
-
-      expect(result.isError).toBeFalsy();
-      expect(context.workspaceManager.createWorkspace).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: "https://example.com",
-          focus: "Test the login flow",
-        })
-      );
-    });
-
-    it("returns analysisId in response", async () => {
-      const result = await tool.handler({
-        url: "https://example.com",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = result.content[0];
-      expect(content.type).toBe("text");
-      expect(content.text).toContain("analysisId");
-    });
-
-    it("uses default limits from config", async () => {
-      await tool.handler({
-        url: "https://example.com",
-      });
-
-      expect(context.workspaceManager.createWorkspace).toHaveBeenCalledWith(
-        expect.objectContaining({
-          limits: expect.objectContaining({
-            maxSteps: context.config.defaultMaxSteps,
-            maxMinutes: context.config.defaultMaxMinutes,
-            maxPages: context.config.defaultMaxPages,
-          }),
-        })
-      );
-    });
-
-    it("respects custom limits", async () => {
-      await tool.handler({
-        url: "https://example.com",
-        limits: {
-          maxSteps: 10,
-          maxMinutes: 5,
-          maxPages: 3,
-        },
-      });
-
-      expect(context.workspaceManager.createWorkspace).toHaveBeenCalledWith(
-        expect.objectContaining({
-          limits: expect.objectContaining({
-            maxSteps: 10,
-            maxMinutes: 5,
-            maxPages: 3,
-          }),
-        })
-      );
-    });
-
-    it("stores allowed domains from input URL", async () => {
-      const result = await tool.handler({
-        url: "https://shop.example.com/products",
-      });
-
-      expect(result.isError).toBeFalsy();
-      // The domain should be extracted and stored
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.domain).toBe("shop.example.com");
-    });
-
-    it("handles custom allowed domains", async () => {
-      const result = await tool.handler({
-        url: "https://shop.example.com",
-        allowedDomains: ["shop.example.com", "api.example.com"],
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.allowedDomains).toContain("shop.example.com");
-      expect(content.allowedDomains).toContain("api.example.com");
-    });
-
-    it("returns error for invalid URL", async () => {
-      const result = await tool.handler({
-        url: "not-a-valid-url",
-      });
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("Error");
-    });
-
-    it("logs analysis start", async () => {
-      await tool.handler({
-        url: "https://example.com",
-        focus: "Test flow",
-      });
-
-      expect(context.logger.info).toHaveBeenCalledWith(
-        expect.stringContaining("analysis"),
-        expect.any(Object)
-      );
-    });
-
-    it("returns workspace URIs", async () => {
-      const result = await tool.handler({
-        url: "https://example.com",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.workspaceRootUri).toContain("webtest://");
-      expect(content.statusUri).toContain("webtest://");
-    });
-  });
-});

package/src/tools/webtest/start-analysis.ts

@@ -1,158 +0,0 @@
-import { z } from "zod";
-import type { McpTool, ToolResult } from "../../types/tool.js";
-import type { ServerContext } from "../../types/context.js";
-import { AnalysisLimitsSchema } from "./schemas.js";
-
-export const startAnalysisInputSchema = z.object({
-  url: z.string().url("Must be a valid URL"),
-  focus: z
-    .string()
-    .optional()
-    .describe("Optional focus area for the analysis (e.g., 'checkout flow', 'user registration')"),
-  limits: AnalysisLimitsSchema.optional().describe(
-    "Optional limits for the analysis"
-  ),
-  allowedDomains: z
-    .array(z.string())
-    .optional()
-    .describe("Additional domains to allow during crawling (target domain is always allowed)"),
-});
-
-export type StartAnalysisInput = z.infer<typeof startAnalysisInputSchema>;
-
-export function createStartAnalysisTool(
-  getContext: () => ServerContext
-): McpTool<StartAnalysisInput> {
-  return {
-    name: "webtest_init",
-    description: `Initialize a new web testing analysis workspace.
-
-This tool creates a workspace for analyzing a web application. It:
-- Validates the target URL
-- Creates a workspace directory structure
-- Records analysis metadata and limits
-- Returns identifiers for subsequent operations
-
-Use this as the first step before crawling, analyzing, or testing.`,
-
-    inputSchema: startAnalysisInputSchema,
-
-    async handler(input: StartAnalysisInput): Promise<ToolResult> {
-      const ctx = getContext();
-      const { config, logger } = ctx;
-
-      logger.info("Starting analysis", { url: input.url, focus: input.focus });
-
-      // Validate and normalize URL
-      let targetUrl: URL;
-      try {
-        targetUrl = new URL(input.url);
-      } catch {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: Invalid URL "${input.url}". Please provide a valid HTTP or HTTPS URL.`,
-            },
-          ],
-          isError: true,
-        };
-      }
-
-      if (!["http:", "https:"].includes(targetUrl.protocol)) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: URL must use HTTP or HTTPS protocol. Got: ${targetUrl.protocol}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-
-      // Determine limits
-      const limits = {
-        maxSteps: input.limits?.maxSteps ?? config.defaultMaxSteps,
-        maxMinutes: input.limits?.maxMinutes ?? config.defaultMaxMinutes,
-        maxPages: input.limits?.maxPages ?? config.defaultMaxPages,
-      };
-
-      // Build allowed domains list
-      const allowedDomains = new Set<string>([targetUrl.hostname]);
-      if (input.allowedDomains) {
-        for (const domain of input.allowedDomains) {
-          allowedDomains.add(domain);
-        }
-      }
-
-      // Create workspace using workspace manager from context
-      // Note: We need to get this from an extended context that includes the workspace manager
-      const workspaceManager = (ctx as any).workspaceManager;
-      if (!workspaceManager) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Workspace manager not available. Server may not be fully initialized.",
-            },
-          ],
-          isError: true,
-        };
-      }
-
-      try {
-        const { analysisId, workspacePath } = await workspaceManager.createWorkspace({
-          url: input.url,
-          focus: input.focus,
-          limits,
-        });
-
-        // Notify clients about new resource
-        const resourceManager = (ctx as any).resourceManager;
-        if (resourceManager) {
-          await resourceManager.notifyListChanged();
-        }
-
-        const result = {
-          analysisId,
-          workspaceRootPath: workspacePath,
-          workspaceRootUri: `webtest://${analysisId}`,
-          statusUri: `webtest://${analysisId}/index.md`,
-          domain: targetUrl.hostname,
-          allowedDomains: Array.from(allowedDomains),
-          limits,
-          nextSteps: [
-            `Use webtest_crawl_app with analysisId="${analysisId}" to explore the application`,
-            "Set a goal describing what you want to explore or test",
-            "After crawling, use webtest_analyze_app to analyze the application structure",
-          ],
-        };
-
-        logger.info("Analysis workspace created", { analysisId, url: input.url });
-
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result, null, 2),
-            },
-          ],
-        };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error";
-        logger.error("Failed to create analysis workspace", { error: message });
-
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error creating workspace: ${message}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-    },
-  };
-}

package/src/transports/http.ts

@@ -1,19 +0,0 @@
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import type { Logger } from "../logger.js";
-
-export interface HttpTransportOptions {
-  port: number;
-}
-
-export function createHttpTransport(
-  options: HttpTransportOptions,
-  logger: Logger
-): StreamableHTTPServerTransport {
-  logger.info("Creating HTTP transport", { port: options.port });
-
-  return new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => crypto.randomUUID(),
-  });
-}
-
-export { StreamableHTTPServerTransport };

package/src/transports/index.ts

@@ -1,30 +0,0 @@
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import type { Config } from "../config.js";
-import type { Logger } from "../logger.js";
-import { createStdioTransport } from "./stdio.js";
-import {
-  createHttpTransport,
-  StreamableHTTPServerTransport,
-} from "./http.js";
-
-export type TransportResult =
-  | { type: "stdio"; transport: Transport }
-  | { type: "http"; transport: StreamableHTTPServerTransport; port: number };
-
-export function createTransport(config: Config, logger: Logger): TransportResult {
-  switch (config.transport) {
-    case "stdio":
-      return {
-        type: "stdio",
-        transport: createStdioTransport(logger),
-      };
-    case "http":
-      return {
-        type: "http",
-        transport: createHttpTransport({ port: config.port }, logger),
-        port: config.port,
-      };
-    default:
-      throw new Error(`Unknown transport type: ${config.transport}`);
-  }
-}

package/src/transports/stdio.ts

@@ -1,7 +0,0 @@
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import type { Logger } from "../logger.js";
-
-export function createStdioTransport(logger: Logger): StdioServerTransport {
-  logger.info("Creating stdio transport");
-  return new StdioServerTransport();
-}

package/src/types/capabilities.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  DEFAULT_CAPABILITIES,
-  hasSampling,
-  hasElicitation,
-  hasLogging,
-  hasProgress,
-  hasResourcesListChanged,
-  hasResourcesSubscribe,
-  isElicitationSupported,
-  type ClientCapabilities,
-} from "./capabilities.js";
-
-describe("capabilities", () => {
-  describe("DEFAULT_CAPABILITIES", () => {
-    it("has all capabilities disabled by default", () => {
-      expect(DEFAULT_CAPABILITIES.sampling).toBe(false);
-      expect(DEFAULT_CAPABILITIES.elicitation).toBe(false);
-      expect(DEFAULT_CAPABILITIES.logging).toBe(false);
-      expect(DEFAULT_CAPABILITIES.progress).toBe(false);
-      expect(DEFAULT_CAPABILITIES.resourcesListChanged).toBe(false);
-      expect(DEFAULT_CAPABILITIES.resourcesSubscribe).toBe(false);
-    });
-
-    it("has unknown protocol version by default", () => {
-      expect(DEFAULT_CAPABILITIES.protocolVersion).toBe("unknown");
-    });
-  });
-
-  describe("capability helper functions", () => {
-    const enabledCaps: ClientCapabilities = {
-      sampling: true,
-      elicitation: true,
-      logging: true,
-      progress: true,
-      resourcesListChanged: true,
-      resourcesSubscribe: true,
-      protocolVersion: "2025-06-18",
-    };
-
-    const disabledCaps: ClientCapabilities = {
-      sampling: false,
-      elicitation: false,
-      logging: false,
-      progress: false,
-      resourcesListChanged: false,
-      resourcesSubscribe: false,
-      protocolVersion: "2024-01-01",
-    };
-
-    describe("hasSampling", () => {
-      it("returns true when sampling is enabled", () => {
-        expect(hasSampling(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when sampling is disabled", () => {
-        expect(hasSampling(disabledCaps)).toBe(false);
-      });
-    });
-
-    describe("hasElicitation", () => {
-      it("returns true when elicitation is enabled", () => {
-        expect(hasElicitation(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when elicitation is disabled", () => {
-        expect(hasElicitation(disabledCaps)).toBe(false);
-      });
-    });
-
-    describe("hasLogging", () => {
-      it("returns true when logging is enabled", () => {
-        expect(hasLogging(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when logging is disabled", () => {
-        expect(hasLogging(disabledCaps)).toBe(false);
-      });
-    });
-
-    describe("hasProgress", () => {
-      it("returns true when progress is enabled", () => {
-        expect(hasProgress(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when progress is disabled", () => {
-        expect(hasProgress(disabledCaps)).toBe(false);
-      });
-    });
-
-    describe("hasResourcesListChanged", () => {
-      it("returns true when resourcesListChanged is enabled", () => {
-        expect(hasResourcesListChanged(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when resourcesListChanged is disabled", () => {
-        expect(hasResourcesListChanged(disabledCaps)).toBe(false);
-      });
-    });
-
-    describe("hasResourcesSubscribe", () => {
-      it("returns true when resourcesSubscribe is enabled", () => {
-        expect(hasResourcesSubscribe(enabledCaps)).toBe(true);
-      });
-
-      it("returns false when resourcesSubscribe is disabled", () => {
-        expect(hasResourcesSubscribe(disabledCaps)).toBe(false);
-      });
-    });
-  });
-
-  describe("isElicitationSupported", () => {
-    it("returns true when elicitation enabled and protocol version sufficient", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "2025-06-18",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(true);
-    });
-
-    it("returns true for newer protocol versions", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "2025-12-01",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(true);
-    });
-
-    it("returns false when protocol version is too old", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "2025-01-01",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(false);
-    });
-
-    it("returns false when protocol version is unknown", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "unknown",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(false);
-    });
-
-    it("returns false when elicitation is disabled", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: false,
-        protocolVersion: "2025-06-18",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(false);
-    });
-
-    it("returns false when both elicitation disabled and old protocol", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: false,
-        protocolVersion: "2024-01-01",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(false);
-    });
-
-    it("handles edge case protocol version exactly matching requirement", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "2025-06-18",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(true);
-    });
-
-    it("handles protocol version one day before requirement", () => {
-      const caps: ClientCapabilities = {
-        ...DEFAULT_CAPABILITIES,
-        elicitation: true,
-        protocolVersion: "2025-06-17",
-      };
-
-      expect(isElicitationSupported(caps)).toBe(false);
-    });
-  });
-});

package/src/types/capabilities.ts

@@ -1,50 +0,0 @@
-export interface ClientCapabilities {
-  sampling: boolean;
-  elicitation: boolean;
-  logging: boolean;
-  progress: boolean;
-  resourcesListChanged: boolean;
-  resourcesSubscribe: boolean;
-  protocolVersion: string;
-}
-
-export const DEFAULT_CAPABILITIES: ClientCapabilities = {
-  sampling: false,
-  elicitation: false,
-  logging: false,
-  progress: false,
-  resourcesListChanged: false,
-  resourcesSubscribe: false,
-  protocolVersion: "unknown",
-};
-
-export function hasSampling(caps: ClientCapabilities): boolean {
-  return caps.sampling;
-}
-
-export function hasElicitation(caps: ClientCapabilities): boolean {
-  return caps.elicitation;
-}
-
-export function hasLogging(caps: ClientCapabilities): boolean {
-  return caps.logging;
-}
-
-export function hasProgress(caps: ClientCapabilities): boolean {
-  return caps.progress;
-}
-
-export function hasResourcesListChanged(caps: ClientCapabilities): boolean {
-  return caps.resourcesListChanged;
-}
-
-export function hasResourcesSubscribe(caps: ClientCapabilities): boolean {
-  return caps.resourcesSubscribe;
-}
-
-export function isElicitationSupported(caps: ClientCapabilities): boolean {
-  // Elicitation requires protocol version 2025-06-18 or later
-  const version = caps.protocolVersion;
-  if (version === "unknown") return false;
-  return version >= "2025-06-18" && caps.elicitation;
-}

package/src/types/context.ts

@@ -1,21 +0,0 @@
-import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import type { Config } from "../schemas/config.js";
-import type { Logger } from "../logger.js";
-import type { ClientCapabilities } from "./capabilities.js";
-import type { PlaywrightClient } from "../playwright-client/index.js";
-import type { CancellationRegistry } from "../progress/index.js";
-import type { ResourceSubscriptions } from "../resources/subscriptions.js";
-
-export interface ServerContext {
-  config: Config;
-  logger: Logger;
-  server: Server;
-  capabilities: ClientCapabilities;
-  playwrightClient: PlaywrightClient | null;
-  cancellationRegistry: CancellationRegistry;
-  resourceSubscriptions: ResourceSubscriptions;
-}
-
-export type ServerContextWithPlaywright = ServerContext & {
-  playwrightClient: PlaywrightClient;
-};

package/src/types/tool.ts

@@ -1,11 +0,0 @@
-import type { z } from "zod";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-
-export type ToolResult = CallToolResult;
-
-export interface McpTool<TInput = unknown> {
-  name: string;
-  description: string;
-  inputSchema: z.ZodType<TInput>;
-  handler: (input: TInput) => Promise<ToolResult>;
-}