@vellumai/cli 0.10.8-dev.202607152039.bc8b1a6 → 0.10.8-staging.1

package/node_modules/@vellumai/local-mode/src/__tests__/gateway-proxy.test.ts

@@ -1,12 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 
-import {
-  readAllowedGatewayPorts,
-  resolveGatewayProxyTarget,
-} from "../gateway-proxy";
+import { resolveGatewayProxyTarget } from "../gateway-proxy";
 
 const allow =
   (...ports: number[]) =>
@@ -70,41 +64,6 @@ describe("resolveGatewayProxyTarget", () => {
     });
   });
 
-  test("allowlists ports from resources, loopback URLs, and docker runtimeUrls — never remote URLs", () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "gateway-proxy-test-"));
-    const lockfilePath = path.join(dir, "assistants.json");
-    try {
-      fs.writeFileSync(
-        lockfilePath,
-        JSON.stringify({
-          assistants: [
-            { assistantId: "local-a", resources: { gatewayPort: 7830 } },
-            { assistantId: "local-b", localUrl: "http://127.0.0.1:7831" },
-            // Docker entries record their published gateway only as a
-            // loopback runtimeUrl.
-            {
-              assistantId: "docker-a",
-              cloud: "docker",
-              runtimeUrl: "http://localhost:7930",
-            },
-            // Remote runtimeUrls (managed / gcp / paired) must never widen
-            // the allowlist.
-            {
-              assistantId: "remote-a",
-              cloud: "gcp",
-              runtimeUrl: "https://assistant.example.com:8443",
-            },
-          ],
-        }),
-      );
-      expect(readAllowedGatewayPorts([lockfilePath])).toEqual(
-        new Set([7830, 7831, 7930]),
-      );
-    } finally {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
   test("never reads the allowlist for non-gateway or invalid-port paths", () => {
     let reads = 0;
     const counting = () => {

package/node_modules/@vellumai/local-mode/src/gateway-proxy.ts

@@ -87,7 +87,6 @@ export function readAllowedGatewayPorts(lockfilePaths: string[]): Set<number> {
         assistants?: Array<{
           gatewayUrl?: unknown;
           localUrl?: unknown;
-          runtimeUrl?: unknown;
           resources?: { gatewayPort?: unknown };
         }>;
       };
@@ -96,10 +95,6 @@ export function readAllowedGatewayPorts(lockfilePaths: string[]): Set<number> {
         if (!assistant) continue;
         addPortFromUrl(assistant.gatewayUrl, ports);
         addPortFromUrl(assistant.localUrl, ports);
-        // Docker entries record their published gateway as a loopback
-        // `runtimeUrl` with no `resources` block; the loopback-hostname filter
-        // in addPortFromUrl keeps remote runtimeUrls out of the allowlist.
-        addPortFromUrl(assistant.runtimeUrl, ports);
         const gp = assistant.resources?.gatewayPort;
         if (typeof gp === "number" && Number.isInteger(gp) && gp >= 1024 && gp <= 65535) {
           ports.add(gp);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.8-dev.202607152039.bc8b1a6",
+  "version": "0.10.8-staging.1",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

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

@@ -7,7 +7,6 @@ import {
   AVATAR_DEVICE_ENV_VAR,
   collectWatchTargets,
   dockerResourceNames,
-  ensureDockerDaemonRunning,
   resolveAvatarDevicePath,
   resolveDockerHatchMode,
   resolveDockerProviderCredentialSetupAction,
@@ -381,58 +380,3 @@ 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, ensuring a Docker daemon is up first (macOS only). */
+/** Start existing stopped containers, starting Colima first if it isn't running (macOS only). */
 export async function wakeContainers(
   res: ReturnType<typeof dockerResourceNames>,
 ): Promise<void> {
   if (platform() !== "linux") {
-    await ensureDockerDaemonRunning();
+    await ensureColimaRunning();
   }
   for (const container of [
     res.assistantContainer,
@@ -793,42 +793,16 @@ export async function wakeContainers(
 }
 
 /**
- * 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).
+ * Checks whether Colima is running and starts it if not.
+ * Assumes the Docker/Colima toolchain is already installed (handled during hatch).
  */
-export async function ensureDockerDaemonRunning(
-  execFn: typeof exec = exec,
-): Promise<void> {
+async function ensureColimaRunning(): 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 execFn("colima", ["status"]);
+    await exec("colima", ["status"]);
   } catch {
-    console.log("🚀 Docker daemon not running. Starting Colima...");
-    await execFn("colima", ["start"]);
+    console.log("🚀 Colima is not running. Starting Colima...");
+    await exec("colima", ["start"]);
   }
 }
 

package/src/lib/provider-secrets.ts

@@ -176,11 +176,6 @@ export function inferProviderFromModel(model: string): string | undefined {
   if (model.startsWith("accounts/fireworks/models/")) {
     return "fireworks";
   }
-  if (model.startsWith("openai/gpt-5.6")) {
-    // Listed by OpenRouter (#37856), the earlier catalog entry; the Vercel
-    // AI Gateway does not carry these IDs.
-    return "openrouter";
-  }
   if (model.startsWith("openai/") || model.startsWith("xai/")) {
     return "vercel-ai-gateway";
   }