@mycadet/cli 0.12.10 → 0.13.0

package/src/commands/tunnel.ts

@@ -10,6 +10,7 @@ import {
 import {
   formatAssistantReference,
   loadAllAssistants,
+  readRootProcesses,
   resolveTargetAssistant,
   type AssistantEntry,
 } from "../lib/assistant-config";
@@ -37,6 +38,8 @@ import {
   hasWebhookIntegrationsConfigured,
   providerSupportsReservedDomain,
   runProviderTunnel,
+  stopTunnelProcess,
+  summarizeStartupFailure,
 } from "../lib/tunnel.js";
 
 // The accepted `--provider` values ARE the shared registry, so validation
@@ -63,7 +66,7 @@ function parseArgs(): TunnelArgs {
     const arg = args[i];
     if (arg === "--help" || arg === "-h") {
       console.log(
-        "Usage: cadet tunnel [<name>] --provider <provider> [options]",
+        "Usage: cadet tunnel [<name>] --provider <provider> [options]\n       cadet tunnel stop [<name>]",
       );
       console.log("");
       console.log("Front a locally running assistant with an HTTPS tunnel.");
@@ -121,7 +124,7 @@ function parseArgs(): TunnelArgs {
         `                                URL, and logs stream to tunnel.log in the CLI log directory. A background`,
       );
       console.log(
-        "                                tunnel stops with `kill <pid>`, except when it adopted an already-running",
+        "                                tunnel stops with `cadet tunnel stop`, except when it adopted an already-running",
       );
       console.log(
         "                                tunnel (started outside this command): killing the supervisor then",
@@ -394,9 +397,17 @@ async function spawnDetachedTunnel(): Promise<void> {
   });
 
   if (exitCode !== undefined) {
+    let logText = "";
+    try {
+      logText = readFileSync(logPath, "utf-8");
+    } catch {
+      // Log file not readable — the summary falls back to none.
+    }
+    const reason = summarizeStartupFailure(logText);
     console.error(
-      `Error: tunnel process exited during startup${exitCode !== null ? ` (exit code ${exitCode})` : ""}. Logs: ${logPath}`,
+      `Error (${exitCode ?? "unknown"}): tunnel process exited during startup${reason ? `: ${reason}` : "."}`,
     );
+    console.error(`Logs: ${logPath}`);
     process.exit(1);
   }
 
@@ -411,12 +422,40 @@ async function spawnDetachedTunnel(): Promise<void> {
   if (adopted) {
     console.log(adoptedTunnelStopNotice(child.pid));
   } else {
-    console.log(`Stop with: kill ${child.pid}`);
+    console.log("Stop with: cadet tunnel stop");
   }
 }
 
 export const tunnel = Object.assign(
   async function tunnel(): Promise<void> {
+    if (process.argv[3] === "stop") {
+      const args = process.argv.slice(4);
+      if (args.includes("--help") || args.includes("-h")) {
+        console.log("Usage: cadet tunnel stop [<name>]");
+        console.log(
+          "Stop the recorded Cadet-managed tunnel, keeping nginx and the saved domain.",
+        );
+        return;
+      }
+      if (args.some((arg) => arg.startsWith("-")))
+        throw new Error("Usage: cadet tunnel stop [<name>]");
+      const { entry, workspaceDir } = resolveLocalTunnelTarget(
+        args.join(" ") || null,
+      );
+      if (!readRootProcesses().tunnel) {
+        console.log(
+          "No Cadet-managed tunnel is recorded. Externally started tunnels must be stopped directly.",
+        );
+        return;
+      }
+      const stopped = await stopTunnelProcess(entry.assistantId, workspaceDir);
+      console.log(
+        stopped
+          ? "Tunnel stopped. nginx and the saved domain are unchanged."
+          : "No running tunnel found; cleared stale tunnel state.",
+      );
+      return;
+    }
     const { assistantName, provider, domain, clearDomain, foreground } =
       parseArgs();
 

package/src/commands/upgrade.ts

@@ -22,6 +22,7 @@ import {
   pullImage,
   startContainers,
   stopContainers,
+  sleepContainers,
 } from "../lib/docker";
 import {
   fetchLatestStableVersion,
@@ -67,6 +68,7 @@ import {
   stripVersionPrefix,
   versionsEqual,
 } from "../lib/version-compat.js";
+import { fetchCurrentVersion } from "../lib/http-client.js";
 import { loopbackSafeFetch } from "../lib/loopback-fetch.js";
 import {
   generateLocalSigningKey,
@@ -76,7 +78,10 @@ import {
   startLocalDaemon,
   stopLocalProcesses,
 } from "../lib/local.js";
-import { restoreTunnelEdgeAndAutoTunnel } from "../lib/tunnel.js";
+import {
+  restoreContainerTunnelEdge,
+  restoreTunnelEdgeAndAutoTunnel,
+} from "../lib/tunnel.js";
 import {
   leaseGuardianToken,
   resetGuardianBootstrap,
@@ -114,7 +119,7 @@ function parseArgs(): UpgradeArgs {
       console.log("Usage: cadet upgrade [<name>] [options]");
       console.log("");
       console.log("Upgrade an assistant to a newer version.");
-      console.log("To roll back to a previous version, use `cadet rollback`.");
+      console.log("To roll back to a previous version, use `cadet restore` with a backup.");
       console.log("");
       console.log("Arguments:");
       console.log(
@@ -291,7 +296,7 @@ async function upgradeDocker(
   }
 
   // Reject downgrades — `cadet upgrade` only handles forward version changes.
-  // Users should use `cadet rollback --version <version>` for downgrades.
+  // Downgrades require a versioned backup restore.
   if (!currentVersion && versionTag) {
     console.warn(
       "⚠️  Could not determine current version from health endpoint — skipping version-direction check.\n",
@@ -300,7 +305,7 @@ async function upgradeDocker(
   if (currentVersion && versionTag) {
     const cmp = compareVersions(versionTag, currentVersion);
     if (cmp !== null && cmp < 0) {
-      const msg = `Cannot upgrade to an older version (${versionTag} < ${currentVersion}). Use \`cadet rollback --version ${versionTag}\` instead.`;
+      const msg = `Cannot upgrade to an older version (${versionTag} < ${currentVersion}). Use \`cadet restore --from <backup-path> --version ${versionTag}\` instead.`;
       console.error(msg);
       emitCliError("VERSION_DIRECTION", msg);
       process.exit(1);
@@ -342,22 +347,6 @@ async function upgradeDocker(
     );
   }
 
-  // Persist rollback state to lockfile BEFORE any destructive changes.
-  // This enables the `cadet rollback` command to restore the previous version.
-  if (entry.containerInfo) {
-    const rollbackEntry: AssistantEntry = {
-      ...entry,
-      previousContainerInfo: { ...entry.containerInfo },
-      previousVersion: currentVersion,
-      previousDbMigrationVersion: preMigrationState.dbVersion,
-      previousWorkspaceMigrationId: preMigrationState.lastWorkspaceMigrationId,
-    };
-    saveAssistantEntry(rollbackEntry);
-    if (currentVersion) {
-      console.log(`   Saved rollback state: ${currentVersion}\n`);
-    }
-  }
-
   // Record version transition start in workspace git history
   await commitWorkspaceViaGateway(
     entry.runtimeUrl,
@@ -437,7 +426,7 @@ async function upgradeDocker(
   const assistantPort =
     entry.containerInfo?.assistantPort ?? ASSISTANT_INTERNAL_PORT;
 
-  // Create pre-upgrade backup (best-effort, daemon must be running)
+  // Capture complete persistent roots before replacing any services.
   await broadcastUpgradeEvent(
     entry.runtimeUrl,
     entry.assistantId,
@@ -453,20 +442,7 @@ async function upgradeDocker(
     // Clean up old pre-upgrade backups, keep last 3
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
-  }
-
-  // Persist the backup path so `cadet rollback` can restore the exact backup
-  // created for this upgrade attempt — never a stale backup from a prior cycle.
-  // Re-read the entry to pick up the rollback state saved earlier.
-  {
-    const current = findAssistantByName(entry.assistantId);
-    if (current) {
-      saveAssistantEntry({
-        ...current,
-        preUpgradeBackupPath: backupPath ?? undefined,
-      });
-    }
+    throw new Error("Pre-upgrade root backup failed; upgrade aborted before replacing services.");
   }
 
   await broadcastUpgradeEvent(
@@ -476,6 +452,7 @@ async function upgradeDocker(
   );
 
   console.log("🛑 Stopping existing containers...");
+  await sleepContainers(res);
   await stopContainers(res);
   console.log("✅ Containers stopped\n");
 
@@ -509,13 +486,10 @@ async function upgradeDocker(
         cesImage: imageTags["credential-executor"],
         assistantPort,
       },
-      previousContainerInfo: entry.containerInfo,
-      previousDbMigrationVersion: preMigrationState.dbVersion,
-      previousWorkspaceMigrationId: preMigrationState.lastWorkspaceMigrationId,
-      // Preserve the backup path so `cadet rollback` can restore it later
-      preUpgradeBackupPath: backupPath ?? undefined,
     };
     saveAssistantEntry(updatedEntry);
+    // Refresh the host-served web bundle before clients reload on completion.
+    await restoreContainerTunnelEdge(updatedEntry);
 
     // Notify clients on the new service group that the upgrade succeeded.
     await broadcastUpgradeEvent(
@@ -581,6 +555,7 @@ async function upgradeDocker(
           );
         }
 
+        await sleepContainers(res);
         await stopContainers(res);
 
         await startContainers(
@@ -647,14 +622,12 @@ async function upgradeDocker(
               entry.runtimeUrl,
               entry.assistantId,
               backupPath,
-              { kind: "docker", assistantId: entry.assistantId },
+              {},
             );
             if (restored) {
               console.log("   ✅ Data restored successfully\n");
             } else {
-              console.warn(
-                "   ⚠️  Data restore failed (rollback continues without data restoration)\n",
-              );
+              throw new Error(`Root restore failed; rollback recovery is incomplete. Backup: ${backupPath}`);
             }
           } else {
             console.log(
@@ -678,11 +651,6 @@ async function upgradeDocker(
                 previousImageRefs["credential-executor"],
               assistantPort,
             },
-            previousContainerInfo: undefined,
-            previousDbMigrationVersion: undefined,
-            previousWorkspaceMigrationId: undefined,
-            // Clear the backup path — the upgrade that created it just failed
-            preUpgradeBackupPath: undefined,
           };
           saveAssistantEntry(rolledBackEntry);
 
@@ -810,40 +778,6 @@ async function ensureGuardianTokenAfterLocalUpgrade(
   }
 }
 
-async function fetchLocalUpgradeState(
-  entry: AssistantEntry,
-  adminUrl: string,
-): Promise<{
-  currentVersion?: string;
-  preMigrationState: {
-    dbVersion?: number;
-    lastWorkspaceMigrationId?: string;
-  };
-}> {
-  try {
-    const healthResp = await loopbackSafeFetch(
-      `${adminUrl}/healthz?include=migrations`,
-      {
-        signal: AbortSignal.timeout(5000),
-      },
-    );
-    if (healthResp.ok) {
-      const health = (await healthResp.json()) as {
-        version?: string;
-        migrations?: { dbVersion?: number; lastWorkspaceMigrationId?: string };
-      };
-      return {
-        currentVersion: health.version,
-        preMigrationState: health.migrations ?? {},
-      };
-    }
-  } catch {
-    // Best-effort — sleeping assistants and unhealthy gateways can still be restarted.
-  }
-
-  return { preMigrationState: {} };
-}
-
 async function upgradeLocal(
   entry: AssistantEntry,
   version: string | null,
@@ -856,6 +790,7 @@ async function upgradeLocal(
     process.exit(1);
   }
 
+  const originalResources = { ...entry.resources };
   const signingKey = resolveExistingLocalSigningKey(entry.resources);
   if (entry.resources.signingKey !== signingKey) {
     entry.resources.signingKey = signingKey;
@@ -864,10 +799,7 @@ async function upgradeLocal(
 
   const targetVersion = await targetVersionFromCli(version);
   const adminUrl = localAdminUrl(entry);
-  const { currentVersion, preMigrationState } = await fetchLocalUpgradeState(
-    entry,
-    adminUrl,
-  );
+  const currentVersion = await fetchCurrentVersion(adminUrl);
 
   if (!currentVersion && targetVersion) {
     console.warn(
@@ -877,7 +809,7 @@ async function upgradeLocal(
   if (currentVersion && targetVersion) {
     const cmp = compareVersions(targetVersion, currentVersion);
     if (cmp !== null && cmp < 0) {
-      const msg = `Cannot upgrade to an older version (${targetVersion} < ${currentVersion}). Use \`cadet rollback --version ${targetVersion}\` instead.`;
+      const msg = `Cannot upgrade to an older version (${targetVersion} < ${currentVersion}). Use \`cadet restore --from <backup-path> --version ${targetVersion}\` instead.`;
       console.error(msg);
       emitCliError("VERSION_DIRECTION", msg);
       process.exit(1);
@@ -933,7 +865,7 @@ async function upgradeLocal(
     console.log(`   Backup saved: ${backupPath}\n`);
     pruneOldBackups(entry.assistantId, 3);
   } else {
-    console.warn("⚠️  Pre-upgrade backup failed, continuing with upgrade\n");
+    throw new Error("Pre-upgrade root backup failed; upgrade aborted before replacing services.");
   }
 
   let bootstrapSecret = entry.guardianBootstrapSecret;
@@ -944,20 +876,8 @@ async function upgradeLocal(
     entryChanged = true;
   }
 
-  if (
-    entryChanged ||
-    backupPath ||
-    currentVersion ||
-    preMigrationState.dbVersion !== undefined ||
-    preMigrationState.lastWorkspaceMigrationId !== undefined
-  ) {
-    saveAssistantEntry({
-      ...entry,
-      previousVersion: currentVersion,
-      previousDbMigrationVersion: preMigrationState.dbVersion,
-      previousWorkspaceMigrationId: preMigrationState.lastWorkspaceMigrationId,
-      preUpgradeBackupPath: backupPath ?? undefined,
-    });
+  if (entryChanged) {
+    saveAssistantEntry(entry);
   }
 
   await broadcastUpgradeEvent(
@@ -977,64 +897,69 @@ async function upgradeLocal(
     runtimeVersion: runtimeInstall.version,
     runtimeInstallDir: runtimeInstall.installDir,
   };
-  saveAssistantEntry({
-    ...entry,
-    previousVersion: currentVersion,
-    previousDbMigrationVersion: preMigrationState.dbVersion,
-    previousWorkspaceMigrationId: preMigrationState.lastWorkspaceMigrationId,
-    preUpgradeBackupPath: backupPath ?? undefined,
-  });
+  saveAssistantEntry(entry);
   console.log(`   Runtime installed: ${runtimeInstall.installDir}\n`);
 
-  console.log("🛑 Stopping local assistant processes...");
-  await stopLocalProcesses(entry.resources);
-  console.log("✅ Local assistant processes stopped\n");
-
-  console.log("🚀 Starting upgraded local assistant...");
-  const previousAppVersion = process.env.APP_VERSION;
-  process.env.APP_VERSION = stripVersionPrefix(targetVersion);
   try {
-    // Bring CES, daemon, and gateway up in parallel, the way the Docker
-    // topology starts its sibling processes together. startCes always
-    // launches the CES sibling.
-    await Promise.all([
-      startCes(false, entry.resources),
-      startLocalDaemon(false, entry.resources, { signingKey }),
-      startGateway(false, entry.resources, { signingKey, bootstrapSecret }),
-    ]);
-  } finally {
-    if (previousAppVersion === undefined) {
-      delete process.env.APP_VERSION;
-    } else {
-      process.env.APP_VERSION = previousAppVersion;
-    }
-  }
-  await ensureGuardianTokenAfterLocalUpgrade(
-    entry,
-    entry.resources.gatewayPort,
-    bootstrapSecret,
-  );
-  console.log("✅ Local assistant processes started\n");
+    console.log("🛑 Stopping local assistant processes...");
+    await stopLocalProcesses(entry.resources);
+    console.log("✅ Local assistant processes stopped\n");
 
-  const workspaceDir = join(entry.resources.instanceDir, "workspace");
-  await restoreTunnelEdgeAndAutoTunnel(
-    entry.assistantId,
-    entry.resources.gatewayPort,
-    workspaceDir,
-  );
+    console.log("🚀 Starting upgraded local assistant...");
+    const previousAppVersion = process.env.APP_VERSION;
+    process.env.APP_VERSION = stripVersionPrefix(targetVersion);
+    try {
+      // Bring CES, daemon, and gateway up in parallel, the way the Docker
+      // topology starts its sibling processes together. startCes always
+      // launches the CES sibling.
+      await Promise.all([
+        startCes(false, entry.resources),
+        startLocalDaemon(false, entry.resources, { signingKey }),
+        startGateway(false, entry.resources, { signingKey, bootstrapSecret }),
+      ]);
+    } finally {
+      if (previousAppVersion === undefined) {
+        delete process.env.APP_VERSION;
+      } else {
+        process.env.APP_VERSION = previousAppVersion;
+      }
+    }
+    await ensureGuardianTokenAfterLocalUpgrade(
+      entry,
+      entry.resources.gatewayPort,
+      bootstrapSecret,
+    );
+    console.log("✅ Local assistant processes started\n");
 
-  console.log("Waiting for assistant to become ready...");
-  const ready = await waitForReady(adminUrl);
-  if (!ready) {
-    await broadcastUpgradeEvent(
-      adminUrl,
+    const workspaceDir = join(entry.resources.instanceDir, "workspace");
+    await restoreTunnelEdgeAndAutoTunnel(
       entry.assistantId,
-      buildCompleteEvent(currentVersion ?? "unknown", false),
+      entry.resources.gatewayPort,
+      workspaceDir,
     );
-    const msg = `Upgrade to ${targetVersion} failed: local assistant did not become ready.`;
-    console.error(`\n❌ ${msg}`);
-    emitCliError("READINESS_TIMEOUT", msg);
-    process.exit(1);
+
+    console.log("Waiting for assistant to become ready...");
+    const ready = await waitForReady(adminUrl);
+    if (!ready) {
+      await broadcastUpgradeEvent(
+        adminUrl,
+        entry.assistantId,
+        buildCompleteEvent(currentVersion ?? "unknown", false),
+      );
+      const msg = `Upgrade to ${targetVersion} failed: local assistant did not become ready.`;
+      console.error(`\n❌ ${msg}`);
+      throw new Error(msg);
+    }
+  } catch (error) {
+    console.error("Local upgrade failed; restoring the previous runtime and service roots...");
+    await stopLocalProcesses(entry.resources);
+    entry.resources = originalResources;
+    saveAssistantEntry(entry);
+    const restored = await restoreBackup(adminUrl, entry.assistantId, backupPath, { resume: false });
+    if (!restored) throw new Error(`Local recovery failed; services remain stopped. Backup: ${backupPath}`, { cause: error });
+    await Promise.all([startCes(false, entry.resources), startLocalDaemon(false, entry.resources, { signingKey }), startGateway(false, entry.resources, { signingKey, bootstrapSecret })]);
+    if (!await waitForReady(adminUrl)) throw new Error(`Previous local runtime did not recover. Backup: ${backupPath}`, { cause: error });
+    throw error;
   }
 
   await broadcastUpgradeEvent(
@@ -1223,7 +1148,7 @@ async function upgradePlatform(
   }
 
   if (resolution.isDowngrade && resolution.target && currentVersion) {
-    const msg = `Cannot upgrade to an older version (${resolution.target} < ${currentVersion}). Use \`cadet rollback --version ${resolution.target}\` instead.`;
+    const msg = `Cannot upgrade to an older version (${resolution.target} < ${currentVersion}). Use \`cadet restore --from <backup-path> --version ${resolution.target}\` instead.`;
     console.error(msg);
     emitCliError("VERSION_DIRECTION", msg);
     process.exit(1);
@@ -1384,6 +1309,8 @@ async function upgradePrepare(
     description: `Pre-upgrade snapshot before ${currentVersion} → ${targetVersion}`,
   });
 
+  if (!backupPath) throw new Error("Pre-upgrade root backup failed; update preparation aborted.");
+
   // 5. Prune old backups (keep 3)
   if (backupPath) {
     pruneOldBackups(entry.assistantId, 3);
@@ -1455,11 +1382,11 @@ async function resolveLatestStableTag(): Promise<string> {
   const latestVersion = await fetchLatestStableVersion();
   if (!latestVersion) {
     console.error(
-      "Error: Could not determine the latest stable release from the Cadet Cloud API.",
+      "Error: Could not determine the latest stable release from Cadet Cloud or GitHub Releases.",
     );
     emitCliError(
       "UNKNOWN",
-      "Could not determine the latest stable release from the cloud API",
+      "Could not determine the latest stable release from Cadet Cloud or GitHub Releases",
     );
     process.exit(1);
   }

package/src/commands/wake.ts

@@ -201,7 +201,7 @@ class WakeExit extends Error {}
  * refusals so the caller decides between exiting (single path) and
  * continuing to the next entry (`--all`).
  */
-async function wakeAssistant(
+export async function wakeAssistant(
   entry: AssistantEntry,
   opts: WakeAssistantOptions,
 ): Promise<void> {

package/src/index.ts

@@ -31,7 +31,6 @@ import { ps } from "./commands/ps";
 import { restore } from "./commands/restore";
 import { retire } from "./commands/retire";
 import { restart } from "./commands/restart";
-import { rollback } from "./commands/rollback";
 import { setup } from "./commands/setup";
 import { sleep } from "./commands/sleep";
 import { debug } from "./commands/debug";
@@ -39,7 +38,6 @@ import { teleport } from "./commands/teleport";
 import { terminal } from "./commands/terminal";
 import { tunnel } from "./commands/tunnel";
 import { uninstall } from "./commands/uninstall";
-import { unpair } from "./commands/unpair";
 import { upgrade } from "./commands/upgrade";
 import { use } from "./commands/use";
 import { voice } from "./commands/voice";
@@ -73,14 +71,12 @@ const commands = {
   restore,
   retire,
   restart,
-  rollback,
   setup,
   sleep,
   teleport,
   terminal,
   tunnel,
   uninstall,
-  unpair,
   upgrade,
   use,
   voice,

package/src/lib/__tests__/http-client-version.test.ts

@@ -0,0 +1,29 @@
+import { afterAll, afterEach, expect, spyOn, test } from "bun:test";
+import { fetchCurrentVersion } from "../http-client.js";
+
+const request = spyOn(globalThis, "fetch");
+afterEach(() => request.mockReset());
+afterAll(() => request.mockRestore());
+
+test("reads the gateway's version through the public health endpoint", async () => {
+  request.mockResolvedValueOnce(
+    Response.json({ version: "1.2.3", status: "ok" }),
+  );
+  expect(await fetchCurrentVersion("http://127.0.0.1:7830")).toBe("1.2.3");
+  expect(request.mock.calls[0][0]).toBe("http://127.0.0.1:7830/healthz");
+});
+
+test("an unverified gateway response never supplies a release version", async () => {
+  for (const value of [{}, null, { version: "" }, { version: 123 }]) {
+    request.mockResolvedValueOnce(Response.json(value));
+    expect(await fetchCurrentVersion("http://127.0.0.1:7830")).toBeUndefined();
+  }
+  request.mockResolvedValueOnce(new Response("not JSON"));
+  expect(await fetchCurrentVersion("http://127.0.0.1:7830")).toBeUndefined();
+  request.mockResolvedValueOnce(
+    Response.json({ version: "1.2.3" }, { status: 503 }),
+  );
+  expect(await fetchCurrentVersion("http://127.0.0.1:7830")).toBeUndefined();
+  request.mockRejectedValueOnce(new Error("offline"));
+  expect(await fetchCurrentVersion("http://127.0.0.1:7830")).toBeUndefined();
+});

package/src/lib/__tests__/runtime-url.test.ts

@@ -1,10 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistantEntry } from "../assistant-config.js";
-import {
-  resolveRuntimeMigrationUrl,
-  resolveRuntimeUrl,
-} from "../runtime-url.js";
+import { resolveRuntimeUrl } from "../runtime-url.js";
 
 function makeEntry(
   overrides: Partial<AssistantEntry> & {
@@ -20,75 +17,6 @@ function makeEntry(
   };
 }
 
-describe("resolveRuntimeMigrationUrl", () => {
-  test("local cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
-    const entry = makeEntry({
-      cloud: "local",
-      runtimeUrl: "http://localhost:7821",
-      assistantId: "ast-local-1",
-    });
-    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
-      "http://localhost:7821/v1/migrations/export-to-gcs",
-    );
-    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
-      "http://localhost:7821/v1/migrations/import-from-gcs",
-    );
-    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-abc")).toBe(
-      "http://localhost:7821/v1/migrations/jobs/job-abc",
-    );
-  });
-
-  test("docker cloud uses gateway-loopback /v1/migrations/<subpath>", () => {
-    const entry = makeEntry({
-      cloud: "docker",
-      runtimeUrl: "http://localhost:7831",
-      assistantId: "ast-docker-1",
-    });
-    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
-      "http://localhost:7831/v1/migrations/export-to-gcs",
-    );
-  });
-
-  test("cadet (cloud-managed) cloud uses wildcard-proxy /v1/assistants/<id>/migrations/<subpath>", () => {
-    const entry = makeEntry({
-      cloud: "cadet",
-      runtimeUrl: "https://cloud.mycadet.ai",
-      assistantId: "11111111-2222-3333-4444-555555555555",
-    });
-    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
-      "https://cloud.mycadet.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/export-to-gcs",
-    );
-    expect(resolveRuntimeMigrationUrl(entry, "import-from-gcs")).toBe(
-      "https://cloud.mycadet.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/import-from-gcs",
-    );
-    expect(resolveRuntimeMigrationUrl(entry, "jobs/job-xyz")).toBe(
-      "https://cloud.mycadet.ai/v1/assistants/11111111-2222-3333-4444-555555555555/migrations/jobs/job-xyz",
-    );
-  });
-
-  test("dev platform URL still routes through the wildcard prefix", () => {
-    const entry = makeEntry({
-      cloud: "cadet",
-      runtimeUrl: "https://dev-cloud.mycadet.ai",
-      assistantId: "ast-dev-1",
-    });
-    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
-      "https://dev-cloud.mycadet.ai/v1/assistants/ast-dev-1/migrations/export-to-gcs",
-    );
-  });
-
-  test("a non-cadet, non-local cloud (e.g. gcp) uses the local-shape URL", () => {
-    const entry = makeEntry({
-      cloud: "gcp",
-      runtimeUrl: "http://10.0.0.5:7821",
-      assistantId: "ast-gcp-1",
-    });
-    expect(resolveRuntimeMigrationUrl(entry, "export-to-gcs")).toBe(
-      "http://10.0.0.5:7821/v1/migrations/export-to-gcs",
-    );
-  });
-});
-
 describe("resolveRuntimeUrl", () => {
   test("local cloud uses gateway-loopback /v1/<subpath>", () => {
     const entry = makeEntry({
@@ -112,9 +40,9 @@ describe("resolveRuntimeUrl", () => {
     );
   });
 
-  test("cadet cloud uses wildcard-proxy /v1/assistants/<id>/<subpath>", () => {
+  test("cloud home uses wildcard-proxy /v1/assistants/<id>/<subpath>", () => {
     const entry = makeEntry({
-      cloud: "cadet",
+      cloud: "cloud",
       runtimeUrl: "https://cloud.mycadet.ai",
       assistantId: "11111111-2222-3333-4444-555555555555",
     });