hackerrun 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hackerrun",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "CLI tool to create and manage VMs using Ubicloud API",
   "type": "module",
   "bin": {

package/src/commands/app.ts

@@ -238,10 +238,20 @@ export function createAppCommands() {
             await platformClient.deleteVM(app.location, node.name);
           }
 
-          // Remove app from backend
+          // Remove app from backend (cascades to delete routes)
           spinner.text = 'Removing app from database...';
+          const appLocation = app.location;  // Store before deletion
           await platformClient.deleteApp(appName);
 
+          // Sync gateway to remove stale route from Caddyfile
+          spinner.text = 'Syncing gateway routes...';
+          try {
+            await platformClient.syncGatewayRoutes(appLocation);
+          } catch (error) {
+            // Non-fatal: gateway sync failure shouldn't block destroy
+            console.log(chalk.dim(`  Warning: Could not sync gateway: ${(error as Error).message}`));
+          }
+
           // Remove uncloud context from local config
           spinner.text = 'Cleaning up local configuration...';
           const contextName = app.uncloudContext || appName;
@@ -369,17 +379,31 @@ export function createAppCommands() {
         const spinner = ora(`Changing domain from '${oldDomain}' to '${newDomain}'...`).start();
 
         try {
-          const updatedApp = await platformClient.renameDomain(appName, newDomain);
-          spinner.succeed(chalk.green(`Domain changed successfully`));
+          let updatedApp = app;
+
+          // Only call rename if domain is actually changing
+          if (oldDomain !== newDomain) {
+            updatedApp = await platformClient.renameDomain(appName, newDomain);
+            spinner.succeed(chalk.green(`Domain changed successfully`));
+          } else {
+            spinner.succeed(chalk.green(`Domain already set to '${newDomain}'`));
+          }
+
+          // Ensure route exists (create if missing, update if exists)
+          const primaryNode = app.nodes.find(n => n.isPrimary);
+          if (primaryNode?.ipv6) {
+            spinner.start('Ensuring route exists...');
+            await platformClient.registerRoute(appName, primaryNode.ipv6, 80);
+            spinner.succeed(chalk.green('Route registered'));
+          }
 
-          // Sync gateway routes with new domain
+          // Sync gateway routes
           spinner.start('Syncing gateway routes...');
           await platformClient.syncGatewayRoutes(app.location);
           spinner.succeed(chalk.green('Gateway routes synced'));
 
           console.log(`\n  App:        ${updatedApp.appName}`);
-          console.log(`  Old domain: https://${oldDomain}.hackerrun.app`);
-          console.log(`  New domain: https://${updatedApp.domainName}.hackerrun.app\n`);
+          console.log(`  Domain:     https://${updatedApp.domainName}.hackerrun.app\n`);
         } catch (error) {
           spinner.fail(chalk.red('Failed to change domain'));
           throw error;

package/src/commands/connect.ts

@@ -78,6 +78,7 @@ export function createConnectCommand() {
             choices: [
               { name: 'Change repository', value: 'change' },
               { name: 'Keep current connection', value: 'keep' },
+              { name: 'Reconnect (delete and re-setup)', value: 'reconnect' },
             ],
           });
 
@@ -85,6 +86,13 @@ export function createConnectCommand() {
             console.log(chalk.green('\nConnection unchanged.\n'));
             return;
           }
+
+          if (action === 'reconnect') {
+            const disconnectSpinner = ora('Disconnecting existing repository...').start();
+            await platformClient.disconnectRepo(appName);
+            disconnectSpinner.succeed('Existing connection removed');
+            console.log(chalk.cyan('\nReconnecting...\n'));
+          }
         }
 
         // Check for GitHub App installation
@@ -118,7 +126,51 @@ export function createConnectCommand() {
 
         // Fetch accessible repos
         const repoSpinner = ora('Fetching accessible repositories...').start();
-        const repos = await platformClient.listAccessibleRepos();
+        let repos: Awaited<ReturnType<typeof platformClient.listAccessibleRepos>>;
+        try {
+          repos = await platformClient.listAccessibleRepos();
+        } catch (error: any) {
+          repoSpinner.stop();
+          // Check if this is a stale installation error (GitHub App was uninstalled)
+          const isStaleInstallation =
+            error.message.includes('create-an-installation-access-token') ||
+            error.message.includes('Bad credentials') ||
+            (error.message.includes('installation') && error.message.includes('Not Found'));
+
+          if (isStaleInstallation) {
+            console.log(chalk.yellow('\nGitHub App installation is stale or was removed from GitHub.'));
+            console.log(chalk.cyan('Clearing stale record and prompting for reinstallation...\n'));
+
+            await platformClient.deleteGitHubInstallation();
+
+            // Re-run installation flow
+            console.log(chalk.cyan('Please reinstall 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 {
+              await pollForInstallation(platformClient, flow.stateToken, pollSpinner);
+              pollSpinner.succeed('GitHub App installed');
+            } catch (pollError) {
+              pollSpinner.fail((pollError as Error).message);
+              process.exit(1);
+            }
+
+            // Retry fetching repos
+            const retrySpinner = ora('Fetching accessible repositories...').start();
+            repos = await platformClient.listAccessibleRepos();
+            retrySpinner.stop();
+          } else {
+            throw error;
+          }
+        }
         repoSpinner.stop();
 
         if (repos.length === 0) {

package/src/commands/deploy.ts

@@ -85,19 +85,23 @@ export function createDeployCommand() {
     .option('-i, --image <image>', 'Boot image')
     .option('--build-token <token>', 'Build token for CI/CD (bypasses normal auth)')
     .action(async (options) => {
+      const deployStartTime = Date.now();
+
       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;
 
+        // Check uncloud CLI is installed
+        // In CI/CD mode, fail fast without interactive prompt (build VM should have it pre-installed)
+        // In interactive mode, offer to auto-install if missing
+        await UncloudManager.ensureInstalled({ nonInteractive: isCIBuild });
+
+        let platformToken: string;
         if (isCIBuild) {
           platformToken = options.buildToken;
         } else {
@@ -123,10 +127,18 @@ export function createDeployCommand() {
         let cluster = await platformClient.getApp(appName);
         let isFirstDeploy = false;
 
-        if (!cluster) {
+        // App exists but has no nodes - this happens when app was created with
+        // metadataOnly (connect-before-deploy flow). Treat it like first deploy.
+        const needsInfrastructure = !cluster || cluster.nodes.length === 0;
+
+        if (needsInfrastructure) {
           // First deployment - create infrastructure
           isFirstDeploy = true;
-          console.log(chalk.yellow('First deployment - creating infrastructure...\n'));
+          if (cluster && cluster.nodes.length === 0) {
+            console.log(chalk.yellow('App exists but has no infrastructure - creating VMs...\n'));
+          } else {
+            console.log(chalk.yellow('First deployment - creating infrastructure...\n'));
+          }
 
           // Initialize cluster (saves to platform and returns with domainName)
           cluster = await clusterManager.initializeCluster({
@@ -163,30 +175,87 @@ export function createDeployCommand() {
         console.log(chalk.cyan('\nRunning deployment...\n'));
 
         try {
-          // Run uc deploy using ssh+cli:// connector
-          await uncloudRunner.deploy(appName, process.cwd());
+          // Run uc deploy with automatic retry for connection failures
+          // This handles tunnel instability when going through gateway
+          const maxDeployAttempts = 3;
+          let lastError: Error | null = null;
+
+          for (let attempt = 1; attempt <= maxDeployAttempts; attempt++) {
+            try {
+              await uncloudRunner.deploy(appName, process.cwd());
+              lastError = null;
+              break;  // Success, exit retry loop
+            } catch (error) {
+              lastError = error as Error;
+              const errorMsg = lastError.message.toLowerCase();
+
+              // Check if this is a retryable error
+              // When using gateway tunnel, connection issues manifest as "exit code 1"
+              // because spawnSync with stdio:inherit doesn't capture the actual error
+              const isRetryableError =
+                errorMsg.includes('connection reset') ||
+                errorMsg.includes('connection refused') ||
+                errorMsg.includes('broken pipe') ||
+                errorMsg.includes('network is unreachable') ||
+                errorMsg.includes('context deadline exceeded') ||
+                errorMsg.includes('exit code 1');  // Generic failure, often connection-related
+
+              if (isRetryableError && attempt < maxDeployAttempts) {
+                console.log(chalk.yellow(`\nDeploy failed, retrying (attempt ${attempt + 1}/${maxDeployAttempts})...\n`));
+                // Clean up current tunnel/session before retry
+                uncloudRunner.cleanup();
+                // Brief pause before retry
+                await new Promise(r => setTimeout(r, 3000));
+              } else {
+                // Non-retryable error or max attempts reached
+                throw lastError;
+              }
+            }
+          }
 
           console.log(chalk.green('\nApp deployed successfully!'));
 
           // Register route for this app (maps domain to VM IPv6, port 80 for HTTP)
+          // Uses retry logic since platform API may be temporarily unavailable after long deploys
           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}`));
+            let success = false;
+
+            for (let attempt = 1; attempt <= 5; attempt++) {
+              try {
+                if (attempt > 1) {
+                  spinner.text = `Registering route (attempt ${attempt}/5)...`;
+                  await new Promise(r => setTimeout(r, 2000));
+                }
+                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'));
+                success = true;
+                break;
+              } catch (error) {
+                if (attempt === 5) {
+                  spinner.warn(chalk.yellow(`Could not register route: ${(error as Error).message}`));
+                  console.log(chalk.dim(`  Run 'hackerrun domain --app ${appName} ${cluster.domainName}' to retry`));
+                }
+              }
             }
           }
 
           // Update last deployed timestamp on backend
           await platformClient.updateLastDeployed(appName);
 
+          // Calculate deploy time
+          const deployDurationMs = Date.now() - deployStartTime;
+          const deployMinutes = Math.floor(deployDurationMs / 60000);
+          const deploySeconds = Math.floor((deployDurationMs % 60000) / 1000);
+          const deployTimeStr = deployMinutes > 0
+            ? `${deployMinutes}m ${deploySeconds}s`
+            : `${deploySeconds}s`;
+
           // Show summary
           console.log(chalk.cyan('\nDeployment Summary:\n'));
           console.log(`  App Name:     ${chalk.bold(appName)}`);
@@ -194,6 +263,7 @@ export function createDeployCommand() {
           console.log(`  URL:          ${chalk.bold(`https://${cluster.domainName}.hackerrun.app`)}`);
           console.log(`  Location:     ${cluster.location}`);
           console.log(`  Nodes:        ${cluster.nodes.length}`);
+          console.log(`  Deploy Time:  ${chalk.bold(deployTimeStr)}`);
 
           console.log(chalk.cyan('\nInfrastructure:\n'));
           cluster.nodes.forEach((node, index) => {

package/src/commands/scale.ts

@@ -0,0 +1,231 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { confirm } from '@inquirer/prompts';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { ClusterManager } from '../lib/cluster.js';
+import { getAppName } from '../lib/app-config.js';
+import { UncloudRunner } from '../lib/uncloud-runner.js';
+
+const DEFAULT_VM_SIZE = 'standard-2';
+const DEFAULT_BOOT_IMAGE = 'ubuntu-noble';
+
+export function createScaleCommand() {
+  const cmd = new Command('scale');
+  cmd
+    .description('Scale an app by adding or removing nodes')
+    .argument('[count]', 'Target node count, or +N/-N to add/remove nodes')
+    .option('--app <app>', 'App name (uses hackerrun.yaml if not specified)')
+    .option('--size <size>', `VM size for new nodes (default: ${DEFAULT_VM_SIZE})`)
+    .option('--force', 'Skip confirmation when removing nodes')
+    .action(async (countArg: string | undefined, options) => {
+      let uncloudRunner: UncloudRunner | null = null;
+
+      try {
+        const appName = options.app || getAppName();
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const clusterManager = new ClusterManager(platformClient);
+        uncloudRunner = new UncloudRunner(platformClient);
+
+        // Get current app state
+        const app = await platformClient.getApp(appName);
+        if (!app) {
+          console.log(chalk.red(`\nApp '${appName}' not found\n`));
+          console.log(`Run ${chalk.bold('hackerrun deploy')} to create an app first.\n`);
+          process.exit(1);
+        }
+
+        const currentNodeCount = app.nodes.length;
+
+        // If no count provided, show current scale info
+        if (!countArg) {
+          console.log(chalk.cyan(`\nApp '${appName}' Scale Info:\n`));
+          console.log(`  Current nodes: ${chalk.bold(currentNodeCount.toString())}`);
+          console.log();
+
+          // List nodes with details
+          app.nodes.forEach((node, index) => {
+            const primaryLabel = node.isPrimary ? chalk.yellow(' (primary)') : '';
+            console.log(`  ${index + 1}. ${chalk.bold(node.name)}${primaryLabel}`);
+            console.log(`     IPv6: ${node.ipv6 || 'pending'}`);
+            console.log();
+          });
+
+          console.log(chalk.dim('Usage:'));
+          console.log(chalk.dim(`  hackerrun scale 3         # Scale to 3 nodes`));
+          console.log(chalk.dim(`  hackerrun scale +1        # Add 1 node`));
+          console.log(chalk.dim(`  hackerrun scale -1        # Remove 1 node`));
+          console.log();
+          return;
+        }
+
+        // Parse count argument
+        let targetCount: number;
+        if (countArg.startsWith('+')) {
+          // Add nodes
+          const delta = parseInt(countArg.slice(1), 10);
+          if (isNaN(delta) || delta <= 0) {
+            console.log(chalk.red(`\nInvalid count: ${countArg}\n`));
+            process.exit(1);
+          }
+          targetCount = currentNodeCount + delta;
+        } else if (countArg.startsWith('-')) {
+          // Remove nodes
+          const delta = parseInt(countArg.slice(1), 10);
+          if (isNaN(delta) || delta <= 0) {
+            console.log(chalk.red(`\nInvalid count: ${countArg}\n`));
+            process.exit(1);
+          }
+          targetCount = currentNodeCount - delta;
+        } else {
+          // Absolute count
+          targetCount = parseInt(countArg, 10);
+          if (isNaN(targetCount)) {
+            console.log(chalk.red(`\nInvalid count: ${countArg}\n`));
+            process.exit(1);
+          }
+        }
+
+        // Validate target count
+        if (targetCount < 1) {
+          console.log(chalk.red(`\nCannot scale below 1 node. Use 'hackerrun destroy' to remove the app.\n`));
+          process.exit(1);
+        }
+
+        if (targetCount === currentNodeCount) {
+          console.log(chalk.yellow(`\nApp already has ${currentNodeCount} node(s). Nothing to do.\n`));
+          return;
+        }
+
+        const vmSize = options.size || DEFAULT_VM_SIZE;
+
+        if (targetCount > currentNodeCount) {
+          // Scale up - add nodes
+          const nodesToAdd = targetCount - currentNodeCount;
+          console.log(chalk.cyan(`\nScaling '${appName}' from ${currentNodeCount} to ${targetCount} nodes (+${nodesToAdd})\n`));
+
+          for (let i = 0; i < nodesToAdd; i++) {
+            console.log(chalk.cyan(`\nAdding node ${i + 1} of ${nodesToAdd}...`));
+            const newNode = await clusterManager.addNode(appName, vmSize, DEFAULT_BOOT_IMAGE);
+            console.log(chalk.green(`  Added: ${newNode.name} (${newNode.ipv6})`));
+          }
+
+          // Refresh app state and sync gateway for load balancing
+          const updatedApp = await platformClient.getApp(appName);
+
+          // Sync gateway to update Caddyfile with all node IPs
+          const syncSpinner = ora('Syncing gateway routes...').start();
+          try {
+            await platformClient.syncGatewayRoutes(app.location);
+            syncSpinner.succeed('Gateway routes synced');
+          } catch (error) {
+            syncSpinner.warn(`Gateway sync failed: ${(error as Error).message}`);
+          }
+
+          console.log(chalk.green(`\n✓ Scaled to ${updatedApp?.nodes.length} nodes\n`));
+
+          // Show x-machines hint
+          console.log(chalk.dim('To deploy to specific nodes, use x-machines in your compose file:'));
+          console.log(chalk.dim('  services:'));
+          console.log(chalk.dim('    web:'));
+          console.log(chalk.dim('      x-machines:'));
+          updatedApp?.nodes.forEach(node => {
+            console.log(chalk.dim(`        - ${node.name}`));
+          });
+          console.log();
+
+        } else {
+          // Scale down - remove nodes
+          const nodesToRemove = currentNodeCount - targetCount;
+
+          // All nodes are equal in uncloud - select nodes to remove (most recently added first)
+          // Sort by node number descending to remove highest-numbered nodes first
+          const sortedNodes = [...app.nodes].sort((a, b) => {
+            const numA = parseInt(a.name.split('-').pop() || '0', 10);
+            const numB = parseInt(b.name.split('-').pop() || '0', 10);
+            return numB - numA;  // Descending order
+          });
+
+          const nodesToRemoveList = sortedNodes.slice(0, nodesToRemove);
+
+          console.log(chalk.yellow(`\nScaling '${appName}' from ${currentNodeCount} to ${targetCount} nodes (-${nodesToRemove})\n`));
+          console.log(chalk.yellow('The following nodes will be removed:'));
+          nodesToRemoveList.forEach(node => {
+            console.log(`  - ${node.name} (${node.ipv6})`);
+          });
+          console.log();
+
+          // Confirm unless --force
+          if (!options.force) {
+            console.log(chalk.yellow('Warning: All containers on these nodes will be stopped and the VMs deleted.'));
+            console.log(chalk.yellow('Data on these nodes will be lost.\n'));
+
+            const confirmed = await confirm({
+              message: 'Are you sure you want to remove these nodes?',
+              default: false,
+            });
+
+            if (!confirmed) {
+              console.log(chalk.dim('\nScale cancelled.\n'));
+              return;
+            }
+          }
+
+          // Remove nodes
+          for (const node of nodesToRemoveList) {
+            console.log(chalk.cyan(`\nRemoving node '${node.name}'...`));
+
+            try {
+              // Step 1: Remove from uncloud cluster
+              const spinner = ora('Removing from uncloud cluster...').start();
+              await uncloudRunner.removeNode(appName, node.name);
+              spinner.succeed('Removed from cluster');
+
+              // Step 2: Delete VM from Ubicloud
+              spinner.start('Deleting VM...');
+              await platformClient.deleteVM(app.location, node.name);
+              spinner.succeed('VM deleted');
+
+              // Step 3: Update app state in platform
+              spinner.start('Updating app state...');
+              const updatedNodes = app.nodes.filter(n => n.name !== node.name);
+              app.nodes = updatedNodes;
+              await platformClient.saveApp(app);
+              spinner.succeed('App state updated');
+
+              console.log(chalk.green(`  Removed: ${node.name}`));
+            } catch (error) {
+              console.log(chalk.red(`  Failed to remove ${node.name}: ${(error as Error).message}`));
+              // Continue with other nodes
+            }
+          }
+
+          // Refresh app state and sync gateway
+          const updatedApp = await platformClient.getApp(appName);
+
+          // Sync gateway to update Caddyfile with remaining node IPs
+          const syncSpinner = ora('Syncing gateway routes...').start();
+          try {
+            await platformClient.syncGatewayRoutes(app.location);
+            syncSpinner.succeed('Gateway routes synced');
+          } catch (error) {
+            syncSpinner.warn(`Gateway sync failed: ${(error as Error).message}`);
+          }
+
+          console.log(chalk.green(`\n✓ Scaled to ${updatedApp?.nodes.length} nodes\n`));
+        }
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      } finally {
+        if (uncloudRunner) {
+          uncloudRunner.cleanup();
+        }
+      }
+    });
+
+  return cmd;
+}