popeye-cli 1.1.0 → 1.2.1

package/src/auth/grok.ts

@@ -0,0 +1,255 @@
+/**
+ * xAI Grok API authentication module
+ * Handles API key validation and storage
+ */
+
+import * as readline from 'node:readline';
+import OpenAI from 'openai';
+import {
+  getCredential,
+  setCredential,
+  deleteCredential,
+  maskCredential,
+} from './keychain.js';
+import { ENV_VARS } from '../config/defaults.js';
+
+/**
+ * Grok API URL (OpenAI-compatible)
+ */
+export const GROK_API_URL = 'https://api.x.ai/v1';
+
+/**
+ * Keychain account for Grok
+ */
+const GROK_ACCOUNT = 'grok-api';
+
+/**
+ * Grok authentication status
+ */
+export interface GrokAuthStatus {
+  authenticated: boolean;
+  keyLastFour?: string;
+  error?: string;
+}
+
+/**
+ * Validate a Grok 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 validateGrokToken(apiKey: string): Promise<boolean> {
+  try {
+    const client = new OpenAI({
+      apiKey,
+      baseURL: GROK_API_URL,
+    });
+
+    // Test the key by making a simple request
+    await client.chat.completions.create({
+      model: 'grok-3',
+      messages: [{ role: 'user', content: 'Say "OK"' }],
+      max_tokens: 5,
+    });
+
+    return true;
+  } catch (error) {
+    // Check for authentication errors
+    const errorMessage = error instanceof Error ? error.message : '';
+    if (
+      errorMessage.includes('401') ||
+      errorMessage.includes('Invalid API') ||
+      errorMessage.includes('Unauthorized')
+    ) {
+      return false;
+    }
+    // For other errors (e.g., rate limits), assume the key might be valid
+    console.warn('Could not fully validate Grok key:', error);
+    return true;
+  }
+}
+
+/**
+ * Get the Grok API credential
+ */
+export async function getGrokCredential(): Promise<string | null> {
+  // First check file storage
+  const stored = await getCredential(GROK_ACCOUNT);
+  if (stored) return stored;
+
+  // Fallback to environment variable
+  return process.env[ENV_VARS.GROK_KEY] || null;
+}
+
+/**
+ * Set the Grok API credential
+ */
+export async function setGrokCredential(apiKey: string): Promise<void> {
+  return setCredential(GROK_ACCOUNT, apiKey);
+}
+
+/**
+ * Delete the Grok API credential
+ */
+export async function deleteGrokCredential(): Promise<boolean> {
+  return deleteCredential(GROK_ACCOUNT);
+}
+
+/**
+ * Check if Grok is already authenticated
+ */
+export async function checkGrokAuth(): Promise<GrokAuthStatus> {
+  try {
+    const apiKey = await getGrokCredential();
+
+    if (!apiKey) {
+      return { authenticated: false };
+    }
+
+    // Validate the key
+    const isValid = await validateGrokToken(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 promptForGrokAPIKey(): 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://console.x.ai/\n');
+
+    rl.question('Enter your Grok API key: ', (answer) => {
+      rl.close();
+      const key = answer.trim();
+      if (key) {
+        resolve(key);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Authenticate with Grok API
+ *
+ * @returns True if authentication was successful
+ */
+export async function authenticateGrok(): Promise<boolean> {
+  // Check if already authenticated
+  const existingAuth = await checkGrokAuth();
+  if (existingAuth.authenticated) {
+    console.log('Already authenticated with Grok API');
+    return true;
+  }
+
+  console.log('Grok API key required for AI reviews.');
+
+  try {
+    // Prompt for the API key
+    const apiKey = await promptForGrokAPIKey();
+
+    if (!apiKey) {
+      console.error('\nNo API key provided');
+      return false;
+    }
+
+    // Validate the token
+    console.log('\nValidating API key...');
+    const isValid = await validateGrokToken(apiKey);
+
+    if (!isValid) {
+      console.error('Invalid Grok API key');
+      return false;
+    }
+
+    // Store the token
+    await setGrokCredential(apiKey);
+    console.log('Grok 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 authenticateGrokWithKey(apiKey: string): Promise<boolean> {
+  // Validate the token
+  const isValid = await validateGrokToken(apiKey);
+
+  if (!isValid) {
+    console.error('Invalid Grok API key');
+    return false;
+  }
+
+  // Store the token
+  await setGrokCredential(apiKey);
+  console.log('Grok API authenticated successfully!\n');
+
+  return true;
+}
+
+/**
+ * Logout from Grok API
+ * Removes stored credentials
+ */
+export async function logoutGrok(): Promise<void> {
+  const deleted = await deleteGrokCredential();
+  if (deleted) {
+    console.log('Grok API credentials removed.');
+  } else {
+    console.log('No Grok API credentials found.');
+  }
+}
+
+/**
+ * Get the Grok API key for API calls
+ */
+export async function getGrokToken(): Promise<string | null> {
+  return getGrokCredential();
+}
+
+/**
+ * Ensure Grok is authenticated
+ * Prompts for authentication if not already authenticated
+ */
+export async function ensureGrokAuth(): Promise<boolean> {
+  const status = await checkGrokAuth();
+
+  if (status.authenticated) {
+    return true;
+  }
+
+  return authenticateGrok();
+}

package/src/auth/index.ts

@@ -1,18 +1,20 @@
 /**
  * Authentication orchestration module
- * Coordinates authentication for Claude CLI, OpenAI API, and Gemini API
+ * Coordinates authentication for Claude CLI, OpenAI API, Gemini API, and Grok API
  */
 
 import { checkClaudeCLIAuth, authenticateClaude, logoutClaude, type ClaudeAuthStatus } from './claude.js';
 import { checkOpenAIAuth, authenticateOpenAI, logoutOpenAI, type OpenAIAuthStatus } from './openai.js';
 import { checkGeminiAuth, authenticateGemini, logoutGemini, type GeminiAuthStatus } from './gemini.js';
-import { clearAllCredentials } from './keychain.js';
+import { checkGrokAuth, authenticateGrok, logoutGrok, type GrokAuthStatus } from './grok.js';
+import { clearAllCredentials, deleteCredential } from './keychain.js';
 import type { AuthStatus } from '../types/index.js';
 
 // Re-export individual auth modules
 export * from './claude.js';
 export * from './openai.js';
 export * from './gemini.js';
+export * from './grok.js';
 export * from './keychain.js';
 export * from './server.js';
 
@@ -23,6 +25,7 @@ export interface CombinedAuthStatus {
   claude: ClaudeAuthStatus;
   openai: OpenAIAuthStatus;
   gemini: GeminiAuthStatus;
+  grok: GrokAuthStatus;
   fullyAuthenticated: boolean;
   hasArbitrator: boolean;
 }
@@ -31,18 +34,20 @@ export interface CombinedAuthStatus {
  * Get the authentication status for all services
  */
 export async function getAuthStatus(): Promise<CombinedAuthStatus> {
-  const [claudeStatus, openaiStatus, geminiStatus] = await Promise.all([
+  const [claudeStatus, openaiStatus, geminiStatus, grokStatus] = await Promise.all([
     checkClaudeCLIAuth(),
     checkOpenAIAuth(),
     checkGeminiAuth(),
+    checkGrokAuth(),
   ]);
 
   return {
     claude: claudeStatus,
     openai: openaiStatus,
     gemini: geminiStatus,
+    grok: grokStatus,
     fullyAuthenticated: claudeStatus.authenticated && openaiStatus.authenticated,
-    hasArbitrator: geminiStatus.authenticated || openaiStatus.authenticated,
+    hasArbitrator: geminiStatus.authenticated || openaiStatus.authenticated || grokStatus.authenticated,
   };
 }
 
@@ -67,6 +72,10 @@ export async function getAuthStatusForDisplay(): Promise<AuthStatus> {
       authenticated: status.gemini.authenticated,
       keyLastFour: status.gemini.keyLastFour,
     },
+    grok: {
+      authenticated: status.grok.authenticated,
+      keyLastFour: status.grok.keyLastFour,
+    },
   };
 }
 
@@ -109,11 +118,11 @@ export async function ensureAuthenticated(): Promise<boolean> {
 /**
  * Authenticate a specific service
  *
- * @param service - The service to authenticate ('claude', 'openai', 'gemini', or 'all')
+ * @param service - The service to authenticate ('claude', 'openai', 'gemini', 'grok', or 'all')
  * @returns True if authentication was successful
  */
 export async function authenticateService(
-  service: 'claude' | 'openai' | 'gemini' | 'all'
+  service: 'claude' | 'openai' | 'gemini' | 'grok' | 'all'
 ): Promise<boolean> {
   switch (service) {
     case 'claude':
@@ -122,6 +131,8 @@ export async function authenticateService(
       return authenticateOpenAI();
     case 'gemini':
       return authenticateGemini();
+    case 'grok':
+      return authenticateGrok();
     case 'all':
       return ensureAuthenticated();
   }
@@ -130,9 +141,9 @@ export async function authenticateService(
 /**
  * Logout from a specific service or all services
  *
- * @param service - The service to logout from ('claude', 'openai', 'gemini', or 'all')
+ * @param service - The service to logout from ('claude', 'openai', 'gemini', 'grok', or 'all')
  */
-export async function logout(service: 'claude' | 'openai' | 'gemini' | 'all'): Promise<void> {
+export async function logout(service: 'claude' | 'openai' | 'gemini' | 'grok' | 'all'): Promise<void> {
   switch (service) {
     case 'claude':
       await logoutClaude();
@@ -143,8 +154,13 @@ export async function logout(service: 'claude' | 'openai' | 'gemini' | 'all'): P
     case 'gemini':
       await logoutGemini();
       break;
+    case 'grok':
+      await logoutGrok();
+      break;
     case 'all':
       await clearAllCredentials();
+      // Also clear grok credential
+      await deleteCredential('grok-api');
       console.log('All credentials removed.');
       break;
   }
@@ -156,7 +172,7 @@ export async function logout(service: 'claude' | 'openai' | 'gemini' | 'all'): P
  * @param service - The service to check
  * @returns True if the service is authenticated
  */
-export async function isAuthenticated(service: 'claude' | 'openai' | 'gemini' | 'both' | 'all'): Promise<boolean> {
+export async function isAuthenticated(service: 'claude' | 'openai' | 'gemini' | 'grok' | 'both' | 'all'): Promise<boolean> {
   const status = await getAuthStatus();
 
   switch (service) {
@@ -166,6 +182,8 @@ export async function isAuthenticated(service: 'claude' | 'openai' | 'gemini' |
       return status.openai.authenticated;
     case 'gemini':
       return status.gemini.authenticated;
+    case 'grok':
+      return status.grok.authenticated;
     case 'both':
       return status.fullyAuthenticated;
     case 'all':

package/src/cli/commands/auth.ts

@@ -1,6 +1,6 @@
 /**
  * Authentication commands
- * Handles login, logout, and status for Claude and OpenAI
+ * Handles login, logout, and status for Claude, OpenAI, Gemini, and Grok
  */
 
 import { Command } from 'commander';
@@ -11,6 +11,8 @@ import {
   isAuthenticated,
 } from '../../auth/index.js';
 import { authenticateOpenAIWithKey } from '../../auth/openai.js';
+import { authenticateGeminiWithKey } from '../../auth/gemini.js';
+import { authenticateGrokWithKey } from '../../auth/grok.js';
 import {
   printHeader,
   printAuthStatus,
@@ -46,6 +48,9 @@ export function createAuthCommand(): Command {
           console.log();
           printInfo('Run "popeye-cli auth login" to authenticate missing services.');
         }
+        if (status.grok && !status.grok.authenticated) {
+          printInfo('Run "popeye-cli auth grok" to authenticate Grok (optional).');
+        }
       } catch (error) {
         failSpinner('Failed to check status');
         printError(error instanceof Error ? error.message : 'Unknown error');
@@ -57,12 +62,12 @@ export function createAuthCommand(): Command {
   auth
     .command('login')
     .description('Authenticate with services')
-    .argument('[service]', 'Service to authenticate (claude, openai, all)', 'all')
-    .option('--api-key <key>', 'OpenAI API key (for openai service)')
-    .action(async (service: 'claude' | 'openai' | 'all', options) => {
+    .argument('[service]', 'Service to authenticate (claude, openai, gemini, grok, all)', 'all')
+    .option('--api-key <key>', 'API key (for openai, gemini, or grok service)')
+    .action(async (service: 'claude' | 'openai' | 'gemini' | 'grok' | 'all', options) => {
       // Validate service
-      if (!['claude', 'openai', 'all'].includes(service)) {
-        printError(`Invalid service: ${service}. Use 'claude', 'openai', or 'all'.`);
+      if (!['claude', 'openai', 'gemini', 'grok', 'all'].includes(service)) {
+        printError(`Invalid service: ${service}. Use 'claude', 'openai', 'gemini', 'grok', or 'all'.`);
         process.exit(1);
       }
 
@@ -113,11 +118,11 @@ export function createAuthCommand(): Command {
   auth
     .command('logout')
     .description('Remove stored credentials')
-    .argument('[service]', 'Service to logout from (claude, openai, all)', 'all')
-    .action(async (service: 'claude' | 'openai' | 'all') => {
+    .argument('[service]', 'Service to logout from (claude, openai, gemini, grok, all)', 'all')
+    .action(async (service: 'claude' | 'openai' | 'gemini' | 'grok' | 'all') => {
       // Validate service
-      if (!['claude', 'openai', 'all'].includes(service)) {
-        printError(`Invalid service: ${service}. Use 'claude', 'openai', or 'all'.`);
+      if (!['claude', 'openai', 'gemini', 'grok', 'all'].includes(service)) {
+        printError(`Invalid service: ${service}. Use 'claude', 'openai', 'gemini', 'grok', or 'all'.`);
         process.exit(1);
       }
 
@@ -190,5 +195,79 @@ export function createAuthCommand(): Command {
       }
     });
 
+  // Gemini-specific subcommand
+  auth
+    .command('gemini')
+    .description('Authenticate with Gemini API')
+    .option('--api-key <key>', 'Gemini API key')
+    .action(async (options) => {
+      printHeader('Gemini API Authentication');
+
+      if (options.apiKey) {
+        startSpinner('Validating API key...');
+        const success = await authenticateGeminiWithKey(options.apiKey);
+
+        if (success) {
+          succeedSpinner('Gemini API authenticated!');
+        } else {
+          failSpinner('Invalid API key');
+          process.exit(1);
+        }
+        return;
+      }
+
+      const alreadyAuth = await isAuthenticated('gemini');
+      if (alreadyAuth) {
+        printInfo('Already authenticated with Gemini API');
+        return;
+      }
+
+      const success = await authenticateService('gemini');
+
+      if (success) {
+        printSuccess('Gemini API authenticated!');
+      } else {
+        printError('Gemini API authentication failed');
+        process.exit(1);
+      }
+    });
+
+  // Grok-specific subcommand
+  auth
+    .command('grok')
+    .description('Authenticate with xAI Grok API')
+    .option('--api-key <key>', 'Grok API key')
+    .action(async (options) => {
+      printHeader('Grok API Authentication');
+
+      if (options.apiKey) {
+        startSpinner('Validating API key...');
+        const success = await authenticateGrokWithKey(options.apiKey);
+
+        if (success) {
+          succeedSpinner('Grok API authenticated!');
+        } else {
+          failSpinner('Invalid API key');
+          process.exit(1);
+        }
+        return;
+      }
+
+      const alreadyAuth = await isAuthenticated('grok');
+      if (alreadyAuth) {
+        printInfo('Already authenticated with Grok API');
+        return;
+      }
+
+      const success = await authenticateService('grok');
+
+      if (success) {
+        printSuccess('Grok API authenticated!');
+      } else {
+        printError('Grok API authentication failed');
+        process.exit(1);
+      }
+    });
+
   return auth;
 }

package/src/cli/commands/create.ts

@@ -35,7 +35,7 @@ export function createCreateCommand(): Command {
     .option('-n, --name <name>', 'Project name')
     .option(
       '-l, --language <lang>',
-      'Output language (python, typescript)',
+      'Output language (python, typescript, fullstack)',
       'python'
     )
     .option(
@@ -66,8 +66,8 @@ export function createCreateCommand(): Command {
       try {
         // Validate inputs
         const language = options.language as OutputLanguage;
-        if (!['python', 'typescript'].includes(language)) {
-          printError(`Invalid language: ${language}. Use 'python' or 'typescript'.`);
+        if (!['python', 'typescript', 'fullstack'].includes(language)) {
+          printError(`Invalid language: ${language}. Use 'python', 'typescript', or 'fullstack'.`);
           process.exit(1);
         }
 
@@ -192,7 +192,16 @@ export function createCreateCommand(): Command {
           printSuccess('Your project is ready!');
           console.log();
           printInfo(`cd ${projectDir}`);
-          printInfo(language === 'python' ? 'python -m pytest tests/' : 'npm test');
+          if (language === 'python') {
+            printInfo('python -m pytest tests/');
+          } else if (language === 'typescript') {
+            printInfo('npm test');
+          } else if (language === 'fullstack') {
+            printInfo('docker-compose up  # Run both frontend and backend');
+            printInfo('# Or run separately:');
+            printInfo('cd apps/frontend && npm install && npm run dev');
+            printInfo('cd apps/backend && pip install -e . && uvicorn src.backend.main:app --reload');
+          }
         } else {
           printHeader('Project Creation Failed');