Peekaboo/peekaboo-mcp.js

#!/usr/bin/env node
// Peekaboo MCP wrapper that restarts the Swift server on crash

import { spawn } from 'child_process';
import { chmodSync, existsSync, realpathSync, statSync } from 'fs';
import { fileURLToPath, pathToFileURL } from 'url';
import { dirname, join } from 'path';

const modulePath = realpathSync(fileURLToPath(import.meta.url));
const __dirname = dirname(modulePath);
const defaultBinaryPath = join(__dirname, 'peekaboo');

const MAX_RESTARTS = 5;
const RESTART_WINDOW_MS = 60_000;
const INITIAL_DELAY_MS = 1000;
const MAX_DELAY_MS = 30_000;

export class PeekabooMCPWrapper {
  constructor(options = {}) {
    this.binaryPath = options.binaryPath || defaultBinaryPath;
    this.initialDelayMs = options.initialDelayMs || INITIAL_DELAY_MS;
    this.maxDelayMs = options.maxDelayMs || MAX_DELAY_MS;
    this.restartTimestamps = [];
    this.delay = this.initialDelayMs;
    this.child = null;
    this.restartTimer = null;
    this.shuttingDown = false;
  }

  start() {
    if (this.shuttingDown) return;

    if (!existsSync(this.binaryPath)) {
      console.error(`[Peekaboo MCP] Binary not found at ${this.binaryPath}`);
      process.exit(1);
    }

    const now = Date.now();
    this.restartTimestamps = this.restartTimestamps.filter(ts => now - ts < RESTART_WINDOW_MS);
    if (this.restartTimestamps.length >= MAX_RESTARTS) {
      console.error(`[Peekaboo MCP] Aborting: restarted ${MAX_RESTARTS} times within a minute.`);
      process.exit(1);
    }

    console.error('[Peekaboo MCP] Starting Swift server...');
    this.child = spawn(this.binaryPath, ['mcp', 'serve'], {
      stdio: 'inherit',
      env: {
        ...process.env,
        PEEKABOO_MCP_WRAPPER: 'true'
      }
    });

    this.child.on('exit', (code, signal) => {
      this.child = null;
      if (this.shuttingDown) return process.exit(code || 0);

      if (code === 0 || signal === 'SIGINT' || signal === 'SIGTERM') {
        console.error('[Peekaboo MCP] Server exited cleanly');
        process.exit(code || 0);
      }

      this.handleCrash(code, signal);
    });

    this.child.on('error', (err) => {
      this.child = null;
      console.error('[Peekaboo MCP] Failed to launch:', err.message);
      if (err.code === 'EACCES') {
        try {
          const mode = statSync(this.binaryPath).mode;
          chmodSync(this.binaryPath, mode | 0o111);
          console.error('[Peekaboo MCP] Fixed executable bit, retrying...');
          this.handleCrash(1);
          return;
        } catch (_) {
          console.error('[Peekaboo MCP] Could not make binary executable.');
        }
      }
      this.handleCrash(err.code || 1);
    });
  }

  handleCrash(code, signal) {
    if (this.shuttingDown) return;

    console.error(`[Peekaboo MCP] Server crashed (code ${code}${signal ? `, signal ${signal}` : ''}).`);
    this.restartTimestamps.push(Date.now());
    this.clearRestartTimer();
    this.restartTimer = setTimeout(() => {
      this.restartTimer = null;
      if (this.shuttingDown) return;
      this.delay = Math.min(this.delay * 2, this.maxDelayMs);
      this.start();
    }, this.delay);
  }

  shutdown() {
    this.shuttingDown = true;
    this.clearRestartTimer();
    if (this.child && !this.child.killed) {
      this.child.kill('SIGTERM');
    }
  }

  clearRestartTimer() {
    if (this.restartTimer) {
      clearTimeout(this.restartTimer);
      this.restartTimer = null;
    }
  }
}

if (isMainModule()) {
  const wrapper = new PeekabooMCPWrapper();
  wrapper.start();

  process.on('SIGINT', () => {
    console.error('\n[Peekaboo MCP] SIGINT received, shutting down...');
    wrapper.shutdown();
  });

  process.on('SIGTERM', () => {
    console.error('[Peekaboo MCP] SIGTERM received, shutting down...');
    wrapper.shutdown();
  });

  process.on('uncaughtException', (err) => {
    console.error('[Peekaboo MCP] Uncaught exception:', err);
    wrapper.shutdown();
  });

  process.on('unhandledRejection', (reason) => {
    console.error('[Peekaboo MCP] Unhandled rejection:', reason);
  });
}

function isMainModule() {
  const entry = process.argv[1];
  if (entry === undefined) return false;

  const entryUrl = pathToFileURL(entry).href;
  if (import.meta.url === entryUrl) return true;

  return pathToFileURL(realpathSync(modulePath)).href === pathToFileURL(realpathSync(entry)).href;
}