hackerrun 0.1.9 → 0.1.11

package/package.json

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

package/src/commands/scale.ts

@@ -1,35 +1,59 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
-import { confirm } from '@inquirer/prompts';
+import { select, 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_VM_SIZE = 'burstable-1';
 const DEFAULT_BOOT_IMAGE = 'ubuntu-noble';
 
+/**
+ * Parse service list output from uncloud
+ */
+function parseServiceList(output: string): string[] {
+  const lines = output.trim().split('\n');
+  const services: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Skip header and connection messages
+    if (!trimmed || trimmed.startsWith('NAME') || trimmed.startsWith('Connecting') || trimmed.startsWith('Connected')) {
+      continue;
+    }
+    // Extract first column (service name)
+    const svcName = trimmed.split(/\s+/)[0];
+    if (svcName) {
+      services.push(svcName);
+    }
+  }
+
+  return services;
+}
+
 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) => {
+    .description('Scale a service in your app')
+    .argument('<app>', 'App name')
+    .argument('[service]', 'Service name (optional - will prompt if not provided)')
+    .argument('[replicas]', 'Number of replicas')
+    .option('--add-machines', 'Automatically add machines if needed')
+    .option('--no-add-machine', 'Scale on existing machines only')
+    .option('--size <size>', `VM size for new machines (default: ${DEFAULT_VM_SIZE})`)
+    .action(async (appName: string, serviceArg: string | undefined, replicasArg: 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);
+        const clusterManager = new ClusterManager(platformClient, uncloudRunner);
 
-        // Get current app state
+        // Get app info
         const app = await platformClient.getApp(appName);
         if (!app) {
           console.log(chalk.red(`\nApp '${appName}' not found\n`));
@@ -37,175 +61,139 @@ export function createScaleCommand() {
           process.exit(1);
         }
 
-        const currentNodeCount = app.nodes.length;
+        // Get list of services
+        let services: string[];
+        const spinner = ora('Fetching services...').start();
+        try {
+          const output = await uncloudRunner.serviceList(appName);
+          services = parseServiceList(output);
+          spinner.stop();
+        } catch (error) {
+          spinner.fail('Failed to fetch services');
+          console.log(chalk.yellow('\nMake sure the app is deployed and running.\n'));
+          process.exit(1);
+        }
 
-        // 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();
+        if (services.length === 0) {
+          console.log(chalk.yellow(`\nNo services found in app '${appName}'`));
+          console.log(`Run ${chalk.bold('hackerrun deploy')} to deploy your app first.\n`);
+          process.exit(1);
+        }
 
-          // 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();
-          });
+        // Determine service name
+        let serviceName: string;
+        let replicas: number;
 
-          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;
-        }
+        if (!serviceArg) {
+          // No service provided - list and prompt
+          console.log(chalk.cyan(`\nServices in '${appName}':\n`));
+
+          serviceName = await select({
+            message: 'Which service would you like to scale?',
+            choices: services.map(s => ({ name: s, value: s })),
+          });
 
-        // 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`));
+          // replicas must be provided as second arg in this case
+          if (!replicasArg) {
+            console.log(chalk.red('\nPlease specify the number of replicas.\n'));
+            console.log(chalk.dim(`Usage: hackerrun scale ${appName} ${serviceName} <replicas>\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`));
+          replicas = parseInt(replicasArg, 10);
+        } else if (!replicasArg) {
+          // Service provided but no replicas - check if serviceArg is actually a number
+          const maybeReplicas = parseInt(serviceArg, 10);
+          if (!isNaN(maybeReplicas)) {
+            // serviceArg is actually the replica count, prompt for service
+            replicas = maybeReplicas;
+
+            console.log(chalk.cyan(`\nServices in '${appName}':\n`));
+
+            serviceName = await select({
+              message: 'Which service would you like to scale?',
+              choices: services.map(s => ({ name: s, value: s })),
+            });
+          } else {
+            // serviceArg is the service name, but no replicas provided
+            console.log(chalk.red('\nPlease specify the number of replicas.\n'));
+            console.log(chalk.dim(`Usage: hackerrun scale ${appName} ${serviceArg} <replicas>\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`));
+          // Both service and replicas provided
+          serviceName = serviceArg;
+          replicas = parseInt(replicasArg, 10);
+
+          // Validate service exists
+          if (!services.includes(serviceName)) {
+            console.log(chalk.red(`\nService '${serviceName}' not found in app '${appName}'.\n`));
+            console.log(chalk.cyan('Available services:'));
+            services.forEach(s => console.log(`  - ${s}`));
+            console.log();
             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`));
+        // Validate replicas
+        if (isNaN(replicas) || replicas < 1) {
+          console.log(chalk.red('\nReplicas must be a positive number.\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?',
+        const currentMachineCount = app.nodes.length;
+
+        console.log(chalk.cyan(`\nScaling '${serviceName}' to ${replicas} replica(s)...`));
+        console.log(chalk.dim(`Current machines: ${currentMachineCount}\n`));
+
+        // Check if we need more machines
+        let shouldAddMachines = false;
+
+        if (replicas > currentMachineCount) {
+          if (options.addMachines) {
+            // --add-machines flag: automatically add
+            shouldAddMachines = true;
+          } else if (options.addMachine === false) {
+            // --no-add-machine flag: don't add
+            shouldAddMachines = false;
+            console.log(chalk.yellow(`Scaling ${replicas} replicas across ${currentMachineCount} machine(s).\n`));
+          } else {
+            // Interactive: ask the user
+            console.log(chalk.yellow(`You want ${replicas} replicas but only have ${currentMachineCount} machine(s).`));
+            console.log(chalk.dim(`You can either:`));
+            console.log(chalk.dim(`  • Add ${replicas - currentMachineCount} new machine(s) for dedicated capacity`));
+            console.log(chalk.dim(`  • Run ${replicas} replicas on your existing ${currentMachineCount} machine(s)\n`));
+
+            shouldAddMachines = await confirm({
+              message: `Add ${replicas - currentMachineCount} new machine(s)?`,
               default: false,
             });
 
-            if (!confirmed) {
-              console.log(chalk.dim('\nScale cancelled.\n'));
-              return;
+            if (!shouldAddMachines) {
+              console.log(chalk.dim(`\nScaling ${replicas} replicas across ${currentMachineCount} existing machine(s).\n`));
             }
           }
+        }
 
-          // Remove nodes
-          for (const node of nodesToRemoveList) {
-            console.log(chalk.cyan(`\nRemoving node '${node.name}'...`));
+        // Add machines if needed
+        if (shouldAddMachines && replicas > currentMachineCount) {
+          const machinesToAdd = replicas - currentMachineCount;
+          const vmSize = options.size || DEFAULT_VM_SIZE;
 
+          console.log(chalk.cyan(`\nAdding ${machinesToAdd} machine(s)...\n`));
+
+          for (let i = 0; i < machinesToAdd; i++) {
+            console.log(chalk.cyan(`Adding machine ${i + 1} of ${machinesToAdd}...`));
             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}`));
+              const newNode = await clusterManager.addNode(appName, vmSize, DEFAULT_BOOT_IMAGE);
+              console.log(chalk.green(`  Added: ${newNode.name} (${newNode.ipv6})`));
             } catch (error) {
-              console.log(chalk.red(`  Failed to remove ${node.name}: ${(error as Error).message}`));
-              // Continue with other nodes
+              console.log(chalk.red(`  Failed to add machine: ${(error as Error).message}`));
+              console.log(chalk.yellow('  Continuing with available machines...\n'));
+              break;
             }
           }
 
-          // Refresh app state and sync gateway
-          const updatedApp = await platformClient.getApp(appName);
-
-          // Sync gateway to update Caddyfile with remaining node IPs
+          // Sync gateway routes after adding machines
           const syncSpinner = ora('Syncing gateway routes...').start();
           try {
             await platformClient.syncGatewayRoutes(app.location);
@@ -213,10 +201,27 @@ export function createScaleCommand() {
           } catch (error) {
             syncSpinner.warn(`Gateway sync failed: ${(error as Error).message}`);
           }
+        }
 
-          console.log(chalk.green(`\n✓ Scaled to ${updatedApp?.nodes.length} nodes\n`));
+        // Scale the service using uc scale
+        const scaleSpinner = ora(`Scaling ${serviceName} to ${replicas} replicas...`).start();
+        try {
+          await uncloudRunner.run(appName, 'scale', [serviceName, String(replicas)], { stdio: 'pipe' });
+          scaleSpinner.succeed(chalk.green(`Scaled '${serviceName}' to ${replicas} replica(s)`));
+        } catch (error) {
+          scaleSpinner.fail(`Failed to scale service: ${(error as Error).message}`);
+          process.exit(1);
         }
 
+        // Show summary
+        const updatedApp = await platformClient.getApp(appName);
+        console.log(chalk.cyan('\nScale Summary:\n'));
+        console.log(`  App:       ${chalk.bold(appName)}`);
+        console.log(`  Service:   ${chalk.bold(serviceName)}`);
+        console.log(`  Replicas:  ${chalk.bold(String(replicas))}`);
+        console.log(`  Machines:  ${chalk.bold(String(updatedApp?.nodes.length || currentMachineCount))}`);
+        console.log();
+
       } catch (error) {
         console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
         process.exit(1);

package/src/lib/cluster.ts

@@ -1,6 +1,7 @@
 import { AppCluster, VMNode, PlatformClient } from './platform-client.js';
 import { SSHCertManager, testIPv6Connectivity } from './ssh-cert.js';
 import { createTunnel, killTunnel, TunnelInfo } from './gateway-tunnel.js';
+import { UncloudRunner } from './uncloud-runner.js';
 import { execSync } from 'child_process';
 import ora from 'ora';
 import chalk from 'chalk';
@@ -18,11 +19,14 @@ export interface ClusterInitOptions {
 
 export class ClusterManager {
   private sshCertManager: SSHCertManager;
+  private uncloudRunner: UncloudRunner;
 
   constructor(
-    private platformClient: PlatformClient
+    private platformClient: PlatformClient,
+    uncloudRunner?: UncloudRunner
   ) {
     this.sshCertManager = new SSHCertManager(platformClient);
+    this.uncloudRunner = uncloudRunner || new UncloudRunner(platformClient);
   }
 
   /**
@@ -207,7 +211,7 @@ export class ClusterManager {
       spinner.text = 'Joining uncloud cluster...';
       spinner.stop();
       console.log(chalk.cyan('\nJoining uncloud cluster...'));
-      await this.joinUncloudCluster(vmWithIp.ip6!, existingNode.ipv6, appName);
+      await this.joinUncloudCluster(vmWithIp.ip6!, appName);
 
       spinner = ora('Configuring Docker for NAT64...').start();
 
@@ -321,26 +325,17 @@ export class ClusterManager {
 
   /**
    * Join a new node to an existing uncloud cluster
-   * Uses --connect ssh:// to avoid local context dependency
+   * Uses `uc machine add` which handles:
+   * - SSH to the new machine
+   * - Installing uncloudd if needed
+   * - Getting token from new machine via gRPC
+   * - Registering machine in cluster
    */
-  private async joinUncloudCluster(newVmIp: string, primaryVmIp: string, contextName: string): Promise<void> {
+  private async joinUncloudCluster(newVmIp: string, appName: string): Promise<void> {
     try {
-      // Get SSH certificates for both nodes and add to agent
-      await this.sshCertManager.getSession(contextName, primaryVmIp);
-      await this.sshCertManager.getSession(contextName, newVmIp);
-
-      // Get join token from primary node using --connect ssh://
-      const token = execSync(`uc --connect ssh://root@${primaryVmIp} machine token`, {
-        encoding: 'utf-8',
-        timeout: 30000,
-      }).trim();
-
-      if (!token) {
-        throw new Error('Failed to get join token from primary node');
-      }
-
-      // Join the new node to the cluster using --connect ssh://
-      execSync(`uc --connect ssh://root@${primaryVmIp} machine add root@${newVmIp} --token "${token}"`, {
+      // Use uc machine add which SSHes to the new VM and joins it to the cluster
+      // The --no-caddy flag skips Caddy deployment (we use the gateway for routing)
+      await this.uncloudRunner.run(appName, 'machine', ['add', `root@${newVmIp}`, '--no-caddy'], {
         stdio: 'inherit',
         timeout: 600000,  // 10 min timeout
       });