hackerrun 0.1.0

package/src/commands/deploy.ts

@@ -0,0 +1,227 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { ClusterManager } from '../lib/cluster.js';
+import { PlatformDetector } from '../lib/platform.js';
+import { UncloudManager } from '../lib/uncloud.js';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { getAppName, hasAppConfig, linkApp } from '../lib/app-config.js';
+import { UncloudRunner } from '../lib/uncloud-runner.js';
+
+// Default VM settings
+const DEFAULT_LOCATION = 'eu-central-h1';
+const DEFAULT_SIZE = 'burstable-1';
+const DEFAULT_STORAGE_SIZE = 10;  // GB
+const DEFAULT_IMAGE = 'ubuntu-noble';
+
+/**
+ * Inject domain into compose file using x-ports extension
+ * This allows custom domain routing without modifying uncloud-dns
+ */
+function injectDomainIntoCompose(composePath: string, domain: string): void {
+  if (!existsSync(composePath)) {
+    return;
+  }
+
+  const content = readFileSync(composePath, 'utf-8');
+
+  // Check if x-ports already exists with our domain
+  if (content.includes(`x-ports:`)) {
+    // Domain injection already present, skip
+    return;
+  }
+
+  // Find services that have ports defined and inject x-ports
+  // This is a simple approach - we add x-ports to services with ports
+  const lines = content.split('\n');
+  const newLines: string[] = [];
+  let inService = false;
+  let currentIndent = 0;
+  let hasInjectedXPorts = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    newLines.push(line);
+
+    // Check if we're entering a service that has ports
+    if (line.match(/^\s+ports:/) && !hasInjectedXPorts) {
+      // Add x-ports after the ports section ends
+      // Find the indent level
+      const indent = line.match(/^(\s*)/)?.[1] || '    ';
+
+      // Look ahead for the port value(s)
+      let j = i + 1;
+      while (j < lines.length && lines[j].match(/^\s+-/)) {
+        newLines.push(lines[j]);
+        j++;
+      }
+      i = j - 1;
+
+      // Inject x-ports with our domain
+      newLines.push(`${indent}x-ports:`);
+      newLines.push(`${indent}  - "443:443"`);
+      newLines.push(`${indent}  host: "${domain}"`);
+      hasInjectedXPorts = true;
+    }
+  }
+
+  // Only write if we made changes
+  if (hasInjectedXPorts) {
+    writeFileSync(composePath, newLines.join('\n'), 'utf-8');
+  }
+}
+
+export function createDeployCommand() {
+  const cmd = new Command('deploy');
+  cmd
+    .description('Deploy your application to hackerrun')
+    .option('-n, --name <name>', 'App name (defaults to hackerrun.yaml or directory name)')
+    .option('--app <app>', 'App name (alias for --name, for CI/CD compatibility)')
+    .option('-l, --location <location>', 'VM location')
+    .option('-s, --size <size>', 'VM size (default: burstable-1)')
+    .option('--storage <gb>', 'Storage size in GB (default: 10)')
+    .option('-i, --image <image>', 'Boot image')
+    .option('--build-token <token>', 'Build token for CI/CD (bypasses normal auth)')
+    .action(async (options) => {
+      try {
+        // Check platform compatibility
+        PlatformDetector.ensureSupported();
+
+        // Check uncloud CLI is installed (offers to auto-install if missing)
+        await UncloudManager.ensureInstalled();
+
+        // Determine authentication mode
+        // CI/CD mode: use build token if provided
+        // Interactive mode: use user's platform token
+        let platformToken: string;
+        const isCIBuild = !!options.buildToken;
+
+        if (isCIBuild) {
+          platformToken = options.buildToken;
+        } else {
+          platformToken = getPlatformToken();
+        }
+
+        const platformClient = new PlatformClient(platformToken);
+        const clusterManager = new ClusterManager(platformClient);
+        const uncloudRunner = new UncloudRunner(platformClient);
+
+        // Determine app name: --app or --name flag > hackerrun.yaml > directory name
+        const appName = options.app || options.name || getAppName();
+
+        // Resolve VM settings
+        const location = options.location || DEFAULT_LOCATION;
+        const vmSize = options.size || DEFAULT_SIZE;
+        const storageSize = options.storage ? parseInt(options.storage) : DEFAULT_STORAGE_SIZE;
+        const bootImage = options.image || DEFAULT_IMAGE;
+
+        console.log(chalk.cyan(`\nDeploying '${appName}' to hackerrun...\n`));
+
+        // Check if app already has infrastructure (from backend)
+        let cluster = await platformClient.getApp(appName);
+        let isFirstDeploy = false;
+
+        if (!cluster) {
+          // First deployment - create infrastructure
+          isFirstDeploy = true;
+          console.log(chalk.yellow('First deployment - creating infrastructure...\n'));
+
+          // Initialize cluster (saves to platform and returns with domainName)
+          cluster = await clusterManager.initializeCluster({
+            appName,
+            location,
+            vmSize,
+            storageSize,
+            bootImage,
+          });
+
+          console.log(chalk.cyan('\nWhat just happened:'));
+          console.log(`  ${chalk.green('✓')} Created 1 IPv6-only VM (${vmSize})`);
+          console.log(`  ${chalk.green('✓')} Installed Docker and Uncloud daemon`);
+          console.log(`  ${chalk.green('✓')} Initialized uncloud cluster`);
+          console.log(`  ${chalk.green('✓')} Assigned domain: ${cluster.domainName}.hackerrun.app`);
+          console.log();
+
+          // Create hackerrun.yaml if not already present
+          if (!hasAppConfig()) {
+            linkApp(appName);
+            console.log(chalk.dim(`Created hackerrun.yaml for app linking\n`));
+          }
+        } else {
+          console.log(chalk.green(`Using existing infrastructure (${cluster.nodes.length} VM(s))\n`));
+        }
+
+        // Get primary node from backend
+        const primaryNode = await platformClient.getPrimaryNode(appName);
+        if (!primaryNode || !primaryNode.ipv6) {
+          throw new Error('Primary node not found or has no IPv6 address');
+        }
+
+        // Deploy using uncloud with SSH certificate authentication
+        console.log(chalk.cyan('\nRunning deployment...\n'));
+
+        try {
+          // Run uc deploy using ssh+cli:// connector
+          await uncloudRunner.deploy(appName, process.cwd());
+
+          console.log(chalk.green('\nApp deployed successfully!'));
+
+          // Register route for this app (maps domain to VM IPv6, port 80 for HTTP)
+          if (cluster.domainName) {
+            const spinner = ora('Registering route...').start();
+            try {
+              const route = await platformClient.registerRoute(appName, primaryNode.ipv6, 80);
+              spinner.succeed(chalk.green(`Route registered: ${route.fullUrl}`));
+
+              // Sync gateway Caddy config with all routes
+              spinner.start('Syncing gateway routes...');
+              await platformClient.syncGatewayRoutes(cluster.location);
+              spinner.succeed(chalk.green('Gateway routes synced'));
+            } catch (error) {
+              spinner.warn(chalk.yellow(`Could not register route: ${(error as Error).message}`));
+            }
+          }
+
+          // Update last deployed timestamp on backend
+          await platformClient.updateLastDeployed(appName);
+
+          // Show summary
+          console.log(chalk.cyan('\nDeployment Summary:\n'));
+          console.log(`  App Name:     ${chalk.bold(appName)}`);
+          console.log(`  Domain:       ${chalk.bold(`${cluster.domainName}.hackerrun.app`)}`);
+          console.log(`  URL:          ${chalk.bold(`https://${cluster.domainName}.hackerrun.app`)}`);
+          console.log(`  Location:     ${cluster.location}`);
+          console.log(`  Nodes:        ${cluster.nodes.length}`);
+
+          console.log(chalk.cyan('\nInfrastructure:\n'));
+          cluster.nodes.forEach((node, index) => {
+            const prefix = node.isPrimary ? chalk.yellow('(primary)') : '         ';
+            const ip = node.ipv6 || node.ipv4 || 'pending';
+            console.log(`  ${prefix} ${node.name} - ${ip}`);
+          });
+
+          console.log(chalk.cyan('\nNext steps:\n'));
+          console.log(`  View logs:     ${chalk.bold(`hackerrun logs ${appName}`)}`);
+          console.log(`  SSH access:    ${chalk.bold(`hackerrun ssh ${appName}`)}`);
+          console.log(`  Change domain: ${chalk.bold(`hackerrun domain --app ${appName} <new-name>`)}`);
+          console.log();
+
+          // Cleanup SSH sessions and tunnels
+          uncloudRunner.cleanup();
+
+        } catch (error) {
+          uncloudRunner.cleanup();
+          console.log(chalk.red('\nDeployment failed'));
+          throw error;
+        }
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/env.ts

@@ -0,0 +1,174 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { password } from '@inquirer/prompts';
+import { readFileSync, existsSync } from 'fs';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { getAppName } from '../lib/app-config.js';
+
+/**
+ * Parse a .env file into key-value pairs
+ */
+function parseEnvFile(content: string): Record<string, string> {
+  const vars: Record<string, string> = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const eqIndex = trimmed.indexOf('=');
+    if (eqIndex === -1) continue;
+
+    const key = trimmed.slice(0, eqIndex);
+    let value = trimmed.slice(eqIndex + 1);
+
+    // Handle quoted values
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+
+    vars[key] = value;
+  }
+  return vars;
+}
+
+export function createEnvCommand() {
+  const cmd = new Command('env');
+  cmd.description('Manage environment variables for an app');
+
+  // env set KEY=value or env set KEY (prompts for value)
+  cmd
+    .command('set')
+    .description('Set an environment variable')
+    .argument('<keyValue>', 'KEY=value or just KEY (will prompt for value)')
+    .option('--app <app>', 'App name (uses hackerrun.yaml if not specified)')
+    .action(async (keyValue: string, options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        let key: string;
+        let value: string;
+
+        if (keyValue.includes('=')) {
+          const parts = keyValue.split('=');
+          key = parts[0];
+          value = parts.slice(1).join('=');  // Handle values with = in them
+        } else {
+          key = keyValue;
+          // Prompt for hidden input
+          value = await password({
+            message: `Enter value for ${key}:`,
+            mask: '*',
+          });
+        }
+
+        if (!key) {
+          console.error(chalk.red('\nError: Key cannot be empty\n'));
+          process.exit(1);
+        }
+
+        const spinner = ora(`Setting ${key}...`).start();
+        await platformClient.setEnvVar(appName, key, value);
+        spinner.succeed(`Set ${key}`);
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // env upload .env
+  cmd
+    .command('upload')
+    .description('Upload environment variables from a file')
+    .argument('<file>', 'Path to .env file')
+    .option('--app <app>', 'App name (uses hackerrun.yaml if not specified)')
+    .action(async (filePath: string, options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        if (!existsSync(filePath)) {
+          console.error(chalk.red(`\nError: File not found: ${filePath}\n`));
+          process.exit(1);
+        }
+
+        const content = readFileSync(filePath, 'utf-8');
+        const vars = parseEnvFile(content);
+        const count = Object.keys(vars).length;
+
+        if (count === 0) {
+          console.log(chalk.yellow('\nNo environment variables found in file.\n'));
+          return;
+        }
+
+        const spinner = ora(`Uploading ${count} variable${count > 1 ? 's' : ''}...`).start();
+        await platformClient.setEnvVars(appName, vars);
+        spinner.succeed(`Uploaded ${count} environment variable${count > 1 ? 's' : ''}`);
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // env list
+  cmd
+    .command('list')
+    .description('List environment variables')
+    .option('--app <app>', 'App name (uses hackerrun.yaml if not specified)')
+    .action(async (options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        const spinner = ora('Fetching environment variables...').start();
+        const vars = await platformClient.listEnvVars(appName);
+        spinner.stop();
+
+        if (vars.length === 0) {
+          console.log(chalk.yellow(`\nNo environment variables set for '${appName}'.\n`));
+          console.log(chalk.cyan('Set variables with:\n'));
+          console.log(`  hackerrun env set KEY=value`);
+          console.log(`  hackerrun env upload .env\n`);
+          return;
+        }
+
+        console.log(chalk.cyan(`\nEnvironment variables for '${appName}':\n`));
+        for (const v of vars) {
+          const masked = '*'.repeat(Math.min(v.valueLength, 20));
+          console.log(`  ${chalk.bold(v.key)}=${chalk.dim(masked)}`);
+        }
+        console.log();
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // env unset KEY
+  cmd
+    .command('unset')
+    .description('Remove an environment variable')
+    .argument('<key>', 'Environment variable key')
+    .option('--app <app>', 'App name (uses hackerrun.yaml if not specified)')
+    .action(async (key: string, options) => {
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        const spinner = ora(`Removing ${key}...`).start();
+        await platformClient.unsetEnvVar(appName, key);
+        spinner.succeed(`Removed ${key}`);
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/commands/login.ts

@@ -0,0 +1,120 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { ConfigManager } from '../lib/config.js';
+
+const PLATFORM_API_URL = process.env.HACKERRUN_API_URL || 'http://localhost:3000';
+
+interface DeviceFlowInitiation {
+  deviceCode: string;
+  userCode: string;
+  verificationUri: string;
+  expiresIn: number;
+  interval: number;
+}
+
+interface DeviceFlowResult {
+  status: 'pending' | 'authorized' | 'expired';
+  token?: string;
+}
+
+export function createLoginCommand() {
+  const cmd = new Command('login');
+  cmd.description('Login to HackerRun platform');
+
+  cmd.action(async () => {
+    try {
+      console.log(chalk.cyan('\n🔐 Logging in to HackerRun\n'));
+
+      // Step 1: Initiate device flow
+      const spinner = ora('Initiating login...').start();
+
+      const initResponse = await fetch(`${PLATFORM_API_URL}/api/auth/device`, {
+        method: 'POST',
+      });
+
+      if (!initResponse.ok) {
+        spinner.fail('Failed to initiate login');
+        const error = await initResponse.json().catch(() => ({ error: 'Unknown error' }));
+        console.error(chalk.red(`\nError: ${error.error || initResponse.statusText}\n`));
+        process.exit(1);
+      }
+
+      const deviceFlow: DeviceFlowInitiation = await initResponse.json();
+      spinner.succeed('Login initiated');
+
+      // Step 2: Show user code and URL
+      console.log(chalk.cyan('\n📋 Please complete the following steps:\n'));
+      console.log(`  1. Visit: ${chalk.bold.blue(deviceFlow.verificationUri)}`);
+      console.log(`  2. Enter code: ${chalk.bold.yellow(deviceFlow.userCode)}\n`);
+      console.log(chalk.dim(`Code expires in ${Math.floor(deviceFlow.expiresIn / 60)} minutes\n`));
+
+      // Step 3: Poll for authorization
+      const pollSpinner = ora('Waiting for authorization...').start();
+
+      const pollInterval = deviceFlow.interval * 1000; // Convert to milliseconds
+      const maxAttempts = Math.floor(deviceFlow.expiresIn / deviceFlow.interval);
+      let attempts = 0;
+
+      while (attempts < maxAttempts) {
+        await sleep(pollInterval);
+        attempts++;
+
+        try {
+          const pollResponse = await fetch(
+            `${PLATFORM_API_URL}/api/auth/device/poll?device_code=${deviceFlow.deviceCode}`
+          );
+
+          if (!pollResponse.ok) {
+            pollSpinner.fail('Failed to check authorization status');
+            console.error(chalk.red('\nPlease try again later\n'));
+            process.exit(1);
+          }
+
+          const result: DeviceFlowResult = await pollResponse.json();
+
+          if (result.status === 'authorized') {
+            pollSpinner.succeed(chalk.green('Authorization successful!'));
+
+            // Save platform token
+            const configManager = new ConfigManager();
+            configManager.set('apiToken', result.token!);
+
+            console.log(chalk.green('\n✓ Login successful!\n'));
+            console.log(chalk.cyan('You can now use HackerRun CLI:\n'));
+            console.log(`  ${chalk.bold('hackerrun deploy')}     Deploy your application`);
+            console.log(`  ${chalk.bold('hackerrun app list')}  List your apps`);
+            console.log(`  ${chalk.bold('hackerrun config list')} View configuration\n`);
+
+            return;
+          } else if (result.status === 'expired') {
+            pollSpinner.fail('Authorization code expired');
+            console.error(chalk.red('\nPlease run `hackerrun login` again\n'));
+            process.exit(1);
+          }
+
+          // Status is 'pending', continue polling
+        } catch (error) {
+          pollSpinner.fail('Failed to check authorization');
+          console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+          process.exit(1);
+        }
+      }
+
+      // Timeout
+      pollSpinner.fail('Authorization timed out');
+      console.error(chalk.red('\nPlease run `hackerrun login` again\n'));
+      process.exit(1);
+
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+      process.exit(1);
+    }
+  });
+
+  return cmd;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/commands/logs.ts

@@ -0,0 +1,97 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { UncloudRunner } from '../lib/uncloud-runner.js';
+
+export function createLogsCommand() {
+  const cmd = new Command('logs');
+
+  cmd
+    .description('View logs for app services')
+    .argument('<app>', 'App name')
+    .argument('[service]', 'Service name (optional - lists services if omitted)')
+    .option('-f, --follow', 'Follow log output')
+    .option('--tail <lines>', 'Number of lines to show from the end of the logs')
+    .action(async (appName: string, serviceName: string | undefined, options) => {
+      const platformToken = getPlatformToken();
+      const platformClient = new PlatformClient(platformToken);
+      const uncloudRunner = new UncloudRunner(platformClient);
+
+      try {
+        const app = await platformClient.getApp(appName);
+
+        if (!app) {
+          console.log(chalk.red(`\n App '${appName}' not found\n`));
+          console.log(chalk.cyan('Available apps:'));
+          const apps = await platformClient.listApps();
+          if (apps.length === 0) {
+            console.log(chalk.yellow('  No apps deployed yet\n'));
+          } else {
+            apps.forEach(a => console.log(`  - ${a.appName}`));
+            console.log();
+          }
+          process.exit(1);
+        }
+
+        // If no service specified, list available services
+        if (!serviceName) {
+          try {
+            const output = await uncloudRunner.serviceList(appName);
+
+            // Parse table output - skip header line and extract service names
+            const lines = output.trim().split('\n');
+            const services: string[] = [];
+
+            for (let i = 0; i < lines.length; i++) {
+              const line = lines[i].trim();
+              // Skip header and empty lines
+              if (!line || line.startsWith('NAME') || line.startsWith('Connecting') || line.startsWith('Connected')) {
+                continue;
+              }
+              // Extract first column (service name)
+              const svcName = line.split(/\s+/)[0];
+              if (svcName) {
+                services.push(svcName);
+              }
+            }
+
+            if (services.length === 0) {
+              console.log(chalk.yellow(`\n No services found in app '${appName}'\n`));
+              return;
+            }
+
+            console.log(chalk.cyan(`\n Available services in '${appName}':\n`));
+            services.forEach(s => console.log(`  ${chalk.bold(s)}`));
+            console.log(chalk.dim(`\nUsage: hackerrun logs ${appName} <service>`));
+            console.log(chalk.dim(`Example: hackerrun logs ${appName} ${services[0]}\n`));
+            return;
+          } catch (error) {
+            console.error(chalk.red('\n Failed to list services'));
+            console.error(chalk.yellow('Make sure the app is deployed and running\n'));
+            process.exit(1);
+          }
+        }
+
+        console.log(chalk.cyan(`\n Viewing logs for '${serviceName}' in app '${appName}'...\n`));
+
+        try {
+          await uncloudRunner.logs(appName, serviceName, {
+            follow: options.follow,
+            tail: options.tail ? parseInt(options.tail) : undefined,
+          });
+        } catch (error) {
+          console.error(chalk.red(`\n Failed to fetch logs for service '${serviceName}'`));
+          console.error(chalk.yellow('The service may not exist or may not be running\n'));
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(chalk.red(`\n Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      } finally {
+        uncloudRunner.cleanup();
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { createLoginCommand } from './commands/login.js';
+import { createDeployCommand } from './commands/deploy.js';
+import { createAppCommands } from './commands/app.js';
+import { createConfigCommand } from './commands/config.js';
+import { createLogsCommand } from './commands/logs.js';
+import { createEnvCommand } from './commands/env.js';
+import { createConnectCommand, createDisconnectCommand } from './commands/connect.js';
+import { createBuildsCommand } from './commands/builds.js';
+
+const program = new Command();
+
+program
+  .name('hackerrun')
+  .description('Deploy apps with full control over your infrastructure')
+  .version('0.1.0');
+
+// Register auth command (should be first)
+program.addCommand(createLoginCommand());
+
+// Register config command
+program.addCommand(createConfigCommand());
+
+// Register PaaS commands
+program.addCommand(createDeployCommand());
+program.addCommand(createLogsCommand());
+
+// Register CI/CD commands
+program.addCommand(createConnectCommand());
+program.addCommand(createDisconnectCommand());
+program.addCommand(createEnvCommand());
+program.addCommand(createBuildsCommand());
+
+const { appsCmd, nodesCmd, sshCmd, destroyCmd, linkCmd, renameCmd, domainCmd } = createAppCommands();
+program.addCommand(appsCmd);
+program.addCommand(nodesCmd);
+program.addCommand(sshCmd);
+program.addCommand(destroyCmd);
+program.addCommand(linkCmd);
+program.addCommand(renameCmd);
+program.addCommand(domainCmd);
+
+program.parse();