vibe-weaver 1.0.0

package/src/auth/index.ts

@@ -0,0 +1,273 @@
+/**
+ * Auth module for Vibe-Weaver CLI
+ * Handles API key and GitHub token storage via keytar with plaintext fallback
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import open from 'open';
+import { loadConfig, saveConfig, getSupabaseUrl, getConfigPath } from '../config/index.js';
+
+const SERVICE_NAME = 'vibe-weaver';
+const API_KEY_ACCOUNT = 'api-key';
+const GITHUB_TOKEN_ACCOUNT = 'github-token';
+
+// Try to use keytar for secure storage
+let keytar: any = null;
+try {
+  keytar = require('keytar');
+} catch {
+  // keytar not available, will use plaintext fallback
+}
+
+function getPlaintextPath(): string {
+  return getConfigPath();
+}
+
+/**
+ * Try to get a secret from keytar, fall back to config file
+ */
+async function getSecret(account: string): Promise<string | null> {
+  if (keytar) {
+    try {
+      const value = await keytar.getPassword(SERVICE_NAME, account);
+      if (value) return value;
+    } catch {
+      // Keytar failed, fall through to plaintext
+    }
+  }
+  
+  // Fallback to config file
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) return config.apiKey || null;
+  if (account === GITHUB_TOKEN_ACCOUNT) return config.githubToken || null;
+  return null;
+}
+
+/**
+ * Store a secret in keytar, fall back to config file
+ */
+async function setSecret(account: string, value: string): Promise<void> {
+  if (keytar) {
+    try {
+      await keytar.setPassword(SERVICE_NAME, account, value);
+      // Also save to config as backup
+      const config = loadConfig();
+      if (account === API_KEY_ACCOUNT) config.apiKey = value;
+      if (account === GITHUB_TOKEN_ACCOUNT) config.githubToken = value;
+      saveConfig(config);
+      return;
+    } catch {
+      // Keytar failed, fall through to plaintext
+    }
+  }
+  
+  // Fallback to config file
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) config.apiKey = value;
+  if (account === GITHUB_TOKEN_ACCOUNT) config.githubToken = value;
+  saveConfig(config);
+}
+
+/**
+ * Remove a secret from keytar and config
+ */
+async function deleteSecret(account: string): Promise<void> {
+  if (keytar) {
+    try {
+      await keytar.deletePassword(SERVICE_NAME, account);
+    } catch {
+      // Ignore errors
+    }
+  }
+  
+  const config = loadConfig();
+  if (account === API_KEY_ACCOUNT) {
+    config.apiKey = undefined;
+  }
+  if (account === GITHUB_TOKEN_ACCOUNT) {
+    config.githubToken = undefined;
+  }
+  saveConfig(config);
+}
+
+/**
+ * Check if user is logged in (has API key)
+ */
+export async function isLoggedIn(): Promise<boolean> {
+  const apiKey = await getSecret(API_KEY_ACCOUNT);
+  return !!apiKey;
+}
+
+/**
+ * Get current API key
+ */
+export async function getApiKey(): Promise<string | null> {
+  return getSecret(API_KEY_ACCOUNT);
+}
+
+/**
+ * Get current GitHub token
+ */
+export async function getGithubToken(): Promise<string | null> {
+  return getSecret(GITHUB_TOKEN_ACCOUNT);
+}
+
+/**
+ * Interactive login - accept API key or open web page
+ */
+export async function login(options: { apiKey?: string; openBrowser?: boolean } = {}): Promise<void> {
+  const supabaseUrl = getSupabaseUrl();
+  
+  if (options.apiKey) {
+    // Direct API key provided
+    await setSecret(API_KEY_ACCOUNT, options.apiKey);
+    console.log(chalk.green('✓ API key saved securely'));
+    
+    // Verify the key works
+    const userInfo = await getUserInfo();
+    if (userInfo) {
+      console.log(chalk.green(`✓ Logged in as ${userInfo.email} (${userInfo.plan} plan)`));
+    }
+    return;
+  }
+  
+  if (options.openBrowser) {
+    // Open the web page for API key creation
+    const apiPageUrl = `${supabaseUrl}/dashboard/api`;
+    console.log(chalk.blue('Opening browser to create API key...'));
+    await open(apiPageUrl);
+  }
+  
+  // Interactive prompt for API key
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'apiKey',
+      message: 'Enter your Vibe-Weaver API key (vw_...):',
+      validate: (input: string) => {
+        if (!input.startsWith('vw_') && input.length < 10) {
+          return 'Please enter a valid API key (starts with vw_)';
+        }
+        return true;
+      }
+    }
+  ]);
+  
+  await setSecret(API_KEY_ACCOUNT, answers.apiKey);
+  console.log(chalk.green('✓ API key saved securely'));
+  
+  // Verify the key works
+  const userInfo = await getUserInfo();
+  if (userInfo) {
+    console.log(chalk.green(`✓ Logged in as ${userInfo.email} (${userInfo.plan} plan)`));
+  }
+}
+
+/**
+ * Login with GitHub token
+ */
+export async function loginGithub(token?: string): Promise<void> {
+  if (!token) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'token',
+        message: 'Enter your GitHub Personal Access Token:',
+        validate: (input: string) => {
+          if (input.length < 10) {
+            return 'Please enter a valid GitHub token';
+          }
+          return true;
+        }
+      }
+    ]);
+    token = answers.token;
+  }
+  
+  await setSecret(GITHUB_TOKEN_ACCOUNT, token);
+  console.log(chalk.green('✓ GitHub token saved securely'));
+}
+
+/**
+ * Logout - clear all stored credentials
+ */
+export async function logout(): Promise<void> {
+  await deleteSecret(API_KEY_ACCOUNT);
+  await deleteSecret(GITHUB_TOKEN_ACCOUNT);
+  console.log(chalk.green('✓ Logged out successfully'));
+}
+
+/**
+ * Get user info from the API
+ */
+export async function getUserInfo(): Promise<{ email: string; plan: string; credits: number } | null> {
+  const apiKey = await getApiKey();
+  if (!apiKey) return null;
+  
+  const supabaseUrl = getSupabaseUrl();
+  
+  try {
+    const response = await fetch(`${supabaseUrl}/rest/v1/profiles?select=email,plan,credits`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'apikey': `${supabaseUrl}/rest/v1/apikey`
+      }
+    });
+    
+    if (response.ok) {
+      const data = await response.json();
+      if (Array.isArray(data) && data.length > 0) {
+        return {
+          email: data[0].email || 'Unknown',
+          plan: data[0].plan || 'free',
+          credits: data[0].credits || 0
+        };
+      }
+    }
+  } catch (error) {
+    console.warn('Warning: Could not fetch user info:', error);
+  }
+  
+  return null;
+}
+
+/**
+ * Show current user info (whoami)
+ */
+export async function whoami(): Promise<void> {
+  const apiKey = await getApiKey();
+  if (!apiKey) {
+    console.log(chalk.yellow('Not logged in. Run "vibe-weaver login" first.'));
+    return;
+  }
+  
+  const userInfo = await getUserInfo();
+  if (userInfo) {
+    console.log(chalk.bold('Logged in as:'));
+    console.log(`  Email: ${userInfo.email}`);
+    console.log(`  Plan: ${chalk.cyan(userInfo.plan)}`);
+    console.log(`  Credits: ${chalk.green(userInfo.credits.toString())}`);
+  } else {
+    console.log(chalk.yellow('API key is set but could not fetch user info.'));
+    console.log(`  API Key: ${chalk.grey(apiKey.substring(0, 10))}...`);
+  }
+  
+  const githubToken = await getGithubToken();
+  if (githubToken) {
+    console.log(chalk.green('✓ GitHub token configured'));
+  } else {
+    console.log(chalk.grey('  GitHub: Not configured (run "vibe-weaver login --github" to add)'));
+  }
+}
+
+export default {
+  login,
+  logout,
+  whoami,
+  loginGithub,
+  isLoggedIn,
+  getApiKey,
+  getGithubToken,
+  getUserInfo
+};

package/src/config/index.ts

@@ -0,0 +1,86 @@
+/**
+ * Configuration module for Vibe-Weaver CLI
+ * Manages config storage in ~/.vibe-weaver/config.json
+ */
+
+import envPaths from 'env-paths';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface CLIConfig {
+  apiKey?: string;
+  githubToken?: string;
+  supabaseUrl?: string;
+  defaultPlatform?: string;
+  defaultMode?: string;
+  autoApprove?: boolean;
+  autoDeploy?: boolean;
+}
+
+export interface UserInfo {
+  email?: string;
+  plan?: string;
+  credits?: number;
+}
+
+const CONFIG_FILE_NAME = 'config.json';
+
+function getConfigDir(): string {
+  const paths = envPaths('vibe-weaver', { suffix: '' });
+  if (!fs.existsSync(paths.config)) {
+    fs.mkdirSync(paths.config, { recursive: true });
+  }
+  // Set restrictive permissions
+  fs.chmodSync(paths.config, 0o700);
+  return paths.config;
+}
+
+export function getConfigPath(): string {
+  return path.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+
+export function loadConfig(): CLIConfig {
+  const configPath = getConfigPath();
+  try {
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.warn('Warning: Failed to load config:', error);
+  }
+  return {};
+}
+
+export function saveConfig(config: CLIConfig): void {
+  const configPath = getConfigPath();
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), {
+      mode: 0o600
+    });
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error}`);
+  }
+}
+
+export function clearConfig(): void {
+  const configPath = getConfigPath();
+  try {
+    if (fs.existsSync(configPath)) {
+      fs.unlinkSync(configPath);
+    }
+  } catch (error) {
+    throw new Error(`Failed to clear config: ${error}`);
+  }
+}
+
+export function getDefaultSupabaseUrl(): string {
+  // Default to vibe-weaver's Supabase instance
+  return process.env.VW_SUPABASE_URL || 'https://mmtsoqelnsjleusqyknc.supabase.co';
+}
+
+export function getSupabaseUrl(): string {
+  const config = loadConfig();
+  return config.supabaseUrl || getDefaultSupabaseUrl();
+}