agent-relay 1.1.0 → 1.2.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);

package/scripts/test-pty-input-auto.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/**
+ * Automated PTY input test for Claude CLI
+ * Tests different input methods without user interaction
+ * Run inside workspace container: node /app/dist/scripts/test-pty-input-auto.js
+ */
+
+import * as pty from 'node-pty';
+
+const TEST_CODE = 'test-auth-code-12345';
+const INPUT_METHOD = process.argv[2] || '1';
+
+// Debug: Log all escape sequences we send
+function logHex(label, data) {
+  const hex = Buffer.from(data).toString('hex').replace(/(.{2})/g, '$1 ').trim();
+  console.log(`[HEX] ${label}: ${hex}`);
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+async function main() {
+  console.log(`\nTesting PTY input method ${INPUT_METHOD} with code: ${TEST_CODE}\n`);
+
+  const proc = pty.spawn('claude', [], {
+    name: 'xterm-256color',
+    cols: 120,
+    rows: 30,
+    cwd: '/workspace',
+    env: {
+      ...process.env,
+      NO_COLOR: '1',
+      TERM: 'xterm-256color',
+      DISPLAY: '',
+    },
+  });
+
+  let output = '';
+  let authUrl = null;
+  let codePromptSeen = false;
+  let codeSent = false;
+  const prompts = [
+    { pattern: /dark\s*(mode|theme)/i, response: '\r', name: 'dark mode' },
+    { pattern: /select\s*login|how\s*would\s*you\s*like|subscription\s*or.*api/i, response: '\r', name: 'login method' },
+  ];
+  const respondedPrompts = new Set();
+
+  proc.onData((data) => {
+    output += data;
+    const clean = stripAnsi(data);
+
+    // Log meaningful output
+    if (clean.trim()) {
+      const lines = clean.trim().split('\n').map(l => l.trim()).filter(l => l);
+      for (const line of lines) {
+        if (line.length > 3 && !line.match(/^[·✢*✶✻✽]+$/)) {
+          console.log('[PTY]', line.substring(0, 120));
+        }
+      }
+    }
+
+    // Auto-respond to prompts
+    for (const prompt of prompts) {
+      if (!respondedPrompts.has(prompt.name) && prompt.pattern.test(clean)) {
+        respondedPrompts.add(prompt.name);
+        console.log(`\n[AUTO] Responding to: ${prompt.name}`);
+        setTimeout(() => proc.write(prompt.response), 100);
+      }
+    }
+
+    // Capture auth URL
+    const urlMatch = clean.match(/(https:\/\/[^\s]+)/);
+    if (urlMatch && !authUrl) {
+      authUrl = urlMatch[1];
+      console.log('\n[CAPTURED] Auth URL detected');
+    }
+
+    // Look for code paste prompt - various patterns Claude might use
+    const codePromptPatterns = [
+      /paste.*code/i,
+      /enter.*code/i,
+      /authorization.*code/i,
+      /code.*here/i,
+      /waiting.*code/i,
+      /input.*code/i,
+    ];
+
+    if (authUrl && !codePromptSeen && !codeSent) {
+      for (const pattern of codePromptPatterns) {
+        if (pattern.test(clean)) {
+          codePromptSeen = true;
+          console.log('\n[DETECTED] Code prompt pattern:', pattern.toString());
+          break;
+        }
+      }
+    }
+
+    // Also look for the text input box indicator from Ink
+    // After URL is shown and some time passes, try sending the code
+    if (authUrl && !codeSent) {
+      // Check if we see any indication we should enter the code
+      const outputLower = stripAnsi(output).toLowerCase();
+      const hasCodePrompt = outputLower.includes('paste') ||
+                           outputLower.includes('enter the code') ||
+                           outputLower.includes('authorization code') ||
+                           outputLower.includes("browser didn't open");
+
+      if (hasCodePrompt || output.length > 5000) {
+        codeSent = true;
+        console.log('\n[SENDING] Sending code after prompt/timeout...');
+        setTimeout(() => sendCode(proc), 500);
+      }
+    }
+  });
+
+  proc.onExit(({ exitCode }) => {
+    console.log('\n[EXIT] Claude exited with code:', exitCode);
+    console.log('[TOTAL OUTPUT LENGTH]', output.length);
+
+    // Check for credentials
+    import('fs').then(fs => {
+      const credPath = '/home/workspace/.claude/.credentials.json';
+      if (fs.existsSync(credPath)) {
+        console.log('[SUCCESS] Credentials file found!');
+        const creds = fs.readFileSync(credPath, 'utf8');
+        console.log('[CREDS]', creds.substring(0, 200));
+      } else {
+        console.log('[RESULT] No credentials file created (expected with test code)');
+      }
+    });
+
+    setTimeout(() => process.exit(exitCode), 1000);
+  });
+
+  async function sendCode(ptyProc) {
+    const PASTE_START = '\x1b[200~';
+    const PASTE_END = '\x1b[201~';
+
+    console.log(`[METHOD ${INPUT_METHOD}] Sending test code...`);
+
+    switch (INPUT_METHOD) {
+      case '1':
+        console.log('[1] Plain code + \\r (carriage return)');
+        logHex('sending', TEST_CODE + '\r');
+        ptyProc.write(TEST_CODE + '\r');
+        break;
+      case '2':
+        console.log('[2] Plain code + \\n (newline)');
+        logHex('sending', TEST_CODE + '\n');
+        ptyProc.write(TEST_CODE + '\n');
+        break;
+      case '3':
+        console.log('[3] Bracketed paste + \\r');
+        logHex('paste start', PASTE_START);
+        logHex('code', TEST_CODE);
+        logHex('paste end', PASTE_END);
+        ptyProc.write(PASTE_START + TEST_CODE + PASTE_END);
+        await new Promise(r => setTimeout(r, 200));
+        logHex('enter', '\r');
+        ptyProc.write('\r');
+        break;
+      case '4':
+        console.log('[4] Plain code + \\r\\n (CRLF)');
+        logHex('sending', TEST_CODE + '\r\n');
+        ptyProc.write(TEST_CODE + '\r\n');
+        break;
+      case '5':
+        console.log('[5] Character by character + \\r');
+        for (const char of TEST_CODE) {
+          ptyProc.write(char);
+          await new Promise(r => setTimeout(r, 10));
+        }
+        await new Promise(r => setTimeout(r, 200));
+        logHex('enter', '\r');
+        ptyProc.write('\r');
+        break;
+      case '6':
+        console.log('[6] Code then wait, then Enter separately');
+        logHex('code only', TEST_CODE);
+        ptyProc.write(TEST_CODE);
+        await new Promise(r => setTimeout(r, 1000));
+        console.log('[6] Now sending Enter...');
+        logHex('enter', '\r');
+        ptyProc.write('\r');
+        break;
+      case '7':
+        console.log('[7] Send Enter first then code then Enter');
+        ptyProc.write('\r'); // Clear any existing state
+        await new Promise(r => setTimeout(r, 200));
+        logHex('code + enter', TEST_CODE + '\r');
+        ptyProc.write(TEST_CODE + '\r');
+        break;
+      case '8':
+        console.log('[8] Ctrl+M (same as \\r but explicit)');
+        logHex('code + ctrl-m', TEST_CODE + '\x0d');
+        ptyProc.write(TEST_CODE + '\x0d');
+        break;
+      default:
+        console.log('[DEFAULT] Plain code + \\r');
+        ptyProc.write(TEST_CODE + '\r');
+    }
+
+    console.log('[SENT] Waiting for response...');
+
+    // Give it more time to process and show error
+    setTimeout(() => {
+      console.log('\n[TIMEOUT] Test complete, terminating...');
+      console.log('[FINAL OUTPUT CHECK] Last 500 chars of output:');
+      console.log(stripAnsi(output).slice(-500));
+      ptyProc.kill();
+    }, 20000);
+  }
+
+  // Failsafe timeout
+  setTimeout(() => {
+    console.log('\n[FAILSAFE] Max time reached, terminating...');
+    proc.kill();
+  }, 60000);
+}
+
+main().catch(console.error);

package/scripts/test-pty-input.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * Test PTY input methods for Claude CLI
+ * Run inside workspace container: node /app/dist/scripts/test-pty-input.js
+ */
+
+import * as pty from 'node-pty';
+import * as readline from 'readline';
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+function ask(question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+async function main() {
+  console.log('Starting Claude CLI via PTY...\n');
+
+  const proc = pty.spawn('claude', [], {
+    name: 'xterm-256color',
+    cols: 120,
+    rows: 30,
+    cwd: '/workspace',
+    env: {
+      ...process.env,
+      NO_COLOR: '1',
+      TERM: 'xterm-256color',
+      DISPLAY: '',
+    },
+  });
+
+  let output = '';
+  let authUrl = null;
+  const prompts = [
+    { pattern: /dark\s*(mode|theme)/i, response: '\r', name: 'dark mode' },
+    { pattern: /select\s*login|how\s*would\s*you\s*like|subscription\s*or.*api/i, response: '\r', name: 'login method' },
+  ];
+  const respondedPrompts = new Set();
+
+  proc.onData((data) => {
+    output += data;
+    const clean = stripAnsi(data);
+
+    // Log output
+    if (clean.trim()) {
+      console.log('[PTY]', clean.substring(0, 200));
+    }
+
+    // Auto-respond to prompts
+    for (const prompt of prompts) {
+      if (!respondedPrompts.has(prompt.name) && prompt.pattern.test(clean)) {
+        respondedPrompts.add(prompt.name);
+        console.log(`\n[AUTO] Responding to: ${prompt.name}`);
+        setTimeout(() => proc.write(prompt.response), 100);
+      }
+    }
+
+    // Capture auth URL
+    const urlMatch = clean.match(/(https:\/\/[^\s]+)/);
+    if (urlMatch && !authUrl) {
+      authUrl = urlMatch[1];
+      console.log('\n[CAPTURED] Auth URL:', authUrl.substring(0, 80) + '...');
+      promptForCode();
+    }
+  });
+
+  proc.onExit(({ exitCode }) => {
+    console.log('\n[EXIT] Claude exited with code:', exitCode);
+    console.log('[OUTPUT LENGTH]', output.length);
+    rl.close();
+    process.exit(exitCode);
+  });
+
+  async function promptForCode() {
+    console.log('\n========================================');
+    console.log('Complete OAuth in browser, then paste the code here.');
+    console.log('========================================\n');
+
+    const code = await ask('Paste auth code: ');
+
+    console.log('\nSelect input method:');
+    console.log('1. Plain code + \\r');
+    console.log('2. Plain code + \\n');
+    console.log('3. Bracketed paste + \\r');
+    console.log('4. Bracketed paste + \\n');
+    console.log('5. Character by character + \\r');
+
+    const method = await ask('Choice (1-5): ');
+
+    const PASTE_START = '\x1b[200~';
+    const PASTE_END = '\x1b[201~';
+    const cleanCode = code.trim();
+
+    console.log(`\n[SENDING] Using method ${method}...`);
+
+    switch (method) {
+      case '1':
+        proc.write(cleanCode + '\r');
+        break;
+      case '2':
+        proc.write(cleanCode + '\n');
+        break;
+      case '3':
+        proc.write(PASTE_START + cleanCode + PASTE_END);
+        await new Promise(r => setTimeout(r, 200));
+        proc.write('\r');
+        break;
+      case '4':
+        proc.write(PASTE_START + cleanCode + PASTE_END);
+        await new Promise(r => setTimeout(r, 200));
+        proc.write('\n');
+        break;
+      case '5':
+        for (const char of cleanCode) {
+          proc.write(char);
+          await new Promise(r => setTimeout(r, 10));
+        }
+        await new Promise(r => setTimeout(r, 200));
+        proc.write('\r');
+        break;
+      default:
+        proc.write(cleanCode + '\r');
+    }
+
+    console.log('[SENT] Waiting for response...\n');
+
+    // Wait and watch output
+    setTimeout(() => {
+      console.log('\n[CHECK] Checking for credentials file...');
+      import('fs').then(fs => {
+        const credPath = '/home/workspace/.claude/.credentials.json';
+        if (fs.existsSync(credPath)) {
+          console.log('[SUCCESS] Credentials file found!');
+          console.log(fs.readFileSync(credPath, 'utf8').substring(0, 200));
+        } else {
+          console.log('[FAIL] No credentials file yet');
+        }
+      });
+    }, 5000);
+  }
+}
+
+main().catch(console.error);