agentgate-mcp 0.2.0 → 0.3.1

package/src/cli.js

@@ -1,15 +1,13 @@
 #!/usr/bin/env -S node --disable-warning=ExperimentalWarning
 
 import process from 'node:process';
+import { execSync } from 'node:child_process';
+import { BrowserSession } from './browser-session.js';
 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');
 
@@ -17,32 +15,21 @@ 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 };
+  const session = new BrowserSession({ browserProfileDir: config.BROWSER_PROFILE_DIR });
+  const orchestrator = new Orchestrator({ db, browserSession: session });
+
+  return { db, session, orchestrator };
 }
 
 async function main() {
   const command = process.argv[2] ?? 'serve';
-  const { vault, db, orchestrator, registry, automationEngine } = bootstrap();
+  const { db, session, orchestrator } = bootstrap();
 
   switch (command) {
     case 'login':
-      await automationEngine.login();
-      process.stdout.write('\nGoogle session saved. AgentGate can now create API keys for any service.\n');
+      await session.login();
+      process.stdout.write('\nGoogle session saved. AgentGate can now open browsers with your Google account.\n');
       process.stdout.write('Start the MCP server with: agentgate serve\n\n');
       break;
 
@@ -52,42 +39,52 @@ async function main() {
       break;
 
     case 'doctor':
-      await runDoctor({ orchestrator, registry, db });
+      await runDoctor({ 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;
+    case 'setup':
+      runSetupClaude();
       break;
-    }
 
     default:
-      process.stderr.write(`Unknown command: ${command}\n`);
-      process.stderr.write('\nUsage:\n');
+      process.stderr.write(`Unknown command: ${command}\n\n`);
+      process.stderr.write('Usage:\n');
       process.stderr.write('  agentgate login     Sign in with Google (opens browser)\n');
+      process.stderr.write('  agentgate setup     Add to Claude Code + auto-approve tools\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.stderr.write('  agentgate doctor    Health check\n\n');
       process.exitCode = 1;
   }
 }
 
-async function runDoctor({ orchestrator, registry, db }) {
-  const checks = {};
+function runSetupClaude() {
+  const steps = [
+    { cmd: 'claude mcp add agentgate -- agentgate serve', label: 'Adding MCP server to Claude Code' },
+    { cmd: 'claude config add allowedTools "mcp__agentgate__*"', label: 'Auto-approving AgentGate tools' }
+  ];
+
+  for (const { cmd, label } of steps) {
+    process.stdout.write(`${label}...\n`);
+    try {
+      execSync(cmd, { stdio: 'inherit' });
+    } catch {
+      process.stderr.write(`Failed: ${cmd}\n`);
+      process.stderr.write('Make sure Claude Code CLI is installed: https://claude.ai/claude-code\n');
+      process.exitCode = 1;
+      return;
+    }
+  }
 
-  checks.googleLoggedIn = fileExists(config.BROWSER_PROFILE_DIR);
-  checks.vaultExists = fileExists(config.VAULT_FILE);
-  checks.keyringExists = fileExists(config.KEYRING_FILE);
+  process.stdout.write('\nDone! AgentGate is ready. Tools will run without approval prompts.\n');
+  process.stdout.write('Next: agentgate login\n\n');
+}
 
-  const recipes = registry.listServices();
-  checks.serviceRecipes = recipes.length;
+async function runDoctor({ db }) {
+  const checks = {};
 
+  checks.googleLoggedIn = fileExists(config.BROWSER_PROFILE_DIR);
   checks.dbFile = config.DB_FILE;
+
   checks.dbAccessible = true;
   try { db.getAllKeys(); } catch { checks.dbAccessible = false; }
 

package/src/config.js

@@ -20,22 +20,14 @@ 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
+  DB_FILE
 };
 
 export function ensureDirs() {

package/src/mcp-server.js

@@ -8,8 +8,7 @@ const log = createLogger('mcp-server');
 function loadVersion() {
   try {
     const pkgPath = path.resolve(import.meta.dirname, '..', 'package.json');
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    return pkg.version || '0.0.0';
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version || '0.0.0';
   } catch {
     return '0.0.0';
   }
@@ -21,63 +20,113 @@ const TOOL_DEFS = [
   {
     name: 'get_or_create_key',
     description:
-      'Get an API key for any service. Returns cached key if one exists, otherwise opens a browser ' +
-      'with the saved Google session to sign up and extract a new key. Works for ANY service — ' +
-      'just provide the service name and signup URL.',
+      'Check if AgentGate has a cached API key for a service. ' +
+      'Returns the key if cached, or tells you no key exists so you can use open_browser to go get one.',
     inputSchema: {
       type: 'object',
       properties: {
-        service: {
+        service: { type: 'string', description: 'Service name, e.g. "openai", "twelvelabs"' }
+      },
+      required: ['service']
+    },
+    annotations: { title: 'Check cached API key', readOnlyHint: true, destructiveHint: false, openWorldHint: false }
+  },
+  {
+    name: 'open_browser',
+    description:
+      'Open a browser with the saved Google session and navigate to a URL. ' +
+      'Returns a screenshot of the page so you can see what is on screen and decide what to do next. ' +
+      'The user must have run `agentgate login` first.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'URL to navigate to' }
+      },
+      required: ['url']
+    },
+    annotations: { title: 'Open browser', readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  {
+    name: 'browser_action',
+    description:
+      'Perform an action in the open browser and get a screenshot back. ' +
+      'Actions: click, fill, select, press, scroll, goto, wait, screenshot, extract_text, extract_all_text. ' +
+      'Use the screenshot to see the result and decide your next step.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Action to perform',
+          enum: ['click', 'fill', 'select', 'press', 'scroll', 'goto', 'wait', 'screenshot', 'extract_text', 'extract_all_text']
+        },
+        selector: {
           type: 'string',
-          description: 'Service name (e.g. "openai", "anthropic", "twelvelabs")'
+          description: 'CSS selector or Playwright selector (e.g. "text=Sign in with Google", "#submit-btn", "input[name=email]")'
         },
-        signup_url: {
+        value: {
           type: 'string',
-          description: 'URL to the service signup or login page (e.g. "https://platform.openai.com/signup")'
+          description: 'Value for fill/select actions, or scroll distance in pixels'
         },
-        api_key_url: {
+        key: {
           type: 'string',
-          description: 'Direct URL to the API keys dashboard (e.g. "https://platform.openai.com/api-keys"). If provided, navigates here after sign-in to find/create the key.'
+          description: 'Key to press (e.g. "Enter", "Tab")'
+        },
+        url: {
+          type: 'string',
+          description: 'URL for goto action'
+        },
+        ms: {
+          type: 'number',
+          description: 'Milliseconds for wait action (default 5000)'
         }
       },
-      required: ['service', 'signup_url']
-    }
+      required: ['action']
+    },
+    annotations: { title: 'Browser action', readOnlyHint: false, destructiveHint: false, openWorldHint: true }
   },
   {
-    name: 'list_my_keys',
-    description: 'List all API keys stored by AgentGate, including active and revoked keys.',
+    name: 'save_key',
+    description: 'Save an API key you found on the page to AgentGate\'s local database for future use.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        service: { type: 'string', description: 'Service name to store the key under' },
+        api_key: { type: 'string', description: 'The API key value to store' }
+      },
+      required: ['service', 'api_key']
+    },
+    annotations: { title: 'Save API key', readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  {
+    name: 'close_browser',
+    description: 'Close the browser session when you are done.',
     inputSchema: {
       type: 'object',
       properties: {}
-    }
+    },
+    annotations: { title: 'Close browser', readOnlyHint: false, destructiveHint: false, openWorldHint: false }
   },
   {
-    name: 'revoke_key',
-    description: 'Revoke the stored API key for a service. This only removes it from AgentGate — it does not revoke it on the provider side.',
+    name: 'list_my_keys',
+    description: 'List all API keys stored by AgentGate.',
     inputSchema: {
       type: 'object',
-      properties: {
-        service: {
-          type: 'string',
-          description: 'Service name to revoke the key for'
-        }
-      },
-      required: ['service']
-    }
+      properties: {}
+    },
+    annotations: { title: 'List API keys', readOnlyHint: true, destructiveHint: false, openWorldHint: false }
   },
   {
-    name: 'check_key_status',
-    description: 'Check whether AgentGate has an active API key stored for a service.',
+    name: 'revoke_key',
+    description: 'Delete a stored API key from AgentGate.',
     inputSchema: {
       type: 'object',
       properties: {
-        service: {
-          type: 'string',
-          description: 'Service name to check'
-        }
+        service: { type: 'string', description: 'Service name to revoke' }
       },
       required: ['service']
-    }
+    },
+    annotations: { title: 'Revoke API key', readOnlyHint: false, destructiveHint: true, openWorldHint: false }
   }
 ];
 
@@ -85,14 +134,10 @@ export class McpServer {
   constructor({ orchestrator }) {
     this.orchestrator = orchestrator;
     this.queue = Promise.resolve();
-    this.initialized = false;
   }
 
   start() {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      crlfDelay: Infinity
-    });
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
 
     rl.on('line', (line) => {
       this.queue = this.queue.then(() => this.processLine(line));
@@ -100,6 +145,7 @@ export class McpServer {
 
     rl.on('close', () => {
       log.info('stdin closed, shutting down');
+      this.orchestrator.closeBrowser().catch(() => {});
     });
 
     log.info('MCP server started', { version: VERSION });
@@ -113,11 +159,7 @@ export class McpServer {
     try {
       request = JSON.parse(trimmed);
     } catch {
-      this.write({
-        jsonrpc: '2.0',
-        error: { code: -32700, message: 'Parse error' },
-        id: null
-      });
+      this.write({ jsonrpc: '2.0', error: { code: -32700, message: 'Parse error' }, id: null });
       return;
     }
 
@@ -132,23 +174,13 @@ export class McpServer {
     } catch (error) {
       const message = error instanceof Error ? error.message : 'Unknown error';
       log.error(`Request failed: ${request.method}`, { error: message });
-      this.write({
-        jsonrpc: '2.0',
-        id: request.id,
-        error: { code: -32000, message }
-      });
+      this.write({ jsonrpc: '2.0', id: request.id, error: { code: -32000, message } });
     }
   }
 
   handleNotification(request) {
-    const { method } = request;
-    if (method === 'notifications/initialized') {
-      this.initialized = true;
+    if (request.method === 'notifications/initialized') {
       log.info('Client initialized');
-    } else if (method === 'notifications/cancelled') {
-      log.info('Client cancelled request', { params: request.params });
-    } else {
-      log.debug(`Unhandled notification: ${method}`);
     }
   }
 
@@ -163,21 +195,14 @@ export class McpServer {
       };
     }
 
-    if (method === 'ping') {
-      return {};
-    }
+    if (method === 'ping') return {};
 
-    if (method === 'tools/list') {
-      return { tools: TOOL_DEFS };
-    }
+    if (method === 'tools/list') return { tools: TOOL_DEFS };
 
     if (method === 'tools/call') {
       const { name, arguments: args } = params || {};
-      log.info(`Calling tool: ${name}`, { args });
-      const output = await this.callTool(name, args || {});
-      return {
-        content: [{ type: 'text', text: JSON.stringify(output) }]
-      };
+      log.info(`Tool call: ${name}`);
+      return this.callTool(name, args || {});
     }
 
     throw new Error(`Unsupported method: ${method}`);
@@ -186,18 +211,69 @@ export class McpServer {
   async callTool(name, args) {
     switch (name) {
       case 'get_or_create_key':
-        return this.orchestrator.getOrCreateKey(args);
+        return this.formatText(this.orchestrator.getKey(args.service));
+
+      case 'open_browser': {
+        const result = await this.orchestrator.openBrowser(args.url);
+        return this.formatBrowserResult(result);
+      }
+
+      case 'browser_action': {
+        const result = await this.orchestrator.browserAction(args);
+        return this.formatBrowserResult(result);
+      }
+
+      case 'save_key':
+        return this.formatText(this.orchestrator.saveKey(args.service, args.api_key));
+
+      case 'close_browser':
+        await this.orchestrator.closeBrowser();
+        return this.formatText({ status: 'browser closed' });
+
       case 'list_my_keys':
-        return this.orchestrator.getAllMyKeys();
+        return this.formatText(this.orchestrator.getAllMyKeys());
+
       case 'revoke_key':
-        return this.orchestrator.revokeKey(args.service);
-      case 'check_key_status':
-        return this.orchestrator.checkKeyStatus(args.service);
+        return this.formatText(this.orchestrator.revokeKey(args.service));
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
   }
 
+  /**
+   * Format a browser result with screenshot as image content.
+   */
+  formatBrowserResult(result) {
+    const content = [];
+
+    if (result.screenshot) {
+      content.push({
+        type: 'image',
+        data: result.screenshot,
+        mimeType: 'image/png'
+      });
+    }
+
+    // Include text metadata
+    const meta = { url: result.url, title: result.title };
+    if (result.extracted_text) {
+      meta.extracted_text = result.extracted_text;
+    }
+    content.push({ type: 'text', text: JSON.stringify(meta) });
+
+    return { content };
+  }
+
+  /**
+   * Format a plain JSON result as text content.
+   */
+  formatText(data) {
+    return {
+      content: [{ type: 'text', text: JSON.stringify(data) }]
+    };
+  }
+
   write(payload) {
     process.stdout.write(`${JSON.stringify(payload)}\n`);
   }

package/src/orchestrator.js

@@ -3,52 +3,20 @@ import { createLogger } from './logger.js';
 const log = createLogger('orchestrator');
 
 export class Orchestrator {
-  constructor({ db, registry, signupEngine }) {
+  constructor({ db, browserSession }) {
     this.db = db;
-    this.registry = registry;
-    this.signupEngine = signupEngine;
-  }
-
-  getAllMyKeys() {
-    return this.db.getAllKeys().map((row) => ({
-      service: row.service,
-      api_key: row.api_key,
-      status: row.status,
-      created_at: row.created_at,
-      updated_at: row.updated_at
-    }));
-  }
-
-  checkKeyStatus(service) {
-    const existing = this.db.getActiveKey(service);
-    if (!existing) {
-      return { service, exists: false, status: 'missing' };
-    }
-    return {
-      service,
-      exists: true,
-      status: existing.status,
-      created_at: existing.created_at,
-      updated_at: existing.updated_at
-    };
+    this.session = browserSession;
   }
 
   /**
-   * Get or create an API key for any service.
-   *
-   * @param {object} opts
-   * @param {string} opts.service - Service name (e.g. "openai")
-   * @param {string} opts.signup_url - Signup or login URL
-   * @param {string} [opts.api_key_url] - Direct URL to API keys dashboard
+   * Check DB for a cached key. Does NOT create one.
    */
-  async getOrCreateKey({ service, signup_url, api_key_url }) {
+  getKey(service) {
     if (!service) throw new Error('service is required');
-    if (!signup_url) throw new Error('signup_url is required');
 
-    // Check cache first
     const existing = this.db.getActiveKey(service);
     if (existing) {
-      log.info(`Returning cached key for ${service}`);
+      log.info(`Cache hit for ${service}`);
       return {
         service,
         api_key: existing.api_key,
@@ -57,51 +25,70 @@ export class Orchestrator {
       };
     }
 
-    // Build service definition — check registry for a recipe, else use smart mode
-    let serviceDef = this.registry.getService(service);
-
-    if (!serviceDef) {
-      // No recipe — create a dynamic service definition
-      serviceDef = {
-        name: service,
-        signup_url,
-        api_key_url: api_key_url || null,
-        workflow: [] // empty = smart navigation mode
-      };
-    } else {
-      // Recipe exists — override URLs if caller provided them
-      if (signup_url) serviceDef.signup_url = signup_url;
-      if (api_key_url) serviceDef.api_key_url = api_key_url;
-    }
+    return {
+      service,
+      exists: false,
+      message: `No key cached for "${service}". Use open_browser to navigate to the service and get one.`
+    };
+  }
 
-    log.info(`Creating key for ${service}`, {
-      mode: serviceDef.workflow?.length > 0 ? 'recipe' : 'smart',
-      signup_url: serviceDef.signup_url,
-      api_key_url: serviceDef.api_key_url
-    });
+  /**
+   * Save a key the agent found on a page.
+   */
+  saveKey(service, apiKey) {
+    if (!service) throw new Error('service is required');
+    if (!apiKey) throw new Error('api_key is required');
 
-    const fresh = await this.signupEngine.createKey(serviceDef);
     const stored = this.db.upsertActiveKey({
       service,
-      apiKey: fresh.apiKey,
-      metadata: fresh.metadata
+      apiKey,
+      metadata: { savedAt: new Date().toISOString() }
     });
 
-    log.info(`Key created for ${service}`, { source: fresh.metadata?.flow });
-
+    log.info(`Key saved for ${service}`);
     return {
       service,
       api_key: stored.api_key,
-      source: fresh.metadata?.flow || 'signup',
+      status: 'saved',
       created_at: stored.created_at
     };
   }
 
+  /**
+   * Open browser with Google session.
+   */
+  async openBrowser(url) {
+    if (!url) throw new Error('url is required');
+    return this.session.open(url);
+  }
+
+  /**
+   * Perform a browser action.
+   */
+  async browserAction(params) {
+    return this.session.action(params);
+  }
+
+  /**
+   * Close browser.
+   */
+  async closeBrowser() {
+    await this.session.close();
+  }
+
+  getAllMyKeys() {
+    return this.db.getAllKeys().map((row) => ({
+      service: row.service,
+      api_key: row.api_key,
+      status: row.status,
+      created_at: row.created_at,
+      updated_at: row.updated_at
+    }));
+  }
+
   revokeKey(service) {
     const changed = this.db.revokeKey(service);
-    if (changed) {
-      log.info(`Revoked key for ${service}`);
-    }
+    if (changed) log.info(`Revoked key for ${service}`);
     return { service, revoked: changed };
   }
 }

package/services/_template.service.json

@@ -1,34 +0,0 @@
-{
-  "name": "replace_me",
-  "signup_url": "https://example.com/signup",
-  "requires": {
-    "google": false,
-    "card": false
-  },
-  "runtime": {
-    "headless": true
-  },
-  "workflow": [
-    { "type": "goto", "url": "{{service.signup_url}}" },
-    { "type": "wait_for", "selector": "body" },
-
-    { "type": "fill", "selector": "input[name='email']", "value": "{{generated.emailAlias}}" },
-    { "type": "fill", "selector": "input[name='password']", "value": "{{generated.password}}" },
-    { "type": "click", "selector": "button[type='submit']" },
-    { "type": "store_alias", "emailPath": "generated.emailAlias", "passwordPath": "generated.password" },
-
-    { "type": "wait_for_email_code", "target": "scratch.emailCode", "timeoutMs": 120000 },
-    { "type": "fill", "selector": "input[name='verification_code']", "value": "{{scratch.emailCode}}" },
-    { "type": "click", "selector": "button[type='submit']" },
-
-    { "type": "solve_captcha", "target": "scratch.captchaToken", "provider": "capsolver" },
-    { "type": "fill_card" },
-
-    { "type": "goto", "url": "https://example.com/dashboard/api-keys" },
-    { "type": "click", "selector": "text=Create API Key" },
-
-    { "type": "extract_text", "selector": "body", "target": "scratch.pageText" },
-    { "type": "regex_extract", "source": "scratch.pageText", "pattern": "api[_-]?key[:\\s]+([A-Za-z0-9_\\-]{20,})", "target": "result.apiKey" },
-    { "type": "assert_present", "path": "result.apiKey", "message": "API key not found in page output" }
-  ]
-}