agentgate-mcp 0.2.0 → 0.3.0

package/src/browser-runtime.js

@@ -1,411 +0,0 @@
-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/integrations/captcha-solver.js

@@ -1,128 +0,0 @@
-import https from 'node:https';
-import { createLogger } from '../logger.js';
-
-const log = createLogger('captcha-solver');
-
-const CAPSOLVER_API = 'https://api.capsolver.com';
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function postJson(url, body) {
-  return new Promise((resolve, reject) => {
-    const data = JSON.stringify(body);
-    const parsed = new URL(url);
-    const req = https.request(
-      {
-        hostname: parsed.hostname,
-        path: parsed.pathname,
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(data)
-        }
-      },
-      (res) => {
-        const chunks = [];
-        res.on('data', (chunk) => chunks.push(chunk));
-        res.on('end', () => {
-          const text = Buffer.concat(chunks).toString('utf8');
-          try {
-            resolve(JSON.parse(text));
-          } catch {
-            reject(new Error(`Invalid JSON from CapSolver: ${text.slice(0, 200)}`));
-          }
-        });
-      }
-    );
-    req.on('error', reject);
-    req.write(data);
-    req.end();
-  });
-}
-
-export class CaptchaSolver {
-  constructor({ vault }) {
-    this.vault = vault;
-  }
-
-  async solve({ serviceName, provider = 'capsolver', siteKey, siteUrl, captchaType = 'ReCaptchaV2TaskProxyLess', timeoutMs = 120_000 }) {
-    // Mock mode for testing
-    const mockToken = process.env.AGENTGATE_CAPTCHA_MOCK_TOKEN;
-    if (mockToken) {
-      log.info(`Returning mock CAPTCHA token for ${serviceName}`);
-      return { provider, service: serviceName, token: mockToken, source: 'mock' };
-    }
-
-    const apiKey = process.env.CAPSOLVER_API_KEY;
-    if (!apiKey) {
-      throw new Error(
-        'CAPTCHA requested but no solver configured. Set CAPSOLVER_API_KEY or AGENTGATE_CAPTCHA_MOCK_TOKEN.'
-      );
-    }
-
-    if (provider !== 'capsolver') {
-      throw new Error(`Unsupported CAPTCHA provider: ${provider}. Only "capsolver" is supported.`);
-    }
-
-    log.info(`Creating CAPTCHA task for ${serviceName}`, { captchaType });
-
-    // Create task
-    const createResult = await postJson(`${CAPSOLVER_API}/createTask`, {
-      clientKey: apiKey,
-      task: {
-        type: captchaType,
-        websiteURL: siteUrl || `https://${serviceName}.com`,
-        websiteKey: siteKey || ''
-      }
-    });
-
-    if (createResult.errorId && createResult.errorId !== 0) {
-      throw new Error(`CapSolver createTask error: ${createResult.errorDescription || createResult.errorCode}`);
-    }
-
-    const taskId = createResult.taskId;
-    if (!taskId) {
-      throw new Error('CapSolver did not return a taskId');
-    }
-
-    log.info(`CapSolver task created: ${taskId}`);
-
-    // Poll for result
-    const started = Date.now();
-    const pollMs = 3_000;
-
-    while (Date.now() - started < timeoutMs) {
-      await sleep(pollMs);
-
-      const result = await postJson(`${CAPSOLVER_API}/getTaskResult`, {
-        clientKey: apiKey,
-        taskId
-      });
-
-      if (result.errorId && result.errorId !== 0) {
-        throw new Error(`CapSolver error: ${result.errorDescription || result.errorCode}`);
-      }
-
-      if (result.status === 'ready') {
-        const token =
-          result.solution?.gRecaptchaResponse ||
-          result.solution?.token ||
-          result.solution?.text ||
-          '';
-
-        if (!token) {
-          throw new Error('CapSolver returned ready status but no token in solution');
-        }
-
-        log.info(`CAPTCHA solved for ${serviceName}`);
-        return { provider, service: serviceName, token, source: 'capsolver' };
-      }
-
-      log.debug(`CapSolver task ${taskId} still processing...`);
-    }
-
-    throw new Error(`CAPTCHA solving timed out after ${timeoutMs}ms for ${serviceName}`);
-  }
-}

package/src/integrations/gmail-watcher.js

@@ -1,129 +0,0 @@
-import https from 'node:https';
-import { createLogger } from '../logger.js';
-
-const log = createLogger('gmail-watcher');
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function httpsRequest(url, options = {}) {
-  return new Promise((resolve, reject) => {
-    const req = https.request(url, options, (res) => {
-      const chunks = [];
-      res.on('data', (chunk) => chunks.push(chunk));
-      res.on('end', () => {
-        const body = Buffer.concat(chunks).toString('utf8');
-        if (res.statusCode >= 400) {
-          reject(new Error(`Gmail API ${res.statusCode}: ${body}`));
-        } else {
-          resolve(JSON.parse(body));
-        }
-      });
-    });
-    req.on('error', reject);
-    req.end();
-  });
-}
-
-export class GmailWatcher {
-  constructor({ vault }) {
-    this.vault = vault;
-  }
-
-  async waitForCode({ serviceName, timeoutMs = 120_000, pollMs = 5_000, regex = '(\\d{6})' }) {
-    // Mock mode: environment variable override for testing
-    const mockCode = process.env.AGENTGATE_GMAIL_MOCK_CODE;
-    if (mockCode) {
-      const compiled = new RegExp(regex);
-      const match = mockCode.match(compiled);
-      if (match && match[1]) {
-        log.info(`Returning mock email code for ${serviceName}`);
-        return { code: match[1], source: 'mock', service: serviceName };
-      }
-    }
-
-    const payload = this.vault.getPayload();
-    const token = payload.google?.gmailOAuthToken;
-    if (!token) {
-      throw new Error('Gmail OAuth token missing. Run `agentgate setup`.');
-    }
-
-    log.info(`Polling Gmail for verification code from ${serviceName}`);
-    const started = Date.now();
-    const compiled = new RegExp(regex);
-    const searchAfter = Math.floor(started / 1000) - 60; // messages from last minute
-
-    while (Date.now() - started < timeoutMs) {
-      try {
-        const code = await this.pollOnce({ token, serviceName, compiled, searchAfter });
-        if (code) {
-          log.info(`Found verification code for ${serviceName}`);
-          return { code, source: 'gmail_api', service: serviceName };
-        }
-      } catch (error) {
-        log.warn(`Gmail poll error: ${error instanceof Error ? error.message : String(error)}`);
-      }
-
-      await sleep(pollMs);
-    }
-
-    throw new Error(`Timed out waiting for verification email for ${serviceName}`);
-  }
-
-  async pollOnce({ token, serviceName, compiled, searchAfter }) {
-    const query = encodeURIComponent(`from:${serviceName} after:${searchAfter} is:unread`);
-    const listUrl = `https://gmail.googleapis.com/gmail/v1/users/me/messages?q=${query}&maxResults=5`;
-
-    const listResult = await httpsRequest(listUrl, {
-      headers: { Authorization: `Bearer ${token}` }
-    });
-
-    if (!listResult.messages || listResult.messages.length === 0) {
-      return null;
-    }
-
-    for (const msg of listResult.messages) {
-      const msgUrl = `https://gmail.googleapis.com/gmail/v1/users/me/messages/${msg.id}?format=full`;
-      const detail = await httpsRequest(msgUrl, {
-        headers: { Authorization: `Bearer ${token}` }
-      });
-
-      const body = this.extractBody(detail);
-      if (!body) continue;
-
-      const match = body.match(compiled);
-      if (match && match[1]) {
-        return match[1];
-      }
-    }
-
-    return null;
-  }
-
-  extractBody(message) {
-    if (!message.payload) return null;
-
-    // Check snippet first (often contains the code)
-    if (message.snippet) {
-      return message.snippet;
-    }
-
-    // Decode body parts
-    const parts = message.payload.parts || [message.payload];
-    for (const part of parts) {
-      if (part.mimeType === 'text/plain' && part.body?.data) {
-        return Buffer.from(part.body.data, 'base64url').toString('utf8');
-      }
-    }
-
-    // Fallback to HTML part
-    for (const part of parts) {
-      if (part.mimeType === 'text/html' && part.body?.data) {
-        return Buffer.from(part.body.data, 'base64url').toString('utf8');
-      }
-    }
-
-    return null;
-  }
-}