@vellumai/cli 0.5.6 → 0.5.8

package/src/lib/platform-client.ts

@@ -9,8 +9,6 @@ import {
 import { homedir } from "os";
 import { join, dirname } from "path";
 
-const DEFAULT_PLATFORM_URL = "https://platform.vellum.ai";
-
 function getXdgConfigHome(): string {
   return process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
 }
@@ -20,7 +18,25 @@ function getPlatformTokenPath(): string {
 }
 
 export function getPlatformUrl(): string {
-  return process.env.VELLUM_PLATFORM_URL ?? DEFAULT_PLATFORM_URL;
+  let configUrl: string | undefined;
+  try {
+    const base = process.env.BASE_DATA_DIR?.trim() || homedir();
+    const configPath = join(base, ".vellum", "workspace", "config.json");
+    if (existsSync(configPath)) {
+      const raw = JSON.parse(readFileSync(configPath, "utf-8")) as Record<
+        string,
+        unknown
+      >;
+      const val = (raw.platform as Record<string, unknown> | undefined)
+        ?.baseUrl;
+      if (typeof val === "string" && val.trim()) configUrl = val.trim();
+    }
+  } catch {
+    // Config not available — fall through
+  }
+  return (
+    configUrl || process.env.VELLUM_PLATFORM_URL || "https://platform.vellum.ai"
+  );
 }
 
 export function readPlatformToken(): string | null {
@@ -113,3 +129,189 @@ export async function fetchCurrentUser(token: string): Promise<PlatformUser> {
   const body = (await response.json()) as AllauthSessionResponse;
   return body.data.user;
 }
+
+// ---------------------------------------------------------------------------
+// Rollback
+// ---------------------------------------------------------------------------
+
+export async function rollbackPlatformAssistant(
+  token: string,
+  orgId: string,
+  version?: string,
+): Promise<{ detail: string; version: string | null }> {
+  const platformUrl = getPlatformUrl();
+  const response = await fetch(`${platformUrl}/v1/assistants/rollback/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Session-Token": token,
+      "Vellum-Organization-Id": orgId,
+    },
+    body: JSON.stringify(version ? { version } : {}),
+  });
+
+  const body = (await response.json().catch(() => ({}))) as {
+    detail?: string;
+    version?: string | null;
+  };
+
+  if (response.status === 200) {
+    return { detail: body.detail ?? "", version: body.version ?? null };
+  }
+
+  if (response.status === 400) {
+    throw new Error(body.detail ?? "Rollback failed: bad request");
+  }
+
+  if (response.status === 404) {
+    throw new Error(body.detail ?? "Rollback target not found");
+  }
+
+  if (response.status === 502) {
+    throw new Error(body.detail ?? "Rollback failed: transport error");
+  }
+
+  throw new Error(`Rollback failed: ${response.status} ${response.statusText}`);
+}
+
+// ---------------------------------------------------------------------------
+// Migration export
+// ---------------------------------------------------------------------------
+
+export async function platformInitiateExport(
+  token: string,
+  orgId: string,
+  description?: string,
+): Promise<{ jobId: string; status: string }> {
+  const platformUrl = getPlatformUrl();
+  const response = await fetch(`${platformUrl}/v1/migrations/export/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Session-Token": token,
+      "Vellum-Organization-Id": orgId,
+    },
+    body: JSON.stringify({ description: description ?? "CLI backup" }),
+  });
+
+  if (response.status !== 201) {
+    const body = (await response.json().catch(() => ({}))) as {
+      detail?: string;
+    };
+    throw new Error(
+      body.detail ??
+        `Export initiation failed: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const body = (await response.json()) as {
+    job_id: string;
+    status: string;
+  };
+  return { jobId: body.job_id, status: body.status };
+}
+
+export async function platformPollExportStatus(
+  jobId: string,
+  token: string,
+  orgId: string,
+): Promise<{ status: string; downloadUrl?: string; error?: string }> {
+  const platformUrl = getPlatformUrl();
+  const response = await fetch(
+    `${platformUrl}/v1/migrations/export/${jobId}/status/`,
+    {
+      headers: {
+        "X-Session-Token": token,
+        "Vellum-Organization-Id": orgId,
+      },
+    },
+  );
+
+  if (response.status === 404) {
+    throw new Error("Export job not found");
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      `Export status check failed: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const body = (await response.json()) as {
+    status: string;
+    download_url?: string;
+    error?: string;
+  };
+  return {
+    status: body.status,
+    downloadUrl: body.download_url,
+    error: body.error,
+  };
+}
+
+export async function platformDownloadExport(
+  downloadUrl: string,
+): Promise<Response> {
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(
+      `Download failed: ${response.status} ${response.statusText}`,
+    );
+  }
+  return response;
+}
+
+// ---------------------------------------------------------------------------
+// Migration import
+// ---------------------------------------------------------------------------
+
+export async function platformImportPreflight(
+  bundleData: Uint8Array<ArrayBuffer>,
+  token: string,
+  orgId: string,
+): Promise<{ statusCode: number; body: Record<string, unknown> }> {
+  const platformUrl = getPlatformUrl();
+  const response = await fetch(
+    `${platformUrl}/v1/migrations/import-preflight/`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        "X-Session-Token": token,
+        "Vellum-Organization-Id": orgId,
+      },
+      body: new Blob([bundleData]),
+      signal: AbortSignal.timeout(120_000),
+    },
+  );
+
+  const body = (await response.json().catch(() => ({}))) as Record<
+    string,
+    unknown
+  >;
+  return { statusCode: response.status, body };
+}
+
+export async function platformImportBundle(
+  bundleData: Uint8Array<ArrayBuffer>,
+  token: string,
+  orgId: string,
+): Promise<{ statusCode: number; body: Record<string, unknown> }> {
+  const platformUrl = getPlatformUrl();
+  const response = await fetch(`${platformUrl}/v1/migrations/import/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/octet-stream",
+      "X-Session-Token": token,
+      "Vellum-Organization-Id": orgId,
+    },
+    body: new Blob([bundleData]),
+    signal: AbortSignal.timeout(120_000),
+  });
+
+  const body = (await response.json().catch(() => ({}))) as Record<
+    string,
+    unknown
+  >;
+  return { statusCode: response.status, body };
+}

package/src/lib/platform-releases.ts

@@ -0,0 +1,112 @@
+import { getPlatformUrl } from "./platform-client.js";
+import { DOCKERHUB_IMAGES } from "./docker.js";
+import type { ServiceName } from "./docker.js";
+
+export interface ResolvedImageRefs {
+  imageTags: Record<ServiceName, string>;
+  source: "platform" | "dockerhub";
+}
+
+/**
+ * Resolve image references for a given version.
+ *
+ * Tries the platform API first (returns GCR digest-based refs when available),
+ * then falls back to DockerHub tag-based refs when the platform is unreachable
+ * or the version is not found.
+ */
+export async function resolveImageRefs(
+  version: string,
+  log?: (msg: string) => void,
+): Promise<ResolvedImageRefs> {
+  log?.("Resolving image references...");
+
+  const platformRefs = await fetchPlatformImageRefs(version, log);
+  if (platformRefs) {
+    log?.("Resolved image refs from platform API");
+    return { imageTags: platformRefs, source: "platform" };
+  }
+
+  log?.("Falling back to DockerHub tags");
+  const imageTags: Record<ServiceName, string> = {
+    assistant: `${DOCKERHUB_IMAGES.assistant}:${version}`,
+    "credential-executor": `${DOCKERHUB_IMAGES["credential-executor"]}:${version}`,
+    gateway: `${DOCKERHUB_IMAGES.gateway}:${version}`,
+  };
+  return { imageTags, source: "dockerhub" };
+}
+
+/**
+ * Fetch image references from the platform releases API.
+ *
+ * Returns a record of service name to image ref (GCR digest-based) for the
+ * given version, or null if the platform is unreachable, the version is not
+ * found, or any error occurs.
+ */
+async function fetchPlatformImageRefs(
+  version: string,
+  log?: (msg: string) => void,
+): Promise<Record<ServiceName, string> | null> {
+  try {
+    const platformUrl = getPlatformUrl();
+    const url = `${platformUrl}/v1/releases/?stable=true`;
+
+    log?.(`Fetching releases from ${url}`);
+
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(10_000),
+    });
+
+    if (!response.ok) {
+      log?.(`Platform API returned ${response.status}`);
+      return null;
+    }
+
+    const releases = (await response.json()) as Array<{
+      version?: string;
+      assistant_image_ref?: string | null;
+      gateway_image_ref?: string | null;
+      credential_executor_image_ref?: string | null;
+    }>;
+
+    // Strip leading "v" from the requested version for matching
+    const normalizedVersion = version.replace(/^v/, "");
+
+    const release = releases.find((r) => {
+      const releaseVersion = (r.version ?? "").replace(/^v/, "");
+      return releaseVersion === normalizedVersion;
+    });
+
+    if (!release) {
+      log?.(`Version ${version} not found in platform releases`);
+      return null;
+    }
+
+    const assistantImage = release.assistant_image_ref;
+    const gatewayImage = release.gateway_image_ref;
+    let credentialExecutorImage = release.credential_executor_image_ref;
+
+    // Assistant and gateway images are required; credential-executor falls back to DockerHub
+    if (!assistantImage || !gatewayImage) {
+      log?.("Platform release missing required image refs");
+      return null;
+    }
+
+    // Fall back to DockerHub for credential-executor if its image ref is null
+    if (!credentialExecutorImage) {
+      credentialExecutorImage = `${DOCKERHUB_IMAGES["credential-executor"]}:${version}`;
+      log?.(
+        "credential-executor image not in platform release, using DockerHub fallback",
+      );
+    }
+
+    return {
+      assistant: assistantImage,
+      "credential-executor": credentialExecutorImage,
+      gateway: gatewayImage,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log?.(`Platform image ref resolution failed: ${message}`);
+    return null;
+  }
+}