@vellumai/cli 0.8.0 → 0.8.2

package/src/lib/upgrade-lifecycle.ts

@@ -18,7 +18,6 @@ import {
 import { getStateDir } from "./environments/paths.js";
 import { getCurrentEnvironment } from "./environments/resolve.js";
 import { loadGuardianToken } from "./guardian-token.js";
-import { getPlatformUrl } from "./platform-client.js";
 import { resolveImageRefs } from "./platform-releases.js";
 import { exec, execOutput } from "./step-runner.js";
 import { compareVersions } from "./version-compat.js";
@@ -481,42 +480,6 @@ export async function performDockerRollback(
   console.log("🔍 Resolving image references...");
   const { imageTags: targetImageTags } = await resolveImageRefs(targetVersion);
 
-  // Fetch target migration ceiling from releases API
-  let targetMigrationCeiling: {
-    dbVersion?: number;
-    workspaceMigrationId?: string;
-  } = {};
-  try {
-    const platformUrl = getPlatformUrl();
-    const releasesResp = await fetch(
-      `${platformUrl}/v1/releases/?stable=true`,
-      { signal: AbortSignal.timeout(10000) },
-    );
-    if (releasesResp.ok) {
-      const releases = (await releasesResp.json()) as Array<{
-        version: string;
-        db_migration_version?: number | null;
-        last_workspace_migration_id?: string;
-      }>;
-      const normalizedTag = targetVersion.replace(/^v/, "");
-      const targetRelease = releases.find(
-        (r) => r.version?.replace(/^v/, "") === normalizedTag,
-      );
-      if (
-        targetRelease?.db_migration_version != null ||
-        targetRelease?.last_workspace_migration_id
-      ) {
-        targetMigrationCeiling = {
-          dbVersion: targetRelease.db_migration_version ?? undefined,
-          workspaceMigrationId:
-            targetRelease.last_workspace_migration_id || undefined,
-        };
-      }
-    }
-  } catch {
-    // Best-effort — fall back to rollbackToRegistryCeiling post-swap
-  }
-
   // Capture current image digests for auto-rollback on failure
   console.log("📸 Capturing current image references for rollback...");
   const currentImageRefs = await captureImageRefs(res);
@@ -702,26 +665,6 @@ export async function performDockerRollback(
   }
   console.log("✅ Docker images pulled\n");
 
-  // Pre-swap migration rollback to target ceiling on the CURRENT (newer) daemon
-  let preSwapRollbackOk = true;
-  if (
-    targetMigrationCeiling.dbVersion !== undefined ||
-    targetMigrationCeiling.workspaceMigrationId !== undefined
-  ) {
-    console.log("🔄 Reverting database changes...");
-    await broadcastUpgradeEvent(
-      entry.runtimeUrl,
-      entry.assistantId,
-      buildProgressEvent(UPGRADE_PROGRESS.REVERTING_MIGRATIONS),
-    );
-    preSwapRollbackOk = await rollbackMigrations(
-      entry.runtimeUrl,
-      entry.assistantId,
-      targetMigrationCeiling.dbVersion,
-      targetMigrationCeiling.workspaceMigrationId,
-    );
-  }
-
   // Progress: switching version
   await broadcastUpgradeEvent(
     entry.runtimeUrl,
@@ -757,22 +700,15 @@ export async function performDockerRollback(
   if (ready) {
     // Success path
 
-    // Post-swap migration rollback fallback: if pre-swap rollback failed
-    // or no ceiling metadata was available, ask the now-running old daemon
-    // to roll back migrations above its own registry ceiling.
-    if (
-      !preSwapRollbackOk ||
-      (targetMigrationCeiling.dbVersion === undefined &&
-        targetMigrationCeiling.workspaceMigrationId === undefined)
-    ) {
-      await rollbackMigrations(
-        entry.runtimeUrl,
-        entry.assistantId,
-        undefined,
-        undefined,
-        true,
-      );
-    }
+    // Post-swap migration rollback: ask the now-running old daemon to roll
+    // back any migrations above its own registry ceiling.
+    await rollbackMigrations(
+      entry.runtimeUrl,
+      entry.assistantId,
+      undefined,
+      undefined,
+      true,
+    );
 
     // Capture new digests from the rolled-back containers
     const newDigests = await captureImageRefs(res);

package/src/shared/provider-env-vars.ts

@@ -1,13 +1,16 @@
 /**
  * Provider API key environment variable names, keyed by provider ID.
  *
- * Two sources are merged into a single combined map:
+ * Two sources are merged into a single combined map. Both are locally-
+ * maintained mirrors of canonical catalogs in `assistant/src/providers/`
+ * — the CLI does not import from `assistant/src/`, so drift is caught by
+ * dedicated parity tests:
  *
- *   1. Search-provider env vars — hardcoded below (Brave, Perplexity).
- *   2. LLM-provider env vars — sourced from `PROVIDER_CATALOG` in
- *      `assistant/src/providers/model-catalog.ts` via a locally-maintained
- *      mirror (the CLI does not import from `assistant/src/`; drift is caught
- *      by `cli/src/__tests__/llm-provider-env-var-parity.test.ts`).
+ *   1. LLM-provider env vars — mirrors `PROVIDER_CATALOG` entries with an
+ *      `envVar`. Drift guard: `cli/src/__tests__/llm-provider-env-var-parity.test.ts`.
+ *   2. Search-provider env vars — mirrors `SEARCH_PROVIDER_CATALOG`
+ *      entries with an `envVar`. Drift guard:
+ *      `cli/src/__tests__/search-provider-env-var-parity.test.ts`.
  *
  * The combined map is what cloud-infra code (docker.ts, aws.ts, gcp.ts)
  * iterates to forward provider API keys from the caller's environment into
@@ -23,12 +26,16 @@ export const LLM_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
   gemini: "GEMINI_API_KEY",
   fireworks: "FIREWORKS_API_KEY",
   openrouter: "OPENROUTER_API_KEY",
+  zai: "ZAI_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  minimax: "MINIMAX_API_KEY",
 };
 
-/** Search-provider env var names. */
+/** Search-provider env var names. Mirrors `SEARCH_PROVIDER_CATALOG` BYOK entries. */
 export const SEARCH_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
-  brave: "BRAVE_API_KEY",
   perplexity: "PERPLEXITY_API_KEY",
+  brave: "BRAVE_API_KEY",
+  tavily: "TAVILY_API_KEY",
 };
 
 /**

package/src/lib/doctor-client.ts

@@ -1,153 +0,0 @@
-const DOCTOR_URL = process.env.DOCTOR_SERVICE_URL?.trim() || "";
-
-export type ProgressPhase =
-  | "invoking_prompt"
-  | "calling_tool"
-  | "processing_tool_result";
-
-export interface ProgressEvent {
-  phase: ProgressPhase;
-  toolName?: string;
-}
-
-interface DoctorResult {
-  assistantId: string;
-  diagnostics: string | null;
-  recommendation: string | null;
-  error: string | null;
-}
-
-export interface ChatLogEntry {
-  role: "user" | "assistant" | "error";
-  content: string;
-}
-
-type DoctorProgressCallback = (event: ProgressEvent) => void;
-type DoctorLogCallback = (message: string) => void;
-
-async function streamDoctorResponse(
-  response: globalThis.Response,
-  onProgress?: DoctorProgressCallback,
-  onLog?: DoctorLogCallback,
-): Promise<DoctorResult> {
-  if (!response.body) {
-    throw new Error(
-      `No response body from doctor (HTTP ${response.status} ${response.statusText})`,
-    );
-  }
-
-  let result: DoctorResult | null = null;
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let chunkCount = 0;
-  const receivedEventTypes: string[] = [];
-
-  try {
-    for await (const chunk of response.body) {
-      chunkCount++;
-      buffer += decoder.decode(chunk, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() ?? "";
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        const parsed = JSON.parse(line) as { type: string } & Record<
-          string,
-          unknown
-        >;
-        receivedEventTypes.push(parsed.type);
-        if (parsed.type === "progress") {
-          onProgress?.(parsed as unknown as ProgressEvent);
-        } else if (parsed.type === "log") {
-          onLog?.((parsed as unknown as { message: string }).message);
-        } else if (parsed.type === "result") {
-          result = parsed as unknown as DoctorResult;
-        }
-      }
-    }
-  } catch (streamErr) {
-    const detail =
-      streamErr instanceof Error ? streamErr.message : String(streamErr);
-    throw new Error(
-      `Doctor stream interrupted after ${chunkCount} chunks ` +
-        `(received events: [${receivedEventTypes.join(", ")}]): ${detail}`,
-    );
-  }
-
-  if (buffer.trim()) {
-    const parsed = JSON.parse(buffer) as { type: string } & Record<
-      string,
-      unknown
-    >;
-    receivedEventTypes.push(parsed.type);
-    if (parsed.type === "result") {
-      result = parsed as unknown as DoctorResult;
-    }
-  }
-
-  if (!result) {
-    throw new Error(
-      `No result received from doctor. ` +
-        `HTTP ${response.status}, ${chunkCount} chunks read, ` +
-        `events received: [${receivedEventTypes.join(", ")}], ` +
-        `trailing buffer: ${buffer.trim() ? JSON.stringify(buffer.trim().slice(0, 200)) : "(empty)"}`,
-    );
-  }
-
-  return result;
-}
-
-async function callDoctorDaemon(
-  assistantId: string,
-  project?: string,
-  zone?: string,
-  userPrompt?: string,
-  onProgress?: DoctorProgressCallback,
-  sessionId?: string,
-  chatContext?: ChatLogEntry[],
-  onLog?: DoctorLogCallback,
-): Promise<DoctorResult> {
-  if (!DOCTOR_URL) {
-    onLog?.("Doctor service not configured (DOCTOR_SERVICE_URL is not set)");
-    return {
-      assistantId,
-      diagnostics: null,
-      recommendation: null,
-      error: "Doctor service not configured",
-    };
-  }
-
-  const MAX_RETRIES = 2;
-  let lastError: unknown;
-
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    try {
-      const response = await fetch(`${DOCTOR_URL}/doctor`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          assistantId,
-          project,
-          zone,
-          userPrompt,
-          sessionId,
-          chatContext,
-        }),
-      });
-      return await streamDoctorResponse(response, onProgress, onLog);
-    } catch (err) {
-      lastError = err;
-      const errMsg = err instanceof Error ? err.message : String(err);
-      const logMsg = `[doctor-client] Attempt ${attempt + 1}/${MAX_RETRIES} failed: ${errMsg}`;
-      onLog?.(logMsg);
-      if (attempt < MAX_RETRIES - 1) {
-        await new Promise((resolve) => setTimeout(resolve, 500));
-      }
-    }
-  }
-
-  throw lastError;
-}
-
-export { callDoctorDaemon };
-export type { DoctorProgressCallback, DoctorResult };