@mycadet/cli 0.12.9 → 0.12.11

package/src/lib/docker.ts

@@ -27,6 +27,7 @@ import {
   ASSISTANT_INTERNAL_PORT,
   getDefaultPorts,
 } from "./environments/paths.js";
+import { green, yellow } from "./color.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
 import { leaseGuardianToken } from "./guardian-token";
 import { logHatchNextSteps } from "./hatch-next-steps.js";
@@ -42,7 +43,6 @@ import { isDevVersion } from "./version-compat.js";
 import {
   collectProviderApiKey,
   configureHatchProviderApiKey,
-  formatProviderName,
   promptProviderChoice,
   resolveHatchProvider,
   shouldPromptForHatchProvider,
@@ -305,7 +305,6 @@ export interface HatchDockerParams {
    * also enables hot-reload.
    */
   sourcePath?: string | null;
-  analyze?: boolean;
   /**
    * Name of an existing container whose network namespace the assistant,
    * gateway, and credential-executor join (`--network=container:<name>`),
@@ -1544,7 +1543,7 @@ export async function hatchDocker(params: HatchDockerParams): Promise<void> {
           }
         }
       }
-      log("✅ Docker images acquired");
+      log(green("✅ Docker images acquired", process.stdout));
     }
 
     const res = dockerResourceNames(instanceName);
@@ -1719,7 +1718,6 @@ export async function hatchDocker(params: HatchDockerParams): Promise<void> {
         logFd,
         runtimeUrl,
         containersUpAt,
-        analyze: params.analyze ?? false,
       });
 
     if (!ready && !(watch && repoRoot)) {
@@ -1745,18 +1743,16 @@ export async function hatchDocker(params: HatchDockerParams): Promise<void> {
         );
       } else if (providerSetupAction === "missing-token" && provider !== null) {
         log(
-          `⚠️  Provider credential setup skipped because the guardian token was not leased.\n` +
-            `   The assistant is still hatched. Run \`cadet setup --provider ${provider}\` after fixing the connection.`,
+          yellow(
+            `⚠️  Provider credential setup skipped because the guardian token was not leased.\n` +
+              `   The assistant is still hatched. Run \`cadet setup --provider ${provider}\` after fixing the connection.`,
+            process.stdout,
+          ),
         );
       } else if (
         providerSetupAction === "configure" &&
         provider !== undefined
       ) {
-        log(
-          provider === null
-            ? "Checking provider credentials..."
-            : `Checking ${formatProviderName(provider)} credentials...`,
-        );
         await configureHatchProviderApiKey({
           gatewayUrl: runtimeUrl,
           provider,
@@ -1830,7 +1826,6 @@ async function waitForGatewayAndLease(opts: {
   logFd: number | "ignore";
   runtimeUrl: string;
   containersUpAt: number;
-  analyze: boolean;
 }): Promise<{
   ready: boolean;
   guardianAccessToken?: string;
@@ -1846,7 +1841,6 @@ async function waitForGatewayAndLease(opts: {
     logFd,
     runtimeUrl,
     containersUpAt,
-    analyze,
   } = opts;
 
   const log = (msg: string): void => {
@@ -1855,25 +1849,12 @@ async function waitForGatewayAndLease(opts: {
   };
 
   if (detached) {
-    log("\n✅ Docker assistant hatched!\n");
-    log("Instance details:");
-    printInstanceDetails(
-      {
-        name: instanceName,
-        runtime: runtimeUrl,
-        container: containerName,
-      },
-      log,
-    );
-    log("");
-    log(`Stop with: cadet retire ${instanceName}`);
-
-    // Lease a guardian token even in detached mode so that `cadet ps`,
-    // `cadet exec`, and other CLI commands can authenticate to the
-    // gateway. Skip the /readyz readiness poll (the caller asked to detach
-    // and not block) but retry the lease itself since the gateway may need
-    // a moment to accept connections after the container starts.
-    const leaseStart = Date.now();
+    // Lease a guardian token BEFORE declaring the assistant hatched so the
+    // banner means `cadet ps`, `cadet exec`, and other CLI commands can
+    // already authenticate. Skip the /readyz readiness poll (the caller
+    // asked to detach and not block) but retry the lease silently since
+    // the gateway may need a moment to accept connections after the
+    // container starts; only a final failure surfaces to the user.
     const leaseDeadline = containersUpAt + DOCKER_READY_TIMEOUT_MS;
     let guardianAccessToken: string | undefined;
     while (Date.now() < leaseDeadline) {
@@ -1884,27 +1865,33 @@ async function waitForGatewayAndLease(opts: {
           bootstrapSecret,
         );
         guardianAccessToken = tokenData.accessToken;
-        const leaseElapsed = ((Date.now() - leaseStart) / 1000).toFixed(1);
-        log(
-          `Guardian token lease: success after ${leaseElapsed}s (principalId=${tokenData.guardianPrincipalId})`,
-        );
         break;
-      } catch (err) {
-        const elapsed = ((Date.now() - leaseStart) / 1000).toFixed(0);
-        const msg = err instanceof Error ? err.message : String(err);
-        log(
-          `Guardian token lease: attempt failed after ${elapsed}s (${msg.split("\n")[0]}), retrying...`,
-        );
+      } catch {
         await new Promise((r) => setTimeout(r, 2000));
       }
     }
     if (!guardianAccessToken) {
       log(
-        `⚠️  Guardian token lease failed after ${DOCKER_READY_TIMEOUT_MS / 1000}s.\n` +
-          `   The assistant is running but CLI commands (cadet ps, cadet exec) will not authenticate.\n` +
-          `   Re-hatch or run \`cadet setup\` to recover.`,
+        yellow(
+          `⚠️  Guardian token lease failed after ${DOCKER_READY_TIMEOUT_MS / 1000}s.\n` +
+            `   The assistant is running but CLI commands (cadet ps, cadet exec) will not authenticate.\n` +
+            `   Re-hatch or run \`cadet setup\` to recover.`,
+          process.stdout,
+        ),
       );
     }
+
+    log(`\n${green("✅ Docker assistant hatched!", process.stdout)}\n`);
+    log("Instance details:");
+    printInstanceDetails(
+      {
+        name: instanceName,
+        runtime: runtimeUrl,
+        container: containerName,
+      },
+      log,
+    );
+    log("");
     return { ready: true, guardianAccessToken };
   }
 
@@ -1973,19 +1960,16 @@ async function waitForGatewayAndLease(opts: {
   const containersUpToReadyMs = readyAt - start;
   const elapsedSec = (containersUpToReadyMs / 1000).toFixed(1);
   log(`Assistant ready after ${elapsedSec}s`);
-  if (analyze) {
-    console.info(
-      `[cadet-hatch-timing] ${JSON.stringify({
-        containers_up_to_ready_ms: containersUpToReadyMs,
-        instance: instanceName,
-      })}`,
-    );
-  }
+  console.info(
+    `[cadet-hatch-timing] ${JSON.stringify({
+      containers_up_to_ready_ms: containersUpToReadyMs,
+      instance: instanceName,
+    })}`,
+  );
 
   // Lease guardian token. The /readyz check confirms both gateway and
   // assistant are reachable. Retry with backoff in case there is a brief
   // window where readiness passes but the guardian endpoint is not yet ready.
-  log(`Guardian token lease: starting for ${instanceName} at ${runtimeUrl}`);
   const leaseStart = Date.now();
   const leaseDeadline = start + DOCKER_READY_TIMEOUT_MS;
   let leaseSuccess = false;
@@ -1999,38 +1983,30 @@ async function waitForGatewayAndLease(opts: {
         instanceName,
         bootstrapSecret,
       );
-      const leaseElapsed = ((Date.now() - leaseStart) / 1000).toFixed(1);
-      log(
-        `Guardian token lease: success after ${leaseElapsed}s (principalId=${tokenData.guardianPrincipalId}, expiresAt=${tokenData.accessTokenExpiresAt})`,
-      );
       guardianAccessToken = tokenData.accessToken;
       leaseSuccess = true;
       break;
     } catch (err) {
       lastLeaseError =
         err instanceof Error ? (err.stack ?? err.message) : String(err);
-      // Log periodically so the user knows we're still trying
-      const elapsed = ((Date.now() - leaseStart) / 1000).toFixed(0);
-      log(
-        `Guardian token lease: attempt failed after ${elapsed}s (${
-          lastLeaseError.split("\n")[0]
-        }), retrying...`,
-      );
     }
     await new Promise((r) => setTimeout(r, 2000));
   }
 
   if (!leaseSuccess) {
     log(
-      `\u26a0\ufe0f  Guardian token lease: FAILED after ${(
-        (Date.now() - leaseStart) /
-        1000
-      ).toFixed(1)}s — ${lastLeaseError ?? "unknown error"}`,
+      yellow(
+        `\u26a0\ufe0f  Guardian token lease: FAILED after ${(
+          (Date.now() - leaseStart) /
+          1000
+        ).toFixed(1)}s — ${lastLeaseError ?? "unknown error"}`,
+        process.stdout,
+      ),
     );
   }
 
   log("");
-  log(`\u2705 Docker containers are up and running!`);
+  log(green(`\u2705 Docker containers are up and running!`, process.stdout));
   log(`   Name: ${instanceName}`);
   log(`   Runtime: ${runtimeUrl}`);
   log("");

package/src/lib/ensure-binary.ts

@@ -31,6 +31,8 @@ export interface EnsureBinaryOptions {
   runInstall?: (argv: string[]) => boolean;
   /** Confirm the install. Default: promptLine "[Y/n]" on Enter-as-yes. */
   confirmInstall?: () => Promise<boolean>;
+  platform?: NodeJS.Platform;
+  confirmHomebrewInstall?: () => Promise<boolean>;
   streams?: {
     input?: NodeJS.ReadStream | Readable;
     output?: NodeJS.WriteStream | Writable;
@@ -69,9 +71,60 @@ export async function ensureBinaryInstalled(
   }
 
   const pmAvailable = opts.pmAvailable ?? probePackageManager;
-  const argv = Object.entries(opts.packages).find(([pm]) =>
-    pmAvailable(pm),
-  )?.[1];
+  let argv = Object.entries(opts.packages).find(([pm]) => pmAvailable(pm))?.[1];
+  if (
+    !argv &&
+    (opts.platform ?? process.platform) === "darwin" &&
+    opts.packages.brew
+  ) {
+    const brew = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"].find(
+      pmAvailable,
+    );
+    if (brew) {
+      const prefix = brew.slice(0, -"/bin/brew".length);
+      process.env.PATH = `${prefix}/bin:${prefix}/sbin:${process.env.PATH ?? ""}`;
+      argv = [brew, ...opts.packages.brew.slice(1)];
+    }
+  }
+  if (
+    !argv &&
+    (opts.platform ?? process.platform) === "darwin" &&
+    opts.packages.brew
+  ) {
+    output.write(
+      "Homebrew is required to install this dependency, but it isn't installed.\n",
+    );
+    const confirmHomebrew =
+      opts.confirmHomebrewInstall ?? defaultConfirm(opts, "Homebrew");
+    let approved = false;
+    try {
+      approved = await confirmHomebrew();
+    } catch {
+      /* No interactive approval. */
+    }
+    if (approved) {
+      const bootstrap = [
+        "/bin/bash",
+        "-c",
+        '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/7a3f48c7e498d7df3237fd41c30f4d492857edf4/install.sh)"',
+      ];
+      const installed = opts.runInstall
+        ? opts.runInstall(bootstrap)
+        : runInstallArgv(bootstrap);
+      const brew = installed
+        ? ["brew", "/opt/homebrew/bin/brew", "/usr/local/bin/brew"].find(
+            pmAvailable,
+          )
+        : undefined;
+      if (brew) {
+        const prefix =
+          brew === "brew" ? "" : brew.slice(0, -"/bin/brew".length);
+        if (prefix)
+          process.env.PATH = `${prefix}/bin:${prefix}/sbin:${process.env.PATH ?? ""}`;
+        argv = [brew, ...opts.packages.brew.slice(1)];
+      }
+    }
+  }
   if (!argv) {
     output.write(`⚠ No supported package manager found. ${opts.manualHint}\n`);
     return null;
@@ -90,7 +143,10 @@ export async function ensureBinaryInstalled(
 }
 
 /** Default confirm: visible prompt, Enter = yes, non-TTY throws. */
-function defaultConfirm(opts: EnsureBinaryOptions): () => Promise<boolean> {
+function defaultConfirm(
+  opts: EnsureBinaryOptions,
+  binary = opts.binary,
+): () => Promise<boolean> {
   return async () => {
     const input = opts.streams?.input ?? process.stdin;
     const output = opts.streams?.output ?? process.stdout;
@@ -99,7 +155,7 @@ function defaultConfirm(opts: EnsureBinaryOptions): () => Promise<boolean> {
       throw new Error("Install confirm requires an interactive terminal.");
     }
     const answer = (
-      await readLineText(`Install ${opts.binary} now? [Y/n] `, {
+      await readLineText(`Install ${binary} now? [Y/n] `, {
         input,
         output,
       })
@@ -114,7 +170,10 @@ function defaultConfirm(opts: EnsureBinaryOptions): () => Promise<boolean> {
 function runInstallArgv(argv: string[]): boolean {
   const [command, ...args] = argv;
   if (!command) return false;
-  const result = spawnSync(command, args, { stdio: "inherit" });
+  const result = spawnSync(command, args, {
+    stdio: "inherit",
+    windowsHide: true,
+  });
   return !result.error && result.status === 0;
 }
 

package/src/lib/environments/__tests__/paths.test.ts

@@ -39,9 +39,11 @@ const {
   getConfigDir,
   getConfigDirs,
   getDefaultPorts,
+  getInputHistoryPath,
   getLockfilePath,
   getLockfilePaths,
   getMultiInstanceDir,
+  getSharedStateDir,
 } = await import("../paths.js");
 type EnvironmentDefinition =
   import("@mycadet/environments").EnvironmentDefinition;
@@ -58,7 +60,12 @@ const dev: EnvironmentDefinition = {
   webUrl: "https://dev.mycadet.ai",
 };
 
-const XDG_ENV_VARS = ["XDG_DATA_HOME", "XDG_CONFIG_HOME", "APPDATA"] as const;
+const XDG_ENV_VARS = [
+  "XDG_DATA_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_STATE_HOME",
+  "APPDATA",
+] as const;
 
 describe("path helpers", () => {
   let savedEnv: Record<string, string | undefined>;
@@ -224,6 +231,25 @@ describe("path helpers", () => {
     });
   });
 
+  describe("getSharedStateDir", () => {
+    test("is not environment-scoped: ~/.local/state/cadet for every env", () => {
+      expect(getSharedStateDir()).toBe(
+        join(TEST_HOME, ".local", "state", "cadet"),
+      );
+    });
+
+    test("respects XDG_STATE_HOME", () => {
+      process.env.XDG_STATE_HOME = "/custom/state";
+      expect(getSharedStateDir()).toBe("/custom/state/cadet");
+    });
+
+    test("holds the shared terminal input history file", () => {
+      expect(getInputHistoryPath()).toBe(
+        join(getSharedStateDir(), "input-history"),
+      );
+    });
+  });
+
   describe("getDefaultPorts", () => {
     test("returns production defaults for production", () => {
       const ports = getDefaultPorts(prod);

package/src/lib/environments/paths.ts

@@ -82,18 +82,26 @@ export function getLogDir(env: EnvironmentDefinition): string {
 }
 
 /**
- * Path to the interactive CLI's input history file.
+ * The interactive CLI's shared state directory — `$XDG_STATE_HOME/cadet`.
  *
- * Follows the XDG Base Directory spec: history files are state data
- * (persistent across runs but not portable / user-owned content), so they
- * belong under `$XDG_STATE_HOME`, mirroring `bash`, `zsh`, `psql`, and `gh`.
- * Defaults to `~/.local/state/cadet/input-history`.
+ * Follows the XDG Base Directory spec: session state is data that persists
+ * across runs but is not portable user-owned content, mirroring `bash`,
+ * `zsh`, `psql`, and `gh`. Defaults to `~/.local/state/cadet`.
  *
- * Not environment-scoped: terminal input history is per-user, not per-assistant,
- * so dev and prod CLIs share the same history file.
+ * Not environment-scoped: it holds per-user state (the terminal input
+ * history, below) that dev and prod CLIs share.
+ */
+export function getSharedStateDir(): string {
+  return join(xdgStateHome(), "cadet");
+}
+
+/**
+ * Path to the interactive CLI's input history file, inside
+ * {@link getSharedStateDir}. Defaults to
+ * `~/.local/state/cadet/input-history`.
  */
 export function getInputHistoryPath(): string {
-  return join(xdgStateHome(), "cadet", "input-history");
+  return join(getSharedStateDir(), "input-history");
 }
 
 /**

package/src/lib/environments/resolve.ts

@@ -67,10 +67,8 @@ export function getCurrentEnvironment(
   const seed = SEEDS[name];
   if (!seed) {
     if (name !== DEFAULT_ENVIRONMENT_NAME) {
-      // Warn on stderr instead of throwing, to match the silent-fallback
-      // behavior in assistant/src/util/platform.ts:getXdgCadetConfigDirName,
-      // which silently falls back to production; the CLI agrees so neither
-      // writer ends up in a disjoint state on a typo.
+      // Warn on stderr instead of throwing: an unknown environment falls back
+      // to production, so a typo never splits writes between two states.
       process.stderr.write(
         `warning: unknown environment "${name}"; falling back to "${DEFAULT_ENVIRONMENT_NAME}". ` +
           `Add it to packages/environments/src/seeds.ts and rebuild if this was intentional.\n`,

package/src/lib/hatch-local.ts

@@ -21,6 +21,7 @@ import {
   setActiveAssistant,
 } from "./assistant-config.js";
 import type { AssistantEntry } from "./assistant-config.js";
+import { green, yellow } from "./color.js";
 import { buildHatchConfigValues, writeInitialConfig } from "./config-utils.js";
 import {
   generateLocalSigningKey,
@@ -51,7 +52,6 @@ import {
 import { logHatchNextSteps } from "./hatch-next-steps.js";
 import { printInstanceDetails } from "./instance-details.js";
 import { checkProviderApiKey } from "./api-key-check.js";
-import { loopbackSafeFetch } from "./loopback-fetch.js";
 import {
   describeLoginError,
   ensureCloudLoginInteractive,
@@ -155,8 +155,6 @@ export interface HatchLocalParams {
   name?: string | null;
   /** Build from a local source tree and hot-reload on change. */
   watch?: boolean;
-  /** Stay attached after hatch and poll the gateway until it stops. */
-  keepAlive?: boolean;
   /** Hatch-time config values (key → value). */
   configValues?: Record<string, string>;
   /** Extra env vars forwarded into the assistant process. */
@@ -191,13 +189,7 @@ export interface HatchLocalResult {
 export async function hatchLocal(
   params: HatchLocalParams = {},
 ): Promise<HatchLocalResult> {
-  const {
-    name,
-    watch = false,
-    keepAlive = false,
-    configValues = {},
-    flagEnvVars = {},
-  } = params;
+  const { name, watch = false, configValues = {}, flagEnvVars = {} } = params;
   const reporter = params.reporter ?? consoleLifecycleReporter;
   const verbose = params.verbose ?? false;
   const setupProviderCredentials = params.setupProviderCredentials !== false;
@@ -379,14 +371,18 @@ export async function hatchLocal(
       ) {
         const delayMs = 2000 * 2 ** (attempt - 1);
         reporter.error(
-          `⚠️  Guardian token lease attempt ${attempt}/${maxLeaseAttempts} failed — retrying in ${delayMs / 1000}s: ${err}`,
+          yellow(
+            `⚠️  Guardian token lease attempt ${attempt}/${maxLeaseAttempts} failed — retrying in ${delayMs / 1000}s: ${err}`,
+          ),
         );
         await new Promise((r) => setTimeout(r, delayMs));
       } else {
         reporter.error(
-          `⚠️  Guardian token lease failed${err instanceof GuardianLeasePermanentError ? ", not retrying — a malformed 200 will not fix itself" : ` after ${maxLeaseAttempts} attempts`}: ${err}\n` +
-            `   The assistant is running but guardian-token.json was not written.\n` +
-            `   Run \`cadet restart ${JSON.stringify(instanceName)} --repair-guardian\` to re-lease a token.`,
+          yellow(
+            `⚠️  Guardian token lease failed${err instanceof GuardianLeasePermanentError ? ", not retrying — a malformed 200 will not fix itself" : ` after ${maxLeaseAttempts} attempts`}: ${err}\n` +
+              `   The assistant is running but guardian-token.json was not written.\n` +
+              `   Run \`cadet restart ${JSON.stringify(instanceName)} --repair-guardian\` to re-lease a token.`,
+          ),
         );
       }
     }
@@ -398,8 +394,10 @@ export async function hatchLocal(
 
   if (provider !== undefined && provider !== null && !guardianAccessToken) {
     reporter.error(
-      `⚠️  Provider credential setup skipped because the guardian token was not leased.\n` +
-        `   The assistant is still hatched. Run \`cadet setup --provider ${provider}\` after fixing the connection.`,
+      yellow(
+        `⚠️  Provider credential setup skipped because the guardian token was not leased.\n` +
+          `   The assistant is still hatched. Run \`cadet setup --provider ${provider}\` after fixing the connection.`,
+      ),
     );
   } else if (provider !== undefined) {
     await configureHatchProviderApiKey({
@@ -429,7 +427,7 @@ export async function hatchLocal(
   }
 
   reporter.log("");
-  reporter.log(`✅ Local assistant hatched!`);
+  reporter.log(green(`✅ Local assistant hatched!`, process.stdout));
   printInstanceDetails(
     {
       name: instanceName,
@@ -438,7 +436,7 @@ export async function hatchLocal(
     },
     (message) => reporter.log(message),
   );
-  logHatchNextSteps((message) => reporter.log(message), verbose);
+  logHatchNextSteps((message) => reporter.log(message));
 
   const result: HatchLocalResult = {
     assistantId: instanceName,
@@ -447,46 +445,5 @@ export async function hatchLocal(
     guardianAccessToken,
   };
 
-  if (keepAlive) {
-    const healthUrl = `http://127.0.0.1:${resources.gatewayPort}/healthz`;
-    const healthTarget = "Gateway";
-    const POLL_INTERVAL_MS = 5000;
-    const MAX_FAILURES = 3;
-    let consecutiveFailures = 0;
-
-    const shutdown = async (): Promise<void> => {
-      reporter.log("\nShutting down local processes...");
-      await stopLocalProcesses(resources);
-      process.exit(0);
-    };
-
-    process.on("SIGTERM", () => void shutdown());
-    process.on("SIGINT", () => void shutdown());
-
-    // Poll the health endpoint until it stops responding.
-    while (true) {
-      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-      try {
-        const res = await loopbackSafeFetch(healthUrl, {
-          signal: AbortSignal.timeout(3000),
-        });
-        if (res.ok) {
-          consecutiveFailures = 0;
-        } else {
-          consecutiveFailures++;
-        }
-      } catch {
-        consecutiveFailures++;
-      }
-      if (consecutiveFailures >= MAX_FAILURES) {
-        reporter.log(
-          `\n⚠️  ${healthTarget} stopped responding — shutting down.`,
-        );
-        await stopLocalProcesses(resources);
-        process.exit(1);
-      }
-    }
-  }
-
   return result;
 }

package/src/lib/hatch-next-steps.ts

@@ -1,12 +1,21 @@
-export function logHatchNextSteps(
-  log: (message: string) => void,
-  verbose = false,
-): void {
+import { getCurrentEnvironment } from "./environments/resolve.js";
+
+function cliCommand(): string {
+  // Production keeps the bare `cadet` binary; every non-production
+  // environment installs as `cadet-<env>` (the same rule as the config and
+  // state dirs — see environments/paths.ts).
+  const env = getCurrentEnvironment();
+  return env.name === "production" ? "cadet" : `cadet-${env.name}`;
+}
+
+export function logHatchNextSteps(log: (message: string) => void): void {
+  const command = cliCommand();
   log("Next steps:");
-  log("  cadet client");
-  if (verbose) {
-    log('  cadet message "hello"');
-    log("  cadet events");
-  }
+  log(
+    `  - Run \`${command} client\` to interact with your cadet via the terminal`,
+  );
+  log(
+    `  - Run \`${command} tunnel\` to make your cadet publicly accessible and interact with it via the browser`,
+  );
   log("");
 }

package/src/lib/live-voice/tunnel.ts

@@ -28,7 +28,7 @@
  * mint again rather than reuse what resolution returned.
  */
 
-import { tunnelHostForPlatformHost } from "@mycadet/service-contracts/ingress";
+import { tunnelHostForCloudHost } from "@mycadet/service-contracts/ingress";
 
 import { authHeaders } from "../cloud-client.js";
 
@@ -66,7 +66,7 @@ export function tunnelHostForCloudUrl(cloudUrl: string): string {
   }
   try {
     return (
-      tunnelHostForPlatformHost(new URL(cloudUrl).host) ??
+      tunnelHostForCloudHost(new URL(cloudUrl).host) ??
       DEFAULT_TUNNEL_HOST
     );
   } catch {