mcp-playwright

Instructions

Implementation Reference

• src/tools/codegen/index.ts:83-173 (handler)

  Primary handler implementation for end_codegen_session tool. Ends the recording session, generates Playwright test using PlaywrightGenerator, writes file to disk, optionally registers as MCP resource, cleans up browser state, and returns file information.

  export const endCodegenSession: Tool = {
    name: "end_codegen_session",
    description: "End the current code generation session and generate Playwright test",
    parameters: {
      type: "object",
      properties: {
        sessionId: {
          type: "string",
          description: "ID of the session to end",
        },
      },
      required: ["sessionId"],
    },
    handler: async ({ sessionId }: { sessionId: string }, context?: { server?: any }) => {
      try {
        const recorder = ActionRecorder.getInstance();
        const session = recorder.endSession(sessionId);
  
        if (!session) {
          throw new Error(`Session ${sessionId} not found`);
        }
  
        if (!session.options) {
          throw new Error(`Session ${sessionId} has no options configured`);
        }
  
        const generator = new PlaywrightGenerator(session.options);
        const result = await generator.generateTest(session);
  
        // Double check output directory exists
        const outputDir = path.dirname(result.filePath);
        await fs.mkdir(outputDir, { recursive: true });
  
        // Write test file
        try {
          await fs.writeFile(result.filePath, result.testCode, "utf-8");
        } catch (writeError: any) {
          throw new Error(`Failed to write test file: ${writeError.message}`);
        }
  
        let resourceLink: Awaited<ReturnType<typeof registerFileResource>> | undefined;
        try {
          resourceLink = await registerFileResource({
            filePath: result.filePath,
            name: path.basename(result.filePath),
            mimeType: "text/plain",
            server: context?.server,
          });
        } catch (error) {
          console.warn("Failed to register generated test as resource:", error);
        }
  
        // Close Playwright browser and cleanup
        try {
          if (global.browser?.isConnected()) {
            await global.browser.close();
          }
        } catch (browserError: any) {
          console.warn("Failed to close browser:", browserError.message);
        } finally {
          global.browser = undefined;
          global.page = undefined;
        }
  
        const absolutePath = path.resolve(result.filePath);
        const displayPath = resourceLink?.uri ?? absolutePath;
  
        return {
          filePath: absolutePath,
          outputDirectory: outputDir,
          testCode: result.testCode,
          message: `Generated test file at: ${displayPath}\nOutput directory: ${outputDir}`,
          ...(resourceLink ? { resourceLinks: [resourceLink] } : {}),
        };
      } catch (error: any) {
        // Ensure browser cleanup even on error
        try {
          if (global.browser?.isConnected()) {
            await global.browser.close();
          }
        } catch {
          // Ignore cleanup errors
        } finally {
          global.browser = undefined;
          global.page = undefined;
        }
  
        throw new Error(`Failed to end codegen session: ${error.message}`);
      }
    },
  };

• src/tools.ts:36-49 (schema)

  Input schema definition for end_codegen_session used in MCP tool definitions list (createToolDefinitions). Defines parameters and validation.

  {
    name: "end_codegen_session",
    description: "End a code generation session and generate the test file",
    inputSchema: {
      type: "object",
      properties: {
        sessionId: {
          type: "string",
          description: "ID of the session to end",
        },
      },
      required: ["sessionId"],
    },
  },

• src/toolHandler.ts:434-435 (registration)

  Tool dispatch/registration in main tool handler switch statement. Imports endCodegenSession from codegen/index.ts and calls its handler via handleCodegenResult.

  case "end_codegen_session":
    return await handleCodegenResult(endCodegenSession.handler(args, { server }));

• src/toolHandler.ts:37-41 (registration)

  Import statement bringing endCodegenSession handler into toolHandler.ts for use in dispatch.

    clearCodegenSession,
    endCodegenSession,
    getCodegenSession,
    startCodegenSession,
  } from "./tools/codegen/index.js";

• src/tools/codegen/index.ts:86-95 (schema)

  Input parameters schema defined directly in the tool object (matches tools.ts schema). Used by the handler.

  parameters: {
    type: "object",
    properties: {
      sessionId: {
        type: "string",
        description: "ID of the session to end",
      },
    },
    required: ["sessionId"],
  },