@nboard-dev/octus 0.3.0

package/src/commands/setup.js

@@ -0,0 +1,439 @@
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { randomUUID } from 'crypto';
+import { execa } from 'execa';
+import chalk from 'chalk';
+import YAML from 'yaml';
+import inquirer from 'inquirer';
+import { config, runLock, runState } from '../lib/config.js';
+import { api } from '../lib/api.js';
+import ui from '../lib/ui.js';
+import {
+  buildEnvironmentSnapshot,
+  buildLogEntries,
+  buildRunContext,
+  buildRunPayload,
+  computeProfileHash,
+  normalizeInitFilePayload,
+  normalizeProfile,
+  scanRepository,
+} from '../lib/octus-contract.js';
+
+export const setupCommand = new Command('setup')
+  .description('Execute onboarding setup run')
+  .argument('[path]', 'Repository path', '.')
+  .option('--profile <key>', 'Profile key (auto|demo-node|demo-python|...)', 'auto')
+  .option('--ignore-repo-profile', 'Ignore repo-local .octus/profile.yaml')
+  .option('--timeout <seconds>', 'Per-step timeout in seconds', '300')
+  .option('--force-lock', 'Break stale run lock')
+  .option('--resume', 'Resume last local run')
+  .option('--force-resume', 'Allow resume from different repo path')
+  .option('--step-delay-ms <ms>', 'Delay before each step (testing)', '0')
+  .option('--turbo', 'Skip confirmations and run fast')
+  .option('--verbose', 'Show detailed output')
+  .action(async (pathArg, options) => {
+    await runSetup(pathArg, options);
+  });
+
+function normalizeRunSteps(steps = []) {
+  return [...steps].sort((a, b) => {
+    const aIndex = a.step_index ?? a.stepIndex ?? 0;
+    const bIndex = b.step_index ?? b.stepIndex ?? 0;
+    return aIndex - bIndex;
+  });
+}
+
+async function ensureLoggedIn(turbo) {
+  if (config.isLoggedIn()) return;
+  if (turbo) {
+    ui.error('Not logged in. Run `octus login` first.');
+    process.exit(1);
+  }
+
+  ui.warning('Not logged in');
+  const { doLogin } = await inquirer.prompt([
+    { type: 'confirm', name: 'doLogin', message: 'Login now?', default: true },
+  ]);
+
+  if (!doLogin) {
+    process.exit(1);
+  }
+
+  const { loginCommand } = await import('./login.js');
+  await loginCommand.parseAsync(['login'], { from: 'user' });
+}
+
+export async function runSetup(pathArg, options = {}) {
+  const repoPath = resolve(pathArg || '.');
+  const timeoutMs = parseInt(options.timeout || '300', 10) * 1000;
+  const stepDelayMs = parseInt(options.stepDelayMs || '0', 10);
+  const turbo = Boolean(options.turbo);
+  const verbose = Boolean(options.verbose);
+
+  await ensureLoggedIn(turbo);
+
+  const octusYamlPath = join(repoPath, '.octus.yaml');
+  if (!existsSync(octusYamlPath)) {
+    ui.error('.octus.yaml not found. Run `octus init` first.');
+    process.exit(1);
+  }
+
+  const lockResult = runLock.acquire(options.forceLock);
+  if (!lockResult.success) {
+    ui.error(`Another setup is running (PID: ${lockResult.lock.pid})`);
+    ui.info('Use --force-lock to override if the other process is dead');
+    process.exit(1);
+  }
+
+  const cleanup = () => runLock.release();
+  process.on('SIGINT', () => { cleanup(); process.exit(130); });
+  process.on('SIGTERM', () => { cleanup(); process.exit(143); });
+
+  try {
+    ui.header('Octus Setup');
+    ui.info(`Repository: ${repoPath}`);
+
+    let initPayload;
+    try {
+      initPayload = normalizeInitFilePayload(
+        YAML.parse(readFileSync(octusYamlPath, 'utf-8'))
+      );
+    } catch (error) {
+      ui.error(error.message);
+      process.exit(1);
+    }
+
+    const verifySpin = ui.spinner('Verifying init file...').start();
+    let verification;
+    try {
+      verification = await api.verifyInitFile(initPayload);
+      verifySpin.succeed('Init file verified');
+    } catch (error) {
+      verifySpin.fail(`Verification failed: ${error.message}`);
+      ui.info('Run `octus init` to regenerate');
+      process.exit(1);
+    }
+
+    const scanResult = scanRepository(repoPath);
+    const registerSpin = ui.spinner('Registering repository...').start();
+    let repoResponse;
+    let currentUser;
+    try {
+      repoResponse = await api.registerRepository({
+        name: scanResult.name,
+        local_path: repoPath,
+        git_url: null,
+        default_branch: 'main',
+        project_type: scanResult.project_type,
+        metadata: scanResult.metadata,
+        has_readme: scanResult.has_readme,
+        has_dockerfile: scanResult.has_dockerfile,
+        has_docker_compose: scanResult.has_docker_compose,
+      });
+      currentUser = await api.getMe();
+      registerSpin.succeed('Repository registered');
+    } catch (error) {
+      registerSpin.fail(`Failed to register repository: ${error.message}`);
+      process.exit(1);
+    }
+
+    if (String(repoResponse.organization_id) !== initPayload.org_id) {
+      ui.error('Invalid .octus.yaml — organization mismatch. Run `octus init` again.');
+      process.exit(1);
+    }
+
+    if (String(repoResponse.id) !== initPayload.repo_id) {
+      ui.error('Invalid .octus.yaml — repository mismatch. Run `octus init` again.');
+      process.exit(1);
+    }
+
+    const localProfilePath = join(repoPath, '.octus', 'profile.json');
+    let profile;
+    let selectedProfileKey = null;
+
+    if (!options.ignoreRepoProfile && existsSync(localProfilePath)) {
+      profile = normalizeProfile(
+        JSON.parse(readFileSync(localProfilePath, 'utf-8')),
+        scanResult.name
+      );
+      ui.info(`Using local profile: ${profile.name}`);
+    } else {
+      const backendProfileKey = options.profile && options.profile !== 'auto'
+        ? options.profile
+        : verification?.profile_key || initPayload.profile_ref;
+      const profileSpin = ui.spinner('Fetching profile from backend...').start();
+      try {
+        profile = normalizeProfile(
+          await api.getProfile(backendProfileKey),
+          backendProfileKey
+        );
+        selectedProfileKey = profile.key || backendProfileKey;
+        profileSpin.succeed(`Using profile: ${profile.name}`);
+      } catch (error) {
+        profileSpin.fail(`Failed to fetch profile: ${error.message}`);
+        process.exit(1);
+      }
+    }
+
+    if (!Array.isArray(profile.steps) || profile.steps.length === 0) {
+      ui.warning('No steps in profile');
+      return;
+    }
+
+    const profileHash = computeProfileHash(profile.name, profile.steps);
+
+    let runResponse;
+    const existingState = runState.get();
+    let localState = {
+      run_id: null,
+      profile_hash: profileHash,
+      repo_path: repoPath,
+      steps: {},
+    };
+
+    if (options.resume && existingState.run_id) {
+      if (existingState.repo_path && existingState.repo_path !== repoPath && !options.forceResume) {
+        ui.error('Saved run is for a different repo path');
+        ui.info(`Saved: ${existingState.repo_path}`);
+        ui.info(`Current: ${repoPath}`);
+        ui.info('Use --force-resume to override');
+        process.exit(1);
+      }
+      const runSpin = ui.spinner(`Loading run ${existingState.run_id.slice(0, 8)}...`).start();
+      try {
+        runResponse = await api.getRun(existingState.run_id);
+        localState = {
+          ...existingState,
+          profile_hash: existingState.profile_hash || profileHash,
+          repo_path: repoPath,
+          steps: existingState.steps || {},
+        };
+        runSpin.succeed('Resume state loaded');
+      } catch (error) {
+        runSpin.fail(`Failed to load saved run: ${error.message}`);
+        process.exit(1);
+      }
+    } else {
+      const runSpin = ui.spinner('Creating onboarding run...').start();
+      try {
+        runResponse = await api.createRun(
+          buildRunPayload({
+            repoResponse,
+            currentUser,
+            scanResult,
+            selectedProfile: profile.name,
+            selectedProfileKey,
+            selectedProfileVersion: profile.version,
+            profileHash,
+            stepDefs: profile.steps,
+            runContext: buildRunContext({
+              scanResult,
+              repoPath,
+              profileName: profile.name,
+              profileVersion: profile.version,
+              resume: false,
+              gitRemoteUrl: null,
+            }),
+            environmentSnapshot: buildEnvironmentSnapshot({
+              scanResult,
+              profileName: profile.name,
+              profileVersion: profile.version,
+              captureSource: 'cli_setup_start',
+            }),
+          })
+        );
+        runSpin.succeed(`Run created: ${runResponse.id.slice(0, 8)}...`);
+        localState.run_id = runResponse.id;
+      } catch (error) {
+        runSpin.fail(`Failed to create run: ${error.message}`);
+        process.exit(1);
+      }
+    }
+
+    runState.set(localState);
+
+    ui.divider();
+    ui.header('Running Onboarding Steps');
+
+    const runSteps = normalizeRunSteps(runResponse?.steps || []);
+    let allPassed = true;
+    let failedStep = null;
+
+    for (let index = 0; index < runSteps.length; index += 1) {
+      const backendStep = runSteps[index];
+      const localStep = profile.steps[index] || backendStep;
+      const stepId = backendStep.id;
+      const stepTitle = localStep.title || backendStep.label || backendStep.title || localStep.step_key;
+      const existingStateForStep = localState.steps[stepId];
+      const knownStatus = existingStateForStep?.status || backendStep.status;
+
+      if (knownStatus === 'success' || knownStatus === 'skipped') {
+        ui.step(index + 1, runSteps.length, stepTitle, 'success');
+        console.log(chalk.dim('     (already completed)'));
+        continue;
+      }
+
+      if (stepDelayMs > 0) {
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, stepDelayMs));
+      }
+
+      ui.step(index + 1, runSteps.length, stepTitle, 'running');
+
+      let exitCode = 0;
+      let stdout = '';
+      let stderr = '';
+      const startedAt = new Date().toISOString();
+      const startedMs = Date.now();
+
+      try {
+        if (backendStep.status !== 'running') {
+          await api.startStep(stepId, {
+            event_id: randomUUID(),
+            sequence: 1,
+            started_at: startedAt,
+          });
+        }
+
+        if (localStep.command) {
+          if (verbose) {
+            console.log(chalk.dim(`     $ ${localStep.command}`));
+          }
+
+          const result = await execa(localStep.command, {
+            cwd: repoPath,
+            timeout: timeoutMs,
+            shell: true,
+            env: { ...process.env, FORCE_COLOR: '1' },
+            reject: false,
+          });
+
+          exitCode = result.exitCode;
+          stdout = result.stdout || '';
+          stderr = result.stderr || '';
+
+          if (verbose && stdout) {
+            stdout.split('\n').slice(0, 10).forEach((line) => {
+              if (line.trim()) console.log(chalk.dim(`     ${line}`));
+            });
+          }
+        }
+
+        const durationMs = Date.now() - startedMs;
+        localState.steps[stepId] = {
+          status: exitCode === 0 ? 'success' : 'failed',
+          metadata: {
+            step_key: localStep.step_key,
+            command: localStep.command,
+            step_index: index,
+            exit_code: exitCode,
+            duration_ms: durationMs,
+          },
+        };
+        runState.set(localState);
+
+        await api.finishStep(stepId, {
+          event_id: randomUUID(),
+          sequence: 2,
+          status: exitCode === 0 ? 'success' : 'failed',
+          exit_code: exitCode,
+          duration_ms: durationMs,
+          stdout_tail: stdout.slice(-2000),
+          stderr_tail: stderr.slice(-2000),
+          finished_at: new Date().toISOString(),
+        });
+
+        if (stdout || stderr) {
+          const { entries } = buildLogEntries(stdout, stderr, 1);
+          if (entries.length > 0) {
+            await api.appendStepLogsBatch(stepId, { entries }).catch(() => {});
+          }
+        }
+
+        process.stdout.write('\x1B[1A\x1B[2K');
+        if (exitCode === 0) {
+          ui.step(index + 1, runSteps.length, stepTitle, 'success');
+          console.log(chalk.dim(`     (${durationMs}ms)`));
+        } else {
+          ui.step(index + 1, runSteps.length, stepTitle, 'failed');
+          console.log(chalk.red(`     Exit code: ${exitCode}`));
+          if (stderr) {
+            stderr.split('\n').slice(0, 3).forEach((line) => {
+              if (line.trim()) console.log(chalk.red(`     ${line}`));
+            });
+          }
+          allPassed = false;
+          failedStep = localStep;
+          break;
+        }
+      } catch (error) {
+        process.stdout.write('\x1B[1A\x1B[2K');
+        ui.step(index + 1, runSteps.length, stepTitle, 'failed');
+        console.log(chalk.red(`     Error: ${error.message}`));
+
+        localState.steps[stepId] = {
+          status: 'failed',
+          metadata: {
+            step_key: localStep.step_key,
+            command: localStep.command,
+            step_index: index,
+            error: error.message,
+          },
+        };
+        runState.set(localState);
+
+        allPassed = false;
+        failedStep = localStep;
+        break;
+      }
+    }
+
+    ui.divider();
+
+    if (allPassed) {
+      runState.clear();
+      ui.successPanel('Setup Complete', `
+All ${runSteps.length} steps completed successfully!
+
+${chalk.bold('Next steps:')}
+  • Start coding
+  • Check ${chalk.cyan('octus doctor')} for environment status
+  • View your dashboard at ${chalk.cyan('https://demo.nboard.tech')}
+`);
+      return;
+    }
+
+    ui.failurePanel('Setup Failed', `
+Step "${failedStep?.title || failedStep?.step_key || 'unknown'}" failed.
+
+${chalk.bold('To retry:')}
+  ${chalk.cyan('octus setup --resume')}
+
+${chalk.bold('To debug:')}
+  ${chalk.cyan('octus doctor')}
+  
+${chalk.bold('To start fresh:')}
+  ${chalk.cyan('octus setup --force-lock')}
+`);
+
+    try {
+      const patterns = await api.getBlockerPatterns({
+        step_key: failedStep?.step_key,
+      });
+      if (Array.isArray(patterns) && patterns.length > 0) {
+        ui.info('Similar issues resolved before:');
+        patterns.slice(0, 3).forEach((pattern) => {
+          console.log(chalk.dim(`  • ${pattern.resolution_summary || pattern.reason}`));
+        });
+      }
+    } catch {
+      // ignore blocker hint failures
+    }
+
+    process.exit(1);
+  } finally {
+    cleanup();
+  }
+}
+
+export default setupCommand;

package/src/index.js

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { version } from './lib/version.js';
+
+// Import commands
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { pingCommand } from './commands/ping.js';
+import { configCommand } from './commands/config.js';
+import { doctorCommand } from './commands/doctor.js';
+import { initCommand } from './commands/init.js';
+import { setupCommand } from './commands/setup.js';
+import { generateProfileCommand } from './commands/generate-profile.js';
+
+export const program = new Command();
+
+// ASCII art banner
+const banner = chalk.cyan(`
+   ____       __            
+  / __ \\____/ /___  _______
+ / / / / __/ __/ / / / ___/
+/ /_/ / /_/ /_/ /_/ (__  ) 
+\\____/\\__/\\__/\\__,_/____/  
+`);
+
+program
+  .name('octus')
+  .description(`${banner}\n  ${chalk.dim('AI-powered onboarding for engineering teams')}`)
+  .version(version, '-V, --version', 'Show version')
+  .addHelpText('after', `
+${chalk.bold('Examples:')}
+  ${chalk.dim('# First time setup')}
+  $ octus login
+  $ octus init .
+  $ octus setup
+
+  ${chalk.dim('# Check everything is working')}
+  $ octus doctor
+
+  ${chalk.dim('# Quick start (login + init + setup)')}
+  $ octus setup --turbo
+
+${chalk.bold('Documentation:')}
+  https://docs.nboard.tech/cli
+`);
+
+// Register all commands
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(pingCommand);
+program.addCommand(configCommand);
+program.addCommand(doctorCommand);
+program.addCommand(initCommand);
+program.addCommand(setupCommand);
+program.addCommand(generateProfileCommand);
+
+// Default action when no command provided
+program.action(() => {
+  program.outputHelp();
+});
+
+export default program;