orquesta-cli 0.1.2

package/src/setup/first-run-setup.ts

@@ -0,0 +1,337 @@
+/**
+ * First Run Setup
+ *
+ * Interactive setup flow for first-time users
+ * Handles Orquesta connection and initial configuration
+ */
+
+import chalk from 'chalk';
+import ora from 'ora';
+import { configManager } from '../core/config/config-manager.js';
+import { syncOrquestaConfigs, fetchOrquestaProjects } from '../orquesta/config-sync.js';
+
+interface FirstRunResult {
+  connected: boolean;
+  organizationName?: string;
+  projectName?: string;
+  configsSynced?: number;
+  skipped?: boolean;
+}
+
+interface OrquestaProject {
+  id: string;
+  name: string;
+  slug?: string;
+  description?: string;
+}
+
+/**
+ * Check if first-run setup is needed
+ * Returns true if no endpoints AND no Orquesta connection
+ */
+export function needsFirstRunSetup(): boolean {
+  return !configManager.hasEndpoints() && !configManager.hasOrquestaConnection();
+}
+
+/**
+ * Run the first-run setup flow
+ * This is a non-interactive version that requires a token to be passed
+ * For interactive setup, use the LLMSetupWizard component
+ */
+export async function runFirstRunSetup(token?: string): Promise<FirstRunResult> {
+  // If token provided via CLI flag, try to connect
+  if (token) {
+    return await connectWithToken(token);
+  }
+
+  // No token provided, return skipped
+  return { connected: false, skipped: true };
+}
+
+/**
+ * Connect to Orquesta with a token
+ * Org-scoped token - fetches projects and lets user select one
+ */
+export async function connectWithToken(token: string, projectId?: string): Promise<FirstRunResult> {
+  const spinner = ora({
+    text: chalk.cyan('Validating token...'),
+    color: 'cyan',
+  }).start();
+
+  try {
+    // Fetch projects (this also validates the token)
+    const projectsData = await fetchOrquestaProjects(token);
+
+    if (!projectsData) {
+      spinner.fail(chalk.red('Invalid token or failed to fetch projects'));
+      return { connected: false };
+    }
+
+    const { organization, projects } = projectsData;
+
+    if (projects.length === 0) {
+      spinner.fail(chalk.red('No projects found in organization'));
+      return { connected: false };
+    }
+
+    spinner.succeed(chalk.green(`Connected to organization: ${organization.name}`));
+
+    // Select project
+    let selectedProject: OrquestaProject;
+
+    if (projectId) {
+      // Project ID provided via flag
+      const found = projects.find((p) => p.id === projectId);
+      if (!found) {
+        console.log(chalk.red(`Project ID ${projectId} not found in organization`));
+        return { connected: false };
+      }
+      selectedProject = found;
+    } else if (projects.length === 1) {
+      // Only one project, auto-select
+      selectedProject = projects[0]!;
+      console.log(chalk.cyan(`  Auto-selected project: ${selectedProject.name}`));
+    } else {
+      // Multiple projects - show selection menu
+      console.log();
+      console.log(chalk.cyan('  Select a project to work with:'));
+      console.log();
+
+      projects.forEach((project, index) => {
+        console.log(chalk.white(`    ${index + 1}. ${project.name}`));
+        if (project.description) {
+          console.log(chalk.dim(`       ${project.description}`));
+        }
+      });
+
+      console.log();
+      console.log(chalk.dim(`  Enter project number (1-${projects.length}), or press Enter for ${projects[0]!.name}:`));
+
+      // Read from stdin
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise<string>((resolve) => {
+        rl.question(chalk.cyan('  > '), (ans) => {
+          rl.close();
+          resolve(ans.trim());
+        });
+      });
+
+      if (!answer) {
+        // Default to first project
+        selectedProject = projects[0]!;
+      } else {
+        const num = parseInt(answer, 10);
+        if (isNaN(num) || num < 1 || num > projects.length) {
+          console.log(chalk.red(`Invalid selection. Using ${projects[0]!.name}`));
+          selectedProject = projects[0]!;
+        } else {
+          selectedProject = projects[num - 1]!;
+        }
+      }
+    }
+
+    console.log(chalk.green(`  Selected project: ${selectedProject.name}`));
+
+    // Save Orquesta config
+    await configManager.setOrquestaConfig({
+      token,
+      organizationId: organization.id,
+      organizationName: organization.name,
+      projectId: selectedProject.id,
+      projectName: selectedProject.name,
+      autoSync: true,
+      connectedAt: new Date().toISOString(),
+    });
+
+    // Sync configurations from Orquesta
+    spinner.start(chalk.cyan('Syncing LLM configurations...'));
+
+    const syncResult = await syncOrquestaConfigs();
+
+    if (syncResult.success) {
+      const total = syncResult.added + syncResult.updated;
+      if (total > 0) {
+        spinner.succeed(
+          chalk.green(`Synced ${total} LLM configuration(s) (${syncResult.added} new, ${syncResult.updated} updated)`)
+        );
+      } else {
+        spinner.info(chalk.yellow('No LLM configurations found in dashboard. Use /config to add endpoints.'));
+      }
+    } else {
+      spinner.warn(chalk.yellow(`Sync warning: ${syncResult.error}`));
+    }
+
+    console.log();
+    console.log(chalk.cyan('  You are now connected to Orquesta!'));
+    console.log(chalk.dim(`  Organization: ${organization.name}`));
+    console.log(chalk.dim(`  Project: ${selectedProject.name}`));
+    console.log(chalk.dim(`  Your prompts and configs will sync with the dashboard.`));
+    console.log();
+    console.log(chalk.dim(`  Use --switch-project to change projects`));
+    console.log();
+
+    return {
+      connected: true,
+      organizationName: organization.name,
+      projectName: selectedProject.name,
+      configsSynced: syncResult.added + syncResult.updated,
+    };
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to connect to Orquesta'));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    return { connected: false };
+  }
+}
+
+/**
+ * Switch to a different project
+ */
+export async function switchProject(projectId?: string): Promise<boolean> {
+  const orquestaConfig = configManager.getOrquestaConfig();
+
+  if (!orquestaConfig?.token) {
+    console.log(chalk.yellow('Not connected to Orquesta.'));
+    return false;
+  }
+
+  const spinner = ora({
+    text: chalk.cyan('Fetching projects...'),
+    color: 'cyan',
+  }).start();
+
+  try {
+    const projectsData = await fetchOrquestaProjects(orquestaConfig.token);
+
+    if (!projectsData) {
+      spinner.fail(chalk.red('Failed to fetch projects'));
+      return false;
+    }
+
+    const { organization, projects } = projectsData;
+    spinner.stop();
+
+    if (projects.length === 0) {
+      console.log(chalk.red('No projects found in organization'));
+      return false;
+    }
+
+    // Select project
+    let selectedProject: OrquestaProject;
+
+    if (projectId) {
+      // Project ID provided via flag
+      const found = projects.find((p) => p.id === projectId);
+      if (!found) {
+        console.log(chalk.red(`Project ID ${projectId} not found in organization`));
+        return false;
+      }
+      selectedProject = found;
+    } else {
+      // Show selection menu
+      console.log();
+      console.log(chalk.cyan(`  Organization: ${organization.name}`));
+      console.log(chalk.cyan(`  Current project: ${orquestaConfig.projectName || 'None'}`));
+      console.log();
+      console.log(chalk.cyan('  Select a project:'));
+      console.log();
+
+      projects.forEach((project, index) => {
+        const current = project.id === orquestaConfig.projectId ? chalk.green(' (current)') : '';
+        console.log(chalk.white(`    ${index + 1}. ${project.name}${current}`));
+        if (project.description) {
+          console.log(chalk.dim(`       ${project.description}`));
+        }
+      });
+
+      console.log();
+
+      // Read from stdin
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise<string>((resolve) => {
+        rl.question(chalk.cyan(`  Enter project number (1-${projects.length}): `), (ans) => {
+          rl.close();
+          resolve(ans.trim());
+        });
+      });
+
+      const num = parseInt(answer, 10);
+      if (isNaN(num) || num < 1 || num > projects.length) {
+        console.log(chalk.red('Invalid selection'));
+        return false;
+      }
+
+      selectedProject = projects[num - 1]!;
+    }
+
+    // Update config
+    await configManager.setOrquestaConfig({
+      ...orquestaConfig,
+      projectId: selectedProject.id,
+      projectName: selectedProject.name,
+    });
+
+    console.log(chalk.green(`  Switched to project: ${selectedProject.name}`));
+    return true;
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to switch project'));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+    return false;
+  }
+}
+
+/**
+ * Disconnect from Orquesta
+ */
+export async function disconnectFromOrquesta(): Promise<void> {
+  const orquestaConfig = configManager.getOrquestaConfig();
+
+  if (!orquestaConfig?.token) {
+    console.log(chalk.yellow('Not connected to Orquesta.'));
+    return;
+  }
+
+  const spinner = ora({
+    text: chalk.cyan('Disconnecting from Orquesta...'),
+    color: 'cyan',
+  }).start();
+
+  try {
+    // Clear local Orquesta config
+    await configManager.clearOrquestaConnection();
+    spinner.succeed(chalk.green('Disconnected from Orquesta'));
+    console.log(chalk.dim('Local LLM configurations are preserved.'));
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to disconnect'));
+    console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+  }
+}
+
+/**
+ * Show Orquesta connection status
+ */
+export function showConnectionStatus(): void {
+  const orquestaConfig = configManager.getOrquestaConfig();
+
+  if (!orquestaConfig?.token) {
+    console.log(chalk.yellow('Not connected to Orquesta'));
+    console.log(chalk.dim('Run: orquesta --token <token> to connect'));
+    return;
+  }
+
+  console.log(chalk.green('Connected to Orquesta'));
+  console.log(chalk.dim(`  Organization: ${orquestaConfig.organizationName || 'Unknown'}`));
+  console.log(chalk.dim(`  Project: ${orquestaConfig.projectName || 'Unknown'}`));
+  console.log(chalk.dim(`  Connected: ${orquestaConfig.connectedAt ? new Date(orquestaConfig.connectedAt).toLocaleString() : 'Unknown'}`));
+  console.log(chalk.dim(`  Last sync: ${orquestaConfig.lastSyncAt ? new Date(orquestaConfig.lastSyncAt).toLocaleString() : 'Never'}`));
+  console.log(chalk.dim(`  Auto-sync: ${orquestaConfig.autoSync !== false ? 'Enabled' : 'Disabled'}`));
+}