@mycadet/cli 0.12.11 → 0.13.0

package/src/lib/local-runtime-client.ts

@@ -1,374 +0,0 @@
-import { isCloudHome } from "./cloud-values.js";
-import type { AssistantEntry } from "./assistant-config.js";
-import {
-  authHeaders,
-  invalidateOrgIdCache,
-  parseUnifiedJobStatus,
-  type UnifiedJobStatus,
-} from "./cloud-client.js";
-import {
-  resolveRuntimeMigrationUrl,
-  resolveRuntimeUrl,
-} from "./runtime-url.js";
-import { loopbackSafeFetch } from "./loopback-fetch.js";
-import { z } from "zod";
-
-const RuntimeIdentitySchema = z.object({ version: z.string().min(1) });
-
-/**
- * Thrown when the local runtime returns 409 for an export/import request
- * because another migration of the same type is already in-flight. The
- * caller can inspect {@link existingJobId} and decide whether to poll the
- * existing job instead of retrying.
- */
-export class MigrationInProgressError extends Error {
-  readonly existingJobId: string;
-  readonly kind: "export_in_progress" | "import_in_progress";
-
-  constructor(
-    kind: "export_in_progress" | "import_in_progress",
-    jobId: string,
-  ) {
-    super(
-      `A migration is already in progress (${kind}); existing job_id=${jobId}`,
-    );
-    this.name = "MigrationInProgressError";
-    this.kind = kind;
-    this.existingJobId = jobId;
-  }
-}
-
-function bearerHeaders(token: string): Record<string, string> {
-  return {
-    Authorization: `Bearer ${token}`,
-    "Content-Type": "application/json",
-    Accept: "application/json",
-  };
-}
-
-/**
- * Build the auth + content headers for a runtime migration request.
- *
- * - For `isCloudHome(cloud)` we go through the cloud's wildcard runtime
- *   proxy, which authenticates user-session / vak_ tokens via DRF's default
- *   authentication classes — `authHeaders()` produces the right combination
- *   (`X-Session-Token` + `Cadet-Organization-Id`, or `Authorization: Bearer
- *   vak_...`).
- * - For local/docker the runtime endpoint expects a guardian-token bearer.
- */
-async function migrationRequestHeaders(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl">,
-  token: string,
-): Promise<Record<string, string>> {
-  if (isCloudHome(entry.cloud)) {
-    return {
-      ...(await authHeaders(token, entry.runtimeUrl)),
-      Accept: "application/json",
-    };
-  }
-  return bearerHeaders(token);
-}
-
-const Raw409BodySchema = z.object({
-  detail: z.string().optional(),
-  // The runtime's current 409 contract nests the payload under `error`:
-  //   { error: { code: "export_in_progress" | "import_in_progress", job_id } }
-  // We also tolerate a legacy flat shape ({ code, job_id }) for resilience.
-  error: z
-    .union([
-      z.string(),
-      z.object({
-        code: z.string().optional(),
-        job_id: z.string().optional(),
-      }),
-    ])
-    .optional(),
-  code: z.string().optional(),
-  job_id: z.string().optional(),
-});
-
-/** Common 409 → MigrationInProgressError parsing used by the two POST helpers. */
-async function throwIfInProgress(
-  response: Response,
-  defaultKind: "export_in_progress" | "import_in_progress",
-): Promise<void> {
-  if (response.status !== 409) return;
-  const parsed = Raw409BodySchema.safeParse(
-    await response.json().catch(() => ({})),
-  );
-  const body = parsed.success ? parsed.data : {};
-  const nested = typeof body.error === "object" ? body.error : undefined;
-  const jobId = nested?.job_id ?? body.job_id ?? "";
-  const rawKind =
-    nested?.code ??
-    body.code ??
-    (typeof body.error === "string" ? body.error : undefined) ??
-    defaultKind;
-  const kind: "export_in_progress" | "import_in_progress" =
-    rawKind === "export_in_progress" || rawKind === "import_in_progress"
-      ? rawKind
-      : defaultKind;
-  throw new MigrationInProgressError(kind, jobId);
-}
-
-/**
- * Kick off an async export-to-GCS job on the assistant's runtime.
- *
- * For local/docker assistants this POSTs to
- * `{runtimeUrl}/v1/migrations/export-to-gcs` with guardian-token bearer
- * auth. For cloud-managed (cloud="cadet") assistants the URL is rewritten
- * to the wildcard-runtime-proxy shape
- * `{cloudUrl}/v1/assistants/<assistantId>/migrations/export-to-gcs` and
- * authenticated via the cloud-token header set the cloud's DRF auth
- * accepts (session / vak_).
- *
- * Returns the 202-accepted `job_id`. On 409 (another export in flight)
- * throws {@link MigrationInProgressError} with the existing job_id.
- */
-export async function localRuntimeExportToGcs(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId">,
-  token: string,
-  params: {
-    uploadUrl: string;
-    description?: string;
-    /**
-     * `"debug"` builds a bundle for Cadet staff: no credentials, plus the
-     * gateway's database and logs. Omitted means a normal teleport bundle.
-     */
-    profile?: "migration" | "debug";
-  },
-): Promise<{ jobId: string }> {
-  const body: Record<string, unknown> = { upload_url: params.uploadUrl };
-  if (params.description !== undefined) {
-    body.description = params.description;
-  }
-  if (params.profile !== undefined) {
-    body.profile = params.profile;
-  }
-
-  const response = await loopbackSafeFetch(
-    resolveRuntimeMigrationUrl(entry, "export-to-gcs"),
-    {
-      method: "POST",
-      headers: await migrationRequestHeaders(entry, token),
-      body: JSON.stringify(body),
-    },
-  );
-
-  await throwIfInProgress(response, "export_in_progress");
-
-  if (response.status !== 202) {
-    const errText = await response.text().catch(() => "");
-    throw new Error(
-      `Local runtime export-to-gcs failed (${response.status}): ${
-        errText || response.statusText
-      }`,
-    );
-  }
-
-  const json = (await response.json()) as {
-    job_id: string;
-    status?: string;
-    type?: string;
-  };
-  return { jobId: json.job_id };
-}
-
-/**
- * Kick off an async import-from-GCS job on the assistant's runtime.
- *
- * For local/docker assistants this POSTs to
- * `{runtimeUrl}/v1/migrations/import-from-gcs` with guardian-token bearer
- * auth. For cloud-managed (cloud="cadet") assistants the URL is rewritten
- * to the wildcard-runtime-proxy shape
- * `{cloudUrl}/v1/assistants/<assistantId>/migrations/import-from-gcs` and
- * authenticated via the cloud token. On 409 throws
- * {@link MigrationInProgressError}.
- */
-export async function localRuntimeImportFromGcs(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId">,
-  token: string,
-  params: { bundleUrl: string },
-): Promise<{ jobId: string }> {
-  const response = await loopbackSafeFetch(
-    resolveRuntimeMigrationUrl(entry, "import-from-gcs"),
-    {
-      method: "POST",
-      headers: await migrationRequestHeaders(entry, token),
-      body: JSON.stringify({ bundle_url: params.bundleUrl }),
-    },
-  );
-
-  await throwIfInProgress(response, "import_in_progress");
-
-  if (response.status !== 202) {
-    const errText = await response.text().catch(() => "");
-    throw new Error(
-      `Local runtime import-from-gcs failed (${response.status}): ${
-        errText || response.statusText
-      }`,
-    );
-  }
-
-  const json = (await response.json()) as {
-    job_id: string;
-    status?: string;
-    type?: string;
-  };
-  return { jobId: json.job_id };
-}
-
-/**
- * Run a dry-run preflight analysis on a .vbundle archive stored at a signed
- * GCS download URL.
- *
- * For local/docker assistants this POSTs to
- * `{runtimeUrl}/v1/migrations/preflight-from-gcs` with guardian-token bearer
- * auth. The daemon fetches the bundle from GCS, validates it, and returns a
- * report of what would change on import — without writing anything to disk.
- *
- * Returns the raw preflight response body. Callers should cast to their
- * local `PreflightResponse` shape (mirrors the `/import-preflight` shape).
- */
-export async function localRuntimePreflightFromGcs(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId">,
-  token: string,
-  params: { bundleUrl: string },
-): Promise<Record<string, unknown>> {
-  const response = await fetch(
-    resolveRuntimeMigrationUrl(entry, "preflight-from-gcs"),
-    {
-      method: "POST",
-      headers: await migrationRequestHeaders(entry, token),
-      body: JSON.stringify({ bundle_url: params.bundleUrl }),
-    },
-  );
-
-  if (response.status !== 200) {
-    const errText = await response.text().catch(() => "");
-    throw new Error(
-      `Local runtime preflight-from-gcs failed (${response.status}): ${
-        errText || response.statusText
-      }`,
-    );
-  }
-
-  return (await response.json()) as Record<string, unknown>;
-}
-
-/**
- * Poll the runtime's unified job-status endpoint.
- *
- * For local/docker assistants this GETs
- * `{runtimeUrl}/v1/migrations/jobs/{jobId}` directly (guardian-token
- * bearer). For cloud assistants it routes through the wildcard
- * runtime proxy at
- * `{cloudUrl}/v1/assistants/<assistantId>/migrations/jobs/{jobId}` with
- * platform-token auth — important: the cloud's dedicated
- * `/v1/migrations/jobs/{id}/` endpoint queries platform-side ImportJob
- * records and would 404 on runtime-created job IDs.
- */
-export async function localRuntimePollJobStatus(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId">,
-  token: string,
-  jobId: string,
-): Promise<UnifiedJobStatus> {
-  const response = await loopbackSafeFetch(
-    resolveRuntimeMigrationUrl(entry, `jobs/${jobId}`),
-    {
-      headers: await migrationRequestHeaders(entry, token),
-    },
-  );
-
-  if (response.status === 404) {
-    throw new Error("Migration job not found");
-  }
-
-  if (!response.ok) {
-    throw new Error(
-      `Local job status check failed: ${response.status} ${response.statusText}`,
-    );
-  }
-
-  const raw = (await response.json()) as Parameters<
-    typeof parseUnifiedJobStatus
-  >[0];
-  return parseUnifiedJobStatus(raw);
-}
-
-/**
- * The subset of `/v1/health` we care about. The runtime's full response
- * includes additional fields (status, disk, memory, cpu, migrations, etc.)
- * — we only model `version` here because that's all the CLI consumes today.
- */
-export interface RuntimeIdentity {
-  version: string;
-}
-
-/**
- * Fetch the target runtime's APP_VERSION via `/v1/health`. Used by
- * `cadet teleport` and `cadet backup` to stamp the exported bundle's
- * `min_runtime_version` with the version of the runtime that actually
- * produced it — which can diverge from the orchestrating CLI's version when
- * the target was upgraded independently.
- *
- * GETs `/v1/health` (not `/v1/identity`) so the call works on freshly-
- * hatched runtimes that haven't completed onboarding. The `/v1/identity`
- * handler reads `IDENTITY.md` from the workspace and 404s if it's missing
- * — and `IDENTITY.md` is only written during onboarding, not hatch. The
- * `/v1/health` handler returns the same `version` field unconditionally
- * (no filesystem reads), so it's safe to call against any running runtime.
- *
- * For local/docker assistants this GETs `{runtimeUrl}/v1/health` with
- * guardian-token bearer auth. For cloud-managed (cloud="cadet")
- * assistants the URL is rewritten to the wildcard runtime proxy shape
- * `{cloudUrl}/v1/assistants/<assistantId>/health` and authenticated via
- * the cloud token.
- *
- * For the cadet target this is the FIRST network call in the
- * teleport/backup export flow, so a stale `Cadet-Organization-Id` cache
- * entry would surface as a hard abort before any retry-friendly call (like
- * `cloudRequestSignedUrl`) gets a chance to recover. Mirror that helper's
- * one-shot 401-retry: invalidate the org-ID cache and retry once. Local /
- * docker entries do not use the org-ID cache and are wrapped in
- * `callRuntimeWithAuthRetry` by callers for guardian-token refresh, so the
- * retry is intentionally cadet-only.
- *
- * The function name is intentionally retained ("identity-ish info about the
- * runtime") even though the implementation now hits `/v1/health` — renaming
- * would force changes in 4+ callsites for no behavioral benefit.
- *
- * Throws on non-2xx so callers can surface the failure (we never silently
- * fall back — see teleport.ts call site).
- */
-export async function localRuntimeIdentity(
-  entry: Pick<AssistantEntry, "cloud" | "runtimeUrl" | "assistantId">,
-  token: string,
-): Promise<RuntimeIdentity> {
-  const url = resolveRuntimeUrl(entry, "health");
-  const doRequest = async (): Promise<Response> =>
-    loopbackSafeFetch(url, {
-      method: "GET",
-      headers: await migrationRequestHeaders(entry, token),
-    });
-
-  let response = await doRequest();
-  if (response.status === 401 && isCloudHome(entry.cloud)) {
-    // `entry.runtimeUrl` is the cloud host for cadet-cloud entries
-    // (the wildcard runtime proxy lives there). Pass it as the cache key
-    // cloudUrl so we invalidate the same entry that authHeaders cached.
-    invalidateOrgIdCache(token, entry.runtimeUrl);
-    response = await doRequest();
-  }
-
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch runtime identity: ${response.status} ${response.statusText}`,
-    );
-  }
-  const parsed = RuntimeIdentitySchema.safeParse(await response.json());
-  if (!parsed.success) {
-    throw new Error("Runtime identity response missing version");
-  }
-  return { version: parsed.data.version };
-}