@viraatdas/rudder 3.0.3 → 3.1.3

package/README.md

@@ -479,6 +479,7 @@ control surface; you decide whether a task runs locally or is handed to the clou
 rudder login                 # sign in with Google (opens straight to the account picker)
 rudder cloud                 # open this repo on your home machine and attach to it
 rudder cloud home            # home machine status: projects, agents, previews
+rudder cloud move            # move this repo's running agents to the home machine
 rudder cloud app             # the phone app link
 rudder cloud list            # list cloud workers
 rudder cloud logs <id>       # worker status
@@ -503,7 +504,9 @@ machine of its own.
 
 **Phone.** Open `rudder cloud app` on your phone and sign in with the same
 Google account. You see every project and agent, read conversations as they
-happen, text any agent, start tasks, stop or merge, and open previews. Claude
+happen, text any agent, start tasks (`/model` picks Claude or Codex for new ones),
+stop, merge or delete agents (swipe left), and open previews. A message that can't
+reach an agent (a menu is open in its pane) says so instead of vanishing. Claude
 panes in the cloud also run with Remote Control, so they appear in the Claude
 app too.
 
@@ -520,11 +523,16 @@ running when this laptop disconnects (`/cloud off` returns to local workers).
 selected auth/config) so the whole dashboard runs on a cloud machine. Completed
 cloud work returns through the same review and merge path as local work.
 
-Bare `/handoff` moves the **selected agent pane** to Rudder Cloud: the local
-worker is quiesced, its workspace and Claude session upload with the snapshot,
-and the pane reattaches to a cloud machine that resumes the same conversation
-(`claude --resume`) — so the work keeps going after this laptop disconnects.
-(`/handoff <session-id>` still adopts an outside CLI chat, like `/resume`.)
+**Taking agents with you.** About to close the laptop? Press `H` in the
+dashboard and every running agent moves to your home machine: its work so far
+(the jj change, including unpushed local changes it builds on) and its
+conversation go along, nothing is pushed to GitHub, and the conversation resumes
+there, so it keeps going with the laptop closed. Quitting with agents running
+offers the same thing ("3 agents are running here. Move them to the home
+machine?"), and `rudder cloud` in a repo with agents asks too. Bare `/handoff`
+moves just the selected agent. (`/handoff <session-id>` still adopts an outside
+CLI chat, like `/resume`.) Delete an agent anywhere (`dd` here, swipe left on the
+phone) and it is gone everywhere.
 
 Cloud comes in two shapes: a **sail** is an ephemeral, task-scoped worker (it goes away
 when the task is done; idle sails pause and can resume), while a **workspace** is a

package/dist/cloud.d.ts

@@ -1,4 +1,6 @@
 import { type MigrationCandidate, type MigrationPlan } from "./migration.js";
+import { type MoveCandidate } from "./move-home.js";
+import type { JsonValue } from "./types.js";
 type CloudCommandOptions = {
     json?: boolean;
     homePaths?: string[];
@@ -6,9 +8,18 @@ type CloudCommandOptions = {
     noAttach?: boolean;
     quietBanner?: boolean;
     latencyProbe?: boolean;
+    /** Coming back to a repo already open on the home machine: skip the first-run offers. */
+    reattach?: boolean;
     /** Skip the y/N confirmation of a destructive command (`--yes`/`--force`). */
     yes?: boolean;
 };
+type CloudClient = {
+    baseUrl: string;
+    request<T>(pathOrUrl: string, init: {
+        method: string;
+        body?: JsonValue;
+    }): Promise<T>;
+};
 export declare function runCloudCommand(command: string, args: string[], options?: CloudCommandOptions): Promise<void>;
 /**
  * Scope a fleet migration plan down to one run: only `runId` moves, every
@@ -25,4 +36,12 @@ export declare function copyRudderState(repoRoot: string, repoStage: string, onl
     runs: number;
     files: string[];
 }>;
+/** Bundle, upload, wait for the home machine to stage them, then hand the local records over. */
+export declare function moveAgentsToHome(client: CloudClient, repoRoot: string, slug: string, candidates: MoveCandidate[], options: CloudCommandOptions): Promise<{
+    adopted: string[];
+    failed: Array<{
+        runId: string;
+        error: string;
+    }>;
+}>;
 export {};

package/dist/cloud.js

@@ -1,11 +1,12 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import fsp from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { WebSocket } from "ws";
 import { currentBranch, currentCommit, findRepoRoot } from "./git.js";
 import { applyDefaultDecisions, buildFreshHandoffPrompt, cloudWorkspaceAbsolutePath, findMigrationCandidates, formatCandidateReason, migrationSummary, summaryAsJson, } from "./migration.js";
+import { buildMoveBundle, findMoveCandidates, markRunsMovedHome } from "./move-home.js";
 import { cloudAuthPath } from "./state.js";
 import { ensureDir, commandExists, expandHome, isTty, newRunId, nowIso, pathExists, promptConfirm, promptText, promptSelect, promptSecret, readJson, runCommand, shortenHome, shellQuote, writeJson, } from "./util.js";
 const DEFAULT_LOGIN_INTERVAL_MS = 2000;
@@ -17,6 +18,9 @@ const DEFAULT_HOME_PATHS = [
     // Agent CLIs
     "~/.claude/.credentials.json",
     "~/.claude/settings.json",
+    // Hook scripts settings.json points at; the home machine rewrites their
+    // /Users/<name> paths to its own home (cloud/worker/hook-paths.mjs).
+    "~/.claude/hooks",
     "~/.claude/CLAUDE.md",
     "~/.claude.json",
     "~/.codex/auth.json",
@@ -180,6 +184,9 @@ export async function runCloudCommand(command, args, options = {}) {
         case "onload":
             await onload(rest, options);
             return;
+        case "move":
+            await moveCommand(rest, options);
+            return;
         case "bootstrap":
             await bootstrap(rest, options);
             return;
@@ -544,6 +551,9 @@ async function handoffRunToCloud(repoRoot, runId, options) {
             body,
         });
         await printResult(result, options);
+        // The sail owns the conversation now. The dashboard watches this record
+        // for exactly that ("migrated") instead of assuming it at spawn time.
+        await markRunsMigrated(repoRoot, [runId]);
         await maybeAutoAttach(result, options);
         // The handoff SUCCEEDED the moment the sail launched: the cloud machine
         // owns the conversation now. An attach that drops afterwards (network
@@ -2728,10 +2738,17 @@ async function workspaceList(options) {
 async function attach(args, options) {
     const sailId = args[0];
     if (!sailId) {
-        throw new Error("Usage: rudder cloud attach <id>");
+        // In a repo, `rudder cloud attach` is coming back to it: open it on the
+        // home machine (waking it if needed) and attach, without the first-run
+        // offers `rudder cloud` makes.
+        await openOnHome(false, { ...options, reattach: true });
+        return;
     }
     await runAttach({ kind: "sail", id: sailId, label: sailId }, options);
 }
+const ATTACH_PING_MS = 5_000;
+const ATTACH_PONG_TIMEOUT_MS = 20_000;
+const ATTACH_SLEEP_GAP_MS = 15_000;
 // The remote TUI pushes the kitty keyboard enhancement flags once, in its own
 // setup_terminal(), and the worker only keeps the TAIL of its output — so by the
 // time an attach connects, that push is long gone and this terminal never sees
@@ -2750,7 +2767,7 @@ function containsCtrlCInput(data) {
 async function attachWithReconnect(target, options, reopen) {
     let result = await runAttach(target, { ...options, quietBanner: false });
     let attempts = 0;
-    while (result === "dropped" && attempts < 40) {
+    while (result === "dropped" && attempts < 120) {
         attempts += 1;
         process.stderr.write(`\r\nLost the connection to Rudder Cloud (it may be restarting). Reconnecting${attempts > 1 ? ` (try ${attempts})` : ""}...\r\n`);
         await sleep(Math.min(15_000, 2_000 * attempts));
@@ -2901,11 +2918,40 @@ async function runAttach(target, options) {
             }
             splash?.redraw();
         };
+        // Liveness. A laptop that slept leaves this socket half-open: nothing
+        // errors, the screen just freezes, and the relay has meanwhile dropped us
+        // (or handed control to the next terminal). Ping the relay, and treat a
+        // missed pong or a timer that fired far too late (the machine was asleep)
+        // as a dropped connection, which attachWithReconnect reopens.
+        let lastHeard = Date.now();
+        let lastTick = Date.now();
+        socket.on("pong", () => { lastHeard = Date.now(); });
+        socket.on("message", () => { lastHeard = Date.now(); });
+        const liveness = setInterval(() => {
+            const now = Date.now();
+            const slept = now - lastTick > ATTACH_SLEEP_GAP_MS;
+            lastTick = now;
+            if (socket.readyState !== WebSocket.OPEN) {
+                return;
+            }
+            if (slept || now - lastHeard > ATTACH_PONG_TIMEOUT_MS) {
+                socket.terminate();
+                return;
+            }
+            try {
+                socket.ping();
+            }
+            catch {
+                socket.terminate();
+            }
+        }, ATTACH_PING_MS);
+        liveness.unref?.();
         const cleanup = () => {
             if (cleaned) {
                 return;
             }
             cleaned = true;
+            clearInterval(liveness);
             stdin.off("data", onStdin);
             stdout.off("resize", onResize);
             process.off("SIGINT", onSigint);
@@ -3407,6 +3453,10 @@ Usage:
       holds every repo) and attach to its dashboard. --snapshot uploads this
       folder to its own machine instead.
   rudder cloud home [status|start|stop|open <owner/repo>]
+  rudder cloud move [runId...] [--yes]
+      move this repo's unfinished agents (or just the named ones) to the
+      home machine: their jj changes and conversations go along, nothing is
+      pushed to GitHub, and they keep working with this laptop closed
   rudder cloud app
       a one-time code that signs the phone app in to this account
   rudder cloud doctor
@@ -3425,7 +3475,7 @@ Usage:
       resumes its conversation there; no runId uploads the current
       Rudder workspace state
   rudder cloud logs <id>
-  rudder cloud attach <id>
+  rudder cloud attach [id]        (no id: reattach this repo on the home machine)
       stream the live cloud worker terminal into this pane
   rudder cloud talk <id> "<message>"
       send a message to a running instance and show its reply
@@ -3509,6 +3559,15 @@ function cloudNameFromTask(task) {
         .replace(/-+$/g, "");
     return slug || randomCloudName();
 }
+async function repoOpenOnHome(client, slug) {
+    try {
+        const result = await client.request("/api/rudder/home", { method: "GET" });
+        return (result.projects ?? []).some((project) => String(project.repo ?? "").toLowerCase() === slug.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}
 async function openOnHome(forceSnapshot, options) {
     if (forceSnapshot) {
         await workspaceAttach([], options);
@@ -3525,11 +3584,21 @@ async function openOnHome(forceSnapshot, options) {
     }
     const client = await cloudClient({ requireToken: true });
     const name = slug.split("/")[1];
+    // Coming back (laptop reopened, terminal closed): a repo already open on
+    // the home machine reattaches straight away, like `rudder cloud attach`.
+    // Credentials are still compared, and running local agents still offered a
+    // move, because those are about this laptop now.
+    const reattach = options.reattach || await repoOpenOnHome(client, slug);
     if (!options.json) {
-        await warnLocalOnlyWork(repoRoot);
+        if (!reattach) {
+            await warnLocalOnlyWork(repoRoot);
+        }
         await ensureVaultGithubToken(client, slug);
         await ensureVaultAws(client);
-        await offerEnvFilesToVault(client, repoRoot, name);
+        if (!reattach) {
+            await offerEnvFilesToVault(client, repoRoot, name);
+        }
+        await offerToMoveAgents(client, repoRoot, slug);
         process.stderr.write(`Opening ${slug} on your home machine...\n`);
     }
     const branch = await pushedBranch(repoRoot);
@@ -3615,9 +3684,15 @@ async function ensureVaultAws(client) {
     if (changed.length === 0) {
         return;
     }
-    const yes = await promptConfirm(`Your AWS setup (${changed.map((file) => file.name).join(", ")}) differs from the cloud vault's copy. Copy it so cloud agents use the same AWS?`, true);
-    if (!yes) {
-        return;
+    // Asked once. After AWS is in the vault, keeping it matched with this laptop
+    // is the point (rotating SSO/session credentials change it daily), so later
+    // changes are copied without a prompt on every `rudder cloud`.
+    const alreadyShared = files.some((file) => stored.has(file.name));
+    if (!alreadyShared) {
+        const yes = await promptConfirm(`Your AWS setup (${changed.map((file) => file.name).join(", ")}) differs from the cloud vault's copy. Copy it so cloud agents use the same AWS?`, true);
+        if (!yes) {
+            return;
+        }
     }
     for (const file of changed) {
         await client.request("/api/rudder/secrets/item", {
@@ -3638,7 +3713,7 @@ async function localGithubToken() {
 // The cloud machine clones from GitHub, so a private repo needs a GitHub token
 // in the vault. gh keeps its token in the OS keychain (hosts.yml has none), so
 // it never arrived with the synced gh config; offer to put it there.
-async function ensureVaultGithubToken(client, slug) {
+async function ensureVaultGithubToken(client, slug, interactive = true) {
     const vault = await client.request("/api/rudder/secrets", { method: "GET" }).catch(() => null);
     if (!vault || (vault.secrets ?? []).some((secret) => secret.name === "GH_TOKEN" || secret.name === "GITHUB_TOKEN")) {
         return;
@@ -3648,7 +3723,7 @@ async function ensureVaultGithubToken(client, slug) {
         process.stderr.write(`The cloud vault has no GitHub token, so private repos can't be cloned there. Run \`gh auth login\` here, or \`rudder cloud secrets set GH_TOKEN\`.\n`);
         return;
     }
-    if (!isTty()) {
+    if (!isTty() || !interactive) {
         process.stderr.write("The cloud vault has no GitHub token; private repos will fail to clone. Run `rudder cloud secrets sync` from a terminal.\n");
         return;
     }
@@ -3662,6 +3737,211 @@ async function ensureVaultGithubToken(client, slug) {
     });
     process.stderr.write("Stored GH_TOKEN in the cloud vault.\n");
 }
+const HOME_MOVE_POLL_MS = 1500;
+const HOME_MOVE_DEADLINE_MS = 15 * 60 * 1000;
+async function moveCommand(args, options) {
+    const yes = options.yes || args.includes("--yes") || args.includes("-y");
+    const runIds = args.filter((arg) => !arg.startsWith("-"));
+    const repoRoot = findRepoRoot();
+    const slug = await githubSlugFromOrigin(repoRoot);
+    if (!slug) {
+        throw new Error("This repo has no GitHub origin, so the home machine can't clone it. `rudder cloud workspace attach` moves agents into a snapshot workspace instead.");
+    }
+    const candidates = await findMoveCandidates(repoRoot, runIds.length > 0 ? runIds : undefined);
+    const missing = runIds.filter((id) => !candidates.some((candidate) => candidate.runId === id));
+    if (missing.length > 0) {
+        throw new Error(`Not movable (finished, not in a workspace of its own, or unknown): ${missing.join(", ")}`);
+    }
+    if (candidates.length === 0) {
+        if (!options.json) {
+            process.stderr.write("No unfinished agents with workspaces of their own to move.\n");
+        }
+        return;
+    }
+    if (!yes && !options.json) {
+        if (!isTty()) {
+            throw new Error("Refusing to move agents without a terminal to confirm in; pass --yes.");
+        }
+        process.stderr.write(`${describeMoveCandidates(candidates)}\n`);
+        if (!(await promptConfirm(`Move ${agentCount(candidates.length)} to the home machine?`, true))) {
+            process.stderr.write("Nothing moved.\n");
+            return;
+        }
+    }
+    const client = await cloudClient({ requireToken: true });
+    if (!options.json) {
+        await ensureVaultGithubToken(client, slug, !yes);
+    }
+    const moved = await moveAgentsToHome(client, repoRoot, slug, candidates, options);
+    if (options.json) {
+        printJson(moved);
+    }
+    if (moved.adopted.length === 0) {
+        process.exitCode = 1;
+    }
+}
+function agentCount(count) {
+    return `${count} agent${count === 1 ? "" : "s"}`;
+}
+function describeMoveCandidates(candidates) {
+    return candidates
+        .map((candidate) => `  ${candidate.status.padEnd(8)} ${(candidate.taskSummary || candidate.task || candidate.runId).replace(/\s+/g, " ").slice(0, 72)}`)
+        .join("\n");
+}
+/** Bundle, upload, wait for the home machine to stage them, then hand the local records over. */
+export async function moveAgentsToHome(client, repoRoot, slug, candidates, options) {
+    const say = (line) => {
+        if (!options.json) {
+            process.stderr.write(`${line}\n`);
+        }
+    };
+    const stageDir = await fsp.mkdtemp(path.join(os.tmpdir(), "rudder-move-stage-"));
+    const archiveDir = await fsp.mkdtemp(path.join(os.tmpdir(), "rudder-move-"));
+    let job;
+    try {
+        say(`Packing ${agentCount(candidates.length)} (their jj changes and conversations)...`);
+        await buildMoveBundle(repoRoot, candidates, stageDir);
+        const archivePath = path.join(archiveDir, "move.tgz");
+        await runCommand("tar", ["-czf", archivePath, "-C", stageDir, "."], { cwd: stageDir });
+        const branch = await pushedBranch(repoRoot);
+        job = await client.request("/api/rudder/home/move", {
+            method: "POST",
+            body: {
+                repo: slug,
+                ...(branch ? { branch } : {}),
+                bundle: await fsp.readFile(archivePath, "base64"),
+            },
+        });
+    }
+    finally {
+        await fsp.rm(stageDir, { recursive: true, force: true });
+        await fsp.rm(archiveDir, { recursive: true, force: true });
+    }
+    const moveId = job.move?.id;
+    if (!moveId) {
+        throw new Error("the control plane did not start the move");
+    }
+    const deadline = Date.now() + HOME_MOVE_DEADLINE_MS;
+    let lastDetail = "";
+    while (job.move?.status !== "done" && job.move?.status !== "failed") {
+        if (Date.now() > deadline) {
+            throw new Error("the home machine did not take the agents in time; they stay here");
+        }
+        const detail = job.move?.detail ?? "";
+        if (detail && detail !== lastDetail) {
+            say(detail);
+            lastDetail = detail;
+        }
+        await new Promise((resolve) => setTimeout(resolve, HOME_MOVE_POLL_MS));
+        job = await client.request(`/api/rudder/home/move/${encodeURIComponent(moveId)}`, { method: "GET" });
+    }
+    if (job.move?.status === "failed") {
+        throw new Error(`the home machine could not take the agents: ${job.move.error || "unknown error"}`);
+    }
+    const adopted = (job.move?.result?.adopted ?? []).map((entry) => entry.runId);
+    const failed = job.move?.result?.failed ?? [];
+    await markRunsMovedHome(repoRoot, adopted, slug);
+    if (adopted.length > 0) {
+        const fresh = (job.move?.result?.adopted ?? []).filter((entry) => entry.resumable === false).length;
+        say(`Moved ${agentCount(adopted.length)} to the home machine. They keep working there with this laptop closed.`);
+        if (fresh > 0) {
+            say(`${agentCount(fresh)} had no saved conversation and restart from a handoff over their diff.`);
+        }
+        say(`Watch them: \`rudder cloud\` here, or on your phone: ${appUrl(client.baseUrl)}`);
+    }
+    for (const entry of failed) {
+        say(`Could not move ${entry.runId}: ${entry.error}. It stays here.`);
+    }
+    return { adopted, failed };
+}
+/**
+ * `rudder cloud` in a repo with agents: offer to take them along. A live
+ * dashboard owns its agents' processes, so it does the move (it pauses them
+ * first); with no dashboard running the agents are already stopped and this
+ * process can move them itself.
+ */
+async function offerToMoveAgents(client, repoRoot, slug) {
+    if (!isTty() || process.env.RUDDER_CLOUD_RUNTIME === "home" || process.env.RUDDER_CLOUD_NO_MOVE_OFFER === "1") {
+        return;
+    }
+    const candidates = await findMoveCandidates(repoRoot).catch(() => []);
+    if (candidates.length === 0) {
+        return;
+    }
+    const dashboardLive = await dashboardServing(repoRoot);
+    const running = candidates.filter((candidate) => candidate.status === "running");
+    if (dashboardLive && running.length > 0) {
+        const yes = await promptConfirm(`${agentCount(running.length)} ${running.length === 1 ? "is" : "are"} running here. Move them to the home machine?`, true);
+        if (!yes) {
+            return;
+        }
+        const receipt = await requestDashboardMove(repoRoot);
+        process.stderr.write(receipt === "failed"
+            ? "The dashboard could not start the move; press H there to try again.\n"
+            : "The dashboard is moving them; they appear on the home machine as they land.\n");
+        return;
+    }
+    if (dashboardLive) {
+        return;
+    }
+    process.stderr.write(`${describeMoveCandidates(candidates)}\n`);
+    const yes = await promptConfirm(`${agentCount(candidates.length)} ${candidates.length === 1 ? "was" : "were"} left unfinished here. Move them to the home machine?`, true);
+    if (!yes) {
+        return;
+    }
+    try {
+        await moveAgentsToHome(client, repoRoot, slug, candidates, {});
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    }
+}
+async function dashboardServing(repoRoot) {
+    let socketPath;
+    try {
+        socketPath = await fsp.realpath(path.join(repoRoot, ".rudder", "attach.sock"));
+    }
+    catch {
+        return false;
+    }
+    const net = await import("node:net");
+    return await new Promise((resolve) => {
+        const socket = net.connect(socketPath);
+        const timer = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 500);
+        socket.once("connect", () => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", () => {
+            clearTimeout(timer);
+            resolve(false);
+        });
+    });
+}
+/** Ask the live dashboard (through its steer inbox) to move every agent it is running. */
+async function requestDashboardMove(repoRoot) {
+    const requestId = randomUUID();
+    const inbox = path.join(repoRoot, ".rudder", "steer");
+    await ensureDir(inbox);
+    const file = path.join(inbox, `${String(Date.now()).padStart(13, "0")}-move-home-${requestId}.json`);
+    const temp = `${file}.${process.pid}.tmp`;
+    await fsp.writeFile(temp, JSON.stringify({ requestId, kind: "move-home", taskId: "", instruction: "move-home", ts: nowIso() }));
+    await fsp.rename(temp, file);
+    const receiptPath = path.join(repoRoot, ".rudder", "steer-receipts", `${requestId}.json`);
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const receipt = await readJson(receiptPath);
+        if (receipt?.status === "delivered" || receipt?.status === "failed") {
+            return receipt.status;
+        }
+    }
+    return "queued";
+}
 async function localIdentities() {
     const [github, claude] = await Promise.all([
         commandExists("gh")
@@ -3852,6 +4132,56 @@ async function printAppLink(options) {
                or open ${pairing.link}
   Browser:     ${pairing.url}`);
 }
+/**
+ * `rudder cloud home runs <runId...>`: which of these agents (moved here from a
+ * laptop) still exist on the home machine; `known: false` when it cannot
+ * answer, which callers must read as "unknown", never "deleted".
+ * `rudder cloud home delete <runId...>`: delete them there, through that repo's
+ * dashboard, which also takes them off the phone. Queued if the machine is
+ * asleep. This is what `dd` on a moved row in the laptop's dashboard runs.
+ */
+async function homeAgentsCommand(client, sub, args, options) {
+    const yes = options.yes || args.includes("--yes") || args.includes("-y");
+    const runIds = args.filter((arg) => !arg.startsWith("-"));
+    if (runIds.length === 0) {
+        throw new Error(`Usage: rudder cloud home ${sub} <runId...>`);
+    }
+    const repo = await githubSlugFromOrigin(findRepoRoot());
+    if (!repo) {
+        throw new Error("This repo has no GitHub origin, so none of its agents live on the home machine.");
+    }
+    if (sub === "delete" && !yes && !options.json) {
+        if (!isTty()) {
+            throw new Error("Refusing to delete agents without a terminal to confirm in; pass --yes.");
+        }
+        if (!(await promptConfirm(`Delete ${runIds.length === 1 ? "this agent" : `${runIds.length} agents`} on the home machine? This cannot be undone.`, false))) {
+            console.log("Nothing deleted.");
+            return;
+        }
+    }
+    const result = await client.request("/api/rudder/home/agents", {
+        method: "POST",
+        body: { repo, action: sub === "runs" ? "check" : "delete", runIds },
+    });
+    if (options.json) {
+        printJson(result);
+        return;
+    }
+    if (sub === "runs") {
+        if (!result.known) {
+            console.log("The home machine is not connected, so it can't say.");
+            return;
+        }
+        const existing = new Set(result.existing ?? []);
+        for (const id of runIds) {
+            console.log(`${existing.has(id) ? "there " : "gone  "} ${id}`);
+        }
+        return;
+    }
+    console.log(result.status === "queued"
+        ? "The home machine is asleep; it deletes them as soon as it is back."
+        : "Deleted on the home machine.");
+}
 async function homeCommand(args, options) {
     const client = await cloudClient({ requireToken: true });
     const sub = args[0] ?? "status";
@@ -3885,8 +4215,12 @@ async function homeCommand(args, options) {
         }
         return;
     }
+    if (sub === "runs" || sub === "delete") {
+        await homeAgentsCommand(client, sub, args.slice(1), options);
+        return;
+    }
     if (sub !== "status") {
-        throw new Error("Usage: rudder cloud home [status|start|stop|open <owner/repo>]");
+        throw new Error("Usage: rudder cloud home [status|start|stop|open <owner/repo>|runs <runId...>|delete <runId...>]");
     }
     const result = await client.request("/api/rudder/home", { method: "GET" });
     if (options.json) {