greenrun-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Greenrun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# greenrun-cli
+
+Browser test management for Claude Code. Connects Claude to the [Greenrun](https://app.greenrun.dev) API via MCP, enabling Claude to run, create, and manage browser tests directly from your terminal.
+
+## Prerequisites
+
+- **Node.js 18+**
+- **Claude Code CLI** - [Install guide](https://docs.anthropic.com/en/docs/claude-code)
+- **Claude in Chrome extension** - Required for browser test execution. [Install from Chrome Web Store](https://chromewebstore.google.com/detail/claude-in-chrome)
+
+## Quick Start
+
+```bash
+npx greenrun-cli init
+```
+
+This interactive wizard will:
+1. Connect your Greenrun API token
+2. Configure the MCP server for Claude Code
+3. Optionally install slash commands and project instructions
+
+## How It Works
+
+Greenrun CLI is an [MCP server](https://modelcontextprotocol.io/) that gives Claude Code access to the Greenrun API. Combined with the Claude in Chrome extension for browser automation, Claude can execute your browser tests end-to-end.
+
+**Flow:** Claude Code -> MCP Server -> Greenrun API -> Test instructions -> Browser automation via Chrome extension
+
+## Slash Commands
+
+After setup, two slash commands are available in Claude Code:
+
+### `/greenrun`
+
+Runs all browser tests for the current project. Optionally pass a test name to run a single test.
+
+### `/greenrun-sweep`
+
+Impact analysis - identifies which tests are affected by recent code changes and offers to run them.
+
+## MCP Tools
+
+The server exposes these tools to Claude:
+
+| Tool | Description |
+|------|-------------|
+| `list_projects` | List all projects |
+| `create_project` | Create a new project |
+| `get_project` | Get project details |
+| `list_pages` | List pages in a project |
+| `create_page` | Register a page URL |
+| `list_tests` | List tests (with latest run status) |
+| `get_test` | Get test details and instructions |
+| `create_test` | Create a new test case |
+| `update_test` | Update test instructions or status |
+| `sweep` | Find tests affected by specific pages |
+| `start_run` | Start a test run |
+| `complete_run` | Record test run result |
+| `get_run` | Get run details |
+| `list_runs` | List run history |
+
+## Manual Setup
+
+If you prefer to configure manually instead of using `init`:
+
+```bash
+claude mcp add --transport stdio -e GREENRUN_API_TOKEN=your_token greenrun -- npx -y greenrun-cli@latest
+```
+
+Or add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "greenrun": {
+      "command": "npx",
+      "args": ["-y", "greenrun-cli@latest"],
+      "env": { "GREENRUN_API_TOKEN": "${GREENRUN_API_TOKEN}" }
+    }
+  }
+}
+```
+
+## CLI Usage
+
+```
+greenrun init             Interactive setup wizard
+greenrun serve            Start MCP server explicitly
+greenrun --version        Print version
+greenrun --help           Print help
+```
+
+Non-interactive init:
+
+```bash
+npx greenrun-cli init --token gr_xxx --scope local --no-claude-md --no-commands
+```
+
+## License
+
+MIT

package/dist/api-client.d.ts

@@ -0,0 +1,63 @@
+export interface ApiConfig {
+    baseUrl: string;
+    token: string;
+}
+export declare class ApiClient {
+    private baseUrl;
+    private token;
+    constructor(config: ApiConfig);
+    private request;
+    listProjects(): Promise<unknown>;
+    createProject(data: {
+        name: string;
+        base_url?: string;
+        description?: string;
+        concurrency?: number;
+    }): Promise<unknown>;
+    getProject(id: string): Promise<unknown>;
+    updateProject(id: string, data: {
+        name?: string;
+        base_url?: string;
+        description?: string;
+        concurrency?: number;
+    }): Promise<unknown>;
+    deleteProject(id: string): Promise<unknown>;
+    listPages(projectId: string): Promise<unknown>;
+    createPage(projectId: string, data: {
+        url: string;
+        name?: string;
+    }): Promise<unknown>;
+    updatePage(id: string, data: {
+        url?: string;
+        name?: string;
+    }): Promise<unknown>;
+    deletePage(id: string): Promise<unknown>;
+    listTests(projectId: string): Promise<unknown>;
+    createTest(projectId: string, data: {
+        name: string;
+        instructions: string;
+        page_ids?: string[];
+        status?: string;
+        tags?: string[];
+    }): Promise<unknown>;
+    getTest(id: string): Promise<unknown>;
+    updateTest(id: string, data: {
+        name?: string;
+        instructions?: string;
+        page_ids?: string[];
+        status?: string;
+        tags?: string[];
+    }): Promise<unknown>;
+    deleteTest(id: string): Promise<unknown>;
+    sweep(projectId: string, params: {
+        pages?: string[];
+        url_pattern?: string;
+    }): Promise<unknown>;
+    startRun(testId: string): Promise<unknown>;
+    completeRun(runId: string, data: {
+        status: string;
+        result?: string;
+    }): Promise<unknown>;
+    getRun(runId: string): Promise<unknown>;
+    listRuns(testId: string): Promise<unknown>;
+}

package/dist/api-client.js

@@ -0,0 +1,105 @@
+export class ApiClient {
+    baseUrl;
+    token;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/+$/, '');
+        this.token = config.token;
+    }
+    async request(method, path, body) {
+        const url = `${this.baseUrl}/api/v1${path}`;
+        const headers = {
+            'Authorization': `Bearer ${this.token}`,
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        };
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            let message;
+            try {
+                const json = JSON.parse(text);
+                message = json.message || text;
+            }
+            catch {
+                message = text;
+            }
+            throw new Error(`API ${method} ${path} failed (${response.status}): ${message}`);
+        }
+        return response.json();
+    }
+    // Projects
+    async listProjects() {
+        return this.request('GET', '/projects');
+    }
+    async createProject(data) {
+        return this.request('POST', '/projects', data);
+    }
+    async getProject(id) {
+        return this.request('GET', `/projects/${id}`);
+    }
+    async updateProject(id, data) {
+        return this.request('PUT', `/projects/${id}`, data);
+    }
+    async deleteProject(id) {
+        return this.request('DELETE', `/projects/${id}`);
+    }
+    // Pages
+    async listPages(projectId) {
+        return this.request('GET', `/projects/${projectId}/pages`);
+    }
+    async createPage(projectId, data) {
+        return this.request('POST', `/projects/${projectId}/pages`, data);
+    }
+    async updatePage(id, data) {
+        return this.request('PUT', `/pages/${id}`, data);
+    }
+    async deletePage(id) {
+        return this.request('DELETE', `/pages/${id}`);
+    }
+    // Tests
+    async listTests(projectId) {
+        return this.request('GET', `/projects/${projectId}/tests`);
+    }
+    async createTest(projectId, data) {
+        return this.request('POST', `/projects/${projectId}/tests`, data);
+    }
+    async getTest(id) {
+        return this.request('GET', `/tests/${id}`);
+    }
+    async updateTest(id, data) {
+        return this.request('PUT', `/tests/${id}`, data);
+    }
+    async deleteTest(id) {
+        return this.request('DELETE', `/tests/${id}`);
+    }
+    // Sweep
+    async sweep(projectId, params) {
+        const searchParams = new URLSearchParams();
+        if (params.pages) {
+            for (const page of params.pages) {
+                searchParams.append('pages[]', page);
+            }
+        }
+        if (params.url_pattern) {
+            searchParams.set('url_pattern', params.url_pattern);
+        }
+        return this.request('GET', `/projects/${projectId}/sweep?${searchParams.toString()}`);
+    }
+    // Test Runs
+    async startRun(testId) {
+        return this.request('POST', `/tests/${testId}/runs`);
+    }
+    async completeRun(runId, data) {
+        return this.request('PUT', `/runs/${runId}`, data);
+    }
+    async getRun(runId) {
+        return this.request('GET', `/runs/${runId}`);
+    }
+    async listRuns(testId) {
+        return this.request('GET', `/tests/${testId}/runs`);
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+function getVersion() {
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+}
+function printHelp() {
+    const version = getVersion();
+    console.log(`greenrun-cli v${version} - Browser test management for Claude Code
+
+Usage:
+  greenrun init             Interactive setup wizard
+  greenrun serve            Start MCP server
+  greenrun --version, -v    Print version
+  greenrun --help, -h       Print this help
+
+When invoked with no arguments over a pipe (non-TTY stdin),
+the MCP server starts automatically (used by Claude Code).
+
+Quick start:
+  npx greenrun-cli init
+`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === '--version' || command === '-v') {
+        console.log(getVersion());
+        return;
+    }
+    if (command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    if (command === 'init') {
+        const { runInit } = await import('./commands/init.js');
+        await runInit(args.slice(1));
+        return;
+    }
+    if (command === 'serve') {
+        const { startServer } = await import('./server.js');
+        await startServer();
+        return;
+    }
+    // No command: auto-detect mode
+    if (!process.stdin.isTTY) {
+        // Non-TTY stdin means Claude Code is invoking us as an MCP server
+        const { startServer } = await import('./server.js');
+        await startServer();
+        return;
+    }
+    // TTY with no command: show help
+    printHelp();
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(args: string[]): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,243 @@
+import { createInterface } from 'readline';
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates');
+const APP_URL = 'https://app.greenrun.dev';
+function parseFlags(args) {
+    const opts = { claudeMd: true, commands: true };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--token' && args[i + 1]) {
+            opts.token = args[++i];
+        }
+        else if (arg === '--scope' && args[i + 1]) {
+            const val = args[++i];
+            if (val === 'local' || val === 'project')
+                opts.scope = val;
+        }
+        else if (arg === '--no-claude-md') {
+            opts.claudeMd = false;
+        }
+        else if (arg === '--no-commands') {
+            opts.commands = false;
+        }
+    }
+    return opts;
+}
+function prompt(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+function checkPrerequisites() {
+    let claude = false;
+    try {
+        execSync('claude --version', { stdio: 'pipe' });
+        claude = true;
+    }
+    catch {
+        // not installed
+    }
+    return { claude, chromeHint: true };
+}
+async function validateToken(token) {
+    try {
+        const response = await fetch(`${APP_URL}/api/v1/projects`, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/json',
+            },
+        });
+        if (!response.ok)
+            return { valid: false };
+        const data = await response.json();
+        const projects = Array.isArray(data) ? data : (data.data ?? []);
+        return { valid: true, projectCount: projects.length };
+    }
+    catch {
+        return { valid: false };
+    }
+}
+function configureMcpLocal(token) {
+    execSync(`claude mcp add --transport stdio -e GREENRUN_API_TOKEN=${token} greenrun -- npx -y greenrun-cli@latest`, { stdio: 'inherit' });
+}
+function configureMcpProject(token) {
+    const mcpConfig = {
+        mcpServers: {
+            greenrun: {
+                command: 'npx',
+                args: ['-y', 'greenrun-cli@latest'],
+                env: { GREENRUN_API_TOKEN: '${GREENRUN_API_TOKEN}' },
+            },
+        },
+    };
+    const mcpPath = join(process.cwd(), '.mcp.json');
+    let existing = {};
+    if (existsSync(mcpPath)) {
+        try {
+            existing = JSON.parse(readFileSync(mcpPath, 'utf-8'));
+        }
+        catch {
+            // overwrite invalid JSON
+        }
+    }
+    existing.mcpServers = existing.mcpServers || {};
+    existing.mcpServers.greenrun = mcpConfig.mcpServers.greenrun;
+    writeFileSync(mcpPath, JSON.stringify(existing, null, 2) + '\n');
+    console.log('  Created .mcp.json');
+    // Add token to .env
+    const envPath = join(process.cwd(), '.env');
+    const envLine = `GREENRUN_API_TOKEN=${token}`;
+    if (existsSync(envPath)) {
+        const envContent = readFileSync(envPath, 'utf-8');
+        if (!envContent.includes('GREENRUN_API_TOKEN=')) {
+            appendFileSync(envPath, `\n${envLine}\n`);
+            console.log('  Added GREENRUN_API_TOKEN to .env');
+        }
+        else {
+            console.log('  GREENRUN_API_TOKEN already in .env (not modified)');
+        }
+    }
+    else {
+        writeFileSync(envPath, `${envLine}\n`);
+        console.log('  Created .env with GREENRUN_API_TOKEN');
+    }
+}
+function installClaudeMd() {
+    const templatePath = join(TEMPLATES_DIR, 'claude-md.md');
+    if (!existsSync(templatePath)) {
+        console.log('  Warning: CLAUDE.md template not found, skipping');
+        return;
+    }
+    const snippet = readFileSync(templatePath, 'utf-8');
+    const claudeMdPath = join(process.cwd(), 'CLAUDE.md');
+    if (existsSync(claudeMdPath)) {
+        const existing = readFileSync(claudeMdPath, 'utf-8');
+        if (existing.includes('## Greenrun')) {
+            console.log('  CLAUDE.md already contains Greenrun section, skipping');
+            return;
+        }
+        appendFileSync(claudeMdPath, '\n' + snippet);
+        console.log('  Appended Greenrun instructions to CLAUDE.md');
+    }
+    else {
+        writeFileSync(claudeMdPath, snippet);
+        console.log('  Created CLAUDE.md with Greenrun instructions');
+    }
+}
+function installCommands() {
+    const commandsDir = join(process.cwd(), '.claude', 'commands');
+    mkdirSync(commandsDir, { recursive: true });
+    const commands = ['greenrun.md', 'greenrun-sweep.md'];
+    for (const cmd of commands) {
+        const src = join(TEMPLATES_DIR, 'commands', cmd);
+        if (!existsSync(src)) {
+            console.log(`  Warning: ${cmd} template not found, skipping`);
+            continue;
+        }
+        const dest = join(commandsDir, cmd);
+        writeFileSync(dest, readFileSync(src, 'utf-8'));
+        console.log(`  Installed /${cmd.replace('.md', '')}`);
+    }
+}
+export async function runInit(args) {
+    const opts = parseFlags(args);
+    const interactive = !opts.token;
+    console.log('\nGreenrun - Browser Test Management for Claude Code\n');
+    // Prerequisites
+    console.log('Prerequisites:');
+    const prereqs = checkPrerequisites();
+    if (prereqs.claude) {
+        console.log('  [x] Claude Code CLI installed');
+    }
+    else {
+        console.log('  [ ] Claude Code CLI not found');
+        console.log('      Install it: https://docs.anthropic.com/en/docs/claude-code');
+        if (interactive) {
+            console.log('\nClaude Code is required. Please install it and run this command again.');
+            process.exit(1);
+        }
+    }
+    console.log('  [i] Claude in Chrome extension required for browser test execution');
+    console.log('      Get it at: https://chromewebstore.google.com/detail/claude-in-chrome\n');
+    let token = opts.token;
+    let scope = opts.scope;
+    if (interactive) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        // Step 1: Token
+        console.log('Step 1: API Token');
+        console.log(`  Get your token at: ${APP_URL}/tokens`);
+        token = await prompt(rl, '  Paste your token: ');
+        if (!token) {
+            console.log('  No token provided. Aborting.');
+            rl.close();
+            process.exit(1);
+        }
+        process.stdout.write('  Validating... ');
+        const validation = await validateToken(token);
+        if (!validation.valid) {
+            console.log('Failed! Invalid token or cannot reach the API.');
+            rl.close();
+            process.exit(1);
+        }
+        console.log(`Connected! (${validation.projectCount} project${validation.projectCount === 1 ? '' : 's'} found)\n`);
+        // Step 2: Scope
+        console.log('Step 2: MCP Configuration');
+        console.log('  [1] Local config (recommended) - token stored in ~/.claude.json');
+        console.log('  [2] Project config (.mcp.json) - token via env var');
+        const scopeChoice = await prompt(rl, '  Choice [1]: ');
+        scope = scopeChoice === '2' ? 'project' : 'local';
+        console.log();
+        // Step 3: Extras
+        console.log('Step 3: Extras (optional)');
+        const claudeMdAnswer = await prompt(rl, '  Add Greenrun instructions to CLAUDE.md? [Y/n]: ');
+        opts.claudeMd = claudeMdAnswer.toLowerCase() !== 'n';
+        const commandsAnswer = await prompt(rl, '  Install slash commands? [Y/n]: ');
+        opts.commands = commandsAnswer.toLowerCase() !== 'n';
+        console.log();
+        rl.close();
+    }
+    else {
+        // Non-interactive: validate token
+        if (!token) {
+            console.error('Error: --token is required for non-interactive mode');
+            process.exit(1);
+        }
+        process.stdout.write('Validating token... ');
+        const validation = await validateToken(token);
+        if (!validation.valid) {
+            console.log('Failed!');
+            process.exit(1);
+        }
+        console.log(`Connected! (${validation.projectCount} project${validation.projectCount === 1 ? '' : 's'} found)`);
+        scope = scope || 'local';
+    }
+    // Configure MCP
+    console.log('Configuring MCP server...');
+    if (scope === 'project') {
+        configureMcpProject(token);
+    }
+    else {
+        configureMcpLocal(token);
+    }
+    console.log('  MCP server configured.\n');
+    // Install extras
+    if (opts.claudeMd) {
+        installClaudeMd();
+    }
+    if (opts.commands) {
+        installCommands();
+    }
+    console.log(`
+Done! Restart Claude Code to connect.
+
+Make sure Chrome is open with the Claude in Chrome extension active
+before running /greenrun - Claude needs browser access to execute tests.
+`);
+}

package/dist/server.d.ts

@@ -0,0 +1 @@
+export declare function startServer(): Promise<void>;

package/dist/server.js

@@ -0,0 +1,128 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { ApiClient } from './api-client.js';
+export async function startServer() {
+    const GREENRUN_API_URL = process.env.GREENRUN_API_URL || 'https://app.greenrun.dev';
+    const GREENRUN_API_TOKEN = process.env.GREENRUN_API_TOKEN;
+    if (!GREENRUN_API_TOKEN) {
+        console.error('Error: GREENRUN_API_TOKEN environment variable is required');
+        process.exit(1);
+    }
+    const api = new ApiClient({
+        baseUrl: GREENRUN_API_URL,
+        token: GREENRUN_API_TOKEN,
+    });
+    const server = new McpServer({
+        name: 'greenrun',
+        version: '0.1.0',
+    });
+    // --- Projects ---
+    server.tool('list_projects', 'List all projects', {}, async () => {
+        const result = await api.listProjects();
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('create_project', 'Create a new project', {
+        name: z.string().describe('Project name'),
+        base_url: z.string().optional().describe('Base URL of the site (e.g. https://myapp.com)'),
+        description: z.string().optional().describe('Project description'),
+        concurrency: z.number().int().min(1).max(20).optional().describe('Number of tests to run in parallel (default: 5)'),
+    }, async (args) => {
+        const result = await api.createProject(args);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('get_project', 'Get project details', { project_id: z.string().describe('Project UUID') }, async (args) => {
+        const result = await api.getProject(args.project_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // --- Pages ---
+    server.tool('list_pages', 'List pages in a project', { project_id: z.string().describe('Project UUID') }, async (args) => {
+        const result = await api.listPages(args.project_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('create_page', 'Register a page URL in a project', {
+        project_id: z.string().describe('Project UUID'),
+        url: z.string().describe('Page URL (absolute or relative to project base_url)'),
+        name: z.string().optional().describe('Human-friendly page name'),
+    }, async (args) => {
+        const result = await api.createPage(args.project_id, { url: args.url, name: args.name });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // --- Tests ---
+    server.tool('list_tests', 'List tests in a project (includes latest run status)', { project_id: z.string().describe('Project UUID') }, async (args) => {
+        const result = await api.listTests(args.project_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('get_test', 'Get test details including instructions, pages, and recent runs', { test_id: z.string().describe('Test UUID') }, async (args) => {
+        const result = await api.getTest(args.test_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('create_test', 'Store a new test case in a project', {
+        project_id: z.string().describe('Project UUID'),
+        name: z.string().describe('Test name (e.g. "User can log in")'),
+        instructions: z.string().describe('Complete test instructions as plain text'),
+        page_ids: z.array(z.string()).optional().describe('UUIDs of pages this test covers'),
+        status: z.enum(['draft', 'active', 'archived']).optional().describe('Test status (default: active)'),
+        tags: z.array(z.string()).optional().describe('Tag names for organizing tests (e.g. ["smoke", "auth"])'),
+    }, async (args) => {
+        const result = await api.createTest(args.project_id, {
+            name: args.name,
+            instructions: args.instructions,
+            page_ids: args.page_ids,
+            status: args.status,
+            tags: args.tags,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('update_test', 'Update test instructions, name, status, or page associations', {
+        test_id: z.string().describe('Test UUID'),
+        name: z.string().optional().describe('Updated test name'),
+        instructions: z.string().optional().describe('Updated test instructions'),
+        page_ids: z.array(z.string()).optional().describe('Updated page UUIDs (replaces existing)'),
+        status: z.enum(['draft', 'active', 'archived']).optional().describe('Updated status'),
+        tags: z.array(z.string()).optional().describe('Updated tag names (replaces existing tags)'),
+    }, async (args) => {
+        const { test_id, ...data } = args;
+        const result = await api.updateTest(test_id, data);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // --- Sweep ---
+    server.tool('sweep', 'Find tests affected by specific pages (impact analysis). Use after making changes to determine which tests to re-run.', {
+        project_id: z.string().describe('Project UUID'),
+        pages: z.array(z.string()).optional().describe('Exact page URLs to match'),
+        url_pattern: z.string().optional().describe('Glob-style URL pattern (e.g. /checkout*)'),
+    }, async (args) => {
+        const result = await api.sweep(args.project_id, {
+            pages: args.pages,
+            url_pattern: args.url_pattern,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // --- Test Runs ---
+    server.tool('start_run', 'Start a test run (sets status to running)', { test_id: z.string().describe('Test UUID') }, async (args) => {
+        const result = await api.startRun(args.test_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('complete_run', 'Record the result of a test run', {
+        run_id: z.string().describe('Run UUID'),
+        status: z.enum(['passed', 'failed', 'error']).describe('Run result status'),
+        result: z.string().optional().describe('Summary of what happened during the run'),
+    }, async (args) => {
+        const result = await api.completeRun(args.run_id, {
+            status: args.status,
+            result: args.result,
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('get_run', 'Get details of a specific test run', { run_id: z.string().describe('Run UUID') }, async (args) => {
+        const result = await api.getRun(args.run_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    server.tool('list_runs', 'List run history for a test (newest first)', { test_id: z.string().describe('Test UUID') }, async (args) => {
+        const result = await api.listRuns(args.test_id);
+        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    });
+    // Start server
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "greenrun-cli",
+  "version": "0.1.0",
+  "description": "CLI and MCP server for Greenrun - browser test management for Claude Code",
+  "type": "module",
+  "main": "dist/server.js",
+  "bin": {
+    "greenrun": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js"
+  },
+  "keywords": [
+    "greenrun",
+    "mcp",
+    "claude",
+    "testing",
+    "browser-testing",
+    "claude-code"
+  ],
+  "author": "Greenrun",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Add-Item-To/greenrun-cli.git"
+  },
+  "homepage": "https://app.greenrun.dev",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/claude-md.md

@@ -0,0 +1,39 @@
+## Greenrun - Browser Test Management
+
+### Prerequisites
+
+- **Claude in Chrome extension** must be installed and active in your browser for test execution
+- MCP server must be connected (check with `/mcp` in Claude Code)
+
+### Available MCP Tools
+
+The Greenrun MCP server provides these tools:
+
+- **list_projects** / **get_project** / **create_project** - Manage projects
+- **list_pages** / **create_page** - Manage page URLs within a project
+- **list_tests** / **get_test** / **create_test** / **update_test** - Manage test cases
+- **start_run** / **complete_run** / **get_run** / **list_runs** - Execute and track test runs
+- **sweep** - Impact analysis: find tests affected by changed pages
+
+### Running Tests
+
+To run tests for this project:
+
+1. Use `list_projects` to find the project, then `list_tests` to get all tests
+2. For each test, call `get_test` to retrieve the full instructions
+3. Call `start_run` to begin a run (returns a run ID)
+4. Execute the test instructions using browser automation (Claude in Chrome)
+5. Call `complete_run` with the run ID, status (passed/failed/error), and a result summary
+
+Or use the `/greenrun` slash command to run all tests automatically.
+
+### Creating Tests
+
+1. Navigate to the page you want to test in Chrome
+2. Write clear, step-by-step test instructions describing what to do and what to verify
+3. Use `create_page` to register the page URL if not already registered
+4. Use `create_test` with the instructions and page IDs
+
+### Impact Analysis
+
+After making code changes, use the `/greenrun-sweep` command or the `sweep` tool to find which tests are affected by the pages you changed. This helps you run only the relevant tests.

package/templates/commands/greenrun-sweep.md

@@ -0,0 +1,71 @@
+Run Greenrun impact analysis to find tests affected by recent code changes.
+
+## Instructions
+
+You are performing impact analysis to determine which browser tests need to be re-run based on code changes. Tests are linked to pages (URL paths) and tags as organizational metadata - sweep uses page associations to find affected tests.
+
+### 1. Find changed files
+
+Run `git diff --name-only HEAD~1` (or `git diff --name-only` for unstaged changes) to identify which files have changed. If the user specified a commit range as an argument ("$ARGUMENTS"), use that instead.
+
+### 2. Find the project
+
+Call `list_projects` to get all projects. Match the current project by name or base URL.
+
+### 3. Map changes to pages
+
+Call `list_pages` for the project. Look at the changed files and determine which page URLs they likely affect. Consider:
+- View/template files -> the routes they render
+- Controller/API files -> the pages that call those endpoints
+- Component files -> pages that use those components
+- CSS/JS assets -> pages that include them
+
+### 4. Run sweep
+
+Call `sweep` with the project ID and either:
+- `pages`: specific page URLs that match the changes
+- `url_pattern`: a glob pattern matching affected URLs
+
+### 5. Report results
+
+Present the affected tests:
+
+| Test | Pages | Tags | Last Status |
+|------|-------|------|-------------|
+| Test name | Affected page URLs | tag1, tag2 | passed/failed/never run |
+
+### 6. Offer to run
+
+Ask the user if they want to run the affected tests. If yes, execute them **in parallel** using the same approach as the `/greenrun` command:
+
+Use the project's `concurrency` setting (default: 5) to determine batch size. Split affected tests into batches and launch each batch simultaneously using the **Task tool** with `run_in_background: true`.
+
+For each test in a batch, launch a background agent with this prompt:
+
+```
+You are executing a single Greenrun browser test. You have access to browser automation tools and Greenrun MCP tools.
+
+**Test: {test_name}** (ID: {test_id})
+
+Step 1: Call `get_test` with test_id "{test_id}" to get full instructions.
+Step 2: Call `start_run` with test_id "{test_id}" to begin - save the returned `run_id`.
+Step 3: Execute the test instructions using browser automation:
+   - Create a new browser tab for this test
+   - Follow each instruction step exactly as written
+   - The instructions will tell you where to navigate and what to do
+   - Observe results and take screenshots as needed for verification
+Step 4: Call `complete_run` with:
+   - run_id: the run ID from step 2
+   - status: "passed" if all checks succeeded, "failed" if any check failed, "error" if execution was blocked
+   - result: a brief summary of what happened
+
+Return a single line summary: {test_name} | {status} | {result_summary}
+```
+
+Wait for each batch to complete before launching the next. After all tests finish, present a summary table:
+
+| Test | Pages | Tags | Status | Result |
+|------|-------|------|--------|--------|
+| Test name | Affected page URLs | tag1, tag2 | passed/failed/error | Brief summary |
+
+Include the total count: "X passed, Y failed, Z errors out of N tests"

package/templates/commands/greenrun.md

@@ -0,0 +1,73 @@
+Run Greenrun browser tests for this project in parallel.
+
+## Instructions
+
+You are executing browser tests managed by Greenrun. Tests run in parallel using background agents, each with its own browser tab. Follow these steps precisely:
+
+### 1. Find the project
+
+Call `list_projects` to get all projects. Match the current project by name or base URL. If no match is found, tell the user and stop.
+
+Note the project's `concurrency` value (default: 5). This controls how many tests run simultaneously.
+
+### 2. Get tests
+
+Call `list_tests` with the project ID. Each test has associated pages and tags which are organizational metadata for filtering.
+
+If the user specified an argument ("$ARGUMENTS"), use it to filter tests:
+- If it starts with `/` (e.g. `/checkout`), filter to tests linked to a page matching that URL
+- If it starts with `tag:` (e.g. `tag:smoke`), filter to tests with that tag
+- Otherwise, treat it as a test name filter
+
+If no argument is given, run all active tests.
+
+If there are no matching active tests, tell the user and stop.
+
+### 3. Execute tests in parallel
+
+Split the test list into batches of size `concurrency` (from the project settings).
+
+For each batch, launch all tests simultaneously using the **Task tool** with `run_in_background: true`. Each background agent receives a prompt containing everything it needs to execute one test independently:
+
+```
+For each test in the current batch, call the Task tool with:
+- subagent_type: "general-purpose"
+- run_in_background: true
+- prompt: (see below)
+```
+
+The prompt for each background agent should be:
+
+```
+You are executing a single Greenrun browser test. You have access to browser automation tools and Greenrun MCP tools.
+
+**Test: {test_name}** (ID: {test_id})
+
+Step 1: Call `get_test` with test_id "{test_id}" to get full instructions.
+Step 2: Call `start_run` with test_id "{test_id}" to begin - save the returned `run_id`.
+Step 3: Execute the test instructions using browser automation:
+   - Create a new browser tab for this test
+   - Follow each instruction step exactly as written
+   - The instructions will tell you where to navigate and what to do
+   - Observe results and take screenshots as needed for verification
+Step 4: Call `complete_run` with:
+   - run_id: the run ID from step 2
+   - status: "passed" if all checks succeeded, "failed" if any check failed, "error" if execution was blocked
+   - result: a brief summary of what happened
+
+Return a single line summary: {test_name} | {status} | {result_summary}
+```
+
+After launching all agents in a batch, wait for them all to complete (use `TaskOutput` to collect results) before launching the next batch.
+
+### 4. Summarize results
+
+After all batches complete, collect results from all background agents and present a summary table:
+
+| Test | Pages | Tags | Status | Result |
+|------|-------|------|--------|--------|
+| Test name | /login, /dashboard | smoke, auth | passed/failed/error | Brief summary |
+
+Include the total count: "X passed, Y failed, Z errors out of N tests"
+
+If any tests failed, highlight what went wrong and suggest next steps.