@mycadet/cli 0.12.7 → 0.12.9

package/src/__tests__/{platform-client.test.ts → cloud-client.test.ts}

@@ -12,15 +12,15 @@ import { join } from "node:path";
 import { mock } from "bun:test";
 
 import {
-  clearPlatformToken,
+  clearCloudToken,
   fetchAssistantDetail,
   fetchUpgradeInProgress,
-  getPlatformUrl,
-  readPlatformToken,
-  savePlatformToken,
-} from "../lib/platform-client.js";
+  getCloudUrl,
+  readCloudToken,
+  saveCloudToken,
+} from "../lib/cloud-client.js";
 
-describe("platform-client token path is env-scoped", () => {
+describe("cloud-client token path is env-scoped", () => {
   let tempHome: string;
   let savedXdg: string | undefined;
   let savedEnv: string | undefined;
@@ -28,7 +28,7 @@ describe("platform-client token path is env-scoped", () => {
   beforeEach(() => {
     savedXdg = process.env.XDG_CONFIG_HOME;
     savedEnv = process.env.CADET_ENVIRONMENT;
-    tempHome = mkdtempSync(join(tmpdir(), "cli-platform-client-test-"));
+    tempHome = mkdtempSync(join(tmpdir(), "cli-cloud-client-test-"));
     process.env.XDG_CONFIG_HOME = tempHome;
     delete process.env.CADET_ENVIRONMENT;
   });
@@ -47,93 +47,93 @@ describe("platform-client token path is env-scoped", () => {
     rmSync(tempHome, { recursive: true, force: true });
   });
 
-  test("prod (CADET_ENVIRONMENT unset) writes to $XDG_CONFIG_HOME/cadet/platform-token", () => {
+  test("prod (CADET_ENVIRONMENT unset) writes to $XDG_CONFIG_HOME/cadet/cloud-token", () => {
     const token = "vak_prod_token_123";
-    savePlatformToken(token);
+    saveCloudToken(token);
 
-    const prodPath = join(tempHome, "cadet", "platform-token");
+    const prodPath = join(tempHome, "cadet", "cloud-token");
     expect(existsSync(prodPath)).toBe(true);
     expect(readFileSync(prodPath, "utf-8").trim()).toBe(token);
-    expect(readPlatformToken()).toBe(token);
+    expect(readCloudToken()).toBe(token);
   });
 
-  test("dev (CADET_ENVIRONMENT=dev) writes to $XDG_CONFIG_HOME/cadet-dev/platform-token", () => {
+  test("dev (CADET_ENVIRONMENT=dev) writes to $XDG_CONFIG_HOME/cadet-dev/cloud-token", () => {
     process.env.CADET_ENVIRONMENT = "dev";
     const token = "vak_dev_token_456";
-    savePlatformToken(token);
+    saveCloudToken(token);
 
-    const devPath = join(tempHome, "cadet-dev", "platform-token");
+    const devPath = join(tempHome, "cadet-dev", "cloud-token");
     expect(existsSync(devPath)).toBe(true);
     expect(readFileSync(devPath, "utf-8").trim()).toBe(token);
 
-    const prodPath = join(tempHome, "cadet", "platform-token");
+    const prodPath = join(tempHome, "cadet", "cloud-token");
     expect(existsSync(prodPath)).toBe(false);
 
-    expect(readPlatformToken()).toBe(token);
+    expect(readCloudToken()).toBe(token);
   });
 
   test("prod and dev tokens are isolated on disk", () => {
     // Save prod token
     delete process.env.CADET_ENVIRONMENT;
-    savePlatformToken("prod-token");
+    saveCloudToken("prod-token");
 
     // Switch to dev and save a different token
     process.env.CADET_ENVIRONMENT = "dev";
-    savePlatformToken("dev-token");
+    saveCloudToken("dev-token");
 
     // Dev read returns dev
-    expect(readPlatformToken()).toBe("dev-token");
+    expect(readCloudToken()).toBe("dev-token");
 
     // Switch back to prod — prod value is unchanged
     delete process.env.CADET_ENVIRONMENT;
-    expect(readPlatformToken()).toBe("prod-token");
+    expect(readCloudToken()).toBe("prod-token");
 
     // Files live at distinct paths
     expect(
-      readFileSync(join(tempHome, "cadet", "platform-token"), "utf-8").trim(),
+      readFileSync(join(tempHome, "cadet", "cloud-token"), "utf-8").trim(),
     ).toBe("prod-token");
     expect(
       readFileSync(
-        join(tempHome, "cadet-dev", "platform-token"),
+        join(tempHome, "cadet-dev", "cloud-token"),
         "utf-8",
       ).trim(),
     ).toBe("dev-token");
   });
 
-  test("clearPlatformToken removes only the env-scoped token", () => {
+  test("clearCloudToken removes only the env-scoped token", () => {
     // Prod token
     delete process.env.CADET_ENVIRONMENT;
-    savePlatformToken("prod-token");
+    saveCloudToken("prod-token");
 
     // Dev token
     process.env.CADET_ENVIRONMENT = "dev";
-    savePlatformToken("dev-token");
+    saveCloudToken("dev-token");
 
     // Clear dev
-    clearPlatformToken();
-    expect(existsSync(join(tempHome, "cadet-dev", "platform-token"))).toBe(
+    clearCloudToken();
+    expect(existsSync(join(tempHome, "cadet-dev", "cloud-token"))).toBe(
       false,
     );
 
     // Prod still there
-    expect(existsSync(join(tempHome, "cadet", "platform-token"))).toBe(true);
+    expect(existsSync(join(tempHome, "cadet", "cloud-token"))).toBe(true);
   });
 });
 
-describe("getPlatformUrl resolution order", () => {
+describe("getCloudUrl resolution order", () => {
   let tempLockDir: string;
   let savedLockDir: string | undefined;
   let savedEnv: string | undefined;
-  let savedPlatformUrl: string | undefined;
+  let savedCloudUrl: string | undefined;
 
   beforeEach(() => {
     savedLockDir = process.env.CADET_LOCKFILE_DIR;
     savedEnv = process.env.CADET_ENVIRONMENT;
-    savedPlatformUrl = process.env.CADET_PLATFORM_URL;
-    tempLockDir = mkdtempSync(join(tmpdir(), "cli-platform-url-test-"));
+    savedCloudUrl = process.env.CADET_CLOUD_URL;
+    tempLockDir = mkdtempSync(join(tmpdir(), "cli-cloud-url-test-"));
     process.env.CADET_LOCKFILE_DIR = tempLockDir;
     delete process.env.CADET_ENVIRONMENT;
-    delete process.env.CADET_PLATFORM_URL;
+    delete process.env.CADET_CLOUD_URL;
   });
 
   afterEach(() => {
@@ -147,10 +147,10 @@ describe("getPlatformUrl resolution order", () => {
     } else {
       process.env.CADET_ENVIRONMENT = savedEnv;
     }
-    if (savedPlatformUrl === undefined) {
-      delete process.env.CADET_PLATFORM_URL;
+    if (savedCloudUrl === undefined) {
+      delete process.env.CADET_CLOUD_URL;
     } else {
-      process.env.CADET_PLATFORM_URL = savedPlatformUrl;
+      process.env.CADET_CLOUD_URL = savedCloudUrl;
     }
     rmSync(tempLockDir, { recursive: true, force: true });
   });
@@ -163,47 +163,47 @@ describe("getPlatformUrl resolution order", () => {
     );
   }
 
-  test("returns lockfile platformBaseUrl when set", () => {
-    writeLockfile({ platformBaseUrl: "https://staging.mycadet.ai" });
-    expect(getPlatformUrl()).toBe("https://staging.mycadet.ai");
+  test("returns lockfile cloudBaseUrl when set", () => {
+    writeLockfile({ cloudBaseUrl: "https://staging.mycadet.ai" });
+    expect(getCloudUrl()).toBe("https://staging.mycadet.ai");
   });
 
-  test("lockfile platformBaseUrl takes priority over CADET_PLATFORM_URL", () => {
-    writeLockfile({ platformBaseUrl: "https://lockfile.mycadet.ai" });
-    process.env.CADET_PLATFORM_URL = "https://env.mycadet.ai";
-    expect(getPlatformUrl()).toBe("https://lockfile.mycadet.ai");
+  test("lockfile cloudBaseUrl takes priority over CADET_CLOUD_URL", () => {
+    writeLockfile({ cloudBaseUrl: "https://lockfile.mycadet.ai" });
+    process.env.CADET_CLOUD_URL = "https://env.mycadet.ai";
+    expect(getCloudUrl()).toBe("https://lockfile.mycadet.ai");
   });
 
-  test("falls back to CADET_PLATFORM_URL when lockfile is missing", () => {
-    process.env.CADET_PLATFORM_URL = "https://env-only.mycadet.ai";
-    expect(getPlatformUrl()).toBe("https://env-only.mycadet.ai");
+  test("falls back to CADET_CLOUD_URL when lockfile is missing", () => {
+    process.env.CADET_CLOUD_URL = "https://env-only.mycadet.ai";
+    expect(getCloudUrl()).toBe("https://env-only.mycadet.ai");
   });
 
-  test("falls back to CADET_PLATFORM_URL when lockfile has no platformBaseUrl", () => {
+  test("falls back to CADET_CLOUD_URL when lockfile has no cloudBaseUrl", () => {
     writeLockfile({ assistants: [] });
-    process.env.CADET_PLATFORM_URL = "https://env-fallback.mycadet.ai";
-    expect(getPlatformUrl()).toBe("https://env-fallback.mycadet.ai");
+    process.env.CADET_CLOUD_URL = "https://env-fallback.mycadet.ai";
+    expect(getCloudUrl()).toBe("https://env-fallback.mycadet.ai");
   });
 
-  test("falls back to CADET_PLATFORM_URL when lockfile platformBaseUrl is blank", () => {
-    writeLockfile({ platformBaseUrl: "   " });
-    process.env.CADET_PLATFORM_URL = "https://env-after-blank.mycadet.ai";
-    expect(getPlatformUrl()).toBe("https://env-after-blank.mycadet.ai");
+  test("falls back to CADET_CLOUD_URL when lockfile cloudBaseUrl is blank", () => {
+    writeLockfile({ cloudBaseUrl: "   " });
+    process.env.CADET_CLOUD_URL = "https://env-after-blank.mycadet.ai";
+    expect(getCloudUrl()).toBe("https://env-after-blank.mycadet.ai");
   });
 
-  test("falls back to prod env seed URL when lockfile and CADET_PLATFORM_URL are unset (prod env)", () => {
+  test("falls back to prod env seed URL when lockfile and CADET_CLOUD_URL are unset (prod env)", () => {
     // CADET_ENVIRONMENT is unset → production → prod seed URL.
-    expect(getPlatformUrl()).toBe("https://cloud.mycadet.ai");
+    expect(getCloudUrl()).toBe("https://cloud.mycadet.ai");
   });
 
   test("falls back to dev env seed URL when CADET_ENVIRONMENT=dev", () => {
     process.env.CADET_ENVIRONMENT = "dev";
-    expect(getPlatformUrl()).toBe("https://dev-cloud.mycadet.ai");
+    expect(getCloudUrl()).toBe("https://dev-cloud.mycadet.ai");
   });
 
-  test("trims whitespace from CADET_PLATFORM_URL", () => {
-    process.env.CADET_PLATFORM_URL = "  https://trimmed.mycadet.ai  ";
-    expect(getPlatformUrl()).toBe("https://trimmed.mycadet.ai");
+  test("trims whitespace from CADET_CLOUD_URL", () => {
+    process.env.CADET_CLOUD_URL = "  https://trimmed.mycadet.ai  ";
+    expect(getCloudUrl()).toBe("https://trimmed.mycadet.ai");
   });
 });
 

package/src/__tests__/{platform-releases.test.ts → cloud-releases.test.ts}

@@ -5,9 +5,13 @@ import {
   fetchReleases,
   resolveImageRefs,
   resolveOwnImageRefs,
-} from "../lib/platform-releases.js";
+} from "../lib/cloud-releases.js";
 import { dockerhubImages } from "../lib/docker.js";
-import { isDevVersion, isLocalVersion, isStagingVersion } from "../lib/version-compat.js";
+import {
+  isDevVersion,
+  isLocalVersion,
+  isStagingVersion,
+} from "../lib/version-compat.js";
 
 const originalFetch = globalThis.fetch;
 
@@ -27,12 +31,12 @@ function mockFetchError() {
 }
 
 beforeEach(() => {
-  process.env.CADET_PLATFORM_URL = "https://platform.test";
+  process.env.CADET_CLOUD_URL = "https://platform.test";
 });
 
 afterEach(() => {
   globalThis.fetch = originalFetch;
-  delete process.env.CADET_PLATFORM_URL;
+  delete process.env.CADET_CLOUD_URL;
 });
 
 const RELEASE = {
@@ -60,9 +64,9 @@ describe("fetchReleases", () => {
     expect(url).toContain("limit=100");
   });
 
-  test("uses the platformUrl override over the resolved default", async () => {
+  test("uses the cloudUrl override over the resolved default", async () => {
     const fetchMock = mockFetchJson([RELEASE]);
-    await fetchReleases({ platformUrl: "https://other-platform.test" });
+    await fetchReleases({ cloudUrl: "https://other-platform.test" });
     const url = String(fetchMock.mock.calls[0][0]);
     expect(url).toContain("https://other-platform.test/v1/releases/");
   });
@@ -79,12 +83,12 @@ describe("fetchReleases", () => {
 });
 
 describe("resolveImageRefs", () => {
-  test("released CLI resolves un-suffixed repos tagged with the target version", () => {
+  test("released CLI resolves un-suffixed repos tagged with the bare version", () => {
     const tags = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(tags.assistant).toBe("mycadet/mycadet-assistant:v0.12.6");
-    expect(tags.gateway).toBe("mycadet/mycadet-gateway:v0.12.6");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant:0.12.6");
+    expect(tags.gateway).toBe("mycadet/mycadet-gateway:0.12.6");
     expect(tags["credential-executor"]).toBe(
-      "mycadet/mycadet-credential-executor:v0.12.6",
+      "mycadet/mycadet-credential-executor:0.12.6",
     );
   });
 
@@ -94,31 +98,32 @@ describe("resolveImageRefs", () => {
       "0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags.assistant).toBe(
-      "mycadet/mycadet-assistant-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-assistant-dev:0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags.gateway).toBe(
-      "mycadet/mycadet-gateway-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-gateway-dev:0.12.6-dev.202610081023.3a27b77",
     );
     expect(tags["credential-executor"]).toBe(
-      "mycadet/mycadet-credential-executor-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-credential-executor-dev:0.12.6-dev.202610081023.3a27b77",
     );
   });
 
   test("repo suffix follows the CLI version, tag follows the target", () => {
     const tags = resolveImageRefs("v0.12.5", "0.12.6-dev.202610081023.3a27b77");
-    expect(tags.assistant).toBe("mycadet/mycadet-assistant-dev:v0.12.5");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant-dev:0.12.5");
   });
 
   test("does not consult the network", async () => {
     mockFetchError();
     const tags = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(tags.assistant).toContain(":v0.12.6");
+    expect(tags.assistant).toContain(":0.12.6");
   });
 
-  test("normalizes the v-prefix on the tag", () => {
+  test("normalizes the v-prefix off the tag", () => {
     const withoutPrefix = resolveImageRefs("0.12.6", "0.12.6");
     const withPrefix = resolveImageRefs("v0.12.6", "0.12.6");
-    expect(withoutPrefix.assistant).toBe(withPrefix.assistant);
+    expect(withoutPrefix.assistant).toBe("mycadet/mycadet-assistant:0.12.6");
+    expect(withPrefix.assistant).toBe(withoutPrefix.assistant);
   });
 });
 
@@ -126,9 +131,14 @@ describe("resolveOwnImageRefs", () => {
   test("uses the CLI's own version for both tag and repo suffix", () => {
     const tags = resolveOwnImageRefs("0.12.6-dev.202610081023.3a27b77");
     expect(tags.assistant).toBe(
-      "mycadet/mycadet-assistant-dev:v0.12.6-dev.202610081023.3a27b77",
+      "mycadet/mycadet-assistant-dev:0.12.6-dev.202610081023.3a27b77",
     );
   });
+
+  test("falls back to the literal latest tag when the CLI version is unknown", () => {
+    const tags = resolveOwnImageRefs("");
+    expect(tags.assistant).toBe("mycadet/mycadet-assistant:latest");
+  });
 });
 
 describe("dockerhubImages", () => {

package/src/__tests__/{cloudflare-tunnel.test.ts → cloudflare.test.ts}

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { EventEmitter } from "node:events";
 import type { ChildProcess } from "node:child_process";
 
-import { waitForCloudflareTunnelUrl } from "../lib/cloudflare-tunnel.js";
+import { waitForCloudflareTunnelUrl } from "../lib/tunnels/cloudflare.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 

package/src/__tests__/connect-import.test.ts

@@ -27,7 +27,9 @@ import {
   findAssistantByName,
   saveAssistantEntry,
 } from "../lib/assistant-config.js";
+import { z } from "zod";
 import { loadGuardianToken } from "../lib/guardian-token.js";
+import { withPreconnect } from "./helpers/http.js";
 
 const HOST = "https://host.example.ts.net";
 const PAIRING_LINK = `${HOST}/assistant/pair#device_code=dev-code`;
@@ -69,6 +71,9 @@ function approvedBody(overrides: Record<string, unknown> = {}) {
   };
 }
 
+/** The commands always send flat string-keyed JSON bodies. */
+const JsonRecord = z.record(z.string(), z.unknown());
+
 interface FetchCall {
   url: string;
   body: Record<string, unknown>;
@@ -79,17 +84,20 @@ function stubFetch(
   replies: (call: FetchCall, index: number) => Response,
 ): FetchCall[] {
   const calls: FetchCall[] = [];
-  globalThis.fetch = (async (url: string, init?: RequestInit) => {
-    const call = {
-      url,
-      body: JSON.parse((init?.body as string) ?? "{}") as Record<
-        string,
-        unknown
-      >,
-    };
-    calls.push(call);
-    return replies(call, calls.length - 1);
-  }) as unknown as typeof fetch;
+  globalThis.fetch = withPreconnect(
+    async (input: RequestInfo | URL, init?: RequestInit) => {
+      const call = {
+        url: String(input),
+        // The command always sends a JSON string body; anything else records
+        // as an empty record.
+        body: JsonRecord.parse(
+          JSON.parse(typeof init?.body === "string" ? init.body : "{}"),
+        ),
+      };
+      calls.push(call);
+      return replies(call, calls.length - 1);
+    },
+  );
   return calls;
 }
 
@@ -112,14 +120,16 @@ async function runExpectingExit(): Promise<{ exited: boolean; out: string }> {
   const logSpy = spyOn(console, "log").mockImplementation((...a: unknown[]) => {
     messages.push(a.join(" "));
   });
-  const exitSpy = spyOn(process, "exit").mockImplementation(((c?: number) => {
-    throw new Error(`exit:${c}`);
-  }) as never);
+  const exitSpy = spyOn(process, "exit").mockImplementation(
+    (c?: number | string | undefined): never => {
+      throw new Error(`exit:${c}`);
+    },
+  );
   let exited = false;
   try {
     await connectImport();
   } catch (e) {
-    exited = (e as Error).message === "exit:1";
+    exited = e instanceof Error && e.message === "exit:1";
   } finally {
     errSpy.mockRestore();
     logSpy.mockRestore();
@@ -144,10 +154,13 @@ describe("connect import", () => {
     // a multi-second cadence is exercised in full without being spent, and
     // both the cadence and the backoff are assertable rather than implicit.
     setSystemTime(new Date());
-    sleepSpy = spyOn(Bun, "sleep").mockImplementation((async (ms: number) => {
-      waits.push(ms);
-      setSystemTime(new Date(Date.now() + ms));
-    }) as never);
+    sleepSpy = spyOn(Bun, "sleep").mockImplementation(
+      async (ms: number | Date) => {
+        const waitMs = typeof ms === "number" ? ms : ms.getTime() - Date.now();
+        waits.push(waitMs);
+        setSystemTime(new Date(Date.now() + waitMs));
+      },
+    );
   });
 
   afterEach(() => {
@@ -312,10 +325,10 @@ describe("connect import", () => {
       "http://insecure.example.com",
     ];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -333,10 +346,10 @@ describe("connect import", () => {
       "https://127.0.0.1:7830",
     ];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -361,10 +374,10 @@ describe("connect import", () => {
       "legacy-box",
     ];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
     const { logs, restore } = captureLogs();
     try {
       await connectImport();
@@ -385,10 +398,10 @@ describe("connect import", () => {
   test("a string that is neither an address nor a bundle keeps the address error", async () => {
     process.argv = ["bun", "cadet", "connect", "import", "not-a-url"];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -410,7 +423,8 @@ describe("connect import", () => {
       "flaky-box",
     ];
     let attempt = 0;
-    globalThis.fetch = (async (url: string) => {
+    globalThis.fetch = withPreconnect(async (input: RequestInfo | URL) => {
+      const url = String(input);
       if (url === CHALLENGE_URL) {
         return jsonResponse(challengeBody());
       }
@@ -420,7 +434,7 @@ describe("connect import", () => {
         throw new Error("connect ECONNRESET");
       }
       return jsonResponse(approvedBody());
-    }) as unknown as typeof fetch;
+    });
     const { logs, restore } = captureLogs();
     try {
       await connectImport();
@@ -448,7 +462,8 @@ describe("connect import", () => {
       "repairing-box",
     ];
     let attempt = 0;
-    globalThis.fetch = (async (url: string) => {
+    globalThis.fetch = withPreconnect(async (input: RequestInfo | URL) => {
+      const url = String(input);
       if (url === CHALLENGE_URL) {
         return jsonResponse(challengeBody());
       }
@@ -459,7 +474,7 @@ describe("connect import", () => {
         return jsonResponse({ error: "guardian repair required" }, 503);
       }
       return jsonResponse(approvedBody());
-    }) as unknown as typeof fetch;
+    });
     const { logs, restore } = captureLogs();
     try {
       await connectImport();
@@ -477,7 +492,8 @@ describe("connect import", () => {
   test("reports expiry once transient failures outlast the code", async () => {
     process.argv = ["bun", "cadet", "connect", "import", HOST];
     let exchanges = 0;
-    globalThis.fetch = (async (url: string) => {
+    globalThis.fetch = withPreconnect(async (input: RequestInfo | URL) => {
+      const url = String(input);
       if (url === CHALLENGE_URL) {
         return jsonResponse(
           challengeBody({
@@ -488,7 +504,7 @@ describe("connect import", () => {
       }
       exchanges += 1;
       throw new Error("connect ECONNREFUSED");
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -507,10 +523,10 @@ describe("connect import", () => {
     // ten-minute TTL.
     process.argv = ["bun", "cadet", "connect", "import", PAIRING_LINK];
     let attempts = 0;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       attempts += 1;
       throw new Error("connect ECONNREFUSED");
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -532,10 +548,10 @@ describe("connect import", () => {
   test("rejects an unknown --flag instead of pairing against it", async () => {
     process.argv = ["bun", "cadet", "connect", "import", "--qr", HOST];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();
 
@@ -560,10 +576,10 @@ describe("connect import", () => {
       "--frobnicate",
     ];
     let fetched = false;
-    globalThis.fetch = (async () => {
+    globalThis.fetch = withPreconnect(async () => {
       fetched = true;
       return jsonResponse({});
-    }) as unknown as typeof fetch;
+    });
 
     const { exited, out } = await runExpectingExit();