@benzsiangco/jarvis 1.0.2 → 1.1.0

package/src/utils/auth-prompt.ts

@@ -0,0 +1,394 @@
+// Interactive Auth using @inquirer/prompts (arrow key navigation)
+import { select, confirm, password, input } from '@inquirer/prompts';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import {
+  startAntigravityLogin,
+  loadAccounts,
+  saveAccounts,
+} from '../providers/antigravity.js';
+
+const CONFIG_DIR = join(homedir(), '.config', 'jarvis');
+const API_KEYS_FILE = join(CONFIG_DIR, 'api-keys.json');
+
+interface Provider {
+  id: string;
+  name: string;
+  envVar: string;
+  hasOAuth?: boolean;
+  apiKeyUrl?: string;
+  description?: string;
+}
+
+// All providers with their auth options
+export const providers: Provider[] = [
+  { 
+    id: 'google', 
+    name: 'Google (Gemini)', 
+    envVar: 'GOOGLE_API_KEY',
+    hasOAuth: true, 
+    apiKeyUrl: 'https://aistudio.google.com/apikey',
+    description: 'Free with OAuth, or use API key'
+  },
+  { 
+    id: 'anthropic', 
+    name: 'Anthropic (Claude)', 
+    envVar: 'ANTHROPIC_API_KEY', 
+    apiKeyUrl: 'https://console.anthropic.com/settings/keys',
+    description: 'Requires API key'
+  },
+  { 
+    id: 'openai', 
+    name: 'OpenAI (GPT)', 
+    envVar: 'OPENAI_API_KEY', 
+    apiKeyUrl: 'https://platform.openai.com/api-keys',
+    description: 'Requires API key'
+  },
+  { 
+    id: 'groq', 
+    name: 'Groq', 
+    envVar: 'GROQ_API_KEY', 
+    apiKeyUrl: 'https://console.groq.com/keys',
+    description: 'Free tier available'
+  },
+  { 
+    id: 'mistral', 
+    name: 'Mistral', 
+    envVar: 'MISTRAL_API_KEY', 
+    apiKeyUrl: 'https://console.mistral.ai/api-keys',
+    description: 'Requires API key'
+  },
+  { 
+    id: 'deepseek', 
+    name: 'DeepSeek', 
+    envVar: 'DEEPSEEK_API_KEY', 
+    apiKeyUrl: 'https://platform.deepseek.com/api_keys',
+    description: 'Very affordable pricing'
+  },
+  { 
+    id: 'together', 
+    name: 'Together AI', 
+    envVar: 'TOGETHER_API_KEY', 
+    apiKeyUrl: 'https://api.together.xyz/settings/api-keys',
+    description: 'Open source models'
+  },
+  { 
+    id: 'perplexity', 
+    name: 'Perplexity', 
+    envVar: 'PERPLEXITY_API_KEY', 
+    apiKeyUrl: 'https://www.perplexity.ai/settings/api',
+    description: 'Web-connected AI'
+  },
+  { 
+    id: 'fireworks', 
+    name: 'Fireworks', 
+    envVar: 'FIREWORKS_API_KEY', 
+    apiKeyUrl: 'https://fireworks.ai/api-keys',
+    description: 'Fast inference'
+  },
+  { 
+    id: 'xai', 
+    name: 'xAI (Grok)', 
+    envVar: 'XAI_API_KEY', 
+    apiKeyUrl: 'https://console.x.ai',
+    description: 'Grok models'
+  },
+];
+
+// Load saved API keys
+function loadApiKeys(): Record<string, string> {
+  if (!existsSync(API_KEYS_FILE)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(API_KEYS_FILE, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+// Save API key
+export function saveApiKey(providerId: string, apiKey: string): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const keys = loadApiKeys();
+  keys[providerId] = apiKey;
+  writeFileSync(API_KEYS_FILE, JSON.stringify(keys, null, 2));
+}
+
+// Remove API key
+export function removeApiKey(providerId: string): void {
+  const keys = loadApiKeys();
+  delete keys[providerId];
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(API_KEYS_FILE, JSON.stringify(keys, null, 2));
+}
+
+// Get configured provider status
+export function getApiKeyStatus(): Array<{ id: string; name: string; configured: boolean; method: string }> {
+  const keys = loadApiKeys();
+  const accounts = loadAccounts();
+  
+  return providers.map(p => {
+    const hasApiKey = !!keys[p.id] || !!process.env[p.envVar];
+    const hasOAuth = p.id === 'google' && accounts.accounts.length > 0;
+    
+    return {
+      id: p.id,
+      name: p.name,
+      configured: hasApiKey || hasOAuth,
+      method: hasOAuth ? 'OAuth' : hasApiKey ? 'API Key' : 'Not configured',
+    };
+  });
+}
+
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[2m';
+const BOLD = '\x1b[1m';
+
+export async function runInteractiveAuth(): Promise<void> {
+  console.log('');
+  console.log(`${CYAN}┌  ${RESET}${BOLD}Add credential${RESET}`);
+  console.log(`${CYAN}│${RESET}`);
+
+  // Show current status
+  const status = getApiKeyStatus();
+  const configured = status.filter(s => s.configured);
+  if (configured.length > 0) {
+    console.log(`${DIM}Currently configured:${RESET}`);
+    configured.forEach(s => {
+      console.log(`  ${GREEN}✓${RESET} ${s.name} (${s.method})`);
+    });
+    console.log(`${CYAN}│${RESET}`);
+  }
+
+  // Provider selection with arrow keys
+  const providerId = await select({
+    message: 'Select provider to configure',
+    choices: providers.map(p => {
+      const s = status.find(st => st.id === p.id);
+      const statusIcon = s?.configured ? `${GREEN}✓${RESET}` : `${DIM}○${RESET}`;
+      return {
+        name: `${statusIcon} ${p.name}${p.id === 'google' ? ` ${GREEN}(recommended)${RESET}` : ''}`,
+        value: p.id,
+        description: p.description,
+      };
+    }),
+    theme: {
+      prefix: `${CYAN}◆${RESET}`,
+      style: {
+        highlight: (text: string) => `${CYAN}${text}${RESET}`,
+      },
+    },
+  });
+
+  const provider = providers.find(p => p.id === providerId)!;
+  
+  console.log(`${CYAN}│${RESET}`);
+  console.log(`${GREEN}◇  ${RESET}Selected: ${provider.name}`);
+  console.log(`${CYAN}│${RESET}`);
+
+  // For Google, offer both OAuth and API key
+  if (provider.hasOAuth) {
+    const method = await select({
+      message: 'Choose authentication method',
+      choices: [
+        { 
+          name: `OAuth with Google ${GREEN}(recommended - FREE)${RESET}`, 
+          value: 'oauth',
+          description: 'Uses Google account, no API key needed'
+        },
+        { 
+          name: 'Enter API Key', 
+          value: 'apikey',
+          description: 'Use your own Google AI Studio API key'
+        },
+      ],
+      theme: {
+        prefix: `${CYAN}◆${RESET}`,
+        style: {
+          highlight: (text: string) => `${CYAN}${text}${RESET}`,
+        },
+      },
+    });
+
+    if (method === 'oauth') {
+      await handleOAuthLogin(provider);
+    } else {
+      await handleApiKeyEntry(provider);
+    }
+  } else {
+    // API key only provider
+    await handleApiKeyEntry(provider);
+  }
+}
+
+async function handleOAuthLogin(provider: Provider): Promise<void> {
+  console.log(`${CYAN}│${RESET}`);
+  console.log(`${GREEN}◇  ${RESET}OAuth with Google (Antigravity)`);
+  console.log(`${CYAN}│${RESET}`);
+
+  // Check for existing accounts
+  const config = loadAccounts();
+
+  if (config.accounts.length > 0) {
+    console.log(`${YELLOW}${config.accounts.length} account(s) already configured:${RESET}`);
+    config.accounts.forEach((acc, i) => {
+      console.log(`  ${i + 1}. ${acc.email || acc.id}`);
+    });
+    console.log('');
+
+    const action = await select({
+      message: 'What would you like to do?',
+      choices: [
+        { 
+          name: 'Add another account', 
+          value: 'add',
+          description: 'Add more accounts for rate limit bypass'
+        },
+        { 
+          name: 'Replace all accounts', 
+          value: 'fresh',
+          description: 'Remove existing and start fresh'
+        },
+        { 
+          name: 'Cancel', 
+          value: 'cancel',
+          description: 'Keep current configuration'
+        },
+      ],
+      theme: {
+        prefix: `${CYAN}◆${RESET}`,
+        style: {
+          highlight: (text: string) => `${CYAN}${text}${RESET}`,
+        },
+      },
+    });
+
+    if (action === 'cancel') {
+      console.log(`${CYAN}└${RESET} No changes made.`);
+      return;
+    }
+
+    if (action === 'fresh') {
+      config.accounts = [];
+      saveAccounts(config);
+      console.log(`${YELLOW}All accounts cleared.${RESET}`);
+    }
+  }
+
+  // Start OAuth flow
+  console.log(`${CYAN}│${RESET}`);
+  console.log(`${DIM}Starting OAuth flow...${RESET}`);
+  
+  try {
+    await startAntigravityLogin();
+
+    // Show updated accounts
+    const updatedConfig = loadAccounts();
+    console.log('');
+    console.log(`${GREEN}✓ ${RESET}${BOLD}Authentication successful!${RESET}`);
+    console.log('');
+    console.log(`${YELLOW}${updatedConfig.accounts.length} account(s) configured:${RESET}`);
+    updatedConfig.accounts.forEach((acc, i) => {
+      console.log(`  ${i + 1}. ${acc.email || acc.id}`);
+    });
+    console.log('');
+    console.log(`${DIM}Tip: Add more accounts with 'jarvis auth login' for rate limit bypass.${RESET}`);
+    console.log(`${CYAN}└${RESET}`);
+  } catch (error) {
+    console.log(`${RED}✗ ${RESET}OAuth failed: ${(error as Error).message}`);
+    console.log(`${CYAN}└${RESET}`);
+  }
+}
+
+async function handleApiKeyEntry(provider: Provider): Promise<void> {
+  const savedKeys = loadApiKeys();
+  const existingKey = savedKeys[provider.id] || process.env[provider.envVar];
+  
+  if (existingKey) {
+    const masked = existingKey.substring(0, 8) + '...' + existingKey.substring(existingKey.length - 4);
+    console.log(`${GREEN}Current key: ${RESET}${DIM}${masked}${RESET}`);
+    console.log(`${CYAN}│${RESET}`);
+    
+    const action = await select({
+      message: 'What would you like to do?',
+      choices: [
+        { name: 'Keep existing key', value: 'keep', description: 'Use the current API key' },
+        { name: 'Update key', value: 'update', description: 'Enter a new API key' },
+        { name: 'Remove key', value: 'remove', description: 'Delete the saved key' },
+      ],
+      theme: {
+        prefix: `${CYAN}◆${RESET}`,
+        style: {
+          highlight: (text: string) => `${CYAN}${text}${RESET}`,
+        },
+      },
+    });
+    
+    if (action === 'keep') {
+      console.log(`${CYAN}└${RESET} No changes made.`);
+      return;
+    }
+    
+    if (action === 'remove') {
+      removeApiKey(provider.id);
+      console.log(`${YELLOW}API key removed.${RESET}`);
+      console.log(`${CYAN}└${RESET}`);
+      return;
+    }
+  }
+  
+  // Show API key URL hint
+  if (provider.apiKeyUrl) {
+    console.log(`${DIM}Get your API key from: ${provider.apiKeyUrl}${RESET}`);
+    console.log(`${CYAN}│${RESET}`);
+  }
+  
+  // Prompt for API key
+  const apiKey = await password({
+    message: `Enter your ${provider.name} API key`,
+    mask: '*',
+    theme: {
+      prefix: `${CYAN}◆${RESET}`,
+    },
+  });
+  
+  if (!apiKey || apiKey.trim().length === 0) {
+    console.log(`${YELLOW}No API key entered.${RESET}`);
+    console.log(`${CYAN}└${RESET}`);
+    return;
+  }
+  
+  // Validate API key format (basic check)
+  const trimmedKey = apiKey.trim();
+  if (trimmedKey.length < 10) {
+    console.log(`${RED}API key seems too short. Please check and try again.${RESET}`);
+    console.log(`${CYAN}└${RESET}`);
+    return;
+  }
+  
+  // Save the API key
+  saveApiKey(provider.id, trimmedKey);
+  
+  // Also set in current environment for immediate use
+  process.env[provider.envVar] = trimmedKey;
+  
+  console.log(`${CYAN}│${RESET}`);
+  console.log(`${GREEN}✓ ${RESET}${BOLD}API key saved!${RESET}`);
+  console.log('');
+  console.log(`${DIM}Stored in: ${API_KEYS_FILE}${RESET}`);
+  console.log(`${DIM}Run 'jarvis' to start using ${provider.name}.${RESET}`);
+  console.log(`${CYAN}└${RESET}`);
+}
+
+// Export API keys loader for use by providers
+export { loadApiKeys };

package/src/utils/index.ts

@@ -0,0 +1,180 @@
+// Utility functions for Jarvis
+import { homedir } from 'os';
+import { join, resolve, relative } from 'path';
+import { existsSync, statSync } from 'fs';
+
+// Get the home directory
+export function getHomeDir(): string {
+  return homedir();
+}
+
+// Expand ~ in paths
+export function expandPath(path: string): string {
+  if (path.startsWith('~')) {
+    return join(homedir(), path.slice(1));
+  }
+  return resolve(path);
+}
+
+// Check if a path is absolute
+export function isAbsolutePath(path: string): boolean {
+  if (process.platform === 'win32') {
+    return /^[A-Za-z]:\\/.test(path) || path.startsWith('\\\\');
+  }
+  return path.startsWith('/');
+}
+
+// Get relative path from cwd
+export function getRelativePath(absolutePath: string, basePath?: string): string {
+  const base = basePath || process.cwd();
+  return relative(base, absolutePath);
+}
+
+// Check if file exists
+export function fileExists(path: string): boolean {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+
+// Check if directory exists
+export function directoryExists(path: string): boolean {
+  try {
+    return existsSync(path) && statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// Truncate text to a maximum length
+export function truncate(text: string, maxLength: number, suffix = '...'): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - suffix.length) + suffix;
+}
+
+// Format bytes to human readable
+export function formatBytes(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let unitIndex = 0;
+  let size = bytes;
+  
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}
+
+// Format duration in milliseconds to human readable
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  if (ms < 60000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+
+// Generate a short ID
+export function shortId(length = 8): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return result;
+}
+
+// Debounce function
+export function debounce<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  delay: number
+): (...args: Parameters<T>) => void {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  
+  return (...args: Parameters<T>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+    }, delay);
+  };
+}
+
+// Throttle function
+export function throttle<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  limit: number
+): (...args: Parameters<T>) => void {
+  let lastCall = 0;
+  
+  return (...args: Parameters<T>) => {
+    const now = Date.now();
+    if (now - lastCall >= limit) {
+      lastCall = now;
+      fn(...args);
+    }
+  };
+}
+
+// Sleep/delay function
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Parse command line style arguments from a string
+export function parseArgs(input: string): string[] {
+  const args: string[] = [];
+  let current = '';
+  let inQuote: string | null = null;
+  let escape = false;
+
+  for (const char of input) {
+    if (escape) {
+      current += char;
+      escape = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      escape = true;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      if (inQuote === char) {
+        inQuote = null;
+      } else if (!inQuote) {
+        inQuote = char;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === ' ' && !inQuote) {
+      if (current) {
+        args.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    args.push(current);
+  }
+
+  return args;
+}

package/src/utils/native-picker.ts

@@ -0,0 +1,71 @@
+/**
+ * Native Folder Picker Utility
+ * Provides an interface to trigger system-level folder dialogs
+ */
+
+export async function pickDirectory(): Promise<{path: string | null, error?: string}> {
+  if (process.platform === 'win32') {
+    const psScript = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+      $dialog.Description = "Select a Workspace Directory"
+      $dialog.ShowNewFolderButton = $true
+      $dialog.RootFolder = [System.Environment+SpecialFolder]::MyComputer
+      
+      if ($dialog.ShowDialog() -eq 'OK') {
+        $path = $dialog.SelectedPath
+        if (Test-Path $path) {
+          Write-Output "SUCCESS:$path"
+        } else {
+          Write-Output "ERROR:Invalid path selected"
+        }
+      } else {
+        Write-Output "CANCELLED"
+      }
+    `;
+    
+    try {
+      console.log('[NativePicker] Opening folder browser...');
+      
+      const proc = Bun.spawn([
+        "powershell",
+        "-ExecutionPolicy", "Bypass",  // CRITICAL FIX: Bypass execution policy
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        psScript
+      ], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      
+      // 60-second timeout
+      const timeoutPromise = new Promise<string>((_, reject) => 
+        setTimeout(() => reject(new Error('Folder picker timed out')), 60000)
+      );
+      
+      const outputPromise = new Response(proc.stdout).text();
+      const output = await Promise.race([outputPromise, timeoutPromise]);
+      
+      const trimmed = output.trim();
+      console.log('[NativePicker] Result:', trimmed);
+      
+      if (trimmed.startsWith('SUCCESS:')) {
+        return { path: trimmed.substring(8) };
+      } else if (trimmed === 'CANCELLED') {
+        return { path: null, error: 'User cancelled' };
+      } else if (trimmed.startsWith('ERROR:')) {
+        return { path: null, error: trimmed.substring(6) };
+      }
+      
+      return { path: null, error: 'Unknown error' };
+      
+    } catch (e) {
+      console.error('[NativePicker] Failed:', e);
+      return { path: null, error: (e as Error).message };
+    }
+  }
+  
+  // macOS/Linux support (future enhancement)
+  return { path: null, error: 'Folder picker not supported on this platform' };
+}