start_codegen_session

Start recording browser automation actions to generate Playwright test code with configurable output options for automated testing workflows.

Instructions

Start a new code generation session to record Playwright actions

Input Schema

TableJSON Schema

Name	Required	Description	Default
`options`	Yes	Code generation options

Implementation Reference

src/tools/codegen/index.ts:26-81 (handler)

Primary implementation of the 'start_codegen_session' tool, including handler function that initializes a codegen session with ActionRecorder, merges options, ensures output directory, and returns session details.

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 }, _context?: { server?: any }) => {
    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)

Input schema definition for 'start_codegen_session' used in createToolDefinitions for MCP tool discovery.

{
  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:431-440 (registration)

Registration and dispatch logic for codegen tools including 'start_codegen_session' in the main tool call handler switch statement.

switch (name) {
  case "start_codegen_session":
    return await handleCodegenResult(startCodegenSession.handler(args, { server }));
  case "end_codegen_session":
    return await handleCodegenResult(endCodegenSession.handler(args, { server }));
  case "get_codegen_session":
    return await handleCodegenResult(getCodegenSession.handler(args, { server }));
  case "clear_codegen_session":
    return await handleCodegenResult(clearCodegenSession.handler(args, { server }));
}

src/toolHandler.ts:37-40 (registration)
Import statement registering the startCodegenSession tool from codegen/index.ts into the main toolHandler.
```
clearCodegenSession,
endCodegenSession,
getCodegenSession,
startCodegenSession,
```
src/tools/codegen/index.ts:219-219 (schema)
Export of codegenTools array including startCodegenSession for registration.
```
export const codegenTools = [startCodegenSession, endCodegenSession, getCodegenSession, clearCodegenSession];
```

mcp-playwright