hackerrun 0.1.11 → 0.1.12

package/dist/index.js

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 
 // src/commands/login.ts
 import { Command } from "commander";
@@ -1153,16 +1153,14 @@ var ClusterManager = class {
    */
   async initializeCluster(options) {
     const { appName, location, vmSize, storageSize, bootImage } = options;
-    const vmName = `${appName}-1`;
-    let spinner = ora2(`Creating VM '${vmName}' in ${location}...`).start();
+    let spinner = ora2(`Creating VM for '${appName}' in ${location}...`).start();
     try {
       spinner.text = "Fetching platform SSH keys...";
       const platformKeys = await this.getPlatformKeys();
       const gateway = await this.platformClient.getGateway(location);
       const privateSubnetId = gateway?.subnetId;
-      spinner.text = `Creating VM '${vmName}'...`;
-      const vm = await this.platformClient.createVM({
-        name: vmName,
+      spinner.text = "Creating VM...";
+      const vm = await this.platformClient.createAppVM(appName, {
         location,
         size: vmSize,
         storage_size: storageSize,
@@ -1171,9 +1169,11 @@ var ClusterManager = class {
         public_key: platformKeys.platformPublicKey,
         enable_ip4: !privateSubnetId,
         // IPv6-only if we have a subnet for NAT64
-        private_subnet_id: privateSubnetId
+        private_subnet_id: privateSubnetId,
+        isPrimary: true
       });
-      spinner.text = `Waiting for VM to be ready...`;
+      const vmName = vm.name;
+      spinner.text = `Waiting for VM '${vmName}' to be ready...`;
       spinner.stop();
       console.log(chalk4.cyan("\nWaiting for VM to get an IPv6 address..."));
       const vmWithIp = await this.waitForVM(location, vmName, 600, false);
@@ -1226,23 +1226,23 @@ var ClusterManager = class {
     }
     const gateway = await this.platformClient.getGateway(cluster.location);
     const privateSubnetId = gateway?.subnetId;
-    const vmName = this.generateNodeName(appName, cluster.nodes);
-    let spinner = ora2(`Adding node '${vmName}' to cluster...`).start();
+    let spinner = ora2("Adding node to cluster...").start();
     try {
       spinner.text = "Fetching platform SSH keys...";
       const platformKeys = await this.getPlatformKeys();
-      spinner.text = `Creating VM '${vmName}'...`;
-      const vm = await this.platformClient.createVM({
-        name: vmName,
+      spinner.text = "Creating VM...";
+      const vm = await this.platformClient.createAppVM(appName, {
         location: cluster.location,
         size: vmSize,
         boot_image: bootImage,
         unix_user: "root",
         public_key: platformKeys.platformPublicKey,
         enable_ip4: !privateSubnetId,
-        private_subnet_id: privateSubnetId
+        private_subnet_id: privateSubnetId,
+        isPrimary: false
       });
-      spinner.text = `Waiting for VM to be ready...`;
+      const vmName = vm.name;
+      spinner.text = `Waiting for VM '${vmName}' to be ready...`;
       spinner.stop();
       console.log(chalk4.cyan("\nWaiting for VM to get an IPv6 address..."));
       const vmWithIp = await this.waitForVM(cluster.location, vmName, 600, false);
@@ -1521,24 +1521,6 @@ The VM may still be provisioning. You can:
     }
     console.log(chalk4.yellow("  Warning: Timeout waiting for unregistry, continuing anyway..."));
   }
-  /**
-   * Generate a sequential node name: appName-1, appName-2, etc.
-   * Finds the next available number by checking existing node names
-   */
-  generateNodeName(appName, existingNodes) {
-    const existingNumbers = existingNodes.map((n) => {
-      const match = n.name.match(new RegExp(`^${appName}-(\\d+)$`));
-      return match ? parseInt(match[1], 10) : 0;
-    }).filter((n) => n > 0);
-    const maxNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) : 0;
-    return `${appName}-${maxNumber + 1}`;
-  }
-  /**
-   * Generate a random ID (used for legacy naming or fallback)
-   */
-  generateId() {
-    return Math.random().toString(36).substring(2, 9);
-  }
   /**
    * Sleep for specified milliseconds
    */
@@ -1956,6 +1938,19 @@ var PlatformClient = class {
     const { vm } = await this.request("POST", "/api/vms", params, { operation: `Create VM '${params.name}'` });
     return vm;
   }
+  /**
+   * Create a new VM for an app with auto-generated name
+   * Name format: u{userId}-{appName}-{nodeNum}
+   */
+  async createAppVM(appName, params) {
+    const { vm } = await this.request(
+      "POST",
+      `/api/apps/${appName}/vms`,
+      params,
+      { operation: `Create VM for app '${appName}'` }
+    );
+    return vm;
+  }
   /**
    * Get a specific VM
    */
@@ -3916,8 +3911,75 @@ Error: ${error.message}
   return cmd;
 }
 
+// src/commands/services.ts
+import { Command as Command11 } from "commander";
+import chalk17 from "chalk";
+import ora11 from "ora";
+function createServicesCommand() {
+  const cmd = new Command11("services");
+  cmd.description("List services and their status for an app").argument("[app]", "App name (uses hackerrun.yaml if not specified)").action(async (appArg) => {
+    const platformToken = getPlatformToken();
+    const platformClient = new PlatformClient(platformToken);
+    const uncloudRunner = new UncloudRunner(platformClient);
+    try {
+      const appName = appArg || getAppName();
+      const app = await platformClient.getApp(appName);
+      if (!app) {
+        console.log(chalk17.red(`
+App '${appName}' not found
+`));
+        process.exit(1);
+      }
+      const spinner = ora11("Fetching services...").start();
+      try {
+        const output = await uncloudRunner.serviceList(appName);
+        spinner.stop();
+        console.log(chalk17.cyan(`
+Services in '${appName}':
+`));
+        const lines = output.trim().split("\n");
+        if (lines.length === 0 || lines.length === 1 && !lines[0].trim()) {
+          console.log(chalk17.yellow("  No services found.\n"));
+          console.log(`Run ${chalk17.bold("hackerrun deploy")} to deploy your app.
+`);
+          return;
+        }
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed.startsWith("Connecting") || trimmed.startsWith("Connected")) {
+            continue;
+          }
+          if (trimmed) {
+            if (trimmed.startsWith("NAME")) {
+              console.log(chalk17.bold(`  ${trimmed}`));
+            } else {
+              console.log(`  ${trimmed}`);
+            }
+          }
+        }
+        console.log();
+        console.log(chalk17.dim(`Machines: ${app.nodes.length}`));
+        console.log(chalk17.dim(`Scale a service: hackerrun scale ${appName} <service> <replicas>`));
+        console.log();
+      } catch (error) {
+        spinner.fail("Failed to fetch services");
+        console.log(chalk17.yellow("\nMake sure the app is deployed and running.\n"));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk17.red(`
+Error: ${error.message}
+`));
+      process.exit(1);
+    } finally {
+      uncloudRunner.cleanup();
+    }
+  });
+  return cmd;
+}
+
 // src/index.ts
-var program = new Command11();
+var program = new Command12();
 program.name("hackerrun").description("Deploy apps with full control over your infrastructure").version("0.1.0");
 program.addCommand(createLoginCommand());
 program.addCommand(createConfigCommand());
@@ -3929,6 +3991,7 @@ program.addCommand(createEnvCommand());
 program.addCommand(createBuildsCommand());
 program.addCommand(createVPNCommands());
 program.addCommand(createScaleCommand());
+program.addCommand(createServicesCommand());
 var { appsCmd, nodesCmd, sshCmd, destroyCmd, linkCmd, renameCmd, domainCmd } = createAppCommands();
 program.addCommand(appsCmd);
 program.addCommand(nodesCmd);

package/package.json

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

package/src/commands/services.ts

@@ -0,0 +1,84 @@
+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 { UncloudRunner } from '../lib/uncloud-runner.js';
+import { getAppName } from '../lib/app-config.js';
+
+export function createServicesCommand() {
+  const cmd = new Command('services');
+
+  cmd
+    .description('List services and their status for an app')
+    .argument('[app]', 'App name (uses hackerrun.yaml if not specified)')
+    .action(async (appArg: string | undefined) => {
+      const platformToken = getPlatformToken();
+      const platformClient = new PlatformClient(platformToken);
+      const uncloudRunner = new UncloudRunner(platformClient);
+
+      try {
+        const appName = appArg || getAppName();
+
+        const app = await platformClient.getApp(appName);
+        if (!app) {
+          console.log(chalk.red(`\nApp '${appName}' not found\n`));
+          process.exit(1);
+        }
+
+        const spinner = ora('Fetching services...').start();
+
+        try {
+          // Get service list from uncloud (includes status, replicas, etc.)
+          const output = await uncloudRunner.serviceList(appName);
+          spinner.stop();
+
+          console.log(chalk.cyan(`\nServices in '${appName}':\n`));
+
+          // Parse and display the output nicely
+          const lines = output.trim().split('\n');
+
+          if (lines.length === 0 || (lines.length === 1 && !lines[0].trim())) {
+            console.log(chalk.yellow('  No services found.\n'));
+            console.log(`Run ${chalk.bold('hackerrun deploy')} to deploy your app.\n`);
+            return;
+          }
+
+          // Print the table output from uncloud
+          for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip connection messages
+            if (trimmed.startsWith('Connecting') || trimmed.startsWith('Connected')) {
+              continue;
+            }
+            if (trimmed) {
+              // Highlight header row
+              if (trimmed.startsWith('NAME')) {
+                console.log(chalk.bold(`  ${trimmed}`));
+              } else {
+                console.log(`  ${trimmed}`);
+              }
+            }
+          }
+
+          console.log();
+          console.log(chalk.dim(`Machines: ${app.nodes.length}`));
+          console.log(chalk.dim(`Scale a service: hackerrun scale ${appName} <service> <replicas>`));
+          console.log();
+
+        } catch (error) {
+          spinner.fail('Failed to fetch services');
+          console.log(chalk.yellow('\nMake sure the app is deployed and running.\n'));
+          process.exit(1);
+        }
+
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      } finally {
+        uncloudRunner.cleanup();
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -9,6 +9,7 @@ import { createConnectCommand, createDisconnectCommand } from './commands/connec
 import { createBuildsCommand } from './commands/builds.js';
 import { createVPNCommands } from './commands/vpn.js';
 import { createScaleCommand } from './commands/scale.js';
+import { createServicesCommand } from './commands/services.js';
 
 const program = new Command();
 
@@ -36,8 +37,9 @@ program.addCommand(createBuildsCommand());
 // Register VPN command
 program.addCommand(createVPNCommands());
 
-// Register scale command
+// Register scale and services commands
 program.addCommand(createScaleCommand());
+program.addCommand(createServicesCommand());
 
 const { appsCmd, nodesCmd, sshCmd, destroyCmd, linkCmd, renameCmd, domainCmd } = createAppCommands();
 program.addCommand(appsCmd);

package/src/lib/cluster.ts

@@ -62,10 +62,7 @@ export class ClusterManager {
   async initializeCluster(options: ClusterInitOptions): Promise<AppCluster> {
     const { appName, location, vmSize, storageSize, bootImage } = options;
 
-    // First node is always appName-1
-    const vmName = `${appName}-1`;
-
-    let spinner = ora(`Creating VM '${vmName}' in ${location}...`).start();
+    let spinner = ora(`Creating VM for '${appName}' in ${location}...`).start();
 
     try {
       // Get platform SSH keys (for VM creation)
@@ -77,10 +74,9 @@ export class ClusterManager {
       const privateSubnetId = gateway?.subnetId;
 
       // Create IPv6-only VM via platform API with platform SSH key
-      // VM is placed in the same private subnet as the gateway for NAT64 routing
-      spinner.text = `Creating VM '${vmName}'...`;
-      const vm = await this.platformClient.createVM({
-        name: vmName,
+      // VM name is auto-generated by platform: u{userId}-{appName}-{nodeNum}
+      spinner.text = 'Creating VM...';
+      const vm = await this.platformClient.createAppVM(appName, {
         location,
         size: vmSize,
         storage_size: storageSize,
@@ -89,9 +85,12 @@ export class ClusterManager {
         public_key: platformKeys.platformPublicKey,
         enable_ip4: !privateSubnetId,  // IPv6-only if we have a subnet for NAT64
         private_subnet_id: privateSubnetId,
+        isPrimary: true,
       });
 
-      spinner.text = `Waiting for VM to be ready...`;
+      const vmName = vm.name;  // Name generated by platform
+
+      spinner.text = `Waiting for VM '${vmName}' to be ready...`;
       spinner.stop();
 
       console.log(chalk.cyan('\nWaiting for VM to get an IPv6 address...'));
@@ -172,10 +171,7 @@ export class ClusterManager {
     const gateway = await this.platformClient.getGateway(cluster.location);
     const privateSubnetId = gateway?.subnetId;
 
-    // Generate sequential node name: appName-1, appName-2, etc.
-    const vmName = this.generateNodeName(appName, cluster.nodes);
-
-    let spinner = ora(`Adding node '${vmName}' to cluster...`).start();
+    let spinner = ora('Adding node to cluster...').start();
 
     try {
       // Get platform SSH keys (for VM creation)
@@ -183,9 +179,9 @@ export class ClusterManager {
       const platformKeys = await this.getPlatformKeys();
 
       // Create new IPv6-only VM via platform API with platform SSH key
-      spinner.text = `Creating VM '${vmName}'...`;
-      const vm = await this.platformClient.createVM({
-        name: vmName,
+      // VM name is auto-generated by platform: u{userId}-{appName}-{nodeNum}
+      spinner.text = 'Creating VM...';
+      const vm = await this.platformClient.createAppVM(appName, {
         location: cluster.location,
         size: vmSize,
         boot_image: bootImage,
@@ -193,9 +189,12 @@ export class ClusterManager {
         public_key: platformKeys.platformPublicKey,
         enable_ip4: !privateSubnetId,
         private_subnet_id: privateSubnetId,
+        isPrimary: false,
       });
 
-      spinner.text = `Waiting for VM to be ready...`;
+      const vmName = vm.name;  // Name generated by platform
+
+      spinner.text = `Waiting for VM '${vmName}' to be ready...`;
       spinner.stop();
       console.log(chalk.cyan('\nWaiting for VM to get an IPv6 address...'));
       const vmWithIp = await this.waitForVM(cluster.location, vmName, 600, false);
@@ -544,31 +543,6 @@ REMOTESCRIPT`, {
     console.log(chalk.yellow('  Warning: Timeout waiting for unregistry, continuing anyway...'));
   }
 
-  /**
-   * Generate a sequential node name: appName-1, appName-2, etc.
-   * Finds the next available number by checking existing node names
-   */
-  private generateNodeName(appName: string, existingNodes: VMNode[]): string {
-    // Extract existing numbers from node names
-    const existingNumbers = existingNodes
-      .map(n => {
-        const match = n.name.match(new RegExp(`^${appName}-(\\d+)$`));
-        return match ? parseInt(match[1], 10) : 0;
-      })
-      .filter(n => n > 0);
-
-    // Find the next available number
-    const maxNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) : 0;
-    return `${appName}-${maxNumber + 1}`;
-  }
-
-  /**
-   * Generate a random ID (used for legacy naming or fallback)
-   */
-  private generateId(): string {
-    return Math.random().toString(36).substring(2, 9);
-  }
-
   /**
    * Sleep for specified milliseconds
    */

package/src/lib/platform-client.ts

@@ -64,6 +64,19 @@ export interface CreateVMParams {
   private_subnet_id?: string;  // Put VM in specific private subnet for NAT64 routing
 }
 
+// Parameters for creating an app VM (name is auto-generated by platform)
+export interface CreateAppVMParams {
+  location: string;
+  size: string;
+  storage_size?: number;
+  unix_user: string;
+  public_key: string;
+  boot_image: string;
+  enable_ip4?: boolean;
+  private_subnet_id?: string;
+  isPrimary?: boolean;
+}
+
 export interface UbicloudVM {
   id: string;
   name: string;
@@ -274,6 +287,20 @@ export class PlatformClient {
     return vm;
   }
 
+  /**
+   * Create a new VM for an app with auto-generated name
+   * Name format: u{userId}-{appName}-{nodeNum}
+   */
+  async createAppVM(appName: string, params: CreateAppVMParams): Promise<UbicloudVM> {
+    const { vm } = await this.request<{ vm: UbicloudVM }>(
+      'POST',
+      `/api/apps/${appName}/vms`,
+      params,
+      { operation: `Create VM for app '${appName}'` }
+    );
+    return vm;
+  }
+
   /**
    * Get a specific VM
    */