mcp-playwright

Instructions

Implementation Reference

• src/tools/codegen/index.ts:25-80 (handler)

  Defines and implements the 'start_codegen_session' tool including its handler function that initializes a new code generation session by merging options, creating output directories, and starting an ActionRecorder session.

  export const startCodegenSession: Tool = {
    name: 'start_codegen_session',
    description: 'Start a new code generation session to record MCP tool actions',
    parameters: {
      type: 'object',
      properties: {
        options: {
          type: 'object',
          description: 'Code generation options',
          properties: {
            outputPath: { type: 'string' },
            testNamePrefix: { type: 'string' },
            includeComments: { type: 'boolean' }
          }
        }
      }
    },
    handler: async ({ options = {} }: { options?: CodegenOptions }) => {
      try {
        // Merge provided options with defaults
        const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
        
        // Ensure output path is absolute and normalized
        const workspaceRoot = getWorkspaceRoot();
        const outputPath = path.isAbsolute(mergedOptions.outputPath) 
          ? mergedOptions.outputPath 
          : path.join(workspaceRoot, mergedOptions.outputPath);
        
        mergedOptions.outputPath = outputPath;
        
        // Ensure output directory exists
        try {
          await fs.mkdir(outputPath, { recursive: true });
        } catch (mkdirError: any) {
          throw new Error(`Failed to create output directory: ${mkdirError.message}`);
        }
        
        const sessionId = ActionRecorder.getInstance().startSession();
        
        // Store options with the session
        const recorder = ActionRecorder.getInstance();
        const session = recorder.getSession(sessionId);
        if (session) {
          session.options = mergedOptions;
        }
        
        return { 
          sessionId,
          options: mergedOptions,
          message: `Started codegen session. Tests will be generated in: ${outputPath}`
        };
      } catch (error: any) {
        throw new Error(`Failed to start codegen session: ${error.message}`);
      }
    }
  };

• src/tools.ts:7-35 (schema)

  MCP input schema definition for the 'start_codegen_session' tool, specifying detailed properties and requirements for the options parameter.

  {
    name: "start_codegen_session",
    description: "Start a new code generation session to record Playwright actions",
    inputSchema: {
      type: "object",
      properties: {
        options: {
          type: "object",
          description: "Code generation options",
          properties: {
            outputPath: { 
              type: "string", 
              description: "Directory path where generated tests will be saved (use absolute path)" 
            },
            testNamePrefix: { 
              type: "string", 
              description: "Prefix to use for generated test names (default: 'GeneratedTest')" 
            },
            includeComments: { 
              type: "boolean", 
              description: "Whether to include descriptive comments in generated tests" 
            }
          },
          required: ["outputPath"]
        }
      },
      required: ["options"]
    }
  },

• src/toolHandler.ts:364-372 (registration)

  Registration and dispatching logic in the main tool handler switch statement that routes 'start_codegen_session' calls to its handler function.

  switch (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));

• src/tools/codegen/index.ts:28-41 (schema)

  Internal parameters schema defined within the Tool object for 'start_codegen_session'.

  parameters: {
    type: 'object',
    properties: {
      options: {
        type: 'object',
        description: 'Code generation options',
        properties: {
          outputPath: { type: 'string' },
          testNamePrefix: { type: 'string' },
          includeComments: { type: 'boolean' }
        }
      }
    }
  },

• src/toolHandler.ts:7-12 (registration)

  Import statement registering the codegen tools including 'start_codegen_session' for use in the tool handler.

  import { 
    startCodegenSession,
    endCodegenSession,
    getCodegenSession,
    clearCodegenSession
  } from './tools/codegen/index.js';