popeye-cli 1.0.1 → 1.2.0

package/src/auth/claude.ts

@@ -1,11 +1,10 @@
 /**
  * Claude CLI authentication module
- * Handles OAuth flow and token management for Claude CLI
+ * Checks for Claude Code CLI installation and authentication status
  */
 
-import open from 'open';
+import { spawn } from 'node:child_process';
 import { getClaudeCredential, setClaudeCredential, deleteClaudeCredential } from './keychain.js';
-import { startAuthCallbackServer, findAvailablePort, getCallbackUrl } from './server.js';
 
 /**
  * Claude authentication status
@@ -15,110 +14,157 @@ export interface ClaudeAuthStatus {
   user?: string;
   expires?: string;
   error?: string;
+  cliInstalled?: boolean;
 }
 
 /**
- * Check if Claude CLI is already authenticated
- * This checks for existing credentials in the keychain or environment
+ * Run a command and capture output
+ */
+function runCommand(command: string, args: string[]): Promise<{ stdout: string; stderr: string; code: number }> {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: true,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout?.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr?.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      resolve({ stdout, stderr, code: code ?? 1 });
+    });
+
+    proc.on('error', () => {
+      resolve({ stdout, stderr, code: 1 });
+    });
+  });
+}
+
+/**
+ * Check if Claude Code CLI is installed
+ */
+export async function isClaudeCLIInstalled(): Promise<boolean> {
+  try {
+    const result = await runCommand('claude', ['--version']);
+    return result.code === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if Claude Code CLI is authenticated
+ * Uses 'claude auth status' to check authentication
  */
 export async function checkClaudeCLIAuth(): Promise<ClaudeAuthStatus> {
   try {
-    const token = await getClaudeCredential();
+    // First check if CLI is installed
+    const installed = await isClaudeCLIInstalled();
+    if (!installed) {
+      return {
+        authenticated: false,
+        cliInstalled: false,
+        error: 'Claude Code CLI is not installed',
+      };
+    }
 
-    if (!token) {
-      return { authenticated: false };
+    // Check auth status by running a simple command
+    // The SDK will fail if not authenticated
+    const result = await runCommand('claude', ['-p', 'echo "auth check"', '--output-format', 'json']);
+
+    if (result.code === 0) {
+      // Also check keychain for cached status
+      const cached = await getClaudeCredential();
+
+      return {
+        authenticated: true,
+        cliInstalled: true,
+        user: cached ? 'authenticated' : 'claude-user',
+      };
+    }
+
+    // Check if the error indicates auth issues
+    const output = result.stdout + result.stderr;
+    if (output.includes('not logged in') || output.includes('authenticate') || output.includes('login')) {
+      return {
+        authenticated: false,
+        cliInstalled: true,
+        error: 'Not logged in to Claude Code',
+      };
     }
 
-    // For now, we assume if there's a token, it's valid
-    // In production, you would validate the token with the Claude API
+    // Some other error - assume authenticated if CLI is installed
+    // The actual auth check will happen when we try to use the SDK
     return {
       authenticated: true,
-      user: 'claude-user', // Would be extracted from token in production
+      cliInstalled: true,
     };
   } catch (error) {
     return {
       authenticated: false,
+      cliInstalled: false,
       error: error instanceof Error ? error.message : 'Unknown error',
     };
   }
 }
 
 /**
- * Authenticate with Claude CLI using browser-based OAuth flow
- *
- * @returns Promise that resolves to true if authentication was successful
+ * Authenticate with Claude Code CLI
+ * Opens the Claude login flow
  */
 export async function authenticateClaude(): Promise<boolean> {
+  // Check if CLI is installed
+  const installed = await isClaudeCLIInstalled();
+
+  if (!installed) {
+    console.log('\nClaude Code CLI is not installed.');
+    console.log('\nTo install Claude Code CLI:');
+    console.log('  npm install -g @anthropic-ai/claude-code');
+    console.log('\nOr visit: https://claude.ai/download\n');
+    return false;
+  }
+
   // Check if already authenticated
-  const existingAuth = await checkClaudeCLIAuth();
-  if (existingAuth.authenticated) {
-    console.log('Already authenticated with Claude CLI');
+  const status = await checkClaudeCLIAuth();
+  if (status.authenticated) {
+    console.log('Already authenticated with Claude Code CLI.');
+    await setClaudeCredential('authenticated');
     return true;
   }
 
-  console.log('Claude CLI authentication required.');
-  console.log('Opening browser for login...\n');
+  console.log('\nClaude Code CLI authentication required.');
+  console.log('\nPlease run the following command in your terminal:');
+  console.log('\n  claude login\n');
+  console.log('After logging in, restart Popeye.\n');
 
+  // Try to open the login flow
   try {
-    // Find an available port for the callback server
-    const port = await findAvailablePort(3000, 3100);
-    const callbackUrl = getCallbackUrl(port, 'claude');
-
-    // Start the callback server
-    const authPromise = startAuthCallbackServer({
-      port,
-      type: 'claude',
-      timeout: 300000, // 5 minutes
-    });
-
-    // Build the login URL
-    // Note: This is a placeholder URL. The actual Claude OAuth URL would be provided by Anthropic
-    const loginUrl = buildClaudeLoginUrl(callbackUrl);
-
-    console.log(`Waiting for authentication...`);
-    console.log(`(Browser opened to: ${loginUrl})\n`);
+    console.log('Attempting to open Claude login...\n');
+    const result = await runCommand('claude', ['login']);
 
-    // Open the browser to the login URL
-    await open(loginUrl);
-
-    // Wait for the callback
-    const result = await authPromise;
-
-    if (result.success && result.token) {
-      // Store the token securely
-      await setClaudeCredential(result.token);
-      console.log('Claude CLI authenticated successfully!\n');
+    if (result.code === 0) {
+      await setClaudeCredential('authenticated');
+      console.log('Claude Code CLI authenticated successfully!\n');
       return true;
     } else {
-      console.error(`Authentication failed: ${result.error || 'Unknown error'}`);
+      console.log('Login process exited. Please run "claude login" manually if needed.\n');
       return false;
     }
-  } catch (error) {
-    console.error(`Authentication error: ${error instanceof Error ? error.message : error}`);
+  } catch {
+    console.log('Could not start login automatically.');
+    console.log('Please run "claude login" manually.\n');
     return false;
   }
 }
 
-/**
- * Build the Claude login URL with the callback redirect
- *
- * @param callbackUrl - The local callback URL
- * @returns The full login URL
- */
-function buildClaudeLoginUrl(callbackUrl: string): string {
-  // This is a placeholder implementation
-  // The actual URL would be provided by Anthropic's OAuth configuration
-  const baseUrl = 'https://claude.ai/login';
-  const params = new URLSearchParams({
-    redirect_uri: callbackUrl,
-    client_id: 'popeye-cli',
-    response_type: 'code',
-    scope: 'cli',
-  });
-
-  return `${baseUrl}?${params.toString()}`;
-}
-
 /**
  * Logout from Claude CLI
  * Removes stored credentials
@@ -126,26 +172,23 @@ function buildClaudeLoginUrl(callbackUrl: string): string {
 export async function logoutClaude(): Promise<void> {
   const deleted = await deleteClaudeCredential();
   if (deleted) {
-    console.log('Claude CLI credentials removed.');
-  } else {
-    console.log('No Claude CLI credentials found.');
+    console.log('Claude CLI credentials removed from Popeye.');
   }
+
+  console.log('\nTo fully logout from Claude Code CLI, run:');
+  console.log('  claude logout\n');
 }
 
 /**
  * Refresh Claude CLI authentication
- * Re-authenticates if the current token is expired or invalid
  */
 export async function refreshClaudeAuth(): Promise<boolean> {
-  // Remove existing credentials
   await deleteClaudeCredential();
-
-  // Re-authenticate
   return authenticateClaude();
 }
 
 /**
- * Get the Claude CLI token for API calls
+ * Get the Claude CLI token (placeholder for API compatibility)
  */
 export async function getClaudeToken(): Promise<string | null> {
   return getClaudeCredential();
@@ -153,7 +196,6 @@ export async function getClaudeToken(): Promise<string | null> {
 
 /**
  * Ensure Claude CLI is authenticated
- * Prompts for authentication if not already authenticated
  */
 export async function ensureClaudeAuth(): Promise<boolean> {
   const status = await checkClaudeCLIAuth();

package/src/auth/gemini.ts

@@ -0,0 +1,207 @@
+/**
+ * Google Gemini API authentication module
+ * Handles API key validation and storage
+ */
+
+import * as readline from 'node:readline';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import {
+  getGeminiCredential,
+  setGeminiCredential,
+  deleteGeminiCredential,
+  maskCredential,
+} from './keychain.js';
+
+/**
+ * Gemini authentication status
+ */
+export interface GeminiAuthStatus {
+  authenticated: boolean;
+  keyLastFour?: string;
+  error?: string;
+}
+
+/**
+ * Validate a Gemini API key by making a test API call
+ *
+ * @param apiKey - The API key to validate
+ * @returns True if the key is valid
+ */
+export async function validateGeminiToken(apiKey: string): Promise<boolean> {
+  try {
+    const client = new GoogleGenerativeAI(apiKey);
+    const model = client.getGenerativeModel({ model: 'gemini-2.0-flash' });
+    // Test the key by making a simple request
+    await model.generateContent('Say "OK"');
+    return true;
+  } catch (error) {
+    // Check for authentication errors
+    const errorMessage = error instanceof Error ? error.message : '';
+    if (errorMessage.includes('API_KEY_INVALID') || errorMessage.includes('401')) {
+      return false;
+    }
+    // For other errors, assume the key might be valid
+    console.warn('Could not fully validate Gemini key:', error);
+    return true;
+  }
+}
+
+/**
+ * Check if Gemini is already authenticated
+ * Checks keychain first, then environment variable
+ */
+export async function checkGeminiAuth(): Promise<GeminiAuthStatus> {
+  try {
+    const apiKey = await getGeminiCredential();
+
+    if (!apiKey) {
+      return { authenticated: false };
+    }
+
+    // Validate the key
+    const isValid = await validateGeminiToken(apiKey);
+
+    if (!isValid) {
+      return {
+        authenticated: false,
+        error: 'Stored API key is invalid',
+      };
+    }
+
+    return {
+      authenticated: true,
+      keyLastFour: maskCredential(apiKey),
+    };
+  } catch (error) {
+    return {
+      authenticated: false,
+      error: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+}
+
+/**
+ * Prompt for API key in the terminal
+ *
+ * @returns The entered API key or null if cancelled
+ */
+export async function promptForGeminiAPIKey(): Promise<string | null> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    console.log('\nGet your API key from: https://aistudio.google.com/app/apikey\n');
+
+    rl.question('Enter your Gemini API key: ', (answer) => {
+      rl.close();
+      const key = answer.trim();
+      if (key) {
+        resolve(key);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Authenticate with Gemini API
+ *
+ * @returns True if authentication was successful
+ */
+export async function authenticateGemini(): Promise<boolean> {
+  // Check if already authenticated
+  const existingAuth = await checkGeminiAuth();
+  if (existingAuth.authenticated) {
+    console.log('Already authenticated with Gemini API');
+    return true;
+  }
+
+  console.log('Gemini API key required for arbitration.');
+
+  try {
+    // Prompt for the API key
+    const apiKey = await promptForGeminiAPIKey();
+
+    if (!apiKey) {
+      console.error('\nNo API key provided');
+      return false;
+    }
+
+    // Validate the token
+    console.log('\nValidating API key...');
+    const isValid = await validateGeminiToken(apiKey);
+
+    if (!isValid) {
+      console.error('Invalid Gemini API key');
+      return false;
+    }
+
+    // Store the token
+    await setGeminiCredential(apiKey);
+    console.log('Gemini API authenticated successfully!\n');
+
+    return true;
+  } catch (error) {
+    console.error(`Authentication error: ${error instanceof Error ? error.message : error}`);
+    return false;
+  }
+}
+
+/**
+ * Authenticate with a provided API key (for CLI --api-key option)
+ *
+ * @param apiKey - The API key to use
+ * @returns True if authentication was successful
+ */
+export async function authenticateGeminiWithKey(apiKey: string): Promise<boolean> {
+  // Validate the token
+  const isValid = await validateGeminiToken(apiKey);
+
+  if (!isValid) {
+    console.error('Invalid Gemini API key');
+    return false;
+  }
+
+  // Store the token
+  await setGeminiCredential(apiKey);
+  console.log('Gemini API authenticated successfully!\n');
+
+  return true;
+}
+
+/**
+ * Logout from Gemini API
+ * Removes stored credentials
+ */
+export async function logoutGemini(): Promise<void> {
+  const deleted = await deleteGeminiCredential();
+  if (deleted) {
+    console.log('Gemini API credentials removed.');
+  } else {
+    console.log('No Gemini API credentials found.');
+  }
+}
+
+/**
+ * Get the Gemini API key for API calls
+ */
+export async function getGeminiToken(): Promise<string | null> {
+  return getGeminiCredential();
+}
+
+/**
+ * Ensure Gemini is authenticated
+ * Prompts for authentication if not already authenticated
+ */
+export async function ensureGeminiAuth(): Promise<boolean> {
+  const status = await checkGeminiAuth();
+
+  if (status.authenticated) {
+    return true;
+  }
+
+  return authenticateGemini();
+}