hackerrun 0.1.0

package/src/commands/builds.ts

@@ -0,0 +1,314 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { getAppName } from '../lib/app-config.js';
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Format duration in human-readable form
+ */
+function formatDuration(startedAt: string | null, completedAt: string | null): string {
+  if (!startedAt) return '-';
+
+  const start = new Date(startedAt);
+  const end = completedAt ? new Date(completedAt) : new Date();
+  const durationMs = end.getTime() - start.getTime();
+
+  const seconds = Math.floor(durationMs / 1000);
+  if (seconds < 60) return `${seconds}s`;
+
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+
+/**
+ * Format relative time (e.g., "2 minutes ago")
+ */
+function formatRelativeTime(dateStr: string): string {
+  const date = new Date(dateStr);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSeconds = Math.floor(diffMs / 1000);
+
+  if (diffSeconds < 60) return 'just now';
+  if (diffSeconds < 3600) return `${Math.floor(diffSeconds / 60)} minutes ago`;
+  if (diffSeconds < 86400) return `${Math.floor(diffSeconds / 3600)} hours ago`;
+  return `${Math.floor(diffSeconds / 86400)} days ago`;
+}
+
+/**
+ * Get status emoji
+ */
+function getStatusIcon(status: string): string {
+  switch (status) {
+    case 'success': return chalk.green('✓');
+    case 'failed': return chalk.red('✗');
+    case 'building': return chalk.yellow('●');
+    case 'pending': return chalk.dim('○');
+    default: return chalk.dim('?');
+  }
+}
+
+/**
+ * Get stage emoji for live output
+ */
+function getStageIcon(stage: string, status: string): string {
+  if (status === 'completed') return chalk.green('✓');
+  if (status === 'failed') return chalk.red('✗');
+  if (status === 'started') return chalk.yellow('●');
+  return chalk.dim('○');
+}
+
+/**
+ * Format timestamp for live output
+ */
+function formatEventTime(startTime: Date, eventTime: Date): string {
+  const diffMs = eventTime.getTime() - startTime.getTime();
+  const totalSeconds = Math.floor(diffMs / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+}
+
+export function createBuildsCommand() {
+  const cmd = new Command('builds');
+  cmd
+    .description('View and monitor builds')
+    .argument('[buildId]', 'Build ID to view details')
+    .option('--app <app>', 'App name (uses hackerrun.yaml or folder name if not specified)')
+    .option('--watch', 'Watch for new builds')
+    .option('--latest', 'Stream the latest/current build in real-time')
+    .option('-n, --limit <number>', 'Number of builds to show', '10')
+    .action(async (buildId, options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        if (buildId) {
+          // Show specific build details
+          await showBuildDetails(platformClient, appName, parseInt(buildId, 10));
+        } else if (options.latest) {
+          // Stream latest build
+          await streamLatestBuild(platformClient, appName);
+        } else if (options.watch) {
+          // Watch for new builds
+          await watchBuilds(platformClient, appName);
+        } else {
+          // List builds
+          await listBuilds(platformClient, appName, parseInt(options.limit, 10));
+        }
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}
+
+/**
+ * List recent builds
+ */
+async function listBuilds(platformClient: PlatformClient, appName: string, limit: number) {
+  const spinner = ora('Fetching builds...').start();
+  const builds = await platformClient.listBuilds(appName, limit);
+  spinner.stop();
+
+  if (builds.length === 0) {
+    console.log(chalk.yellow(`\nNo builds found for '${appName}'.\n`));
+    console.log(chalk.cyan('Connect a GitHub repo to enable auto-deploy:\n'));
+    console.log(`  hackerrun connect\n`);
+    return;
+  }
+
+  console.log(chalk.cyan(`\nBuilds for '${appName}':\n`));
+
+  for (const build of builds) {
+    const icon = getStatusIcon(build.status);
+    const sha = build.commitSha.substring(0, 7);
+    const msg = build.commitMsg
+      ? (build.commitMsg.length > 50 ? build.commitMsg.substring(0, 47) + '...' : build.commitMsg)
+      : chalk.dim('No message');
+    const duration = formatDuration(build.startedAt, build.completedAt);
+    const time = formatRelativeTime(build.createdAt);
+
+    console.log(`  ${icon} ${chalk.bold(`#${build.id}`)} ${chalk.dim(sha)} ${msg}`);
+    console.log(`    ${chalk.dim(`${build.branch} • ${duration} • ${time}`)}`);
+    console.log();
+  }
+}
+
+/**
+ * Show details for a specific build
+ */
+async function showBuildDetails(platformClient: PlatformClient, appName: string, buildId: number) {
+  const spinner = ora('Fetching build details...').start();
+  const build = await platformClient.getBuild(appName, buildId);
+  const events = await platformClient.getBuildEvents(appName, buildId);
+  spinner.stop();
+
+  const icon = getStatusIcon(build.status);
+  const sha = build.commitSha.substring(0, 7);
+
+  console.log(chalk.cyan(`\nBuild #${build.id}\n`));
+  console.log(`  Status: ${icon} ${build.status}`);
+  console.log(`  Commit: ${chalk.dim(sha)} ${build.commitMsg || chalk.dim('No message')}`);
+  console.log(`  Branch: ${build.branch}`);
+  console.log(`  Duration: ${formatDuration(build.startedAt, build.completedAt)}`);
+  console.log(`  Created: ${formatRelativeTime(build.createdAt)}`);
+
+  if (events.length > 0) {
+    console.log(chalk.cyan('\nBuild Events:\n'));
+    const startTime = new Date(events[0].timestamp);
+
+    for (const event of events) {
+      const eventTime = new Date(event.timestamp);
+      const timeStr = formatEventTime(startTime, eventTime);
+      const icon = getStageIcon(event.stage, event.status);
+      console.log(`  [${timeStr}] ${icon} ${event.message || event.stage}`);
+    }
+  }
+
+  if (build.logs) {
+    console.log(chalk.cyan('\nBuild Logs:\n'));
+    console.log(chalk.dim(build.logs));
+  }
+
+  console.log();
+}
+
+/**
+ * Stream the latest build in real-time
+ */
+async function streamLatestBuild(platformClient: PlatformClient, appName: string) {
+  console.log(chalk.cyan(`\nWatching latest build for '${appName}'...\n`));
+  console.log(chalk.dim('Press Ctrl+C to stop\n'));
+
+  let currentBuildId: number | null = null;
+  let lastEventTimestamp: Date | null = null;
+  let buildStartTime: Date | null = null;
+
+  // Set up Ctrl+C handler
+  process.on('SIGINT', () => {
+    console.log(chalk.dim('\n\nStopped watching.\n'));
+    process.exit(0);
+  });
+
+  while (true) {
+    try {
+      // Get latest builds
+      const builds = await platformClient.listBuilds(appName, 1);
+
+      if (builds.length === 0) {
+        console.log(chalk.dim('Waiting for builds...'));
+        await sleep(5000);
+        continue;
+      }
+
+      const latestBuild = builds[0];
+
+      // New build started
+      if (latestBuild.id !== currentBuildId) {
+        currentBuildId = latestBuild.id;
+        lastEventTimestamp = null;
+        buildStartTime = latestBuild.startedAt ? new Date(latestBuild.startedAt) : new Date();
+
+        console.log(chalk.bold(`\nBuild #${latestBuild.id}`) +
+          ` - commit ${chalk.dim(latestBuild.commitSha.substring(0, 7))} "${latestBuild.commitMsg || 'No message'}"`);
+        console.log(chalk.dim(`Branch: ${latestBuild.branch} | Started: ${formatRelativeTime(latestBuild.createdAt)}`));
+        console.log();
+      }
+
+      // Fetch new events
+      const events = await platformClient.getBuildEvents(appName, currentBuildId, lastEventTimestamp || undefined);
+
+      for (const event of events) {
+        const eventTime = new Date(event.timestamp);
+        const timeStr = formatEventTime(buildStartTime!, eventTime);
+        const icon = getStageIcon(event.stage, event.status);
+        console.log(`[${timeStr}] ${icon} ${event.message || event.stage}`);
+        lastEventTimestamp = eventTime;
+      }
+
+      // Check if build is complete
+      if (latestBuild.status === 'success' || latestBuild.status === 'failed') {
+        const duration = formatDuration(latestBuild.startedAt, latestBuild.completedAt);
+        const icon = getStatusIcon(latestBuild.status);
+
+        console.log();
+        console.log(`${icon} Build #${latestBuild.id} ${latestBuild.status} in ${duration}`);
+
+        // Wait for next build
+        console.log(chalk.dim('\nWaiting for next build...\n'));
+        currentBuildId = null;
+      }
+
+      await sleep(2000);  // Poll every 2 seconds
+
+    } catch (error) {
+      // Ignore transient errors and keep polling
+      await sleep(5000);
+    }
+  }
+}
+
+/**
+ * Watch for new builds
+ */
+async function watchBuilds(platformClient: PlatformClient, appName: string) {
+  console.log(chalk.cyan(`\nWatching builds for '${appName}'...\n`));
+  console.log(chalk.dim('Press Ctrl+C to stop\n'));
+
+  let lastBuildId: number | null = null;
+
+  // Set up Ctrl+C handler
+  process.on('SIGINT', () => {
+    console.log(chalk.dim('\n\nStopped watching.\n'));
+    process.exit(0);
+  });
+
+  while (true) {
+    try {
+      const builds = await platformClient.listBuilds(appName, 5);
+
+      if (builds.length === 0) {
+        console.log(chalk.dim('No builds yet. Waiting...'));
+        await sleep(5000);
+        continue;
+      }
+
+      // Check for new builds
+      const latestBuild = builds[0];
+      if (latestBuild.id !== lastBuildId) {
+        if (lastBuildId !== null) {
+          // New build detected
+          const icon = getStatusIcon(latestBuild.status);
+          const sha = latestBuild.commitSha.substring(0, 7);
+          console.log(`${icon} New build #${latestBuild.id} ${chalk.dim(sha)} "${latestBuild.commitMsg || 'No message'}" [${latestBuild.status}]`);
+        }
+        lastBuildId = latestBuild.id;
+      }
+
+      // Show status updates for in-progress builds
+      for (const build of builds) {
+        if (build.status === 'building') {
+          const duration = formatDuration(build.startedAt, null);
+          console.log(chalk.yellow(`  ● Build #${build.id} in progress (${duration})...`));
+        }
+      }
+
+      await sleep(5000);
+
+    } catch (error) {
+      await sleep(5000);
+    }
+  }
+}

package/src/commands/config.ts

@@ -0,0 +1,129 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { ConfigManager } from '../lib/config.js';
+
+export function createConfigCommand() {
+  const cmd = new Command('config');
+  cmd.description('Manage hackerrun configuration');
+
+  // config set
+  cmd
+    .command('set')
+    .description('Set a configuration value')
+    .argument('<key>', 'Configuration key (apiToken)')
+    .argument('<value>', 'Configuration value')
+    .action((key: string, value: string) => {
+      try {
+        const configManager = new ConfigManager();
+
+        if (key !== 'apiToken') {
+          console.log(chalk.red(`\n❌ Invalid key: ${key}\n`));
+          console.log(chalk.cyan('Valid keys:'));
+          console.log('  - apiToken    Platform API token\n');
+          process.exit(1);
+        }
+
+        configManager.set(key as any, value);
+
+        const displayValue = configManager.getAll(true).apiToken;
+        console.log(chalk.green(`\n✓ Set ${key} = ${displayValue}\n`));
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // config get
+  cmd
+    .command('get')
+    .description('Get a configuration value')
+    .argument('<key>', 'Configuration key')
+    .option('--show-secrets', 'Show unmasked sensitive values')
+    .action((key: string, options) => {
+      try {
+        const configManager = new ConfigManager();
+
+        if (key !== 'apiToken') {
+          console.log(chalk.red(`\n❌ Invalid key: ${key}\n`));
+          process.exit(1);
+        }
+
+        const value = configManager.get(key as any);
+
+        if (!value) {
+          console.log(chalk.yellow(`\n⚠️  ${key} is not set\n`));
+          process.exit(1);
+        }
+
+        const displayValue = options.showSecrets ? value : configManager.getAll(true).apiToken;
+        console.log(chalk.cyan(`\n${key} = ${displayValue}\n`));
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // config list
+  cmd
+    .command('list')
+    .description('List all configuration values')
+    .option('--show-secrets', 'Show unmasked sensitive values')
+    .action((options) => {
+      try {
+        const configManager = new ConfigManager();
+        const config = configManager.getAll(!options.showSecrets);
+
+        if (Object.keys(config).length === 0) {
+          console.log(chalk.yellow('\n⚠️  No configuration found\n'));
+          console.log(chalk.cyan('Get started by logging in:\n'));
+          console.log('  hackerrun login\n');
+          return;
+        }
+
+        console.log(chalk.cyan('\n📝 Configuration:\n'));
+        console.log(`  apiToken: ${config.apiToken || chalk.red('not set')}`);
+        console.log(chalk.dim(`\nConfig file: ${configManager.getConfigPath()}\n`));
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // config unset
+  cmd
+    .command('unset')
+    .description('Remove a configuration value')
+    .argument('<key>', 'Configuration key')
+    .action((key: string) => {
+      try {
+        const configManager = new ConfigManager();
+
+        if (key !== 'apiToken') {
+          console.log(chalk.red(`\n❌ Invalid key: ${key}\n`));
+          process.exit(1);
+        }
+
+        configManager.unset(key as any);
+        console.log(chalk.green(`\n✓ Removed ${key}\n`));
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // config path
+  cmd
+    .command('path')
+    .description('Show the config file path')
+    .action(() => {
+      try {
+        const configManager = new ConfigManager();
+        console.log(configManager.getConfigPath());
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/connect.ts

@@ -0,0 +1,197 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { select } from '@inquirer/prompts';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { getAppName, linkApp, hasAppConfig } from '../lib/app-config.js';
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Poll for GitHub App installation completion
+ */
+async function pollForInstallation(
+  platformClient: PlatformClient,
+  stateToken: string,
+  spinner: ReturnType<typeof ora>,
+  maxAttempts: number = 60,  // 5 minutes at 5s intervals
+  intervalMs: number = 5000
+): Promise<{ installationId: number }> {
+  let attempts = 0;
+
+  while (attempts < maxAttempts) {
+    await sleep(intervalMs);
+    attempts++;
+
+    const result = await platformClient.pollGitHubConnect(stateToken);
+
+    if (result.status === 'complete' && result.installationId) {
+      return { installationId: result.installationId };
+    } else if (result.status === 'expired') {
+      throw new Error('Authorization expired. Please try again.');
+    }
+    // Status is 'pending', continue polling
+  }
+
+  throw new Error('Authorization timed out. Please try again.');
+}
+
+export function createConnectCommand() {
+  const cmd = new Command('connect');
+  cmd
+    .description('Connect a GitHub repository for automatic deploys')
+    .option('--app <app>', 'App name (uses hackerrun.yaml or folder name if not specified)')
+    .action(async (options) => {
+      try {
+        // Get app name: --app flag > hackerrun.yaml > folder name
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        console.log(chalk.cyan(`\nConnecting GitHub repository to '${appName}'\n`));
+
+        // Check if app exists, create metadata if not
+        let app = await platformClient.getApp(appName);
+        if (!app) {
+          const spinner = ora('Creating app...').start();
+          app = await platformClient.createAppMetadata(appName);
+          spinner.succeed(`Created app '${appName}'`);
+
+          // Create hackerrun.yaml if it doesn't exist
+          if (!hasAppConfig()) {
+            linkApp(appName);
+            console.log(chalk.dim(`  Created hackerrun.yaml`));
+          }
+        }
+
+        // Check for existing repo connection
+        const existingRepo = await platformClient.getConnectedRepo(appName);
+        if (existingRepo) {
+          console.log(chalk.yellow(`\nApp '${appName}' is already connected to:`));
+          console.log(`  ${chalk.bold(existingRepo.repoFullName)} (branch: ${existingRepo.branch})\n`);
+
+          const action = await select({
+            message: 'What would you like to do?',
+            choices: [
+              { name: 'Change repository', value: 'change' },
+              { name: 'Keep current connection', value: 'keep' },
+            ],
+          });
+
+          if (action === 'keep') {
+            console.log(chalk.green('\nConnection unchanged.\n'));
+            return;
+          }
+        }
+
+        // Check for GitHub App installation
+        let installation = await platformClient.getGitHubInstallation();
+
+        if (!installation) {
+          // Need to install GitHub App
+          console.log(chalk.cyan('First, install the HackerRun GitHub App:\n'));
+
+          const spinner = ora('Initiating GitHub connection...').start();
+          const flow = await platformClient.initiateGitHubConnect();
+          spinner.succeed('GitHub connection initiated');
+
+          console.log(chalk.cyan('\nPlease complete the following steps:\n'));
+          console.log(`  1. Visit: ${chalk.bold.blue(flow.authUrl)}`);
+          console.log(`  2. Install the HackerRun app on your account`);
+          console.log(`  3. Select the repositories you want to access\n`);
+
+          const pollSpinner = ora('Waiting for GitHub authorization...').start();
+
+          try {
+            installation = await pollForInstallation(platformClient, flow.stateToken, pollSpinner);
+            pollSpinner.succeed('GitHub App installed');
+          } catch (error) {
+            pollSpinner.fail((error as Error).message);
+            process.exit(1);
+          }
+        } else {
+          console.log(chalk.green(`✓ GitHub App already installed (${installation.accountLogin})\n`));
+        }
+
+        // Fetch accessible repos
+        const repoSpinner = ora('Fetching accessible repositories...').start();
+        const repos = await platformClient.listAccessibleRepos();
+        repoSpinner.stop();
+
+        if (repos.length === 0) {
+          console.log(chalk.yellow('\nNo repositories found.'));
+          console.log(chalk.cyan('Make sure you have given HackerRun access to your repositories.\n'));
+          console.log(`Visit ${chalk.blue('https://github.com/settings/installations')} to manage access.\n`);
+          process.exit(1);
+        }
+
+        // Select repository
+        const selectedRepo = await select({
+          message: 'Select repository to connect:',
+          choices: repos.map(r => ({
+            name: `${r.fullName}${r.private ? chalk.dim(' (private)') : ''} [${r.defaultBranch}]`,
+            value: r.fullName,
+          })),
+        });
+
+        // Get default branch for the selected repo
+        const selectedRepoInfo = repos.find(r => r.fullName === selectedRepo);
+        const branch = selectedRepoInfo?.defaultBranch || 'main';
+
+        // Connect repository
+        const connectSpinner = ora('Connecting repository...').start();
+        await platformClient.connectRepo(appName, selectedRepo, branch);
+        connectSpinner.succeed(`Connected ${selectedRepo}`);
+
+        console.log(chalk.green(`\n✓ Successfully connected!\n`));
+        console.log(chalk.cyan('Auto-deploy is now enabled:'));
+        console.log(`  Repository: ${chalk.bold(selectedRepo)}`);
+        console.log(`  Branch: ${chalk.bold(branch)}`);
+        console.log(`  App: ${chalk.bold(appName)}\n`);
+        console.log(chalk.dim('Every push to this branch will trigger a build and deploy.\n'));
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}
+
+export function createDisconnectCommand() {
+  const cmd = new Command('disconnect');
+  cmd
+    .description('Disconnect GitHub repository from an app')
+    .option('--app <app>', 'App name (uses hackerrun.yaml or folder name if not specified)')
+    .action(async (options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        // Check for existing connection
+        const existingRepo = await platformClient.getConnectedRepo(appName);
+        if (!existingRepo) {
+          console.log(chalk.yellow(`\nNo repository connected to '${appName}'.\n`));
+          return;
+        }
+
+        const spinner = ora('Disconnecting repository...').start();
+        await platformClient.disconnectRepo(appName);
+        spinner.succeed('Repository disconnected');
+
+        console.log(chalk.green(`\n✓ Disconnected ${existingRepo.repoFullName} from '${appName}'\n`));
+        console.log(chalk.dim('Auto-deploy is now disabled. Use `hackerrun connect` to reconnect.\n'));
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}