@girardmedia/bootspring 2.0.21 → 2.0.23

package/src/cli/switch.ts

@@ -0,0 +1,518 @@
+/**
+ * Bootspring Switch Command
+ *
+ * Switch between project contexts.
+ *
+ * Commands:
+ *   (default)        Show current project and list available
+ *   <project>        Switch to a project by name or slug
+ *   recent           Show and switch to recent projects
+ *   init             Create .bootspring.json in current directory
+ *   clear            Clear current project context
+ *   status           Show detailed context status
+ *
+ * @package bootspring
+ * @module cli/switch
+ */
+
+import * as https from 'https';
+import * as http from 'http';
+import type { IncomingMessage, ClientRequest } from 'http';
+
+// Import JS modules with type interfaces
+interface AuthModule {
+  getApiKey(): string | null;
+  getToken(): string | null;
+  getDeviceId(): string;
+  isAuthenticated(): boolean;
+}
+
+interface Project {
+  id: string;
+  name: string;
+  slug?: string;
+  lastUsed?: string;
+  source?: string;
+}
+
+interface SessionState {
+  project: Project | null;
+  source: string;
+  hasLocalConfig: boolean;
+  localConfigPath?: string;
+  hasSession: boolean;
+  lastUpdated?: string;
+  recentProjects: Project[];
+}
+
+interface LocalConfig {
+  _path: string;
+  _dir: string;
+  projectId?: string;
+  projectName?: string;
+}
+
+interface SessionModule {
+  getEffectiveProject(): Project | null;
+  setCurrentProject(project: Project | null): void;
+  addRecentProject(project: Project): void;
+  getRecentProjects(): Project[];
+  getSessionState(): SessionState;
+  findLocalConfig(dir?: string): LocalConfig | null;
+  createLocalConfig(dir: string, project: Project): string;
+  SESSION_FILE: string;
+  LOCAL_CONFIG_NAME: string;
+}
+
+interface ParsedArgs {
+  _: string[];
+  init?: boolean;
+  help?: boolean;
+  h?: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const auth = require('../../core/auth') as AuthModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const session = require('../../core/session') as SessionModule;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const utils = require('../../core/utils') as typeof import('../core/utils');
+
+const API_BASE = process.env.BOOTSPRING_API_URL || 'https://www.bootspring.com';
+
+interface ApiResponse {
+  projects?: Project[];
+  error?: string;
+  message?: string;
+}
+
+/**
+ * Make a direct API request (without v1 prefix)
+ */
+async function directRequest(method: string, path: string): Promise<ApiResponse> {
+  const apiKey = auth.getApiKey();
+  const token = auth.getToken();
+  const deviceId = auth.getDeviceId();
+  const url = new URL(`/api${path}`, API_BASE);
+  const isHttps = url.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const pkg = require('../../package.json') as { version: string };
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'User-Agent': `bootspring-cli/${pkg.version}`,
+    'X-Device-Id': deviceId
+  };
+
+  if (apiKey) {
+    headers['X-API-Key'] = apiKey;
+  } else if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+
+  return new Promise((resolve, reject) => {
+    const req: ClientRequest = httpModule.request(url, {
+      method,
+      headers,
+      timeout: 30000
+    }, (res: IncomingMessage) => {
+      let body = '';
+      res.on('data', (chunk: Buffer | string) => body += chunk);
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body) as ApiResponse;
+          if (res.statusCode && res.statusCode >= 400) {
+            const error = new Error(json.error || json.message || 'API Error') as Error & { status?: number };
+            error.status = res.statusCode;
+            reject(error);
+          } else {
+            resolve(json);
+          }
+        } catch {
+          if (res.statusCode && res.statusCode >= 400) {
+            reject(new Error(`API Error: ${res.statusCode}`));
+          } else {
+            resolve({} as ApiResponse);
+          }
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+    req.end();
+  });
+}
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m'
+};
+
+/**
+ * Run switch command
+ */
+export async function run(args: string[]): Promise<void> {
+  const parsedArgs = utils.parseArgs(args) as ParsedArgs;
+  const subcommand = parsedArgs._[0];
+
+  // Handle --init flag anywhere
+  if (parsedArgs.init) {
+    if (!auth.isAuthenticated()) {
+      console.log(`${colors.yellow}Not logged in${colors.reset}`);
+      console.log(`${colors.dim}Run 'bootspring auth login' first${colors.reset}`);
+      return;
+    }
+    await initLocalConfig();
+    return;
+  }
+
+  // Handle --help flag
+  if (parsedArgs.help || parsedArgs.h || subcommand === 'help') {
+    showHelp();
+    return;
+  }
+
+  // Handle subcommands that don't require auth (local data only)
+  if (subcommand === 'status') {
+    showStatus();
+    return;
+  }
+
+  if (subcommand === 'clear') {
+    clearContext();
+    return;
+  }
+
+  if (subcommand === 'recent') {
+    showRecent();
+    return;
+  }
+
+  // Commands that require authentication
+  if (!auth.isAuthenticated()) {
+    console.log(`${colors.yellow}Not logged in${colors.reset}`);
+    console.log(`${colors.dim}Run 'bootspring auth login' first${colors.reset}`);
+    return;
+  }
+
+  if (subcommand === 'init') {
+    await initLocalConfig();
+    return;
+  }
+
+  // If no subcommand or unknown, treat as project identifier or show projects
+  if (!subcommand) {
+    await showProjects();
+    return;
+  }
+
+  // Switch to specified project
+  await switchTo(subcommand);
+}
+
+/**
+ * Show current project and list available projects
+ */
+async function showProjects(): Promise<void> {
+  console.log(`\n${colors.bold}Project Context${colors.reset}\n`);
+
+  // Show current project
+  const current = session.getEffectiveProject();
+  if (current) {
+    console.log(`${colors.cyan}Current:${colors.reset} ${colors.bold}${current.name}${colors.reset}`);
+    if (current.slug) {
+      console.log(`${colors.dim}         ${current.slug}${colors.reset}`);
+    }
+    const sourceLabel = current.source === 'local' ? '(from .bootspring.json)' : '(from session)';
+    console.log(`${colors.dim}         ${sourceLabel}${colors.reset}`);
+    console.log();
+  } else {
+    console.log(`${colors.yellow}No project selected${colors.reset}\n`);
+  }
+
+  // Fetch available projects
+  console.log(`${colors.dim}Fetching projects...${colors.reset}`);
+
+  try {
+    const response = await directRequest('GET', '/projects');
+    const projects = response.projects || [];
+
+    if (projects.length === 0) {
+      console.log(`\n${colors.yellow}No projects found${colors.reset}`);
+      console.log(`${colors.dim}Create a project at https://bootspring.com/dashboard/projects${colors.reset}`);
+      return;
+    }
+
+    console.log(`\n${colors.bold}Available Projects${colors.reset}\n`);
+    for (const project of projects) {
+      const isCurrent = current?.id === project.id;
+      const marker = isCurrent ? colors.green + '* ' + colors.reset : '  ';
+      console.log(`${marker}${colors.bold}${project.name}${colors.reset} ${colors.dim}(${project.slug})${colors.reset}`);
+    }
+
+    console.log(`\n${colors.dim}Usage: bootspring switch <project-name-or-slug>${colors.reset}`);
+  } catch (error) {
+    console.log(`\n${colors.red}Failed to fetch projects: ${(error as Error).message}${colors.reset}`);
+  }
+}
+
+/**
+ * Switch to a specific project
+ */
+async function switchTo(identifier: string): Promise<void> {
+  console.log(`${colors.dim}Switching to project...${colors.reset}`);
+
+  try {
+    const response = await directRequest('GET', '/projects');
+    const projects = response.projects || [];
+
+    // Find project by name or slug
+    const project = projects.find(
+      p => p.name.toLowerCase() === identifier.toLowerCase() ||
+           p.slug === identifier.toLowerCase()
+    );
+
+    if (!project) {
+      console.log(`\n${colors.red}Project not found: ${identifier}${colors.reset}`);
+      console.log(`${colors.dim}Run 'bootspring switch' to see available projects${colors.reset}`);
+      return;
+    }
+
+    // Update session
+    session.setCurrentProject(project);
+    session.addRecentProject(project);
+
+    console.log(`\n${colors.green}Switched to: ${project.name}${colors.reset}`);
+
+    // Automatically create/update local config to lock this directory to the project
+    const existingConfig = session.findLocalConfig();
+    if (existingConfig && existingConfig._dir === process.cwd()) {
+      // Update existing config in same directory
+      try {
+        session.createLocalConfig(process.cwd(), project);
+        console.log(`${colors.dim}Updated: ${existingConfig._path}${colors.reset}`);
+      } catch {
+        // Ignore errors
+      }
+    } else if (!existingConfig) {
+      // Create new local config to lock this directory
+      try {
+        const configPath = session.createLocalConfig(process.cwd(), project);
+        console.log(`${colors.dim}Locked directory to "${project.name}"${colors.reset}`);
+        console.log(`${colors.dim}Config: ${configPath}${colors.reset}`);
+      } catch {
+        // Ignore errors - some directories may not be writable
+      }
+    } else {
+      // Config exists in parent directory
+      console.log(`${colors.dim}Note: Parent directory locked to "${existingConfig.projectName}"${colors.reset}`);
+      console.log(`${colors.dim}Run 'bootspring switch --init' here to override${colors.reset}`);
+    }
+  } catch (error) {
+    console.log(`\n${colors.red}Failed to switch project: ${(error as Error).message}${colors.reset}`);
+  }
+}
+
+/**
+ * Show recent projects and allow quick switching
+ */
+function showRecent(): void {
+  const recent = session.getRecentProjects();
+
+  console.log(`\n${colors.bold}Recent Projects${colors.reset}\n`);
+
+  if (recent.length === 0) {
+    console.log(`${colors.dim}No recent projects${colors.reset}`);
+    console.log(`${colors.dim}Use 'bootspring switch <project>' to switch to a project${colors.reset}`);
+    return;
+  }
+
+  const current = session.getEffectiveProject();
+
+  for (let i = 0; i < recent.length; i++) {
+    const project = recent[i];
+    if (!project) continue;
+    const isCurrent = current?.id === project.id;
+    const marker = isCurrent ? colors.green + '* ' + colors.reset : '  ';
+    const index = colors.dim + `[${i + 1}]` + colors.reset;
+    const lastUsed = project.lastUsed ? formatRelativeTime(project.lastUsed) : '';
+
+    console.log(`${marker}${index} ${colors.bold}${project.name}${colors.reset} ${colors.dim}(${project.slug})${colors.reset}`);
+    if (lastUsed) {
+      console.log(`       ${colors.dim}${lastUsed}${colors.reset}`);
+    }
+  }
+
+  console.log(`\n${colors.dim}Usage: bootspring switch <name-or-number>${colors.reset}`);
+}
+
+/**
+ * Initialize local .bootspring.json config
+ */
+async function initLocalConfig(): Promise<void> {
+  const current = session.getEffectiveProject();
+
+  if (!current) {
+    console.log(`${colors.yellow}No project selected${colors.reset}`);
+    console.log(`${colors.dim}First switch to a project: bootspring switch <project>${colors.reset}`);
+    return;
+  }
+
+  // Check if local config already exists
+  const existingConfig = session.findLocalConfig(process.cwd());
+  if (existingConfig && existingConfig._dir === process.cwd()) {
+    console.log(`${colors.yellow}Local config already exists${colors.reset}`);
+    console.log(`${colors.dim}Path: ${existingConfig._path}${colors.reset}`);
+    console.log(`${colors.dim}Project: ${existingConfig.projectName || existingConfig.projectId}${colors.reset}`);
+    return;
+  }
+
+  // Create local config
+  try {
+    const configPath = session.createLocalConfig(process.cwd(), current);
+    console.log(`\n${colors.green}Created local config${colors.reset}`);
+    console.log(`${colors.dim}Path: ${configPath}${colors.reset}`);
+    console.log(`${colors.dim}Project: ${current.name}${colors.reset}`);
+    console.log(`\n${colors.dim}This directory is now linked to project "${current.name}"${colors.reset}`);
+  } catch (error) {
+    console.log(`${colors.red}Failed to create config: ${(error as Error).message}${colors.reset}`);
+  }
+}
+
+/**
+ * Show detailed context status
+ */
+function showStatus(): void {
+  const state = session.getSessionState();
+
+  console.log(`\n${colors.bold}${colors.cyan}⚡ Project Context Status${colors.reset}\n`);
+
+  // Current project
+  console.log(`${colors.bold}Current Project${colors.reset}`);
+  if (state.project) {
+    console.log(`  Name: ${colors.bold}${state.project.name}${colors.reset}`);
+    if (state.project.slug) {
+      console.log(`  Slug: ${state.project.slug}`);
+    }
+    console.log(`  ID: ${colors.dim}${state.project.id}${colors.reset}`);
+    console.log(`  Source: ${state.source === 'local' ? colors.green + 'local config' : colors.cyan + 'session'}${colors.reset}`);
+  } else {
+    console.log(`  ${colors.yellow}None selected${colors.reset}`);
+  }
+  console.log();
+
+  // Local config
+  console.log(`${colors.bold}Local Config${colors.reset}`);
+  if (state.hasLocalConfig) {
+    console.log(`  ${colors.green}●${colors.reset} Found: ${state.localConfigPath}`);
+  } else {
+    console.log(`  ${colors.dim}○ Not found in current directory or ancestors${colors.reset}`);
+    console.log(`    ${colors.dim}Run 'bootspring switch --init' to create one${colors.reset}`);
+  }
+  console.log();
+
+  // Session
+  console.log(`${colors.bold}Session${colors.reset}`);
+  console.log(`  Status: ${state.hasSession ? colors.green + 'active' : colors.dim + 'inactive'}${colors.reset}`);
+  if (state.lastUpdated) {
+    console.log(`  Last updated: ${formatRelativeTime(state.lastUpdated)}`);
+  }
+  console.log(`  Recent projects: ${state.recentProjects.length}`);
+  console.log();
+
+  // Paths
+  console.log(`${colors.bold}Paths${colors.reset}`);
+  console.log(`  Session file: ${colors.dim}${session.SESSION_FILE}${colors.reset}`);
+  console.log(`  Config name: ${colors.dim}${session.LOCAL_CONFIG_NAME}${colors.reset}`);
+}
+
+/**
+ * Clear current project context
+ */
+function clearContext(): void {
+  const current = session.getEffectiveProject();
+
+  if (!current) {
+    console.log(`${colors.dim}No project context to clear${colors.reset}`);
+    return;
+  }
+
+  // Clear session project
+  session.setCurrentProject(null);
+
+  console.log(`\n${colors.green}Cleared project context${colors.reset}`);
+  console.log(`${colors.dim}Previous project: ${current.name}${colors.reset}`);
+
+  // Check for local config
+  const localConfig = session.findLocalConfig();
+  if (localConfig) {
+    console.log(`\n${colors.yellow}Note:${colors.reset} Local config still exists at:`);
+    console.log(`  ${localConfig._path}`);
+    console.log(`${colors.dim}Delete it manually if needed${colors.reset}`);
+  }
+}
+
+/**
+ * Show help
+ */
+function showHelp(): void {
+  console.log(`
+${colors.cyan}${colors.bold}⚡ Bootspring Switch${colors.reset}
+${colors.dim}Switch between project contexts${colors.reset}
+
+${colors.bold}Usage:${colors.reset}
+  bootspring switch                     Show current and available projects
+  bootspring switch <project>           Switch to a project by name or slug
+  bootspring switch recent              Show recent projects
+  bootspring switch init                Create .bootspring.json in current directory
+  bootspring switch --init              Same as above
+  bootspring switch clear               Clear current project context
+  bootspring switch status              Show detailed context status
+
+${colors.bold}Options:${colors.reset}
+  --init              Create local .bootspring.json config
+  --help, -h          Show this help
+
+${colors.bold}Examples:${colors.reset}
+  bootspring switch my-project          Switch to "my-project"
+  bootspring switch                     List all available projects
+  bootspring switch recent              Show recently used projects
+  bootspring switch --init              Link current directory to active project
+
+${colors.bold}Context Priority:${colors.reset}
+  1. Local .bootspring.json (in current directory or ancestors)
+  2. Session project (from 'bootspring switch <project>')
+`);
+}
+
+/**
+ * Format relative time
+ */
+function formatRelativeTime(isoDate: string): string {
+  const date = new Date(isoDate);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1000);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffSecs < 60) return 'just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+
+  return date.toLocaleDateString();
+}