agent-relay 1.0.22 → 1.2.0

package/scripts/test-cli-auth/ci-test-runner.ts

@@ -0,0 +1,263 @@
+#!/usr/bin/env npx tsx
+/**
+ * CI Test Runner for CLI OAuth Flow
+ *
+ * This script runs in a Docker container and tests each provider's
+ * CLI OAuth flow to ensure URL extraction works correctly.
+ *
+ * Exit codes:
+ *   0 - All tests passed
+ *   1 - One or more tests failed
+ *
+ * Output format (JSON):
+ *   { "results": [...], "summary": { "passed": N, "failed": N } }
+ */
+
+import * as pty from 'node-pty';
+import { writeFileSync } from 'fs';
+
+// Provider configurations - must match CLI_AUTH_CONFIG in onboarding.ts
+const PROVIDERS = {
+  anthropic: {
+    command: 'claude',
+    args: [] as string[],
+    urlPattern: /(https:\/\/[^\s]+)/,
+    expectedUrlPrefix: 'https://console.anthropic.com',
+    prompts: [
+      { pattern: /dark\s*(mode|theme)/i, response: '\r' },
+      { pattern: /(subscription|api\s*key)/i, response: '\r' },
+      { pattern: /trust/i, response: 'y\r' },
+    ],
+  },
+  openai: {
+    command: 'codex',
+    args: ['login'],
+    urlPattern: /(https:\/\/[^\s]+)/,
+    expectedUrlPrefix: 'https://auth.openai.com',
+    prompts: [
+      { pattern: /trust/i, response: 'y\r' },
+    ],
+  },
+  google: {
+    command: 'gemini',
+    args: [] as string[],
+    urlPattern: /(https:\/\/[^\s]+)/,
+    expectedUrlPrefix: 'https://accounts.google.com',
+    prompts: [],
+  },
+  opencode: {
+    command: 'opencode',
+    args: [] as string[],
+    urlPattern: /(https:\/\/[^\s]+)/,
+    expectedUrlPrefix: 'https://opencode.ai',
+    prompts: [],
+  },
+  droid: {
+    command: 'droid',
+    args: [] as string[],
+    urlPattern: /(https:\/\/[^\s]+)/,
+    expectedUrlPrefix: 'https://factory.ai',
+    prompts: [],
+  },
+};
+
+interface TestResult {
+  provider: string;
+  command: string;
+  passed: boolean;
+  urlExtracted: string | null;
+  urlValid: boolean;
+  promptsHandled: number;
+  exitCode: number | null;
+  duration: number;
+  output: string;
+  error?: string;
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+async function testProvider(providerId: string): Promise<TestResult> {
+  const config = PROVIDERS[providerId as keyof typeof PROVIDERS];
+  if (!config) {
+    return {
+      provider: providerId,
+      command: 'unknown',
+      passed: false,
+      urlExtracted: null,
+      urlValid: false,
+      promptsHandled: 0,
+      exitCode: null,
+      duration: 0,
+      output: '',
+      error: `Unknown provider: ${providerId}`,
+    };
+  }
+
+  const startTime = Date.now();
+  const result: TestResult = {
+    provider: providerId,
+    command: `${config.command} ${config.args.join(' ')}`.trim(),
+    passed: false,
+    urlExtracted: null,
+    urlValid: false,
+    promptsHandled: 0,
+    exitCode: null,
+    duration: 0,
+    output: '',
+  };
+
+  return new Promise((resolve) => {
+    const respondedPrompts = new Set<number>();
+
+    try {
+      const proc = pty.spawn(config.command, config.args, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 30,
+        env: { ...process.env, TERM: 'xterm-256color', NO_COLOR: '1' },
+      });
+
+      const timeout = setTimeout(() => {
+        proc.kill();
+        result.error = 'Timeout waiting for CLI';
+        result.duration = Date.now() - startTime;
+        resolve(result);
+      }, 15000);
+
+      proc.onData((data: string) => {
+        result.output += data;
+        const cleanText = stripAnsi(data);
+
+        // Check for prompts and respond
+        for (let i = 0; i < config.prompts.length; i++) {
+          if (respondedPrompts.has(i)) continue;
+          if (config.prompts[i].pattern.test(cleanText)) {
+            respondedPrompts.add(i);
+            result.promptsHandled++;
+            setTimeout(() => {
+              try {
+                proc.write(config.prompts[i].response);
+              } catch {
+                // Process may have exited
+              }
+            }, 100);
+          }
+        }
+
+        // Check for URL
+        const match = cleanText.match(config.urlPattern);
+        if (match && match[1] && !result.urlExtracted) {
+          result.urlExtracted = match[1];
+          result.urlValid = result.urlExtracted.startsWith(config.expectedUrlPrefix);
+        }
+      });
+
+      proc.onExit(({ exitCode }) => {
+        clearTimeout(timeout);
+        result.exitCode = exitCode;
+        result.duration = Date.now() - startTime;
+
+        // Determine pass/fail
+        result.passed = !!(
+          result.urlExtracted &&
+          result.urlValid &&
+          exitCode === 0
+        );
+
+        resolve(result);
+      });
+
+      // Send signal to continue after prompts are done
+      setTimeout(() => {
+        try {
+          proc.write('\n');
+        } catch {
+          // Ignore
+        }
+      }, 5000);
+    } catch (err) {
+      result.error = err instanceof Error ? err.message : 'Unknown error';
+      result.duration = Date.now() - startTime;
+      resolve(result);
+    }
+  });
+}
+
+async function runAllTests() {
+  console.log('╔══════════════════════════════════════════════════════════════╗');
+  console.log('║           CLI OAuth Flow CI Tests                            ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  const results: TestResult[] = [];
+
+  for (const providerId of Object.keys(PROVIDERS)) {
+    process.stdout.write(`Testing ${providerId}... `);
+    const result = await testProvider(providerId);
+    results.push(result);
+
+    if (result.passed) {
+      console.log('✅ PASSED');
+    } else {
+      console.log(`❌ FAILED${result.error ? `: ${result.error}` : ''}`);
+    }
+
+    // Detailed output
+    console.log(`  Command: ${result.command}`);
+    console.log(`  URL: ${result.urlExtracted || 'NOT FOUND'}`);
+    console.log(`  Valid: ${result.urlValid ? 'Yes' : 'No'}`);
+    console.log(`  Prompts: ${result.promptsHandled}/${PROVIDERS[providerId as keyof typeof PROVIDERS].prompts.length}`);
+    console.log(`  Exit: ${result.exitCode}`);
+    console.log(`  Duration: ${result.duration}ms`);
+    console.log('');
+  }
+
+  // Summary
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log(`Summary: ${passed} passed, ${failed} failed out of ${results.length} tests`);
+  console.log('═══════════════════════════════════════════════════════════════');
+
+  // Write JSON results for CI parsing
+  const jsonResults = {
+    timestamp: new Date().toISOString(),
+    results: results.map(r => ({
+      provider: r.provider,
+      command: r.command,
+      passed: r.passed,
+      urlExtracted: r.urlExtracted,
+      urlValid: r.urlValid,
+      promptsHandled: r.promptsHandled,
+      exitCode: r.exitCode,
+      duration: r.duration,
+      error: r.error,
+    })),
+    summary: {
+      total: results.length,
+      passed,
+      failed,
+    },
+  };
+
+  // Write to file for CI artifact
+  try {
+    writeFileSync('/tmp/cli-oauth-test-results.json', JSON.stringify(jsonResults, null, 2));
+    console.log('\nResults written to /tmp/cli-oauth-test-results.json');
+  } catch {
+    // Might not have write access, output to stdout instead
+    console.log('\n--- JSON Results ---');
+    console.log(JSON.stringify(jsonResults, null, 2));
+  }
+
+  // Exit with appropriate code
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+runAllTests().catch((err) => {
+  console.error('Test runner failed:', err);
+  process.exit(1);
+});

package/scripts/test-cli-auth/mock-cli.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+# Mock CLI for testing OAuth flow prompt handling
+# Usage: ./mock-cli.sh <provider> [delay]
+#
+# This script simulates the interactive prompts of various AI CLI tools
+# for testing the onboarding OAuth flow without actual CLI binaries.
+#
+# When installed as symlinks (e.g., /usr/local/bin/claude -> mock-cli.sh),
+# it auto-detects the provider from the command name.
+
+# Detect provider from how the script was called
+SCRIPT_NAME=$(basename "$0")
+
+case "$SCRIPT_NAME" in
+  claude) PROVIDER="claude" ;;
+  codex) PROVIDER="codex" ;;
+  gemini) PROVIDER="gemini" ;;
+  opencode) PROVIDER="opencode" ;;
+  droid) PROVIDER="droid" ;;
+  mock-cli.sh|mock-cli|mock-cli-impl.sh)
+    PROVIDER="${1:-claude}"
+    shift 2>/dev/null || true
+    ;;
+  *) PROVIDER="${1:-claude}" ;;
+esac
+
+# Handle 'login' subcommand for codex
+if [ "$PROVIDER" = "codex" ] && [ "$1" = "login" ]; then
+  shift
+fi
+
+DELAY="${1:-0.3}"
+
+# Colors for output
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+case "$PROVIDER" in
+  claude|anthropic)
+    echo -e "${BLUE}Claude Code CLI${NC}"
+    echo ""
+    sleep "$DELAY"
+
+    # Dark mode prompt
+    echo -e "Would you like to use ${YELLOW}dark mode${NC}? (y/n) "
+    read -r -n 1 response 2>/dev/null || true
+    echo ""
+    sleep "$DELAY"
+
+    # Login method selection prompt (matches real Claude CLI)
+    echo -e "Select login method:"
+    echo ""
+    echo -e " ❯ 1. Claude account with ${YELLOW}subscription${NC} · Pro, Max, Team, or Enterprise"
+    echo ""
+    echo -e "   2. Anthropic Console account · API usage billing"
+    read -r -n 1 response 2>/dev/null || true
+    echo ""
+    sleep "$DELAY"
+
+    # Trust directory prompt
+    echo -e "Do you ${YELLOW}trust this directory${NC}? [y/N] "
+    read -r -n 1 response 2>/dev/null || true
+    echo ""
+    sleep "$DELAY"
+
+    # Auth URL
+    echo ""
+    echo -e "Please visit the following URL to authenticate:"
+    echo -e "${GREEN}https://console.anthropic.com/oauth/authorize?client_id=mock-test-123&state=abc${NC}"
+    echo ""
+    echo "Waiting for authentication..."
+
+    # Wait for completion signal (or timeout)
+    read -r -t 30 2>/dev/null || true
+    echo -e "${GREEN}Authentication successful!${NC}"
+    ;;
+
+  codex|openai)
+    echo -e "${BLUE}Codex CLI${NC}"
+    echo ""
+    sleep "$DELAY"
+
+    # Trust directory prompt
+    echo -e "Do you ${YELLOW}trust this workspace${NC}? [y/N] "
+    read -r -n 1 response 2>/dev/null || true
+    echo ""
+    sleep "$DELAY"
+
+    # Auth URL
+    echo ""
+    echo -e "Open this URL to log in:"
+    echo -e "${GREEN}https://auth.openai.com/authorize?client_id=mock-test-456&state=def${NC}"
+    echo ""
+    echo "Waiting..."
+
+    read -r -t 30 2>/dev/null || true
+    echo -e "${GREEN}Logged in successfully${NC}"
+    ;;
+
+  gemini|google)
+    echo -e "${BLUE}Gemini CLI${NC}"
+    echo ""
+    sleep "$DELAY"
+
+    # Auth URL
+    echo -e "Authenticate at:"
+    echo -e "${GREEN}https://accounts.google.com/o/oauth2/v2/auth?client_id=mock-test-789${NC}"
+    echo ""
+
+    read -r -t 30 2>/dev/null || true
+    echo -e "${GREEN}Authenticated!${NC}"
+    ;;
+
+  opencode)
+    echo -e "${BLUE}OpenCode CLI${NC}"
+    echo ""
+    sleep "$DELAY"
+
+    echo -e "Login URL:"
+    echo -e "${GREEN}https://opencode.ai/auth?session=mock-session${NC}"
+    echo ""
+
+    read -r -t 30 2>/dev/null || true
+    echo -e "${GREEN}Success${NC}"
+    ;;
+
+  droid)
+    echo -e "${BLUE}Droid CLI${NC}"
+    echo ""
+    sleep "$DELAY"
+
+    echo -e "Visit to authenticate:"
+    echo -e "${GREEN}https://factory.ai/droid/auth?id=mock-droid${NC}"
+    echo ""
+
+    read -r -t 30 2>/dev/null || true
+    echo -e "${GREEN}Authenticated${NC}"
+    ;;
+
+  *)
+    echo "Unknown provider: $PROVIDER"
+    echo "Supported: claude, codex, gemini, opencode, droid"
+    exit 1
+    ;;
+esac

package/scripts/test-cli-auth/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "cli-oauth-test",
+  "version": "1.0.0",
+  "description": "CLI OAuth flow testing for agent-relay",
+  "type": "module",
+  "scripts": {
+    "test": "tsx ci-test-runner.ts",
+    "test:local": "tsx test-oauth-flow.ts"
+  },
+  "dependencies": {
+    "node-pty": "^1.0.0",
+    "tsx": "^4.19.0"
+  }
+}

package/scripts/test-cli-auth/test-oauth-flow.ts

@@ -0,0 +1,220 @@
+#!/usr/bin/env npx tsx
+/**
+ * CLI OAuth Flow Integration Test
+ *
+ * Tests the prompt handling and URL extraction for each provider
+ * using mock CLIs that simulate the real interactive flows.
+ *
+ * Usage:
+ *   npx tsx scripts/test-cli-auth/test-oauth-flow.ts [provider]
+ *
+ * Examples:
+ *   npx tsx scripts/test-cli-auth/test-oauth-flow.ts           # Test all providers
+ *   npx tsx scripts/test-cli-auth/test-oauth-flow.ts claude    # Test Claude only
+ */
+
+import * as pty from 'node-pty';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  CLI_AUTH_CONFIG,
+  stripAnsiCodes,
+  matchesSuccessPattern,
+  findMatchingPrompt,
+} from '../../src/cloud/api/onboarding.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+interface TestResult {
+  provider: string;
+  passed: boolean;
+  urlExtracted: string | null;
+  promptsResponded: string[];
+  successDetected: boolean;
+  output: string;
+  error?: string;
+}
+
+/**
+ * Test a single provider's OAuth flow using the mock CLI
+ */
+async function testProvider(providerId: string): Promise<TestResult> {
+  const config = CLI_AUTH_CONFIG[providerId];
+  if (!config) {
+    return {
+      provider: providerId,
+      passed: false,
+      urlExtracted: null,
+      promptsResponded: [],
+      successDetected: false,
+      output: '',
+      error: `Unknown provider: ${providerId}`,
+    };
+  }
+
+  const result: TestResult = {
+    provider: providerId,
+    passed: false,
+    urlExtracted: null,
+    promptsResponded: [],
+    successDetected: false,
+    output: '',
+  };
+
+  return new Promise((resolve) => {
+    const mockCliPath = path.join(__dirname, 'mock-cli.sh');
+    const respondedPrompts = new Set<string>();
+
+    // Map provider IDs to mock CLI provider names
+    const mockProviderName = providerId === 'anthropic' ? 'claude' :
+                             providerId === 'openai' ? 'codex' :
+                             providerId === 'google' ? 'gemini' : providerId;
+
+    const proc = pty.spawn('bash', [mockCliPath, mockProviderName, '0.2'], {
+      name: 'xterm-256color',
+      cols: 120,
+      rows: 30,
+      cwd: __dirname,
+      env: { ...process.env, TERM: 'xterm-256color' },
+    });
+
+    const timeout = setTimeout(() => {
+      proc.kill();
+      result.error = 'Timeout waiting for completion';
+      resolve(result);
+    }, 10000);
+
+    proc.onData((data: string) => {
+      result.output += data;
+
+      // Check for matching prompts and auto-respond
+      const matchingPrompt = findMatchingPrompt(data, config.prompts, respondedPrompts);
+      if (matchingPrompt) {
+        respondedPrompts.add(matchingPrompt.description);
+        result.promptsResponded.push(matchingPrompt.description);
+        setTimeout(() => {
+          try {
+            proc.write(matchingPrompt.response);
+          } catch {
+            // Process may have exited
+          }
+        }, matchingPrompt.delay ?? 50);
+      }
+
+      // Look for auth URL
+      const cleanText = stripAnsiCodes(data);
+      const match = cleanText.match(config.urlPattern);
+      if (match && match[1] && !result.urlExtracted) {
+        result.urlExtracted = match[1];
+      }
+
+      // Check for success indicators
+      if (matchesSuccessPattern(data, config.successPatterns)) {
+        result.successDetected = true;
+      }
+    });
+
+    proc.onExit(({ exitCode }) => {
+      clearTimeout(timeout);
+
+      // Determine if test passed
+      result.passed = !!(
+        result.urlExtracted &&
+        result.successDetected &&
+        exitCode === 0
+      );
+
+      // Send completion signal to mock CLI
+      setTimeout(() => resolve(result), 100);
+    });
+
+    // For mock CLI, send signal to continue after prompts
+    setTimeout(() => {
+      try {
+        proc.write('\n'); // Signal to continue
+      } catch {
+        // Ignore
+      }
+    }, 3000);
+  });
+}
+
+/**
+ * Run tests for specified providers or all providers
+ */
+async function runTests(providers?: string[]) {
+  const providerIds = providers ?? Object.keys(CLI_AUTH_CONFIG);
+
+  console.log('╔══════════════════════════════════════════════════════════════╗');
+  console.log('║           CLI OAuth Flow Integration Tests                    ║');
+  console.log('╚══════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  const results: TestResult[] = [];
+
+  for (const providerId of providerIds) {
+    const config = CLI_AUTH_CONFIG[providerId];
+    if (!config) {
+      console.log(`⚠️  Unknown provider: ${providerId}`);
+      continue;
+    }
+
+    console.log(`Testing ${config.displayName} (${providerId})...`);
+
+    const result = await testProvider(providerId);
+    results.push(result);
+
+    if (result.passed) {
+      console.log(`  ✅ PASSED`);
+    } else {
+      console.log(`  ❌ FAILED${result.error ? `: ${result.error}` : ''}`);
+    }
+
+    console.log(`     URL extracted: ${result.urlExtracted ? '✓' : '✗'}`);
+    console.log(`     Success detected: ${result.successDetected ? '✓' : '✗'}`);
+    if (result.promptsResponded.length > 0) {
+      console.log(`     Prompts responded: ${result.promptsResponded.join(', ')}`);
+    }
+    console.log('');
+  }
+
+  // Summary
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log(`Summary: ${passed} passed, ${failed} failed`);
+  console.log('═══════════════════════════════════════════════════════════════');
+
+  // Exit with error if any tests failed
+  if (failed > 0) {
+    console.log('\nFailed tests:');
+    for (const result of results.filter(r => !r.passed)) {
+      console.log(`  - ${result.provider}: ${result.error || 'See details above'}`);
+    }
+    process.exit(1);
+  }
+}
+
+// Parse CLI args
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+CLI OAuth Flow Integration Test
+
+Usage:
+  npx tsx scripts/test-cli-auth/test-oauth-flow.ts [provider...]
+
+Examples:
+  npx tsx scripts/test-cli-auth/test-oauth-flow.ts           # Test all providers
+  npx tsx scripts/test-cli-auth/test-oauth-flow.ts anthropic # Test Claude only
+  npx tsx scripts/test-cli-auth/test-oauth-flow.ts anthropic openai # Test multiple
+
+Providers:
+  ${Object.keys(CLI_AUTH_CONFIG).join(', ')}
+`);
+  process.exit(0);
+}
+
+runTests(args.length > 0 ? args : undefined).catch(console.error);