hackerrun 0.1.0

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "hackerrun",
+  "version": "0.1.0",
+  "description": "CLI tool to create and manage VMs using Ubicloud API",
+  "type": "module",
+  "bin": {
+    "hackerrun": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "ubicloud",
+    "vm",
+    "cli",
+    "cloud"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.0.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "dotenv": "^16.4.7",
+    "ora": "^8.1.1",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/app.ts

@@ -0,0 +1,394 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { getPlatformToken } from '../lib/platform-auth.js';
+import { PlatformClient } from '../lib/platform-client.js';
+import { linkApp, readAppConfig } from '../lib/app-config.js';
+import { UncloudRunner } from '../lib/uncloud-runner.js';
+import YAML from 'yaml';
+
+/**
+ * Remove an uncloud context from the config file
+ */
+function removeUncloudContext(contextName: string): boolean {
+  const configPath = join(homedir(), '.config', 'uncloud', 'config.yaml');
+
+  if (!existsSync(configPath)) {
+    return false;
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const config = YAML.parse(content);
+
+    if (!config.contexts || !config.contexts[contextName]) {
+      return false;
+    }
+
+    // Remove the context
+    delete config.contexts[contextName];
+
+    // If current context was the deleted one, switch to another context
+    if (config.current_context === contextName) {
+      const remainingContexts = Object.keys(config.contexts);
+      config.current_context = remainingContexts.length > 0 ? remainingContexts[0] : '';
+    }
+
+    writeFileSync(configPath, YAML.stringify(config));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function createAppCommands() {
+  // Apps list command
+  const appsCmd = new Command('apps');
+  appsCmd
+    .description('List all your apps and their infrastructure')
+    .action(async () => {
+      try {
+        // Fetch apps from backend (single source of truth)
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const apps = await platformClient.listApps();
+
+        if (apps.length === 0) {
+          console.log(chalk.yellow('\nNo apps deployed yet.\n'));
+          console.log(`Run ${chalk.bold('hackerrun deploy')} to deploy your first app!\n`);
+          return;
+        }
+
+        console.log(chalk.cyan('\n Your Apps:\n'));
+
+        apps.forEach(app => {
+          console.log(chalk.bold(`  ${app.appName}`));
+          console.log(`    Domain:       ${app.domainName}.hackerrun.app`);
+          console.log(`    URL:          https://${app.domainName}.hackerrun.app`);
+          console.log(`    Location:     ${app.location}`);
+          console.log(`    Nodes:        ${app.nodes.length}`);
+          console.log(`    Created:      ${new Date(app.createdAt).toLocaleString()}`);
+          if (app.lastDeployedAt) {
+            console.log(`    Last Deploy:  ${new Date(app.lastDeployedAt).toLocaleString()}`);
+          }
+          const primaryNode = app.nodes.find(n => n.isPrimary);
+          console.log(`    Primary Node: ${primaryNode?.ipv6 || primaryNode?.ipv4 || 'N/A'}`);
+          console.log();
+        });
+
+        console.log(chalk.green(`Total: ${apps.length} app(s)\n`));
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // Nodes list command
+  const nodesCmd = new Command('nodes');
+  nodesCmd
+    .description('List all VMs in an app\'s cluster')
+    .argument('<app>', 'App name')
+    .action(async (appName: string) => {
+      try {
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const app = await platformClient.getApp(appName);
+
+        if (!app) {
+          console.log(chalk.red(`\nApp '${appName}' not found\n`));
+          process.exit(1);
+        }
+
+        console.log(chalk.cyan(`\nNodes in '${appName}':\n`));
+
+        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'}`);
+          if (node.ipv4) {
+            console.log(`     IPv4: ${node.ipv4}`);
+          }
+          console.log(`     ID:   ${node.id}`);
+          console.log();
+        });
+
+        console.log(chalk.green(`Total: ${app.nodes.length} node(s)\n`));
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // SSH command
+  const sshCmd = new Command('ssh');
+  sshCmd
+    .description('SSH into an app\'s VM')
+    .argument('<app>', 'App name')
+    .option('-n, --node <node>', 'Node name or index (defaults to primary node)')
+    .action(async (appName: string, 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(`\nApp '${appName}' not found\n`));
+          process.exit(1);
+        }
+
+        let targetNode;
+
+        if (options.node) {
+          // Check if it's a number (index) or name
+          const nodeIndex = parseInt(options.node);
+          if (!isNaN(nodeIndex) && nodeIndex > 0 && nodeIndex <= app.nodes.length) {
+            targetNode = app.nodes[nodeIndex - 1];
+          } else {
+            targetNode = app.nodes.find(n => n.name === options.node);
+          }
+
+          if (!targetNode) {
+            console.log(chalk.red(`\nNode '${options.node}' not found\n`));
+            process.exit(1);
+          }
+        } else {
+          // Default to primary node
+          targetNode = app.nodes.find(n => n.isPrimary);
+        }
+
+        // Get IP address (prefer IPv6, fall back to IPv4)
+        const nodeIp = targetNode?.ipv6 || targetNode?.ipv4;
+        if (!targetNode || !nodeIp) {
+          console.log(chalk.red(`\nTarget node not found or has no IP\n`));
+          process.exit(1);
+        }
+
+        // Get connection info (handles certificate and gateway tunnel if needed)
+        const connInfo = await uncloudRunner.getConnectionInfo(appName);
+
+        if (connInfo.viaGateway) {
+          console.log(chalk.cyan(`\nConnecting to ${targetNode.name} via gateway...\n`));
+        } else {
+          console.log(chalk.cyan(`\nConnecting to ${targetNode.name}...\n`));
+        }
+
+        // SSH to the VM (certificate is in SSH agent)
+        if (connInfo.viaGateway && connInfo.localPort) {
+          // Use the tunnel
+          execSync(
+            `ssh -p ${connInfo.localPort} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR root@localhost`,
+            { stdio: 'inherit' }
+          );
+        } else {
+          // Direct connection
+          execSync(
+            `ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR root@${nodeIp}`,
+            { stdio: 'inherit' }
+          );
+        }
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      } finally {
+        uncloudRunner.cleanup();
+      }
+    });
+
+  // Destroy command
+  const destroyCmd = new Command('destroy');
+  destroyCmd
+    .description('Delete an app and all its infrastructure')
+    .argument('<app>', 'App name')
+    .option('--force', 'Skip confirmation')
+    .action(async (appName: string, options) => {
+      try {
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const app = await platformClient.getApp(appName);
+
+        if (!app) {
+          console.log(chalk.red(`\n❌ App '${appName}' not found\n`));
+          process.exit(1);
+        }
+
+        // Confirm deletion
+        if (!options.force) {
+          console.log(chalk.yellow(`\n⚠️  You are about to delete '${appName}' and all its infrastructure:`));
+          console.log(`  - ${app.nodes.length} VM(s) will be deleted`);
+          console.log(`  - All data will be lost\n`);
+
+          // For now, we'll skip interactive confirmation in CLI
+          // In a real implementation, you'd use a package like 'prompts'
+          console.log(chalk.red('Use --force flag to confirm deletion\n'));
+          process.exit(1);
+        }
+
+        const spinner = ora('Deleting infrastructure...').start();
+
+        try {
+          // Delete all VMs via platform API
+          for (const node of app.nodes) {
+            spinner.text = `Deleting VM '${node.name}'...`;
+            await platformClient.deleteVM(app.location, node.name);
+          }
+
+          // Remove app from backend
+          spinner.text = 'Removing app from database...';
+          await platformClient.deleteApp(appName);
+
+          // Remove uncloud context from local config
+          spinner.text = 'Cleaning up local configuration...';
+          const contextName = app.uncloudContext || appName;
+          removeUncloudContext(contextName);
+
+          spinner.succeed(chalk.green(`App '${appName}' destroyed successfully`));
+
+          console.log(chalk.cyan('\n💡 All infrastructure has been deleted.\n'));
+        } catch (error) {
+          spinner.fail(chalk.red('Failed to destroy app'));
+          throw error;
+        }
+      } catch (error) {
+        console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // Link command
+  const linkCmd = new Command('link');
+  linkCmd
+    .description('Link current directory to an existing app')
+    .argument('<app-name>', 'App name to link to')
+    .action(async (appName: string) => {
+      try {
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+
+        // Check if app exists
+        const app = await platformClient.getApp(appName);
+        if (!app) {
+          console.log(chalk.red(`\nApp '${appName}' not found\n`));
+          console.log(`Run ${chalk.bold('hackerrun apps')} to see your apps.\n`);
+          process.exit(1);
+        }
+
+        // Check if already linked
+        const existingConfig = readAppConfig();
+        if (existingConfig) {
+          if (existingConfig.appName === appName) {
+            console.log(chalk.yellow(`\nThis directory is already linked to '${appName}'\n`));
+            return;
+          }
+          console.log(chalk.yellow(`\nThis directory is currently linked to '${existingConfig.appName}'`));
+          console.log(`Updating link to '${appName}'...\n`);
+        }
+
+        // Create hackerrun.yaml
+        linkApp(appName);
+
+        console.log(chalk.green(`\nLinked to app '${appName}'\n`));
+        console.log(`  Domain: https://${app.domainName}.hackerrun.app`);
+        console.log(`  Run ${chalk.bold('hackerrun deploy')} to deploy changes.\n`);
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // Rename command
+  const renameCmd = new Command('rename');
+  renameCmd
+    .description('Rename an app (per-user unique)')
+    .requiredOption('--app <current-name>', 'Current app name')
+    .argument('<new-name>', 'New app name')
+    .action(async (newName: string, options) => {
+      try {
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const currentName = options.app;
+
+        // Check if app exists
+        const app = await platformClient.getApp(currentName);
+        if (!app) {
+          console.log(chalk.red(`\nApp '${currentName}' not found\n`));
+          process.exit(1);
+        }
+
+        const spinner = ora(`Renaming app '${currentName}' to '${newName}'...`).start();
+
+        try {
+          const updatedApp = await platformClient.renameApp(currentName, newName);
+          spinner.succeed(chalk.green(`App renamed successfully`));
+
+          console.log(`\n  Old name: ${currentName}`);
+          console.log(`  New name: ${updatedApp.appName}`);
+          console.log(`  Domain:   https://${updatedApp.domainName}.hackerrun.app\n`);
+
+          // Update local config if linked to this app
+          const existingConfig = readAppConfig();
+          if (existingConfig?.appName === currentName) {
+            linkApp(newName);
+            console.log(chalk.dim(`Updated local hackerrun.yaml\n`));
+          }
+        } catch (error) {
+          spinner.fail(chalk.red('Failed to rename app'));
+          throw error;
+        }
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  // Domain command
+  const domainCmd = new Command('domain');
+  domainCmd
+    .description('Change app\'s domain name (globally unique)')
+    .requiredOption('--app <app-name>', 'App name')
+    .argument('<new-domain>', 'New domain name (without .hackerrun.app)')
+    .action(async (newDomain: string, options) => {
+      try {
+        const platformToken = getPlatformToken();
+        const platformClient = new PlatformClient(platformToken);
+        const appName = options.app;
+
+        // Check if app exists
+        const app = await platformClient.getApp(appName);
+        if (!app) {
+          console.log(chalk.red(`\nApp '${appName}' not found\n`));
+          process.exit(1);
+        }
+
+        const oldDomain = app.domainName;
+        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`));
+
+          // Sync gateway routes with new domain
+          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`);
+        } catch (error) {
+          spinner.fail(chalk.red('Failed to change domain'));
+          throw error;
+        }
+      } catch (error) {
+        console.error(chalk.red(`\nError: ${(error as Error).message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return { appsCmd, nodesCmd, sshCmd, destroyCmd, linkCmd, renameCmd, domainCmd };
+}