mcp-playwright

Instructions

Implementation Reference

• src/tools/codegen/index.ts:82-158 (handler)

  The complete tool definition including name, description, parameters schema, and the main handler function that ends the codegen session, generates the Playwright test file, and cleans up browser resources.

  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 }) => {
      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}`);
        }
  
        // 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);
  
        return {
          filePath: absolutePath,
          outputDirectory: outputDir,
          testCode: result.testCode,
          message: `Generated test file at: ${absolutePath}\nOutput directory: ${outputDir}`
        };
      } 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 (registration)

  MCP tool registration definition providing the input schema for end_codegen_session as part of createToolDefinitions().

  {
    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:365-373 (registration)

  Runtime dispatch/registration in handleToolCall switch statement that invokes the endCodegenSession.handler for the 'end_codegen_session' tool name.

    case 'start_codegen_session':
      return await handleCodegenResult(startCodegenSession.handler(args));
    case 'end_codegen_session':
      return await handleCodegenResult(endCodegenSession.handler(args));
    case 'get_codegen_session':
      return await handleCodegenResult(getCodegenSession.handler(args));
    case 'clear_codegen_session':
      return await handleCodegenResult(clearCodegenSession.handler(args));
  }