feat(hydra): add update command to upgrade runner binaries

Author: deralaxo

packages/hydra/src/cli.ts

@@ -8,6 +8,7 @@ import {
   StartCommand,
   StatusCommand,
   StopCommand,
+  UpdateCommand,
 } from "./commands";
 import { CLI_BIN, DEFAULT_CONFIG, HYDRA_CONFIG_FILE } from "./constants";
 import type { HydraConfig } from "./types";
@@ -33,6 +34,7 @@ class HydraCLI extends AbstractCLI {
       new StopCommand(),
       new StatusCommand(),
       new RemoveCommand(),
+      new UpdateCommand(),
       new ProfileCommand(),
     ]);
   }

packages/hydra/src/commands/index.ts

@@ -5,3 +5,4 @@ export { RemoveCommand } from "./remove";
 export { StartCommand } from "./start";
 export { StatusCommand } from "./status";
 export { StopCommand } from "./stop";
+export { UpdateCommand } from "./update";

packages/hydra/src/commands/update.ts

@@ -0,0 +1,66 @@
+import { color, Exit, log, spinner } from "@r5n/cli-core";
+import { BaseCommand, type Ctx } from "../base-command";
+import { createProvider } from "../providers";
+import type { Profile } from "../types";
+
+type UpdateCtx = Ctx;
+
+export class UpdateCommand extends BaseCommand {
+  name = "update";
+  description = "Update runners to the latest version";
+
+  async execute(ctx: UpdateCtx) {
+    const profiles = ctx.config.get("profiles");
+    const entries = ctx.config.get("runners") ?? [];
+
+    if (entries.length === 0) {
+      throw new Exit("No runners found", "Run hydra create to provision runners");
+    }
+
+    const s = spinner();
+    const byProfile = Map.groupBy(entries, (e) => e.profile);
+    let currentVersion: string | null = null;
+    let latestVersion = "";
+    let versionChecked = false;
+
+    for (const [profileName, profileEntries] of byProfile) {
+      const profile = profiles[profileName] as Profile | undefined;
+      const firstRunner = profileEntries[0];
+      if (!profile || !firstRunner) continue;
+
+      const provider = createProvider(profile);
+
+      if (!versionChecked) {
+        versionChecked = true;
+        s.start("Checking for updates...");
+        const result = await provider.download();
+        latestVersion = result.version;
+        currentVersion = await provider.currentVersion(firstRunner.id);
+        s.stop(`Current: v${currentVersion ?? "unknown"} | Latest: v${latestVersion}`);
+
+        if (currentVersion === latestVersion) {
+          log.info(`Already on latest version ${color.dim(`(v${latestVersion})`)}`);
+          return;
+        }
+      }
+
+      const statuses = await provider.list();
+      const runningIds = new Set(statuses.filter((r) => r.status === "running").map((r) => r.id));
+
+      for (const entry of profileEntries) {
+        const wasRunning = runningIds.has(entry.id);
+
+        s.start(`Updating ${entry.id}...`);
+
+        if (wasRunning) await provider.stop([entry.id]);
+        await provider.update([entry.id]);
+        if (wasRunning) await provider.start([entry.id]);
+
+        const suffix = wasRunning ? ` ${color.dim("(restarted)")}` : "";
+        s.stop(`${color.green("✓")} ${entry.id}${suffix}`);
+      }
+    }
+
+    log.info(`${color.green("Updated")} ${entries.length} runner(s) from v${currentVersion} to v${latestVersion}`);
+  }
+}

packages/hydra/src/providers/GitHubRunnerProvider.ts

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { cp, link, mkdir, readdir, readFile, symlink, unlink, writeFile } from "node:fs/promises";
+import { cp, link, mkdir, readdir, readFile, readlink, rm, symlink, unlink, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { SHARED_DIR } from "../constants";
 import type { Profile } from "../types";
@@ -104,6 +104,21 @@ export class GitHubRunnerProvider implements RunnerProvider {
     return runners;
   }
 
+  async currentVersion(id: string): Promise<string | null> {
+    const runnerDir = join(this.profile.directory, id);
+    return this.detectVersion(runnerDir);
+  }
+
+  async update(ids: string[]): Promise<void> {
+    const sharedPath = await this.ensureDownloaded();
+
+    for (const id of ids) {
+      const runnerDir = join(this.profile.directory, id);
+      await this.removeRunnerBinaries(runnerDir);
+      await this.setupRunnerDir(sharedPath, runnerDir);
+    }
+  }
+
   private async getRunnerStatus(runnerDir: string, id: string): Promise<RunnerInfo> {
     const name = await this.readRunnerName(runnerDir);
     const pid = await this.readPidFile(runnerDir);
@@ -240,6 +255,31 @@ export class GitHubRunnerProvider implements RunnerProvider {
     }
   }
 
+  private async detectVersion(runnerDir: string): Promise<string | null> {
+    try {
+      const target = await readlink(join(runnerDir, "externals"));
+      const match = target.match(/github\/([^/]+)/);
+      return match?.[1] ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async removeRunnerBinaries(runnerDir: string) {
+    for (const dir of HARDLINK_DIRS) {
+      await rm(join(runnerDir, dir), { force: true, recursive: true });
+    }
+    for (const dir of SYMLINK_DIRS) {
+      await rm(join(runnerDir, dir), { force: true });
+    }
+    for (const pattern of ["*.sh", "*.sh.template"]) {
+      const files = await Array.fromAsync(new Bun.Glob(pattern).scan(runnerDir));
+      for (const file of files) {
+        await rm(join(runnerDir, file), { force: true });
+      }
+    }
+  }
+
   private stripBom(content: string) {
     return content.replace(/^\uFEFF/, "");
   }

packages/hydra/src/providers/types.ts

@@ -11,4 +11,6 @@ export interface RunnerProvider {
   start(ids: string[]): Promise<void>;
   stop(ids: string[]): Promise<void>;
   list(): Promise<RunnerInfo[]>;
+  currentVersion(id: string): Promise<string | null>;
+  update(ids: string[]): Promise<void>;
 }