@vellumai/cli 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.9",
+  "version": "0.10.10-dev.202607162206.d08e98e",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/lib/__tests__/docker.test.ts

@@ -7,6 +7,7 @@ import {
   AVATAR_DEVICE_ENV_VAR,
   collectWatchTargets,
   dockerResourceNames,
+  ensureDockerDaemonRunning,
   resolveAvatarDevicePath,
   resolveDockerHatchMode,
   resolveDockerProviderCredentialSetupAction,
@@ -380,3 +381,58 @@ describe("collectWatchTargets", () => {
     expect(files).toEqual([join(repoRoot, "gateway", "package.json")]);
   });
 });
+
+/**
+ * Build a fake `exec` that records calls and fails the probes named in `fail`.
+ * Injected into `ensureDockerDaemonRunning` so these cases need no `mock.module`
+ * (which is process-global and would leak across the CLI's single-process test
+ * run) and no real Docker/Colima subprocesses.
+ */
+function fakeExec(fail: { dockerInfo?: boolean; colimaStatus?: boolean }) {
+  const calls: Array<{ cmd: string; args: string[] }> = [];
+  const exec = async (cmd: string, args: string[] = []): Promise<void> => {
+    calls.push({ cmd, args });
+    if (cmd === "docker" && args[0] === "info" && fail.dockerInfo) {
+      throw new Error("Cannot connect to the Docker daemon");
+    }
+    if (cmd === "colima" && args[0] === "status" && fail.colimaStatus) {
+      throw new Error("colima is not running");
+    }
+  };
+  const ran = (cmd: string, sub: string): boolean =>
+    calls.some((c) => c.cmd === cmd && c.args[0] === sub);
+  return { exec: exec as typeof import("../step-runner.js").exec, ran };
+}
+
+describe("ensureDockerDaemonRunning", () => {
+  // Regression: waking an instance hatched under Docker Desktop must NOT start
+  // Colima, because that switches the active `docker context` and points
+  // `docker start` at a VM that never held the instance's containers.
+  test("reuses an already-reachable daemon (e.g. Docker Desktop) and never touches Colima", async () => {
+    const { exec, ran } = fakeExec({ dockerInfo: false });
+
+    await ensureDockerDaemonRunning(exec);
+
+    expect(ran("docker", "info")).toBe(true);
+    expect(ran("colima", "status")).toBe(false);
+    expect(ran("colima", "start")).toBe(false);
+  });
+
+  test("starts Colima only when no daemon is reachable", async () => {
+    const { exec, ran } = fakeExec({ dockerInfo: true, colimaStatus: true });
+
+    await ensureDockerDaemonRunning(exec);
+
+    expect(ran("docker", "info")).toBe(true);
+    expect(ran("colima", "start")).toBe(true);
+  });
+
+  test("does not restart Colima when it is already running", async () => {
+    const { exec, ran } = fakeExec({ dockerInfo: true, colimaStatus: false });
+
+    await ensureDockerDaemonRunning(exec);
+
+    expect(ran("colima", "status")).toBe(true);
+    expect(ran("colima", "start")).toBe(false);
+  });
+});

package/src/lib/docker.ts

@@ -776,12 +776,12 @@ export async function sleepContainers(
   }
 }
 
-/** Start existing stopped containers, starting Colima first if it isn't running (macOS only). */
+/** Start existing stopped containers, ensuring a Docker daemon is up first (macOS only). */
 export async function wakeContainers(
   res: ReturnType<typeof dockerResourceNames>,
 ): Promise<void> {
   if (platform() !== "linux") {
-    await ensureColimaRunning();
+    await ensureDockerDaemonRunning();
   }
   for (const container of [
     res.assistantContainer,
@@ -793,16 +793,42 @@ export async function wakeContainers(
 }
 
 /**
- * Checks whether Colima is running and starts it if not.
- * Assumes the Docker/Colima toolchain is already installed (handled during hatch).
+ * Ensure a Docker daemon is reachable before waking an instance's containers
+ * (macOS only — on Linux the daemon runs natively).
+ *
+ * If a daemon is already reachable, reuse it and return: `hatch` created the
+ * containers under whatever `docker context` was active at the time (Docker
+ * Desktop, an already-running Colima, a remote context, …), and `docker start`
+ * targets the active context. Unconditionally starting Colima would switch the
+ * active context to `colima` and point `docker start` at a VM that never held
+ * those containers — so Colima is only started as a fallback when no daemon is
+ * reachable at all (the toolchain `hatch` installs on macOS when Docker Desktop
+ * isn't present). This mirrors {@link ensureDockerInstalled}, which likewise
+ * only starts Colima when `docker info` fails.
+ *
+ * `execFn` is injectable so unit tests can drive the probe outcomes without a
+ * real Docker/Colima toolchain; production callers use the real {@link exec}.
+ * Assumes the toolchain is already installed (handled during hatch).
  */
-async function ensureColimaRunning(): Promise<void> {
+export async function ensureDockerDaemonRunning(
+  execFn: typeof exec = exec,
+): Promise<void> {
   ensureLocalBinOnPath();
+
+  // A reachable daemon — Docker Desktop, a running Colima, or any other active
+  // context — is exactly what hatch used. Reuse it rather than forcing Colima.
+  try {
+    await execFn("docker", ["info"]);
+    return;
+  } catch {
+    // No daemon reachable — fall through to the Colima fallback below.
+  }
+
   try {
-    await exec("colima", ["status"]);
+    await execFn("colima", ["status"]);
   } catch {
-    console.log("🚀 Colima is not running. Starting Colima...");
-    await exec("colima", ["start"]);
+    console.log("🚀 Docker daemon not running. Starting Colima...");
+    await execFn("colima", ["start"]);
   }
 }
 

package/src/lib/provider-secrets.ts

@@ -75,6 +75,7 @@ const PROVIDER_LABELS: Record<LlmProviderId, string> = {
   minimax: "MiniMax",
   atlascloud: "Atlas Cloud",
   together: "Together AI",
+  baseten: "Baseten",
 };
 
 export function formatProviderName(provider: LlmProviderId): string {
@@ -190,6 +191,9 @@ export function inferProviderFromModel(model: string): string | undefined {
   if (model.startsWith("deepseek-ai/")) {
     return "atlascloud";
   }
+  if (model.startsWith("thinkingmachines/")) {
+    return "baseten";
+  }
   if (model.includes("/")) {
     return "openrouter";
   }

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

@@ -30,6 +30,7 @@ export const LLM_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
   minimax: "MINIMAX_API_KEY",
   atlascloud: "ATLASCLOUD_API_KEY",
   together: "TOGETHER_API_KEY",
+  baseten: "BASETEN_API_KEY",
 };
 
 /** Search-provider env var names. Mirrors `SEARCH_PROVIDER_CATALOG` BYOK entries. */