agentgate-mcp 0.2.0

package/src/browser-runtime.js

@@ -0,0 +1,411 @@
+import { createLogger } from './logger.js';
+
+const log = createLogger('browser-runtime');
+
+function getByPath(obj, path) {
+  const parts = path.split('.');
+  let cursor = obj;
+  for (const part of parts) {
+    if (cursor == null) {
+      return undefined;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+function setByPath(obj, path, value) {
+  const parts = path.split('.');
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    const key = parts[i];
+    if (typeof cursor[key] !== 'object' || cursor[key] === null) {
+      cursor[key] = {};
+    }
+    cursor = cursor[key];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+
+function interpolate(template, state) {
+  if (typeof template !== 'string') {
+    return template;
+  }
+
+  return template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_match, token) => {
+    const value = getByPath(state, token.trim());
+    return value == null ? '' : String(value);
+  });
+}
+
+function coerceTimeout(value, fallback = 15_000) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+async function withRetry(fn, { retries = 0, delayMs = 1_000, label = '' } = {}) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        log.warn(`Retry ${attempt + 1}/${retries} for ${label}: ${error instanceof Error ? error.message : String(error)}`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+  throw lastError;
+}
+
+export class BrowserRuntime {
+  constructor({ page, state, db, gmailWatcher, captchaSolver }) {
+    this.page = page;
+    this.state = state;
+    this.db = db;
+    this.gmailWatcher = gmailWatcher;
+    this.captchaSolver = captchaSolver;
+  }
+
+  async run(actions) {
+    for (const [index, action] of actions.entries()) {
+      if (!action || typeof action !== 'object') {
+        throw new Error(`Invalid action at index ${index}`);
+      }
+      log.debug(`Action ${index}: ${action.type}`, { selector: action.selector, url: action.url });
+
+      const retries = Number(action.retries) || 0;
+      const retryDelay = Number(action.retryDelayMs) || 1_000;
+
+      await withRetry(() => this.execute(action, index), {
+        retries,
+        delayMs: retryDelay,
+        label: `${action.type}@${index}`
+      });
+    }
+  }
+
+  async execute(action, index) {
+    const type = action.type;
+
+    switch (type) {
+      case 'goto':
+        await this.page.goto(interpolate(action.url, this.state), {
+          waitUntil: action.waitUntil || 'domcontentloaded',
+          timeout: coerceTimeout(action.timeoutMs)
+        });
+        break;
+
+      case 'click':
+        await this.page.click(interpolate(action.selector, this.state), {
+          timeout: coerceTimeout(action.timeoutMs)
+        });
+        break;
+
+      case 'fill':
+        await this.page.fill(
+          interpolate(action.selector, this.state),
+          interpolate(action.value, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        break;
+
+      case 'select':
+        await this.page.selectOption(
+          interpolate(action.selector, this.state),
+          interpolate(action.value, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        break;
+
+      case 'press':
+        await this.page.press(
+          interpolate(action.selector, this.state),
+          interpolate(action.key, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        break;
+
+      case 'wait_for':
+        await this.page.waitForSelector(interpolate(action.selector, this.state), {
+          timeout: coerceTimeout(action.timeoutMs),
+          state: action.state || 'visible'
+        });
+        break;
+
+      case 'wait_for_navigation':
+        await this.page.waitForNavigation({
+          waitUntil: action.waitUntil || 'domcontentloaded',
+          timeout: coerceTimeout(action.timeoutMs)
+        });
+        break;
+
+      case 'sleep':
+        await this.page.waitForTimeout(coerceTimeout(action.ms, 500));
+        break;
+
+      case 'screenshot': {
+        const screenshotPath = interpolate(action.path, this.state) || '/tmp/agentgate-screenshot.png';
+        await this.page.screenshot({ path: screenshotPath, fullPage: Boolean(action.fullPage) });
+        log.info(`Screenshot saved to ${screenshotPath}`);
+        break;
+      }
+
+      case 'extract_text': {
+        const target = this.resolveTarget(action);
+        const text = await target.textContent(
+          interpolate(action.selector, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        setByPath(this.state, action.target, (text || '').trim());
+        break;
+      }
+
+      case 'extract_value': {
+        const target = this.resolveTarget(action);
+        const value = await target.inputValue(
+          interpolate(action.selector, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        setByPath(this.state, action.target, value);
+        break;
+      }
+
+      case 'extract_attribute': {
+        const target = this.resolveTarget(action);
+        const value = await target.getAttribute(
+          interpolate(action.selector, this.state),
+          interpolate(action.attribute, this.state),
+          { timeout: coerceTimeout(action.timeoutMs) }
+        );
+        setByPath(this.state, action.target, value || '');
+        break;
+      }
+
+      case 'regex_extract': {
+        const source = getByPath(this.state, action.source);
+        const pattern = new RegExp(action.pattern, action.flags || '');
+        const match = String(source || '').match(pattern);
+        if (!match) {
+          throw new Error(`regex_extract failed at action ${index}: pattern did not match`);
+        }
+        const group = Number.isInteger(action.group) ? action.group : 1;
+        setByPath(this.state, action.target, match[group] || '');
+        break;
+      }
+
+      case 'set_var':
+        setByPath(this.state, action.target, interpolate(action.value, this.state));
+        break;
+
+      case 'assert_present': {
+        const value = getByPath(this.state, action.path);
+        if (value == null || value === '') {
+          throw new Error(action.message || `Missing required state value: ${action.path}`);
+        }
+        break;
+      }
+
+      case 'store_alias': {
+        const emailAlias = getByPath(this.state, action.emailPath || 'generated.emailAlias');
+        const password = getByPath(this.state, action.passwordPath || 'generated.password');
+        if (!emailAlias) {
+          throw new Error('store_alias action missing email alias in state');
+        }
+        this.db.saveAlias({
+          service: this.state.service.name,
+          emailAlias,
+          passwordHint: password ? `${String(password).slice(0, 2)}...${String(password).slice(-2)}` : null
+        });
+        break;
+      }
+
+      case 'wait_for_email_code': {
+        if (!this.gmailWatcher) {
+          throw new Error('wait_for_email_code requested but Gmail watcher is not configured');
+        }
+        const result = await this.gmailWatcher.waitForCode({
+          serviceName: this.state.service.name,
+          timeoutMs: coerceTimeout(action.timeoutMs, 120_000),
+          pollMs: coerceTimeout(action.pollMs, 5_000),
+          regex: action.regex || '(\\d{6})'
+        });
+        setByPath(this.state, action.target || 'scratch.emailCode', result.code);
+        break;
+      }
+
+      case 'solve_captcha': {
+        if (!this.captchaSolver) {
+          throw new Error('solve_captcha requested but CAPTCHA solver is not configured');
+        }
+        const solved = await this.captchaSolver.solve({
+          serviceName: this.state.service.name,
+          provider: action.provider || 'capsolver',
+          siteKey: action.siteKey,
+          siteUrl: action.siteUrl || this.page.url(),
+          captchaType: action.captchaType,
+          timeoutMs: coerceTimeout(action.timeoutMs, 120_000)
+        });
+        setByPath(this.state, action.target || 'scratch.captchaToken', solved.token);
+        break;
+      }
+
+      case 'fill_card':
+        await this.fillCard(action);
+        break;
+
+      case 'switch_to_iframe': {
+        const frameSelector = interpolate(action.selector, this.state);
+        const frameElement = await this.page.waitForSelector(frameSelector, {
+          timeout: coerceTimeout(action.timeoutMs),
+          state: 'attached'
+        });
+        const frame = await frameElement.contentFrame();
+        if (!frame) {
+          throw new Error(`No iframe found at selector: ${frameSelector}`);
+        }
+        this.state._iframeStack = this.state._iframeStack || [];
+        this.state._iframeStack.push(this.page);
+        this.page = frame;
+        log.debug(`Switched to iframe: ${frameSelector}`);
+        break;
+      }
+
+      case 'switch_to_parent': {
+        const stack = this.state._iframeStack;
+        if (!stack || stack.length === 0) {
+          throw new Error('switch_to_parent: no parent frame to switch to');
+        }
+        this.page = stack.pop();
+        log.debug('Switched to parent frame');
+        break;
+      }
+
+      default:
+        throw new Error(`Unsupported workflow action type: ${type}`);
+    }
+  }
+
+  /**
+   * Returns the page or iframe to operate on.
+   * If the action specifies an `iframe` selector, resolves into that frame first.
+   */
+  resolveTarget(action) {
+    return this.page;
+  }
+
+  async fillCard(action) {
+    const billing = this.state.vault?.billing || {};
+    const required = ['cardNumber', 'cardExpMonth', 'cardExpYear', 'cardCvc'];
+    for (const field of required) {
+      if (!billing[field]) {
+        throw new Error(`fill_card requires billing.${field} in vault`);
+      }
+    }
+
+    // Detect Stripe iframe and switch context if needed
+    let target = this.page;
+    let switchedToIframe = false;
+
+    const stripeIframeSelectors = [
+      "iframe[name*='__privateStripeFrame']",
+      "iframe[src*='stripe.com']",
+      "iframe[title*='card']",
+      "iframe[name*='__stripe']"
+    ];
+
+    const paddleIframeSelectors = [
+      "iframe[src*='paddle.com']",
+      "iframe[class*='paddle']"
+    ];
+
+    const allIframeSelectors = [...stripeIframeSelectors, ...paddleIframeSelectors];
+
+    for (const iframeSelector of allIframeSelectors) {
+      try {
+        const frameElement = await this.page.waitForSelector(iframeSelector, {
+          timeout: 2_000,
+          state: 'attached'
+        });
+        const frame = await frameElement.contentFrame();
+        if (frame) {
+          target = frame;
+          switchedToIframe = true;
+          log.info(`Detected payment iframe: ${iframeSelector}`);
+          break;
+        }
+      } catch {
+        // No such iframe, try next
+      }
+    }
+
+    const selectors = {
+      cardNumber: [
+        "input[name='cardnumber']",
+        "input[autocomplete='cc-number']",
+        "input[id*='card'][id*='number']",
+        "input[data-elements-stable-field-name='cardNumber']",
+        "input[name='number']"
+      ],
+      cardExp: [
+        "input[name='exp-date']",
+        "input[autocomplete='cc-exp']",
+        "input[id*='exp']",
+        "input[data-elements-stable-field-name='cardExpiry']",
+        "input[name='expiry']"
+      ],
+      cardCvc: [
+        "input[name='cvc']",
+        "input[autocomplete='cc-csc']",
+        "input[id*='cvc']",
+        "input[data-elements-stable-field-name='cardCvc']",
+        "input[name='verification_value']"
+      ],
+      cardName: [
+        "input[name='name']",
+        "input[autocomplete='cc-name']",
+        "input[id*='cardholder']"
+      ],
+      cardZip: [
+        "input[name='postal']",
+        "input[autocomplete='postal-code']",
+        "input[name='postalCode']"
+      ]
+    };
+
+    await this.fillFirstAvailable(target, selectors.cardNumber, billing.cardNumber, action.timeoutMs);
+    await this.fillFirstAvailable(
+      target,
+      selectors.cardExp,
+      `${billing.cardExpMonth}/${String(billing.cardExpYear).slice(-2)}`,
+      action.timeoutMs
+    );
+    await this.fillFirstAvailable(target, selectors.cardCvc, billing.cardCvc, action.timeoutMs);
+
+    if (billing.cardHolder) {
+      await this.fillFirstAvailable(target, selectors.cardName, billing.cardHolder, action.timeoutMs, true);
+    }
+    if (billing.cardZip) {
+      await this.fillFirstAvailable(target, selectors.cardZip, billing.cardZip, action.timeoutMs, true);
+    }
+  }
+
+  async fillFirstAvailable(target, selectors, value, timeoutMs, optional = false) {
+    for (const selector of selectors) {
+      try {
+        await target.waitForSelector(selector, {
+          timeout: coerceTimeout(timeoutMs, 1_000),
+          state: 'visible'
+        });
+        await target.fill(selector, String(value));
+        return;
+      } catch {
+        // Try next selector.
+      }
+    }
+    if (!optional) {
+      throw new Error(`Could not find any card field selector: ${selectors.join(', ')}`);
+    }
+  }
+}

package/src/cli.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env -S node --disable-warning=ExperimentalWarning
+
+import process from 'node:process';
+import { config, ensureDirs, fileExists } from './config.js';
+import { KeyDatabase } from './db.js';
+import { enableFileLogging, createLogger } from './logger.js';
+import { McpServer } from './mcp-server.js';
+import { Orchestrator } from './orchestrator.js';
+import { ServiceRegistry } from './registry.js';
+import { runScaffold } from './scaffold.js';
+import { SignupEngine } from './signup-engine.js';
+import { Vault } from './vault.js';
+
+const log = createLogger('cli');
+
+function bootstrap() {
+  ensureDirs();
+  enableFileLogging(config.LOG_DIR);
+
+  const vault = new Vault({
+    vaultFile: config.VAULT_FILE,
+    keyringFile: config.KEYRING_FILE
+  });
+  vault.initialize();
+
+  const db = new KeyDatabase(config.DB_FILE);
+  const registry = new ServiceRegistry(config.REGISTRY_DIR);
+  const automationEngine = new SignupEngine({
+    db,
+    vault,
+    browserProfileDir: config.BROWSER_PROFILE_DIR
+  });
+  const orchestrator = new Orchestrator({ db, registry, signupEngine: automationEngine });
+
+  return { vault, db, orchestrator, registry, automationEngine };
+}
+
+async function main() {
+  const command = process.argv[2] ?? 'serve';
+  const { vault, db, orchestrator, registry, automationEngine } = bootstrap();
+
+  switch (command) {
+    case 'login':
+      await automationEngine.login();
+      process.stdout.write('\nGoogle session saved. AgentGate can now create API keys for any service.\n');
+      process.stdout.write('Start the MCP server with: agentgate serve\n\n');
+      break;
+
+    case 'serve':
+      log.info('Starting MCP server');
+      new McpServer({ orchestrator }).start();
+      break;
+
+    case 'doctor':
+      await runDoctor({ orchestrator, registry, db });
+      break;
+
+    case 'scaffold': {
+      const code = runScaffold({
+        registryDir: config.REGISTRY_DIR,
+        argv: process.argv.slice(3),
+        stdout: process.stdout,
+        stderr: process.stderr
+      });
+      process.exitCode = code;
+      break;
+    }
+
+    default:
+      process.stderr.write(`Unknown command: ${command}\n`);
+      process.stderr.write('\nUsage:\n');
+      process.stderr.write('  agentgate login     Sign in with Google (opens browser)\n');
+      process.stderr.write('  agentgate serve     Start MCP server\n');
+      process.stderr.write('  agentgate doctor    Health check\n');
+      process.stderr.write('  agentgate scaffold  Generate a service recipe\n\n');
+      process.exitCode = 1;
+  }
+}
+
+async function runDoctor({ orchestrator, registry, db }) {
+  const checks = {};
+
+  checks.googleLoggedIn = fileExists(config.BROWSER_PROFILE_DIR);
+  checks.vaultExists = fileExists(config.VAULT_FILE);
+  checks.keyringExists = fileExists(config.KEYRING_FILE);
+
+  const recipes = registry.listServices();
+  checks.serviceRecipes = recipes.length;
+
+  checks.dbFile = config.DB_FILE;
+  checks.dbAccessible = true;
+  try { db.getAllKeys(); } catch { checks.dbAccessible = false; }
+
+  try {
+    const keys = db.getAllKeys();
+    checks.storedKeys = keys.length;
+    checks.activeKeys = keys.filter((k) => k.status === 'active').length;
+  } catch {
+    checks.storedKeys = 0;
+    checks.activeKeys = 0;
+  }
+
+  checks.playwrightInstalled = false;
+  try { await import('playwright'); checks.playwrightInstalled = true; } catch {}
+
+  checks.nodeVersion = process.version;
+  checks.browserProfileDir = config.BROWSER_PROFILE_DIR;
+  checks.logDir = config.LOG_DIR;
+
+  process.stdout.write(`${JSON.stringify(checks, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  log.error('Fatal error', { error: error instanceof Error ? error.message : String(error) });
+  process.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
+  process.exit(1);
+});

package/src/config.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+function resolveAppDir() {
+  if (process.env.AGENTGATE_HOME) {
+    return path.resolve(process.env.AGENTGATE_HOME);
+  }
+
+  const preferred = path.join(os.homedir(), '.agentgate');
+  try {
+    fs.mkdirSync(preferred, { recursive: true });
+    return preferred;
+  } catch {
+    return path.resolve(process.cwd(), '.agentgate');
+  }
+}
+
+const APP_DIR = resolveAppDir();
+const DATA_DIR = path.join(APP_DIR, 'data');
+const LOG_DIR = path.join(APP_DIR, 'logs');
+const BROWSER_PROFILE_DIR = path.join(APP_DIR, 'browser-profile');
+const REGISTRY_DIR = path.resolve(process.cwd(), 'services');
+const VAULT_FILE = path.join(APP_DIR, 'vault.enc');
+const KEYRING_FILE = path.join(APP_DIR, 'keyring.json');
+const DB_FILE = path.join(DATA_DIR, 'agentgate.sqlite');
+const SETTINGS_FILE = path.join(APP_DIR, 'settings.json');
+
+export const config = {
+  APP_DIR,
+  DATA_DIR,
+  LOG_DIR,
+  BROWSER_PROFILE_DIR,
+  REGISTRY_DIR,
+  VAULT_FILE,
+  KEYRING_FILE,
+  DB_FILE,
+  SETTINGS_FILE
+};
+
+export function ensureDirs() {
+  fs.mkdirSync(APP_DIR, { recursive: true });
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+export function fileExists(filePath) {
+  return fs.existsSync(filePath);
+}

package/src/db.js

@@ -0,0 +1,89 @@
+import { DatabaseSync } from 'node:sqlite';
+import crypto from 'node:crypto';
+
+export class KeyDatabase {
+  constructor(filePath) {
+    this.db = new DatabaseSync(filePath);
+    this.migrate();
+  }
+
+  migrate() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS api_keys (
+        id TEXT PRIMARY KEY,
+        service TEXT NOT NULL,
+        api_key TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_api_keys_service_active
+      ON api_keys(service)
+      WHERE status = 'active';
+
+      CREATE TABLE IF NOT EXISTS aliases (
+        id TEXT PRIMARY KEY,
+        service TEXT NOT NULL,
+        email_alias TEXT NOT NULL,
+        password_hint TEXT,
+        created_at TEXT NOT NULL
+      );
+    `);
+  }
+
+  getActiveKey(service) {
+    const stmt = this.db.prepare(
+      'SELECT * FROM api_keys WHERE service = ? AND status = ? LIMIT 1'
+    );
+    return stmt.get(service, 'active') ?? null;
+  }
+
+  upsertActiveKey({ service, apiKey, metadata }) {
+    const now = new Date().toISOString();
+    const existing = this.getActiveKey(service);
+    const serializedMetadata = JSON.stringify(metadata || {});
+
+    if (existing) {
+      const stmt = this.db.prepare(
+        'UPDATE api_keys SET api_key = ?, updated_at = ?, metadata_json = ? WHERE id = ?'
+      );
+      stmt.run(apiKey, now, serializedMetadata, existing.id);
+      return this.getActiveKey(service);
+    }
+
+    const id = crypto.randomUUID();
+    const stmt = this.db.prepare(
+      'INSERT INTO api_keys (id, service, api_key, status, created_at, updated_at, metadata_json) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    );
+    stmt.run(id, service, apiKey, 'active', now, now, serializedMetadata);
+    return this.getActiveKey(service);
+  }
+
+  revokeKey(service) {
+    const now = new Date().toISOString();
+    const stmt = this.db.prepare(
+      'UPDATE api_keys SET status = ?, updated_at = ? WHERE service = ? AND status = ?'
+    );
+    const result = stmt.run('revoked', now, service, 'active');
+    return result.changes > 0;
+  }
+
+  getAllKeys() {
+    const stmt = this.db.prepare(
+      'SELECT service, api_key, status, created_at, updated_at FROM api_keys ORDER BY created_at DESC'
+    );
+    return stmt.all();
+  }
+
+  saveAlias({ service, emailAlias, passwordHint }) {
+    const id = crypto.randomUUID();
+    const now = new Date().toISOString();
+    const stmt = this.db.prepare(
+      'INSERT INTO aliases (id, service, email_alias, password_hint, created_at) VALUES (?, ?, ?, ?, ?)'
+    );
+    stmt.run(id, service, emailAlias, passwordHint || null, now);
+    return id;
+  }
+}