@vellumai/cli 0.8.10-dev.202606110240.ef9212e → 0.8.10-dev.202606110422.8c0e9aa

package/node_modules/@vellumai/local-mode/src/config.ts

@@ -64,3 +64,16 @@ export function resolveConfigDir(
   }
   return path.join(xdgConfigHome, `vellum-${vellumEnv}`);
 }
+
+/**
+ * The on-disk location of an assistant's guardian token, given an already
+ * resolved config dir. The single source of truth for this path so the CLI
+ * writer and every host-seam reader agree — a divergence here is what leaves a
+ * freshly leased token unreadable and bricks the connect.
+ */
+export function guardianTokenPath(
+  configDir: string,
+  assistantId: string,
+): string {
+  return path.join(configDir, "assistants", assistantId, "guardian-token.json");
+}

package/node_modules/@vellumai/local-mode/src/guardian-token.ts

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
-import path from "node:path";
 
+import { guardianTokenPath } from "./config";
 import type { CliInvocation } from "./util";
 
 const GUARDIAN_TOKEN_REFRESH_TIMEOUT_MS = 15_000;
@@ -40,7 +40,7 @@ export function getGuardianAccessToken(
     return Promise.resolve({ ok: false, status: 403, error: "Forbidden" });
   }
 
-  const tokenPath = path.join(configDir, "assistants", assistantId, "guardian-token.json");
+  const tokenPath = guardianTokenPath(configDir, assistantId);
 
   let raw: string;
   try {

package/node_modules/@vellumai/local-mode/src/index.ts

@@ -14,7 +14,7 @@ export {
   resolveDevCliInvocation,
 } from "./util";
 export type { CliInvocation } from "./util";
-export { resolveLocalConfigFromEnv, resolveLockfilePaths, resolveConfigDir } from "./config";
+export { resolveLocalConfigFromEnv, resolveLockfilePaths, resolveConfigDir, guardianTokenPath } from "./config";
 export type { LocalEndpointConfig } from "./config";
 export { defaultEnvironmentFilePath, readDefaultEnvironment, resolveEnvironmentName } from "./environment";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.8.10-dev.202606110240.ef9212e",
+  "version": "0.8.10-dev.202606110422.8c0e9aa",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/guardian-token.test.ts

@@ -11,6 +11,8 @@ import {
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
+import { guardianTokenPath, resolveConfigDir } from "@vellumai/local-mode";
+
 import {
   getOrCreatePersistedDeviceId,
   guardianTokenDueForRenewal,
@@ -20,6 +22,8 @@ import {
   seedGuardianTokenFromSiblingEnv,
   type GuardianTokenData,
 } from "../lib/guardian-token.js";
+import { getConfigDir } from "../lib/environments/paths.js";
+import { getCurrentEnvironment } from "../lib/environments/resolve.js";
 
 function makeTokenData(suffix: string): GuardianTokenData {
   const now = new Date().toISOString();
@@ -473,3 +477,78 @@ describe("guardianTokenDueForRenewal", () => {
     ).toBe(false);
   });
 });
+
+// Drift guard between the guardian-token WRITE path (CLI: getGuardianTokenPath
+// → getConfigDir(getCurrentEnvironment())) and the READ path used by every
+// host-seam reader (getGuardianAccessToken → resolveConfigDir(env) from
+// @vellumai/local-mode). A divergence here writes a freshly leased token where
+// the connect can't read it, bricking local-assistant connect. saveGuardianToken
+// already resolves through the shared resolver; this asserts the two resolvers
+// stay in lockstep so a future change to either can't silently relocate tokens.
+describe("guardian-token path resolver parity (CLI ↔ shared)", () => {
+  let tempHome: string;
+  let savedXdg: string | undefined;
+  let savedEnv: string | undefined;
+
+  beforeEach(() => {
+    savedXdg = process.env.XDG_CONFIG_HOME;
+    savedEnv = process.env.VELLUM_ENVIRONMENT;
+    tempHome = mkdtempSync(join(tmpdir(), "cli-guardian-parity-test-"));
+    process.env.XDG_CONFIG_HOME = tempHome;
+    delete process.env.VELLUM_ENVIRONMENT;
+  });
+
+  afterEach(() => {
+    if (savedXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = savedXdg;
+    if (savedEnv === undefined) delete process.env.VELLUM_ENVIRONMENT;
+    else process.env.VELLUM_ENVIRONMENT = savedEnv;
+    rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  // The CLI's own resolver and the shared @vellumai/local-mode resolver must
+  // agree on the config dir for every environment source.
+  const expectResolversAgree = () => {
+    expect(getConfigDir(getCurrentEnvironment())).toBe(
+      resolveConfigDir(process.env),
+    );
+  };
+
+  test("unset → production: resolvers agree and saveGuardianToken lands there", () => {
+    expectResolversAgree();
+    saveGuardianToken("alpha", makeTokenData("prod"));
+    expect(
+      existsSync(guardianTokenPath(resolveConfigDir(process.env), "alpha")),
+    ).toBe(true);
+  });
+
+  test("VELLUM_ENVIRONMENT=dev: resolvers agree and token lands there", () => {
+    process.env.VELLUM_ENVIRONMENT = "dev";
+    expectResolversAgree();
+    saveGuardianToken("alpha", makeTokenData("dev"));
+    expect(
+      existsSync(guardianTokenPath(resolveConfigDir(process.env), "alpha")),
+    ).toBe(true);
+  });
+
+  test("VELLUM_ENVIRONMENT=local: resolvers agree and token lands there", () => {
+    process.env.VELLUM_ENVIRONMENT = "local";
+    expectResolversAgree();
+    saveGuardianToken("alpha", makeTokenData("local"));
+    expect(
+      existsSync(guardianTokenPath(resolveConfigDir(process.env), "alpha")),
+    ).toBe(true);
+  });
+
+  test("persisted default env file (no VELLUM_ENVIRONMENT): resolvers agree", () => {
+    // Mirror `vellum env set dev`: the default-env file lives at the fixed,
+    // env-agnostic path $XDG_CONFIG_HOME/vellum/environment.
+    mkdirSync(join(tempHome, "vellum"), { recursive: true });
+    writeFileSync(join(tempHome, "vellum", "environment"), "dev\n");
+    expectResolversAgree();
+    saveGuardianToken("alpha", makeTokenData("default-dev"));
+    expect(
+      existsSync(guardianTokenPath(resolveConfigDir(process.env), "alpha")),
+    ).toBe(true);
+  });
+});

package/src/__tests__/wake.test.ts

@@ -58,10 +58,27 @@ mock.module("../lib/docker.js", () => ({
 const seedGuardianTokenFromSiblingEnvMock = mock<
   typeof guardianToken.seedGuardianTokenFromSiblingEnv
 >(() => false);
+// Default: a token exists, so the re-provision recovery path is skipped. Tests
+// that exercise recovery override loadGuardianToken to return null.
+const loadGuardianTokenMock = mock<typeof guardianToken.loadGuardianToken>(
+  () => ({ accessToken: "existing" }) as ReturnType<
+    typeof guardianToken.loadGuardianToken
+  >,
+);
+const resetGuardianBootstrapMock = mock<
+  typeof guardianToken.resetGuardianBootstrap
+>(async () => {});
+const leaseGuardianTokenMock = mock<typeof guardianToken.leaseGuardianToken>(
+  async () =>
+    ({}) as Awaited<ReturnType<typeof guardianToken.leaseGuardianToken>>,
+);
 
 mock.module("../lib/guardian-token.js", () => ({
   ...realGuardianToken,
   seedGuardianTokenFromSiblingEnv: seedGuardianTokenFromSiblingEnvMock,
+  loadGuardianToken: loadGuardianTokenMock,
+  resetGuardianBootstrap: resetGuardianBootstrapMock,
+  leaseGuardianToken: leaseGuardianTokenMock,
 }));
 
 const resolveProcessStateMock = mock<typeof processLib.resolveProcessState>(
@@ -169,6 +186,16 @@ beforeEach(() => {
   startGatewayMock.mockResolvedValue("http://127.0.0.1:7830");
   seedGuardianTokenFromSiblingEnvMock.mockReset();
   seedGuardianTokenFromSiblingEnvMock.mockReturnValue(false);
+  loadGuardianTokenMock.mockReset();
+  loadGuardianTokenMock.mockReturnValue({ accessToken: "existing" } as ReturnType<
+    typeof guardianToken.loadGuardianToken
+  >);
+  resetGuardianBootstrapMock.mockReset();
+  resetGuardianBootstrapMock.mockResolvedValue(undefined);
+  leaseGuardianTokenMock.mockReset();
+  leaseGuardianTokenMock.mockResolvedValue(
+    {} as Awaited<ReturnType<typeof guardianToken.leaseGuardianToken>>,
+  );
   maybeStartNgrokTunnelMock.mockReset();
   maybeStartNgrokTunnelMock.mockResolvedValue(null);
 });
@@ -212,4 +239,45 @@ describe("vellum wake", () => {
       },
     );
   });
+
+  test("re-provisions the guardian token when missing and --repair-guardian is passed", async () => {
+    process.argv = ["bun", "vellum", "wake", "--repair-guardian", "local-assistant"];
+    loadGuardianTokenMock.mockReturnValue(null);
+
+    await wake();
+
+    // Resets the gateway's spent bootstrap state, then re-leases against the
+    // loopback gateway with the lockfile's bootstrap secret.
+    expect(resetGuardianBootstrapMock).toHaveBeenCalledWith(
+      "http://127.0.0.1:7830",
+      "generated-bootstrap-secret",
+    );
+    expect(leaseGuardianTokenMock).toHaveBeenCalledWith(
+      "http://127.0.0.1:7830",
+      "local-assistant",
+      "generated-bootstrap-secret",
+    );
+  });
+
+  test("does NOT re-provision without --repair-guardian, even when the token is missing", async () => {
+    // The automatic connect-repair path spawns `wake <id>` with no flags. A
+    // re-lease here would revoke other device-bound tokens (other tabs / local
+    // clients), so it must never run from auto-repair.
+    process.argv = ["bun", "vellum", "wake", "local-assistant"];
+    loadGuardianTokenMock.mockReturnValue(null);
+
+    await wake();
+
+    expect(resetGuardianBootstrapMock).not.toHaveBeenCalled();
+    expect(leaseGuardianTokenMock).not.toHaveBeenCalled();
+  });
+
+  test("skips re-provision when a guardian token already exists", async () => {
+    process.argv = ["bun", "vellum", "wake", "--repair-guardian", "local-assistant"];
+    // loadGuardianToken returns a token by default — recovery must not run.
+    await wake();
+
+    expect(resetGuardianBootstrapMock).not.toHaveBeenCalled();
+    expect(leaseGuardianTokenMock).not.toHaveBeenCalled();
+  });
 });

package/src/commands/wake.ts

@@ -7,7 +7,12 @@ import {
   saveAssistantEntry,
 } from "../lib/assistant-config.js";
 import { dockerResourceNames, wakeContainers } from "../lib/docker.js";
-import { seedGuardianTokenFromSiblingEnv } from "../lib/guardian-token.js";
+import {
+  leaseGuardianToken,
+  loadGuardianToken,
+  resetGuardianBootstrap,
+  seedGuardianTokenFromSiblingEnv,
+} from "../lib/guardian-token.js";
 import { resolveProcessState, stopProcessByPidFile } from "../lib/process";
 import {
   generateLocalSigningKey,
@@ -37,11 +42,23 @@ export async function wake(): Promise<void> {
     console.log(
       "  --foreground   Run assistant in foreground with logs printed to terminal",
     );
+    console.log(
+      "  --repair-guardian  Re-provision the guardian token if missing (resets the\n" +
+        "                     gateway bootstrap and re-leases — REVOKES other device-bound\n" +
+        "                     tokens, so only use deliberately, never from auto-repair)",
+    );
     process.exit(0);
   }
 
   const watch = args.includes("--watch");
   const foreground = args.includes("--foreground");
+  // Re-leasing the guardian token calls guardian/init, which revokes every
+  // other device-bound token (other tabs, other local clients on this machine).
+  // Gate it behind an explicit flag so the automatic connect-repair path
+  // (`runWake` spawns `wake <id>` with no flags) can never revoke a live session
+  // — it only ever restarts + sibling-seeds. A genuine spent-bootstrap brick is
+  // recovered deliberately via `vellum wake <id> --repair-guardian`.
+  const repairGuardian = args.includes("--repair-guardian");
   const nameArg = args.find((a) => !a.startsWith("-"));
   const entry = resolveTargetAssistant(nameArg);
 
@@ -221,6 +238,37 @@ export async function wake(): Promise<void> {
     console.log("   Seeded guardian token from sibling environment.");
   }
 
+  // Last-resort recovery (explicit `--repair-guardian` only): if no guardian
+  // token exists for this env even after sibling seeding, re-provision one. The
+  // single-use bootstrap secret may already be spent — a prior connect can
+  // lease a token that's then lost, or the gateway marks the secret consumed
+  // before the client persists it — which otherwise bricks connect into a
+  // 401 → auth-rate-limit → 429 cascade with no path back short of retire+hatch.
+  // Reset the gateway's bootstrap lock+consumed state (loopback-only, authorized
+  // by the lockfile secret — mirrors the macOS client's forceReBootstrap), then
+  // re-lease. Gated behind the flag because the re-lease revokes other
+  // device-bound tokens; it must never run from the automatic repair path.
+  if (repairGuardian && !loadGuardianToken(entry.assistantId)) {
+    const loopbackUrl = `http://127.0.0.1:${resources.gatewayPort}`;
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        await resetGuardianBootstrap(loopbackUrl, bootstrapSecret);
+        await leaseGuardianToken(loopbackUrl, entry.assistantId, bootstrapSecret);
+        console.log("   Re-provisioned guardian token.");
+        break;
+      } catch (err) {
+        if (attempt < maxAttempts) {
+          await new Promise((r) => setTimeout(r, 2000 * 2 ** (attempt - 1)));
+        } else {
+          console.warn(
+            `   Guardian token re-provision failed after ${maxAttempts} attempts: ${err}`,
+          );
+        }
+      }
+    }
+  }
+
   // Auto-start ngrok if webhook integrations (e.g. Telegram) are configured.
   const workspaceDir = join(resources.instanceDir, ".vellum", "workspace");
   const ngrokChild = await maybeStartNgrokTunnel(

package/src/lib/guardian-token.ts

@@ -17,6 +17,10 @@ import { platform } from "os";
 import { dirname, join } from "path";
 
 import { SEEDS } from "@vellumai/environments";
+import {
+  guardianTokenPath,
+  resolveConfigDir,
+} from "@vellumai/local-mode";
 
 import { getConfigDir } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
@@ -38,12 +42,12 @@ export interface GuardianTokenData {
 }
 
 function getGuardianTokenPath(assistantId: string): string {
-  return join(
-    getConfigDir(getCurrentEnvironment()),
-    "assistants",
-    assistantId,
-    "guardian-token.json",
-  );
+  // Resolve via the shared @vellumai/local-mode resolver — the same one every
+  // host-seam reader (`getGuardianAccessToken`) uses — so the token is always
+  // written where it's read. Must stay in lockstep with `getConfigDir(
+  // getCurrentEnvironment())`; the parity test in guardian-token.test.ts guards
+  // against drift.
+  return guardianTokenPath(resolveConfigDir(process.env), assistantId);
 }
 
 /**
@@ -430,6 +434,37 @@ export async function leaseGuardianToken(
   return tokenData;
 }
 
+/**
+ * Clear the gateway's guardian-init lock + consumed-secret state via
+ * `POST /v1/guardian/reset-bootstrap`, so a spent single-use bootstrap secret
+ * can be used again by a subsequent `leaseGuardianToken`. Loopback-only on the
+ * gateway; when bootstrap secrets are configured the gateway requires a
+ * matching `x-bootstrap-secret`. Mirrors the macOS client's `forceReBootstrap`
+ * recovery. Throws on a non-OK response.
+ */
+export async function resetGuardianBootstrap(
+  gatewayUrl: string,
+  bootstrapSecret?: string,
+): Promise<void> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (bootstrapSecret) {
+    headers["x-bootstrap-secret"] = bootstrapSecret;
+  }
+  const response = await fetch(`${gatewayUrl}/v1/guardian/reset-bootstrap`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({}),
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(
+      `guardian/reset-bootstrap failed (${response.status}): ${body}`,
+    );
+  }
+}
+
 /**
  * Copy a guardian token from a sibling environment's config directory into
  * the current environment's dir when the current one is missing it.

package/src/lib/health-check.ts

@@ -1,3 +1,5 @@
+import { loopbackSafeFetch } from "./loopback-fetch.js";
+
 export const HEALTH_CHECK_TIMEOUT_MS = 1500;
 
 interface HealthResponse {
@@ -44,7 +46,7 @@ export async function checkManagedHealth(
       HEALTH_CHECK_TIMEOUT_MS,
     );
 
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers,
     });
@@ -105,7 +107,7 @@ export async function fetchManagedPs(
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5000);
 
-    const response = await fetch(psUrl, {
+    const response = await loopbackSafeFetch(psUrl, {
       signal: controller.signal,
       headers,
     });
@@ -144,7 +146,7 @@ async function fetchLegacyConnectionStatus(
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5000);
 
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       method: "POST",
       signal: controller.signal,
       headers,
@@ -188,7 +190,7 @@ export async function checkHealth(
       headers["Authorization"] = `Bearer ${bearerToken}`;
     }
 
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers,
     });

package/src/lib/loopback-fetch.ts

@@ -0,0 +1,28 @@
+/**
+ * Bun's fetch pools sockets even when the server responds `Connection:
+ * close` (e.g. the Werkzeug dev platform on localhost), so the next request
+ * to the same origin is written to a dead socket and hangs until its abort
+ * timeout fires. Disable keepalive for loopback targets to force a fresh
+ * connection per request; remote hosts are unaffected.
+ */
+
+function isLoopbackUrl(url: string): boolean {
+  try {
+    // WHATWG URL canonicalizes hostnames, so IPv6 loopback is always "[::1]".
+    const h = new URL(url).hostname;
+    return (
+      h === "localhost" || h === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(h)
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function loopbackSafeFetch(
+  url: string,
+  init?: RequestInit,
+): Promise<Response> {
+  return isLoopbackUrl(url)
+    ? fetch(url, { ...init, keepalive: false })
+    : fetch(url, init);
+}

package/src/lib/platform-client.ts

@@ -11,6 +11,7 @@ import { join, dirname } from "path";
 import { getLockfilePlatformBaseUrl } from "./assistant-config.js";
 import { getConfigDir } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
+import { loopbackSafeFetch } from "./loopback-fetch.js";
 
 function getPlatformTokenPath(): string {
   return join(getConfigDir(getCurrentEnvironment()), "platform-token");
@@ -229,7 +230,7 @@ export async function ensureSelfHostedLocalRegistration(
     body.public_ingress_url = publicBaseUrl;
   }
 
-  const response = await fetch(
+  const response = await loopbackSafeFetch(
     `${resolvedUrl}/v1/assistants/self-hosted-local/ensure-registration/`,
     {
       method: "POST",
@@ -292,7 +293,7 @@ export async function reprovisionAssistantApiKey(
     body.assistant_version = assistantVersion;
   }
 
-  const response = await fetch(
+  const response = await loopbackSafeFetch(
     `${resolvedUrl}/v1/assistants/self-hosted-local/reprovision-api-key/`,
     {
       method: "POST",
@@ -358,7 +359,7 @@ export async function readGatewayCredential(
       headers["Authorization"] = `Bearer ${bearerToken}`;
     }
 
-    const response = await fetch(`${gatewayUrl}/v1/secrets/read`, {
+    const response = await loopbackSafeFetch(`${gatewayUrl}/v1/secrets/read`, {
       method: "POST",
       headers,
       body: JSON.stringify({ type: "credential", name, reveal: true }),
@@ -416,7 +417,7 @@ async function injectGatewayCredential(
     headers["Authorization"] = `Bearer ${bearerToken}`;
   }
 
-  const response = await fetch(`${gatewayUrl}/v1/secrets`, {
+  const response = await loopbackSafeFetch(`${gatewayUrl}/v1/secrets`, {
     method: "POST",
     headers,
     body: JSON.stringify({ type: "credential", name, value }),
@@ -486,7 +487,7 @@ export async function hatchAssistant(
   const resolvedUrl = platformUrl || getPlatformUrl();
   const url = `${resolvedUrl}/v1/assistants/hatch/`;
 
-  const response = await fetch(url, {
+  const response = await loopbackSafeFetch(url, {
     method: "POST",
     headers: await authHeaders(token, platformUrl),
     body: JSON.stringify({}),
@@ -545,7 +546,7 @@ export async function checkExistingPlatformAssistant(
   );
 
   try {
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers: await authHeaders(token, platformUrl),
     });
@@ -583,7 +584,7 @@ export async function fetchPlatformAssistants(
   );
 
   try {
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers: await authHeaders(token, platformUrl),
     });
@@ -624,7 +625,7 @@ export async function fetchOrganizationId(
   );
 
   try {
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers: { ...tokenAuthHeader(token) },
     });
@@ -671,7 +672,7 @@ export async function fetchCurrentUser(
   );
 
   try {
-    const response = await fetch(url, {
+    const response = await loopbackSafeFetch(url, {
       signal: controller.signal,
       headers: { "X-Session-Token": token },
     });
@@ -706,11 +707,14 @@ export async function rollbackPlatformAssistant(
   platformUrl?: string,
 ): Promise<{ detail: string; version: string | null }> {
   const resolvedUrl = platformUrl || getPlatformUrl();
-  const response = await fetch(`${resolvedUrl}/v1/assistants/rollback/`, {
-    method: "POST",
-    headers: await authHeaders(token, platformUrl),
-    body: JSON.stringify(version ? { version } : {}),
-  });
+  const response = await loopbackSafeFetch(
+    `${resolvedUrl}/v1/assistants/rollback/`,
+    {
+      method: "POST",
+      headers: await authHeaders(token, platformUrl),
+      body: JSON.stringify(version ? { version } : {}),
+    },
+  );
 
   const body = (await response.json().catch(() => ({}))) as {
     detail?: string;
@@ -744,7 +748,7 @@ export async function platformUploadToSignedUrl(
   uploadUrl: string,
   bundleData: Uint8Array<ArrayBuffer>,
 ): Promise<void> {
-  const response = await fetch(uploadUrl, {
+  const response = await loopbackSafeFetch(uploadUrl, {
     method: "PUT",
     headers: {
       "Content-Type": "application/octet-stream",
@@ -766,7 +770,7 @@ export async function platformImportPreflightFromGcs(
   platformUrl?: string,
 ): Promise<{ statusCode: number; body: Record<string, unknown> }> {
   const resolvedUrl = platformUrl || getPlatformUrl();
-  const response = await fetch(
+  const response = await loopbackSafeFetch(
     `${resolvedUrl}/v1/migrations/import-preflight-from-gcs/`,
     {
       method: "POST",
@@ -789,7 +793,7 @@ export async function platformImportBundleFromGcs(
   platformUrl?: string,
 ): Promise<{ statusCode: number; body: Record<string, unknown> }> {
   const resolvedUrl = platformUrl || getPlatformUrl();
-  const response = await fetch(
+  const response = await loopbackSafeFetch(
     `${resolvedUrl}/v1/migrations/import-from-gcs/`,
     {
       method: "POST",
@@ -970,7 +974,7 @@ export async function platformRequestSignedUrl(
   }
 
   const doRequest = async (): Promise<Response> =>
-    fetch(`${resolvedUrl}/v1/migrations/signed-url/`, {
+    loopbackSafeFetch(`${resolvedUrl}/v1/migrations/signed-url/`, {
       method: "POST",
       headers: await authHeaders(token, platformUrl),
       body: JSON.stringify(body),
@@ -1040,9 +1044,12 @@ export async function platformPollJobStatus(
   platformUrl?: string,
 ): Promise<UnifiedJobStatus> {
   const resolvedUrl = platformUrl || getPlatformUrl();
-  const response = await fetch(`${resolvedUrl}/v1/migrations/jobs/${jobId}/`, {
-    headers: await authHeaders(token, platformUrl),
-  });
+  const response = await loopbackSafeFetch(
+    `${resolvedUrl}/v1/migrations/jobs/${jobId}/`,
+    {
+      headers: await authHeaders(token, platformUrl),
+    },
+  );
 
   if (response.status === 404) {
     throw new Error("Migration job not found");