@vellumai/cli 0.8.2 → 0.8.4

package/src/__tests__/host-image-loader.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  type FetchLike,
+  HOST_IMAGE_LOADER_URL,
+  HostImageLoaderError,
+  isLocalBuildRef,
+  loadImageViaHost,
+} from "../lib/host-image-loader.js";
+
+describe("HOST_IMAGE_LOADER_URL", () => {
+  test("resolves to the well-known image-loader port/path", () => {
+    expect(HOST_IMAGE_LOADER_URL).toBe("http://127.0.0.1:5500/v1/images/load");
+  });
+});
+
+describe("isLocalBuildRef", () => {
+  test("recognizes the `vellum-local/` prefix as a local build", () => {
+    expect(isLocalBuildRef("vellum-local/assistant-server:sha-abc123")).toBe(
+      true,
+    );
+    expect(isLocalBuildRef("vellum-local/gateway:sha-def")).toBe(true);
+  });
+
+  test("treats external registry refs as pullable", () => {
+    expect(isLocalBuildRef("docker.io/example/image:v0.8.2")).toBe(false);
+    expect(
+      isLocalBuildRef("us-east1-docker.pkg.dev/example/image@sha256:deadbeef"),
+    ).toBe(false);
+    expect(isLocalBuildRef("postgres:17")).toBe(false);
+  });
+});
+
+function silentLog(_msg: string): void {
+  // intentionally swallow logs in test
+}
+
+function makeFetch(
+  responses: Array<{ url: string; body: unknown; status: number }>,
+  recordedRequests: Array<{ url: string; body: unknown }>,
+): FetchLike {
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const body = init?.body ? JSON.parse(init.body) : null;
+    recordedRequests.push({ url, body });
+    const planned = responses.shift();
+    if (!planned) throw new Error(`unexpected request to ${url}`);
+    return new Response(JSON.stringify(planned.body), {
+      status: planned.status,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+}
+
+describe("loadImageViaHost", () => {
+  test("POSTs {ref} to the URL and resolves on 200", async () => {
+    const recorded: Array<{ url: string; body: unknown }> = [];
+    const fetchImpl = makeFetch(
+      [
+        {
+          url: "http://127.0.0.1:5500/v1/images/load",
+          body: {
+            loaded: true,
+            ref: "vellum-local/assistant:sha-abc",
+          },
+          status: 200,
+        },
+      ],
+      recorded,
+    );
+
+    await loadImageViaHost(
+      "http://127.0.0.1:5500/v1/images/load",
+      "vellum-local/assistant:sha-abc",
+      silentLog,
+      { fetchImpl },
+    );
+
+    expect(recorded).toHaveLength(1);
+    expect(recorded[0].url).toBe("http://127.0.0.1:5500/v1/images/load");
+    expect(recorded[0].body).toEqual({
+      ref: "vellum-local/assistant:sha-abc",
+    });
+  });
+
+  test("throws HostImageLoaderError with status when server returns non-2xx", async () => {
+    const recorded: Array<{ url: string; body: unknown }> = [];
+    const fetchImpl = makeFetch(
+      [
+        {
+          url: "http://127.0.0.1:5500/v1/images/load",
+          body: { loaded: false, error: "docker save failed: image not found" },
+          status: 502,
+        },
+      ],
+      recorded,
+    );
+
+    await expect(
+      loadImageViaHost(
+        "http://127.0.0.1:5500/v1/images/load",
+        "vellum-local/nope:abc",
+        silentLog,
+        { fetchImpl },
+      ),
+    ).rejects.toBeInstanceOf(HostImageLoaderError);
+
+    // Re-run to inspect fields (one-shot fetchImpl, so build a new one)
+    const recorded2: Array<{ url: string; body: unknown }> = [];
+    const fetchImpl2 = makeFetch(
+      [
+        {
+          url: "http://127.0.0.1:5500/v1/images/load",
+          body: { loaded: false, error: "docker save failed: image not found" },
+          status: 502,
+        },
+      ],
+      recorded2,
+    );
+
+    let caught: HostImageLoaderError | null = null;
+    try {
+      await loadImageViaHost(
+        "http://127.0.0.1:5500/v1/images/load",
+        "vellum-local/nope:abc",
+        silentLog,
+        { fetchImpl: fetchImpl2 },
+      );
+    } catch (err) {
+      caught = err as HostImageLoaderError;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught?.status).toBe(502);
+    expect(caught?.ref).toBe("vellum-local/nope:abc");
+    expect(caught?.message).toContain("502");
+    expect(caught?.message).toContain("docker save failed");
+  });
+
+  test("provides helpful guidance when the loader is unreachable", async () => {
+    const fetchImpl: FetchLike = async () => {
+      const err = new TypeError("fetch failed") as TypeError & {
+        cause?: { code?: string };
+      };
+      err.cause = { code: "ECONNREFUSED" };
+      throw err;
+    };
+
+    let caught: HostImageLoaderError | null = null;
+    try {
+      await loadImageViaHost(
+        "http://127.0.0.1:5500/v1/images/load",
+        "vellum-local/anything:xyz",
+        silentLog,
+        { fetchImpl },
+      );
+    } catch (err) {
+      caught = err as HostImageLoaderError;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught?.message).toContain("loader running");
+    expect(caught?.message).toContain("VELLUM_ASSISTANT_IMAGE");
+  });
+
+  test("wraps generic fetch errors", async () => {
+    const fetchImpl: FetchLike = async () => {
+      throw new Error("ETIMEDOUT");
+    };
+
+    let caught: HostImageLoaderError | null = null;
+    try {
+      await loadImageViaHost(
+        "http://127.0.0.1:5500/v1/images/load",
+        "x",
+        silentLog,
+        { fetchImpl },
+      );
+    } catch (err) {
+      caught = err as HostImageLoaderError;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught?.message).toContain("ETIMEDOUT");
+  });
+
+  test("handles non-JSON error bodies", async () => {
+    const fetchImpl: FetchLike = async () =>
+      new Response("<html>500 internal</html>", {
+        status: 500,
+        headers: { "Content-Type": "text/html" },
+      });
+
+    let caught: HostImageLoaderError | null = null;
+    try {
+      await loadImageViaHost(
+        "http://127.0.0.1:5500/v1/images/load",
+        "x",
+        silentLog,
+        { fetchImpl },
+      );
+    } catch (err) {
+      caught = err as HostImageLoaderError;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught?.status).toBe(500);
+    expect(caught?.message).toContain("HTTP 500");
+  });
+});

package/src/__tests__/ps-platform-status.test.ts

@@ -1,4 +1,12 @@
-import { afterAll, afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -16,6 +24,7 @@ process.env.VELLUM_LOCKFILE_DIR = testDir;
 // ---------------------------------------------------------------------------
 
 import * as assistantConfig from "../lib/assistant-config.js";
+import * as healthCheck from "../lib/health-check.js";
 import * as orphanDetection from "../lib/orphan-detection.js";
 import * as platformClient from "../lib/platform-client.js";
 
@@ -57,6 +66,10 @@ const fetchPlatformAssistantsMock = spyOn(
   platformClient,
   "fetchPlatformAssistants",
 ).mockResolvedValue([]);
+const checkManagedHealthMock = spyOn(
+  healthCheck,
+  "checkManagedHealth",
+).mockResolvedValue({ status: "healthy", detail: null });
 
 // ---------------------------------------------------------------------------
 // stdout / stderr capture
@@ -66,23 +79,32 @@ let stdout: string[];
 let stderr: string[];
 let originalLog: typeof console.log;
 let originalError: typeof console.error;
+let originalStdoutWrite: typeof process.stdout.write;
 
 beforeEach(() => {
   stdout = [];
   stderr = [];
   originalLog = console.log;
   originalError = console.error;
+  originalStdoutWrite = process.stdout.write;
   console.log = ((...args: unknown[]) => {
     stdout.push(args.map((a) => String(a)).join(" "));
   }) as typeof console.log;
   console.error = ((...args: unknown[]) => {
     stderr.push(args.map((a) => String(a)).join(" "));
   }) as typeof console.error;
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    stdout.push(String(chunk));
+    return true;
+  }) as typeof process.stdout.write;
 });
 
 afterEach(() => {
   console.log = originalLog;
   console.error = originalError;
+  process.stdout.write = originalStdoutWrite;
+  loadAllAssistantsMock.mockReturnValue([]);
+  getActiveAssistantMock.mockReturnValue(null);
   readPlatformTokenMock.mockReturnValue(null);
   fetchCurrentUserMock.mockReset();
   fetchCurrentUserMock.mockResolvedValue({
@@ -92,6 +114,8 @@ afterEach(() => {
   });
   fetchPlatformAssistantsMock.mockReset();
   fetchPlatformAssistantsMock.mockResolvedValue([]);
+  checkManagedHealthMock.mockReset();
+  checkManagedHealthMock.mockResolvedValue({ status: "healthy", detail: null });
 });
 
 afterAll(() => {
@@ -102,6 +126,7 @@ afterAll(() => {
   readPlatformTokenMock.mockRestore();
   fetchCurrentUserMock.mockRestore();
   fetchPlatformAssistantsMock.mockRestore();
+  checkManagedHealthMock.mockRestore();
   rmSync(testDir, { recursive: true, force: true });
 });
 
@@ -125,12 +150,12 @@ describe("vellum ps — platform status line", () => {
     expect(stdout.filter((l) => l.startsWith("Platform:"))).toEqual([
       "Platform: not logged in",
     ]);
-    expect(
-      stderr.some((l) => l.includes("Failed to fetch organization")),
-    ).toBe(false);
-    expect(
-      stdout.some((l) => l.includes("Failed to fetch organization")),
-    ).toBe(false);
+    expect(stderr.some((l) => l.includes("Failed to fetch organization"))).toBe(
+      false,
+    );
+    expect(stdout.some((l) => l.includes("Failed to fetch organization"))).toBe(
+      false,
+    );
 
     // Structural guarantee: we never even tried to talk to the platform.
     expect(fetchCurrentUserMock).not.toHaveBeenCalled();
@@ -152,31 +177,84 @@ describe("vellum ps — platform status line", () => {
     expect(stdout.filter((l) => l.startsWith("Platform:"))).toEqual([
       "Platform: not logged in",
     ]);
-    expect(
-      stderr.some((l) => l.includes("Failed to fetch organization")),
-    ).toBe(false);
-    expect(
-      stdout.some((l) => l.includes("Failed to fetch organization")),
-    ).toBe(false);
-    expect(
-      stderr.some((l) => l.includes("Unable to connect")),
-    ).toBe(false);
+    expect(stderr.some((l) => l.includes("Failed to fetch organization"))).toBe(
+      false,
+    );
+    expect(stdout.some((l) => l.includes("Failed to fetch organization"))).toBe(
+      false,
+    );
+    expect(stderr.some((l) => l.includes("Unable to connect"))).toBe(false);
   });
 
   test("local token present and platform reachable: prints 'Platform: logged in as <email>'", async () => {
     readPlatformTokenMock.mockReturnValue("session_abc123");
     fetchCurrentUserMock.mockResolvedValue({
       id: "u1",
-      email: "vargas@vellum.ai",
-      display: "Vargas",
+      email: "user@example.com",
+      display: "Example User",
     });
     fetchPlatformAssistantsMock.mockResolvedValue([]);
 
     await listAllAssistants(false);
 
-    expect(stdout).toContain("Platform: logged in as vargas@vellum.ai");
-    expect(
-      stderr.some((l) => l.includes("Failed to fetch organization")),
-    ).toBe(false);
+    expect(stdout).toContain("Platform: logged in as user@example.com");
+    expect(stderr.some((l) => l.includes("Failed to fetch organization"))).toBe(
+      false,
+    );
+  });
+
+  test("assistant rows use display name as primary label and keep id visible", async () => {
+    loadAllAssistantsMock.mockReturnValue([
+      {
+        assistantId: "assistant-123",
+        name: "Alice",
+        runtimeUrl: "https://platform.example",
+        cloud: "vellum",
+        species: "vellum",
+      },
+    ]);
+    getActiveAssistantMock.mockReturnValue("assistant-123");
+
+    await listAllAssistants(false);
+
+    const output = stdout.join("\n");
+    expect(output).toContain("* Alice");
+    expect(output).toContain("id: assistant-123");
+    expect(output).toContain("https://platform.example");
+    expect(output).not.toContain("* assistant-123");
+  });
+
+  test("assistant list renders one stable final row per assistant", async () => {
+    loadAllAssistantsMock.mockReturnValue([
+      {
+        assistantId: "assistant-123",
+        name: "Alice",
+        runtimeUrl: "https://platform.example/a",
+        cloud: "vellum",
+        species: "vellum",
+      },
+      {
+        assistantId: "assistant-456",
+        name: "Bob",
+        runtimeUrl: "https://platform.example/b",
+        cloud: "vellum",
+        species: "vellum",
+      },
+    ]);
+    getActiveAssistantMock.mockReturnValue("assistant-123");
+    checkManagedHealthMock.mockImplementation(async (_runtimeUrl, id) => ({
+      status: id === "assistant-123" ? "healthy" : "sleeping",
+      detail: null,
+    }));
+
+    await listAllAssistants(false);
+
+    const output = stdout.join("\n");
+    expect(output).not.toContain("\x1b[");
+    expect(output).not.toContain("checking...");
+    expect(output.match(/Alice/g)).toHaveLength(1);
+    expect(output.match(/Bob/g)).toHaveLength(1);
+    expect(output).toContain("healthy");
+    expect(output).toContain("sleeping");
   });
 });

package/src/__tests__/setup.test.ts

@@ -75,7 +75,10 @@ function writeLockfile(entry: AssistantEntry): void {
 }
 
 function installFetchStub(
-  options: { refreshedToken?: GuardianTokenData } = {},
+  options: {
+    leasedToken?: GuardianTokenData;
+    refreshedToken?: GuardianTokenData;
+  } = {},
 ) {
   fetchCalls = [];
   globalThis.fetch = (async (input, init) => {
@@ -103,6 +106,19 @@ function installFetchStub(
       });
     }
 
+    if (url.endsWith("/v1/guardian/init")) {
+      if (!options.leasedToken) {
+        return new Response(JSON.stringify({ error: "not allowed" }), {
+          status: 401,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+      return new Response(JSON.stringify(options.leasedToken), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+
     if (url.endsWith("/v1/secrets/read")) {
       return new Response(JSON.stringify({ found: false }), {
         status: 200,
@@ -209,6 +225,54 @@ describe("setup command", () => {
     );
   });
 
+  test("leases a guardian token for local assistants when no token exists", async () => {
+    process.env.ANTHROPIC_API_KEY = "test-anthropic-key";
+    writeLockfile({
+      assistantId: "assistant-123",
+      runtimeUrl: "http://runtime.example",
+      localUrl: "http://127.0.0.1:3000",
+      cloud: "local",
+    });
+    installFetchStub({
+      leasedToken: guardianTokenFixture({
+        accessToken: "leased-guardian-token",
+      }),
+    });
+
+    await setup();
+
+    expect(fetchCalls[0].url).toBe("http://127.0.0.1:3000/v1/guardian/init");
+    expect(fetchCalls[1].url).toBe("http://127.0.0.1:3000/v1/secrets/read");
+    expect(fetchCalls[1].headers.get("Authorization")).toBe(
+      "Bearer leased-guardian-token",
+    );
+  });
+
+  test("uses saved bootstrap secret when leasing a Docker guardian token", async () => {
+    process.env.ANTHROPIC_API_KEY = "test-anthropic-key";
+    writeLockfile({
+      assistantId: "assistant-123",
+      runtimeUrl: "http://localhost:7831",
+      cloud: "docker",
+      guardianBootstrapSecret: "test-bootstrap-secret",
+    });
+    installFetchStub({
+      leasedToken: guardianTokenFixture({
+        accessToken: "leased-docker-token",
+      }),
+    });
+
+    await setup();
+
+    expect(fetchCalls[0].url).toBe("http://localhost:7831/v1/guardian/init");
+    expect(fetchCalls[0].headers.get("x-bootstrap-secret")).toBe(
+      "test-bootstrap-secret",
+    );
+    expect(fetchCalls[1].headers.get("Authorization")).toBe(
+      "Bearer leased-docker-token",
+    );
+  });
+
   test("falls back to runtime URL and lockfile bearer token", async () => {
     process.env.ANTHROPIC_API_KEY = "test-anthropic-key";
     writeLockfile({

package/src/__tests__/teleport.test.ts

@@ -779,6 +779,7 @@ describe("resolveOrHatchTarget", () => {
       "new-one",
       false,
       {},
+      { setupProviderCredentials: false },
     );
     expect(result).toBe(newEntry);
   });

package/src/__tests__/use.test.ts

@@ -0,0 +1,144 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  getActiveAssistant,
+  type AssistantEntry,
+} from "../lib/assistant-config.js";
+import { use } from "../commands/use.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "cli-use-test-"));
+const originalArgv = [...process.argv];
+const originalExit = process.exit;
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+
+let consoleLogSpy: ReturnType<typeof spyOn>;
+let consoleErrorSpy: ReturnType<typeof spyOn>;
+
+function makeEntry(
+  assistantId: string,
+  extra: Partial<AssistantEntry> = {},
+): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: `http://localhost:${7800 + assistantId.length}`,
+    cloud: "local",
+    ...extra,
+  };
+}
+
+function writeLockfile(
+  entries: AssistantEntry[],
+  activeAssistant?: string,
+): void {
+  mkdirSync(testDir, { recursive: true });
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify(
+      {
+        assistants: entries,
+        ...(activeAssistant ? { activeAssistant } : {}),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+describe("vellum use", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    rmSync(join(testDir, ".vellum.lock.json"), { force: true });
+    process.argv = ["bun", "vellum", "use"];
+    process.exit = ((code?: number) => {
+      throw new Error(`process.exit:${code}`);
+    }) as typeof process.exit;
+    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  afterAll(() => {
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("sets active assistant by unique display name", async () => {
+    writeLockfile([
+      makeEntry("assistant-1", { name: "Alice" }),
+      makeEntry("assistant-2", { name: "Bob" }),
+    ]);
+    process.argv = ["bun", "vellum", "use", "Alice"];
+
+    await use();
+
+    expect(getActiveAssistant()).toBe("assistant-1");
+    expect(consoleLogSpy.mock.calls.flat().join("\n")).toContain(
+      "Active assistant set to Alice (assistant-1).",
+    );
+  });
+
+  test("sets active assistant by unquoted multi-word display name", async () => {
+    writeLockfile([
+      makeEntry("assistant-1", { name: "Example Assistant" }),
+      makeEntry("assistant-2", { name: "Bob" }),
+    ]);
+    process.argv = ["bun", "vellum", "use", "Example", "Assistant"];
+
+    await use();
+
+    expect(getActiveAssistant()).toBe("assistant-1");
+    expect(consoleLogSpy.mock.calls.flat().join("\n")).toContain(
+      "Active assistant set to Example Assistant (assistant-1).",
+    );
+  });
+
+  test("prints active assistant with display name and id", async () => {
+    writeLockfile([makeEntry("assistant-1", { name: "Alice" })], "assistant-1");
+
+    await use();
+
+    expect(consoleLogSpy.mock.calls.flat().join("\n")).toContain(
+      "Active assistant: Alice (assistant-1)",
+    );
+  });
+
+  test("rejects ambiguous display names without changing active assistant", async () => {
+    writeLockfile(
+      [
+        makeEntry("assistant-1", { name: "Alice" }),
+        makeEntry("assistant-2", { name: "Alice" }),
+      ],
+      "assistant-2",
+    );
+    process.argv = ["bun", "vellum", "use", "Alice"];
+
+    await expect(use()).rejects.toThrow("process.exit:1");
+
+    expect(getActiveAssistant()).toBe("assistant-2");
+    const output = consoleErrorSpy.mock.calls.flat().join("\n");
+    expect(output).toContain("Multiple assistants match 'Alice'");
+    expect(output).toContain("assistant-1");
+    expect(output).toContain("assistant-2");
+  });
+});