@everydaydevopsio/pilot 0.5.0

package/src/commands/wait.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import type { Client } from 'chrome-remote-interface';
+import type { BrowserManager } from '../browser.js';
+
+export const WaitParamsSchema = z
+  .object({
+    selector: z.string().optional(),
+    selectorVisible: z.string().optional(),
+    networkIdle: z.boolean().optional(),
+    ms: z.number().int().min(0).optional(),
+    timeoutMs: z.number().int().positive().default(10000)
+  })
+  .refine(
+    (v) =>
+      v.selector !== undefined ||
+      v.selectorVisible !== undefined ||
+      v.networkIdle !== undefined ||
+      v.ms !== undefined,
+    { message: 'At least one wait condition is required' }
+  );
+
+export type WaitParams = z.infer<typeof WaitParamsSchema>;
+
+export interface WaitResult {
+  ok: boolean;
+  elapsed: number;
+}
+
+async function waitForSelectorPresent(
+  client: Client,
+  selector: string,
+  timeoutMs: number
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const result = await client.Runtime.evaluate({
+      expression: `!!document.querySelector(${JSON.stringify(selector)})`,
+      returnByValue: true
+    });
+    if (result.result.value === true) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`timeout waiting for selector: ${selector}`);
+}
+
+async function waitForSelectorVisible(
+  client: Client,
+  selector: string,
+  timeoutMs: number
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const result = await client.Runtime.evaluate({
+      expression: `(function() {
+        const el = document.querySelector(${JSON.stringify(selector)});
+        if (!el) return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      })()`,
+      returnByValue: true
+    });
+    if (result.result.value === true) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(`timeout waiting for visible selector: ${selector}`);
+}
+
+export async function executeWait(
+  client: Client,
+  manager: BrowserManager,
+  params: WaitParams
+): Promise<WaitResult> {
+  const start = Date.now();
+
+  if (params.ms !== undefined) {
+    await new Promise((r) => setTimeout(r, params.ms));
+  } else if (params.selector !== undefined) {
+    await waitForSelectorPresent(client, params.selector, params.timeoutMs);
+  } else if (params.selectorVisible !== undefined) {
+    await waitForSelectorVisible(
+      client,
+      params.selectorVisible,
+      params.timeoutMs
+    );
+  } else if (params.networkIdle) {
+    await manager.waitForNetworkIdle(params.timeoutMs);
+  }
+
+  return { ok: true, elapsed: Date.now() - start };
+}

package/src/mcp/console-buffer.ts

@@ -0,0 +1,94 @@
+export type ConsoleLevel = 'log' | 'warn' | 'error' | 'info' | 'debug';
+
+export interface ConsoleMessage {
+  level: ConsoleLevel;
+  text: string;
+  url: string;
+  lineNumber: number;
+  timestamp: number;
+}
+
+export interface ConsoleFilter {
+  level?: ConsoleLevel | ConsoleLevel[];
+  sinceMs?: number;
+  limit?: number;
+}
+
+export class ConsoleBuffer {
+  private buffer: ConsoleMessage[] = [];
+  private head = 0;
+  private count = 0;
+
+  constructor(private readonly maxSize: number = 1000) {}
+
+  push(msg: ConsoleMessage): void {
+    if (this.count < this.maxSize) {
+      this.buffer.push(msg);
+      this.count++;
+    } else {
+      this.buffer[this.head] = msg;
+      this.head = (this.head + 1) % this.maxSize;
+    }
+  }
+
+  getAll(filter?: ConsoleFilter): ConsoleMessage[] {
+    const messages = this.toArray();
+    return this.applyFilter(messages, filter);
+  }
+
+  getErrors(sinceMs?: number): ConsoleMessage[] {
+    return this.getAll({
+      level: 'error',
+      sinceMs
+    });
+  }
+
+  clear(): number {
+    const cleared = this.count;
+    this.buffer = [];
+    this.head = 0;
+    this.count = 0;
+    return cleared;
+  }
+
+  size(): number {
+    return this.count;
+  }
+
+  private toArray(): ConsoleMessage[] {
+    if (this.count < this.maxSize) {
+      return [...this.buffer];
+    }
+    return [
+      ...this.buffer.slice(this.head),
+      ...this.buffer.slice(0, this.head)
+    ];
+  }
+
+  private applyFilter(
+    messages: ConsoleMessage[],
+    filter?: ConsoleFilter
+  ): ConsoleMessage[] {
+    if (!filter) return messages;
+
+    let result = messages;
+
+    if (filter.level) {
+      const levels = Array.isArray(filter.level)
+        ? filter.level
+        : [filter.level];
+      result = result.filter((m) => levels.includes(m.level));
+    }
+
+    if (filter.sinceMs !== undefined) {
+      const cutoff = Date.now() - filter.sinceMs;
+      result = result.filter((m) => m.timestamp >= cutoff);
+    }
+
+    if (filter.limit !== undefined && result.length > filter.limit) {
+      result = result.slice(-filter.limit);
+    }
+
+    return result;
+  }
+}

package/src/mcp/index.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createMcpServer } from './server.js';
+import { loadConfig } from '../util/config.js';
+import { createLogger } from '../util/logger.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(
+  readFileSync(join(__dirname, '../../package.json'), 'utf-8')
+) as { version: string; description: string; name: string };
+
+const args = process.argv.slice(2);
+
+async function run(): Promise<void> {
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(pkg.version);
+    return;
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`${pkg.name} v${pkg.version}`);
+    console.log(pkg.description);
+    console.log('');
+    console.log('Usage: pilot [command] [options]');
+    console.log('');
+    console.log('Commands:');
+    console.log(
+      '  init [--force]    Install the Claude Code debug-browser skill'
+    );
+    console.log('  (default)         Start the MCP server on stdio');
+    console.log('');
+    console.log('Options:');
+    console.log('  --version, -v     Show version number');
+    console.log('  --help, -h        Show this help message');
+    console.log('');
+    console.log('Environment variables:');
+    console.log(
+      '  PILOT_CDP_PORT          Chrome DevTools Protocol port (default: 9222)'
+    );
+    console.log(
+      '  PILOT_CDP_HOST          Chrome DevTools Protocol host (default: 127.0.0.1)'
+    );
+    console.log(
+      '  PILOT_MCP_BUFFER_SIZE   Console event buffer size (default: 1000)'
+    );
+    console.log(
+      '  PILOT_LOG_LEVEL         Log level: trace|debug|info|warn|error|fatal (default: info)'
+    );
+    console.log(
+      '  PILOT_PROFILE_NAME      Browser profile name (default: profile1)'
+    );
+    console.log(
+      '  PILOT_CHROME_NO_SANDBOX Override Chrome sandbox (true/false)'
+    );
+    console.log('  PILOT_VIEWPORT          Viewport preset (default: desktop)');
+    console.log(
+      '                        Presets: desktop, desktop-small, tablet,'
+    );
+    console.log(
+      '                        tablet-landscape, mobile, mobile-landscape, mobile-small'
+    );
+    return;
+  }
+
+  const subcommand = args[0] && !args[0].startsWith('-') ? args[0] : null;
+
+  const baseConfig = loadConfig();
+  createLogger(baseConfig.logLevel);
+
+  if (subcommand === 'init') {
+    const { runInit } = await import('../cli/init.js');
+    const force = args.includes('--force');
+    await runInit({ force });
+    return;
+  }
+
+  const config = {
+    bufferSize: parseInt(process.env.PILOT_MCP_BUFFER_SIZE ?? '1000', 10),
+    cdpPort: process.env.PILOT_CDP_PORT
+      ? parseInt(process.env.PILOT_CDP_PORT, 10)
+      : undefined,
+    cdpHost: process.env.PILOT_CDP_HOST
+  };
+
+  const { server, cleanup } = await createMcpServer(config);
+  const transport = new StdioServerTransport();
+
+  async function shutdown(): Promise<void> {
+    await cleanup();
+    process.exit(0);
+  }
+
+  process.on('SIGINT', () => void shutdown());
+  process.on('SIGTERM', () => void shutdown());
+
+  await server.connect(transport);
+  console.error('[pilot] MCP server running on stdio');
+}
+
+run().catch((err) => {
+  console.error('[pilot] Failed to start:', err);
+  process.exit(1);
+});

package/src/mcp/server.ts

@@ -0,0 +1,67 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { BrowserManager } from '../browser.js';
+import { loadConfig } from '../util/config.js';
+import { ConsoleBuffer, type ConsoleMessage } from './console-buffer.js';
+import { registerBrowserTools } from './tools/browser.js';
+import { registerErrorTools } from './tools/errors.js';
+
+export interface McpConfig {
+  bufferSize: number;
+  cdpPort?: number;
+  cdpHost?: string;
+}
+
+export interface BrowserContext {
+  manager: BrowserManager | null;
+  consoleBuffer: ConsoleBuffer;
+  baseConfig: McpConfig;
+}
+
+export async function createMcpServer(config: McpConfig): Promise<{
+  server: McpServer;
+  cleanup: () => Promise<void>;
+}> {
+  const server = new McpServer({
+    name: 'pilot',
+    version: '0.1.0'
+  });
+
+  const consoleBuffer = new ConsoleBuffer(config.bufferSize);
+
+  const context: BrowserContext = {
+    manager: null,
+    consoleBuffer,
+    baseConfig: config
+  };
+
+  function attachConsoleBuffer(manager: BrowserManager): void {
+    manager.setEventCallback((event, data) => {
+      if (event === 'console_message') {
+        consoleBuffer.push(data as ConsoleMessage);
+      }
+    });
+  }
+
+  function makeBrowserManager(): BrowserManager {
+    const browserConfig = loadConfig({
+      cdpPort: config.cdpPort,
+      cdpHost: config.cdpHost
+    });
+    const manager = new BrowserManager(browserConfig);
+    attachConsoleBuffer(manager);
+    return manager;
+  }
+
+  registerBrowserTools(server, context, makeBrowserManager);
+  registerErrorTools(server, consoleBuffer);
+
+  return {
+    server,
+    cleanup: async () => {
+      if (context.manager) {
+        await context.manager.destroy();
+        context.manager = null;
+      }
+    }
+  };
+}