codeslick-cli 1.0.0

package/src/commands/auth.ts

@@ -0,0 +1,308 @@
+/**
+ * CLI Authentication Commands
+ * Phase 1.5 Week 10 - CLI Authentication System
+ *
+ * Commands:
+ * - login: Browser-based OAuth authentication
+ * - logout: Remove local credentials
+ * - whoami: Display current user info and quota
+ */
+
+import { spawn } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Configuration
+const CONFIG_DIR = join(homedir(), '.codeslick');
+const AUTH_FILE = join(CONFIG_DIR, 'auth.json');
+const API_BASE = process.env.CODESLICK_API_URL || 'https://codeslick.dev';
+
+// Types
+interface AuthConfig {
+  accessToken: string;
+  email: string;
+  plan: string;
+  expiresAt?: string;
+}
+
+interface AuthRequestResponse {
+  token: string;
+  authUrl: string;
+  expiresIn: number;
+}
+
+interface AuthStatusResponse {
+  status: string;
+  accessToken?: string;
+  error?: string;
+}
+
+interface UserResponse {
+  user: {
+    id: string;
+    email: string;
+    name: string | null;
+    plan: string;
+    quota: {
+      used: number;
+      limit: number;
+      remaining: number;
+    };
+  };
+  team?: {
+    id: string;
+    name: string;
+    plan: string;
+  } | null;
+}
+
+/**
+ * Login Command
+ * Opens browser for authentication and polls for validation
+ */
+export async function loginCommand() {
+  console.log(chalk.bold('🔐 CodeSlick CLI Authentication\n'));
+
+  // Check if already logged in
+  const existingAuth = loadAuth();
+  if (existingAuth) {
+    console.log(chalk.yellow('Already logged in as:'), chalk.bold(existingAuth.email));
+    console.log(chalk.gray('Run: codeslick auth logout\n'));
+    return;
+  }
+
+  const spinner = ora('Requesting authentication token...').start();
+
+  try {
+    // Step 1: Request auth token
+    const tokenRes = await fetch(`${API_BASE}/api/cli/auth/request`, {
+      method: 'POST',
+    });
+
+    if (!tokenRes.ok) {
+      throw new Error('Failed to request auth token');
+    }
+
+    const { token, authUrl, expiresIn } = await tokenRes.json() as AuthRequestResponse;
+
+    spinner.succeed('Token generated');
+
+    // Step 2: Open browser
+    console.log(chalk.cyan('\n📱 Opening browser for authentication...'));
+    console.log(chalk.gray(`If browser doesn't open, visit: ${authUrl}\n`));
+
+    openBrowser(authUrl);
+
+    // Step 3: Poll for validation
+    spinner.start('Waiting for authentication...');
+
+    let attempts = 0;
+    const maxAttempts = 60; // 10 minutes (10s intervals)
+
+    while (attempts < maxAttempts) {
+      await sleep(10000); // Wait 10 seconds
+
+      const statusRes = await fetch(`${API_BASE}/api/cli/auth/status/${token}`);
+      const statusData = await statusRes.json() as AuthStatusResponse;
+
+      if (statusData.status === 'validated') {
+        spinner.succeed('Authentication successful!');
+
+        // Step 4: Get user info and store credentials
+        const meRes = await fetch(`${API_BASE}/api/cli/auth/me`, {
+          headers: {
+            Authorization: `Bearer ${statusData.accessToken}`,
+          },
+        });
+
+        if (!meRes.ok) {
+          throw new Error('Failed to fetch user info');
+        }
+
+        const userData = await meRes.json() as UserResponse;
+
+        // Save credentials
+        ensureConfigDir();
+        writeFileSync(
+          AUTH_FILE,
+          JSON.stringify(
+            {
+              accessToken: statusData.accessToken,
+              email: userData.user.email,
+              plan: userData.user.plan,
+            } as AuthConfig,
+            null,
+            2
+          )
+        );
+
+        // Display success message
+        console.log(chalk.green('\n✓ Logged in as:'), chalk.bold(userData.user.email));
+        console.log(chalk.green('✓ Plan:'), chalk.bold(userData.user.plan.toUpperCase()));
+        console.log(
+          chalk.green('✓ AI-Fix Quota:'),
+          chalk.bold(`${userData.user.quota.remaining}/${userData.user.quota.limit}`)
+        );
+
+        if (userData.team) {
+          console.log(chalk.green('✓ Team:'), chalk.bold(userData.team.name));
+        }
+
+        console.log(chalk.gray('\nRun: codeslick scan <files> to start scanning\n'));
+        return;
+      }
+
+      if (statusData.status === 'expired') {
+        throw new Error('Authentication token expired. Please try again.');
+      }
+
+      attempts++;
+    }
+
+    throw new Error('Authentication timeout. Please try again.');
+  } catch (error: any) {
+    spinner.fail('Authentication failed');
+    console.error(chalk.red('\nError:'), error.message);
+    console.log(chalk.gray('\nTry again: codeslick auth login\n'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Logout Command
+ * Removes local credentials
+ */
+export async function logoutCommand() {
+  if (!existsSync(AUTH_FILE)) {
+    console.log(chalk.yellow('Not logged in'));
+    console.log(chalk.gray('Run: codeslick auth login\n'));
+    return;
+  }
+
+  // Get current user before deleting
+  const auth = loadAuth();
+
+  // Delete credentials
+  unlinkSync(AUTH_FILE);
+
+  console.log(chalk.green('✓ Logged out successfully'));
+  if (auth) {
+    console.log(chalk.gray(`  Removed credentials for: ${auth.email}\n`));
+  }
+}
+
+/**
+ * Whoami Command
+ * Displays current user info and quota
+ */
+export async function whoamiCommand() {
+  const auth = loadAuth();
+
+  if (!auth) {
+    console.log(chalk.yellow('Not logged in'));
+    console.log(chalk.gray('Run: codeslick auth login\n'));
+    return;
+  }
+
+  const spinner = ora('Fetching user info...').start();
+
+  try {
+    const res = await fetch(`${API_BASE}/api/cli/auth/me`, {
+      headers: {
+        Authorization: `Bearer ${auth.accessToken}`,
+      },
+    });
+
+    if (!res.ok) {
+      if (res.status === 401) {
+        throw new Error('Access token expired. Please log in again.');
+      }
+      throw new Error('Failed to fetch user info');
+    }
+
+    const data = await res.json() as UserResponse;
+
+    spinner.succeed('User info retrieved');
+
+    console.log(chalk.bold('\n👤 User Information:'));
+    console.log(chalk.gray('───────────────────────────────'));
+    console.log(chalk.cyan('Email:'), data.user.email);
+    console.log(chalk.cyan('Name:'), data.user.name || chalk.gray('(not set)'));
+    console.log(chalk.cyan('Plan:'), data.user.plan.toUpperCase());
+    console.log();
+    console.log(chalk.bold('📊 AI-Fix Quota:'));
+    console.log(chalk.gray('───────────────────────────────'));
+    console.log(chalk.cyan('Used:'), `${data.user.quota.used}/${data.user.quota.limit}`);
+    console.log(chalk.cyan('Remaining:'), chalk.bold(data.user.quota.remaining));
+
+    if (data.team) {
+      console.log();
+      console.log(chalk.bold('👥 Team:'));
+      console.log(chalk.gray('───────────────────────────────'));
+      console.log(chalk.cyan('Name:'), data.team.name);
+      console.log(chalk.cyan('Plan:'), data.team.plan.toUpperCase());
+    }
+
+    console.log();
+  } catch (error: any) {
+    spinner.fail('Failed to fetch user info');
+    console.error(chalk.red('\nError:'), error.message);
+    console.log(chalk.gray('Try: codeslick auth login\n'));
+    process.exit(1);
+  }
+}
+
+// ==================== HELPER FUNCTIONS ====================
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load authentication config from disk
+ */
+export function loadAuth(): AuthConfig | null {
+  if (!existsSync(AUTH_FILE)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(AUTH_FILE, 'utf-8');
+    return JSON.parse(content) as AuthConfig;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url: string) {
+  const platform = process.platform;
+
+  let command: string;
+  if (platform === 'darwin') {
+    command = 'open';
+  } else if (platform === 'win32') {
+    command = 'start';
+  } else {
+    command = 'xdg-open';
+  }
+
+  spawn(command, [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/commands/config.ts

@@ -0,0 +1,226 @@
+/**
+ * Config Command - Configuration Management
+ *
+ * This command allows users to manage their .codeslick.json configuration
+ * from the command line without manually editing the file.
+ *
+ * Supported actions:
+ * - get: Read a specific configuration value
+ * - set: Update a specific configuration value
+ * - list: Display all configuration values
+ *
+ * Examples:
+ * ```bash
+ * codeslick config list
+ * codeslick config get severity
+ * codeslick config set severity high
+ * codeslick config set autofix true
+ * ```
+ *
+ * @module packages/cli/src/commands/config
+ */
+
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import {
+  loadConfig,
+  updateConfig,
+  configExists,
+  type CodeSlickConfig,
+} from '../config/config-loader';
+import { printSuccess, printError } from '../reporters/cli-reporter';
+
+/**
+ * Command arguments type
+ */
+interface ConfigArgs {
+  action: 'get' | 'set' | 'list';
+  key?: string;
+  value?: string;
+}
+
+/**
+ * Display all configuration values in a table
+ */
+async function listConfig(): Promise<void> {
+  try {
+    const config = await loadConfig();
+
+    console.log('');
+    console.log(chalk.bold('CodeSlick Configuration'));
+    console.log(chalk.gray('─'.repeat(50)));
+
+    const table = new Table({
+      head: [chalk.bold('Key'), chalk.bold('Value')],
+      colWidths: [20, 40],
+      wordWrap: true,
+      style: {
+        head: [],
+        border: ['gray'],
+      },
+    });
+
+    table.push(
+      ['version', chalk.white(config.version)],
+      ['severity', chalk.cyan(config.severity)],
+      ['autofix', config.autofix ? chalk.green('true') : chalk.red('false')],
+      ['languages', chalk.white(config.languages.join(', '))],
+      ['exclude', chalk.gray(config.exclude.join('\n'))]
+    );
+
+    console.log(table.toString());
+    console.log('');
+
+    if (!configExists()) {
+      console.log(chalk.yellow('Note: Using default configuration (.codeslick.json not found)'));
+      console.log(chalk.gray('Run "codeslick init" to create a configuration file'));
+      console.log('');
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('Failed to load configuration');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Get a specific configuration value
+ */
+async function getConfigValue(key: string): Promise<void> {
+  try {
+    const config = await loadConfig();
+
+    if (!(key in config)) {
+      printError(`Unknown configuration key: ${key}`);
+      console.log('Available keys: version, severity, autofix, languages, exclude');
+      console.log('');
+      process.exit(1);
+    }
+
+    const value = config[key as keyof CodeSlickConfig];
+
+    console.log('');
+    if (Array.isArray(value)) {
+      console.log(chalk.cyan(key + ':'));
+      value.forEach((item) => console.log(`  - ${item}`));
+    } else {
+      console.log(chalk.cyan(key + ':'), chalk.white(String(value)));
+    }
+    console.log('');
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('Failed to get configuration value');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Set a configuration value
+ */
+async function setConfigValue(key: string, value: string): Promise<void> {
+  try {
+    // Check if config file exists
+    if (!configExists()) {
+      printError('.codeslick.json not found. Run "codeslick init" first.');
+      process.exit(1);
+    }
+
+    // Parse value based on key
+    let parsedValue: unknown;
+
+    switch (key) {
+      case 'severity':
+        parsedValue = value;
+        break;
+
+      case 'autofix':
+        if (value === 'true' || value === '1') {
+          parsedValue = true;
+        } else if (value === 'false' || value === '0') {
+          parsedValue = false;
+        } else {
+          printError(`Invalid value for autofix: ${value}. Must be true or false`);
+          process.exit(1);
+        }
+        break;
+
+      case 'languages':
+        parsedValue = value.split(',').map((lang) => lang.trim());
+        break;
+
+      case 'exclude':
+        parsedValue = value.split(',').map((pattern) => pattern.trim());
+        break;
+
+      case 'version':
+        printError('Cannot modify version field');
+        process.exit(1);
+        break;
+
+      default:
+        printError(`Unknown configuration key: ${key}`);
+        console.log('Available keys: severity, autofix, languages, exclude');
+        console.log('');
+        process.exit(1);
+    }
+
+    // Update configuration
+    await updateConfig(key as keyof CodeSlickConfig, parsedValue);
+
+    printSuccess(`Configuration updated: ${key} = ${value}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      printError(error.message);
+    } else {
+      printError('Failed to update configuration');
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * Config Command Handler
+ *
+ * This function routes to the appropriate action (get/set/list).
+ */
+export async function configCommand(args: ConfigArgs): Promise<void> {
+  const { action, key, value } = args;
+
+  switch (action) {
+    case 'list':
+      await listConfig();
+      break;
+
+    case 'get':
+      if (!key) {
+        printError('Missing configuration key');
+        console.log('Usage: codeslick config get <key>');
+        console.log('');
+        process.exit(1);
+      }
+      await getConfigValue(key);
+      break;
+
+    case 'set':
+      if (!key || !value) {
+        printError('Missing configuration key or value');
+        console.log('Usage: codeslick config set <key> <value>');
+        console.log('');
+        process.exit(1);
+      }
+      await setConfigValue(key, value);
+      break;
+
+    default:
+      printError(`Unknown action: ${action}`);
+      console.log('Available actions: get, set, list');
+      console.log('');
+      process.exit(1);
+  }
+}