[r5n-64] hydra cli

package.json

@@ -23,6 +23,8 @@
     "release:version": "bun sis version",
     "sis": "bun --bun packages/sisyphus/src/cli.ts",
     "sis:dbg": "bun --inspect-brk packages/sisyphus/src/cli.ts",
+    "hydra": "bun --bun packages/hydra/src/cli.ts",
+    "hydra:dbg": "bun --inspect-brk packages/hydra/src/cli.ts",
     "test": "bun test",
     "type-check": "bun --elide-lines=0 --filter '*' type-check",
     "type-check:ci": "bun --filter '*' type-check",

packages/core/src/command-router.ts

@@ -1,9 +1,10 @@
 import { Cancel } from "./cancel";
 import type { AbstractCommand, ArgValue, CommandContext } from "./command";
 import type { ConfigManager } from "./config-manager";
+import { Exit } from "./exit";
 import { log, select } from "./prompts";
 import type { CliMetadata } from "./types";
-import { handleUnknownItem, mapPositionals, parseCommandArgs, validatePositionals } from "./util";
+import { color, handleUnknownItem, mapPositionals, parseCommandArgs, validatePositionals } from "./util";
 
 const EXIT_MENU_VALUE = "__exit__";
 
@@ -144,6 +145,11 @@ export class CommandRouter<TConfig extends object = object> {
       await subRouter.route([], true);
     } catch (error) {
       if (error instanceof Cancel) return;
+      if (error instanceof Exit) {
+        log.warn(color.yellow(error.message));
+        if (error.hint) log.info(color.dim(error.hint));
+        return;
+      }
       throw error;
     }
   }

packages/hydra/package.json

@@ -2,6 +2,7 @@
   "author": "@ice-chillios",
   "bin": { "hydra": "./dist/cli.js" },
   "description": "A tool for spawning multiple local GitHub self-hosted runners",
+  "dependencies": { "@r5n/cli-core": "workspace:*" },
   "devDependencies": { "@clack/prompts": "1.1.0", "@r5n/tools": "workspace:*" },
   "files": ["dist", "schema.json", "LICENSE"],
   "keywords": ["github", "runner", "self-hosted", "ci", "cd", "automation"],

packages/hydra/src/base-command.ts

@@ -0,0 +1,9 @@
+import { AbstractCommand, type ArgDefinition, type BaseCtx, type PositionalDefinition } from "@r5n/cli-core";
+import type { HydraConfig } from "./types";
+
+export abstract class BaseCommand extends AbstractCommand<HydraConfig> {}
+
+export type Ctx<
+  TArgDefs extends Record<string, ArgDefinition> = Record<string, never>,
+  TPositionalDefs extends Record<string, PositionalDefinition> = Record<string, never>,
+> = BaseCtx<HydraConfig, TArgDefs, TPositionalDefs>;

packages/hydra/src/cli.ts

@@ -1 +1,35 @@
-console.log("hello");
+import { AbstractCLI, ConfigManager } from "@r5n/cli-core";
+import { version } from "../package.json";
+import { CreateCommand, InitCommand, ProfileCommand, RemoveCommand, StartCommand, StatusCommand, StopCommand } from "./commands";
+import { CLI_BIN, DEFAULT_CONFIG, HYDRA_CONFIG_FILE } from "./constants";
+import type { HydraConfig } from "./types";
+
+class HydraCLI extends AbstractCLI {
+  constructor() {
+    super(new ConfigManager<HydraConfig>(HYDRA_CONFIG_FILE, DEFAULT_CONFIG), {
+      bin: CLI_BIN,
+      clearOnStart: true,
+      exitLabel: "Exit",
+      goodbyeMessage: "Heads down.",
+      name: "HYDRA",
+      promptMessage: "What do you need?",
+      version,
+    });
+  }
+
+  init() {
+    this.registerCommands([
+      new InitCommand(),
+      new CreateCommand(),
+      new StartCommand(),
+      new StopCommand(),
+      new StatusCommand(),
+      new RemoveCommand(),
+      new ProfileCommand(),
+    ]);
+  }
+}
+
+const cli = new HydraCLI();
+
+void cli.run();

packages/hydra/src/commands/create.ts

@@ -0,0 +1,91 @@
+import { join } from "node:path";
+import { Exit, color, log, positionals, spinner, text } from "@r5n/cli-core";
+import { BaseCommand, type Ctx } from "../base-command";
+import { createProvider } from "../providers";
+import type { RunnerEntry } from "../types";
+import { resolveProfile, selectProfile } from "../utils";
+
+const createPositionals = positionals({
+  profile: { description: "Profile name" },
+  count: { description: "Number of runners to create (overrides profile)" },
+});
+
+type CreateCtx = Ctx<Record<string, never>, typeof createPositionals>;
+
+export class CreateCommand extends BaseCommand {
+  name = "create";
+  description = "Create and register runners";
+  positionals = createPositionals;
+
+  async execute(ctx: CreateCtx) {
+    const { name: profileName, profile } = ctx.interactive
+      ? resolveProfile(ctx.config, await selectProfile(ctx.config))
+      : resolveProfile(ctx.config, ctx.positionals.profile);
+
+    const count = ctx.interactive
+      ? await this.promptCount(profile.numberOfMachines)
+      : (ctx.positionals.count ? Number.parseInt(ctx.positionals.count, 10) : profile.numberOfMachines);
+
+    if (!count || count < 1) {
+      throw new Exit("Runner count must be at least 1");
+    }
+
+    const provider = createProvider(profile);
+
+    const s = spinner();
+    s.start("Downloading runner binary...");
+    const { version } = await provider.download();
+    s.stop(`Runner v${version} ready`);
+
+    const entries: RunnerEntry[] = ctx.config.get("runners") ?? [];
+    const existing = entries.filter((e) => e.profile === profileName);
+    const toCreate = count - existing.length;
+
+    if (toCreate <= 0) {
+      log.warn(`Already have ${existing.length} runner(s) for profile "${profileName}". Nothing to create.`);
+      return;
+    }
+
+    const existingIds = new Set(entries.map((e) => e.id));
+    let nextIndex = 1;
+
+    for (let created = 0; created < toCreate; ) {
+      const id = `${profile.name}-${nextIndex++}`;
+      if (existingIds.has(id)) continue;
+      created++;
+
+      s.start(`Registering ${id}...`);
+      await provider.create([id]);
+      s.stop(`${color.green("+")} ${id}`);
+
+      entries.push({
+        createdAt: new Date().toISOString(),
+        directory: join(profile.directory, id),
+        id,
+        name: id,
+        profile: profileName,
+        provider: profile.provider,
+        url: profile.url,
+      });
+    }
+
+    ctx.config.set("runners", entries);
+
+    const isDefault = profileName === ctx.config.get("defaultProfile");
+    const profileSuffix = isDefault ? "" : ` ${profileName}`;
+    log.info(`${color.green("Created")} ${toCreate} runner(s) for "${profileName}". Run ${color.green(`hydra start${profileSuffix}`)} to start them.`);
+  }
+
+  private async promptCount(defaultCount: number): Promise<number> {
+    const value = await text({
+      initialValue: String(defaultCount),
+      message: "Number of runners to create",
+      validate: (v): string | undefined => {
+        const n = Number.parseInt(v ?? "", 10);
+        if (Number.isNaN(n) || n < 1) return "Must be a positive number";
+        return undefined;
+      },
+    });
+    return Number.parseInt(value, 10);
+  }
+}

packages/hydra/src/commands/index.ts

@@ -0,0 +1,7 @@
+export { CreateCommand } from "./create";
+export { InitCommand } from "./init";
+export { StatusCommand } from "./status";
+export { ProfileCommand } from "./profile";
+export { RemoveCommand } from "./remove";
+export { StartCommand } from "./start";
+export { StopCommand } from "./stop";

packages/hydra/src/commands/init.ts

@@ -0,0 +1,186 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { Cancel, Exit, args, color, confirm, group, note, positionals, text } from "@r5n/cli-core";
+import { BaseCommand, type Ctx } from "../base-command";
+import { CLI_BIN, DEFAULT_PROFILE, RUNNERS_DIR, SHARED_DIR } from "../constants";
+import type { Profile } from "../types";
+
+const initPositionals = positionals({
+  url: { description: "GitHub repository or organization URL" },
+});
+
+const initArgs = args({
+  force: { alias: "f", default: false, description: "Overwrite existing config", type: "boolean" },
+  labels: { alias: "l", description: "Comma-separated runner labels", type: "string" },
+  name: { alias: "n", description: "Base name for runners", type: "string" },
+  profile: { alias: "p", description: "Profile name", type: "string" },
+  runners: { alias: "c", description: "Number of runners to create", type: "number" },
+});
+
+type InitCtx = Ctx<typeof initArgs, typeof initPositionals>;
+
+export class InitCommand extends BaseCommand {
+  name = "init";
+  description = "Initialize Hydra runner manager";
+  positionals = initPositionals;
+  args = initArgs;
+  prompts = true;
+
+  async execute(ctx: InitCtx) {
+    const profileName = ctx.interactive
+      ? await this.promptProfileName(ctx)
+      : (ctx.args.profile ?? DEFAULT_PROFILE);
+
+    const isNewInit = !ctx.config.exists();
+
+    const profileExists = !isNewInit && ctx.config.get("profiles")[profileName];
+    if (profileExists && !ctx.args.force) {
+      if (!ctx.interactive) {
+        throw new Exit(`Profile "${profileName}" already exists. Use --force to overwrite.`);
+      }
+      const overwrite = await confirm({ initialValue: false, message: `Profile "${profileName}" already exists. Overwrite?` });
+      if (!overwrite) return;
+    }
+
+    await this.ensureDirectories();
+
+    const profile = ctx.interactive ? await this.runInitForm() : this.buildProfileFromArgs(ctx);
+    const profiles = isNewInit ? {} : { ...ctx.config.get("profiles") };
+    profiles[profileName] = profile;
+
+    ctx.config.set("profiles", profiles);
+    if (!ctx.config.get("defaultProfile")) {
+      ctx.config.set("defaultProfile", profileName);
+    }
+
+    note(
+      [
+        `${color.dim("Profile:")} ${profileName}`,
+        `${color.dim("URL:")} ${profile.url}`,
+        `${color.dim("Runners:")} ${profile.numberOfMachines}`,
+        `${color.dim("Name:")} ${profile.name}`,
+        profile.labels ? `${color.dim("Labels:")} ${profile.labels}` : "",
+        "",
+        `Run ${color.green(`${CLI_BIN} create${profileName !== ctx.config.get("defaultProfile") ? ` ${profileName}` : ""}`)} to provision runners.`,
+      ]
+        .filter(Boolean)
+        .join("\n"),
+      color.green(isNewInit ? "Hydra initialized" : `Profile "${profileName}" added`),
+    );
+  }
+
+  private async promptProfileName(ctx: InitCtx): Promise<string> {
+    return text({
+      initialValue: ctx.args.profile ?? DEFAULT_PROFILE,
+      message: "Profile name",
+    });
+  }
+
+  private async ensureDirectories() {
+    if (!existsSync(SHARED_DIR)) {
+      await mkdir(SHARED_DIR, { recursive: true });
+    }
+    if (!existsSync(RUNNERS_DIR)) {
+      await mkdir(RUNNERS_DIR, { recursive: true });
+    }
+  }
+
+  private async runInitForm(): Promise<Profile> {
+    const values = await group(
+      {
+        url: () =>
+          text({
+            message: "GitHub repository or organization URL",
+            placeholder: "https://github.com/owner/repo",
+            validate: (v): string | undefined => {
+              if (!v) return "URL is required";
+              try {
+                new URL(v);
+              } catch {
+                return "Must be a valid URL";
+              }
+              return undefined;
+            },
+          }),
+        name: () =>
+          text({
+            initialValue: "runner",
+            message: "Base name for runners",
+            placeholder: "runner",
+          }),
+        runners: () =>
+          text({
+            initialValue: "1",
+            message: "Number of runners",
+            placeholder: "1",
+            validate: (v): string | undefined => {
+              if (!v) return "Must be a positive number";
+              const n = Number.parseInt(v, 10);
+              if (Number.isNaN(n) || n < 1) return "Must be a positive number";
+              return undefined;
+            },
+          }),
+        labels: () =>
+          text({
+            message: "Additional labels (comma-separated, optional)",
+            placeholder: "self-hosted,macOS,ARM64",
+          }),
+      },
+      { onCancel: () => { throw new Cancel(); } },
+    );
+
+    return {
+      directory: RUNNERS_DIR,
+      labels: values.labels || undefined,
+      name: values.name,
+      numberOfMachines: Number.parseInt(values.runners, 10) || 1,
+      os: this.detectOs(),
+      overwrite: false,
+      provider: "github",
+      run: false,
+      url: values.url,
+    };
+  }
+
+  private buildProfileFromArgs(ctx: InitCtx): Profile {
+    if (!ctx.positionals.url) {
+      throw new Exit("URL is required", "Usage: hydra init <url>");
+    }
+
+    this.validateUrl(ctx.positionals.url);
+    this.validateRunnerCount(ctx.args.runners);
+
+    return {
+      directory: RUNNERS_DIR,
+      labels: ctx.args.labels,
+      name: ctx.args.name ?? "runner",
+      numberOfMachines: ctx.args.runners ?? 1,
+      os: this.detectOs(),
+      overwrite: false,
+      provider: "github",
+      run: false,
+      url: ctx.positionals.url,
+    };
+  }
+
+  private validateUrl(url: string) {
+    try {
+      new URL(url);
+    } catch {
+      throw new Exit(`Invalid URL: ${url}`);
+    }
+  }
+
+  private validateRunnerCount(count?: number) {
+    if (count !== undefined && count < 1) {
+      throw new Exit("Runner count must be at least 1");
+    }
+  }
+
+  private detectOs() {
+    const platform = process.platform;
+    if (platform === "darwin") return "osx" as const;
+    if (platform === "win32") return "windows" as const;
+    return "linux" as const;
+  }
+}