@vellumai/cli 0.8.3 → 0.8.5

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__/retire.test.ts

@@ -0,0 +1,241 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { AssistantEntry } from "../lib/assistant-config.js";
+import { loadAllAssistants } from "../lib/assistant-config.js";
+import * as retireLocalModule from "../lib/retire-local.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "cli-retire-test-"));
+const originalArgv = [...process.argv];
+const originalExit = process.exit;
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+const originalStdinIsTTY = process.stdin.isTTY;
+const originalStdoutIsTTY = process.stdout.isTTY;
+const originalStdinIsRaw = process.stdin.isRaw;
+const originalSetRawMode = process.stdin.setRawMode;
+const originalStdoutWrite = process.stdout.write;
+const realRetireLocalModule = { ...retireLocalModule };
+
+const retireLocalMock = mock(async () => {});
+
+mock.module("../lib/retire-local.js", () => ({
+  ...realRetireLocalModule,
+  retireLocal: retireLocalMock,
+}));
+
+import { retire } from "../commands/retire.js";
+
+let consoleLogSpy: ReturnType<typeof spyOn>;
+let consoleErrorSpy: ReturnType<typeof spyOn>;
+
+function makeEntry(
+  assistantId: string,
+  extra: Partial<AssistantEntry> = {},
+): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: `http://127.0.0.1:${7800 + assistantId.length}`,
+    cloud: "local",
+    resources: {
+      instanceDir: join(testDir, assistantId),
+      daemonPort: 7801,
+      gatewayPort: 7831,
+      qdrantPort: 6334,
+      cesPort: 7790,
+    },
+    ...extra,
+  };
+}
+
+function writeLockfile(entries: AssistantEntry[]): void {
+  mkdirSync(testDir, { recursive: true });
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify({ assistants: entries }, null, 2) + "\n",
+  );
+}
+
+function readLockfile(): string {
+  return readFileSync(join(testDir, ".vellum.lock.json"), "utf-8");
+}
+
+function setTerminalMode(isTTY: boolean): void {
+  Object.defineProperty(process.stdin, "isTTY", {
+    configurable: true,
+    value: isTTY,
+  });
+  Object.defineProperty(process.stdout, "isTTY", {
+    configurable: true,
+    value: isTTY,
+  });
+}
+
+function setInteractiveTerminal(): void {
+  setTerminalMode(true);
+  Object.defineProperty(process.stdin, "isRaw", {
+    configurable: true,
+    value: false,
+  });
+  Object.defineProperty(process.stdin, "setRawMode", {
+    configurable: true,
+    value: mock(() => process.stdin),
+  });
+  process.stdout.write = (() => true) as typeof process.stdout.write;
+}
+
+function restoreTerminal(): void {
+  Object.defineProperty(process.stdin, "isTTY", {
+    configurable: true,
+    value: originalStdinIsTTY,
+  });
+  Object.defineProperty(process.stdout, "isTTY", {
+    configurable: true,
+    value: originalStdoutIsTTY,
+  });
+  Object.defineProperty(process.stdin, "isRaw", {
+    configurable: true,
+    value: originalStdinIsRaw,
+  });
+  Object.defineProperty(process.stdin, "setRawMode", {
+    configurable: true,
+    value: originalSetRawMode,
+  });
+  process.stdout.write = originalStdoutWrite;
+}
+
+describe("vellum retire", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    rmSync(join(testDir, ".vellum.lock.json"), { force: true });
+    process.argv = ["bun", "vellum", "retire"];
+    process.exit = ((code?: number) => {
+      throw new Error(`process.exit:${code}`);
+    }) as typeof process.exit;
+    retireLocalMock.mockReset();
+    retireLocalMock.mockResolvedValue(undefined);
+    setTerminalMode(false);
+    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    restoreTerminal();
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  afterAll(() => {
+    mock.module("../lib/retire-local.js", () => realRetireLocalModule);
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("--yes retires by unquoted display name and removes by assistant ID", async () => {
+    const entry = makeEntry("assistant-1", { name: "Example Assistant" });
+    writeLockfile([entry]);
+    process.argv = ["bun", "vellum", "retire", "Example", "Assistant", "--yes"];
+
+    await retire();
+
+    expect(retireLocalMock).toHaveBeenCalledWith("assistant-1", entry);
+    expect(loadAllAssistants()).toEqual([]);
+    const output = consoleLogSpy.mock.calls.flat().join("\n");
+    expect(output).toContain("Name: Example Assistant");
+    expect(output).toContain("ID: assistant-1");
+    expect(output).toContain(
+      "Removed Example Assistant (assistant-1) from config.",
+    );
+  });
+
+  test("non-interactive retire without --yes fails before deleting", async () => {
+    const entry = makeEntry("assistant-1", { name: "Example Assistant" });
+    writeLockfile([entry]);
+    const before = readLockfile();
+    process.argv = ["bun", "vellum", "retire", "Example", "Assistant"];
+
+    await expect(retire()).rejects.toThrow("process.exit:1");
+
+    expect(retireLocalMock).not.toHaveBeenCalled();
+    expect(readLockfile()).toBe(before);
+    const output = consoleErrorSpy.mock.calls.flat().join("\n");
+    expect(output).toContain("Refusing to retire without confirmation");
+    expect(output).toContain("--yes");
+  });
+
+  test("interactive cancel leaves the assistant untouched", async () => {
+    const entry = makeEntry("assistant-1", { name: "Example Assistant" });
+    writeLockfile([entry]);
+    const before = readLockfile();
+    setInteractiveTerminal();
+    process.argv = ["bun", "vellum", "retire", "Example", "Assistant"];
+
+    const pending = retire();
+    queueMicrotask(() => {
+      process.stdin.emit("data", Buffer.from("q"));
+    });
+
+    await expect(pending).rejects.toThrow("process.exit:1");
+    expect(retireLocalMock).not.toHaveBeenCalled();
+    expect(readLockfile()).toBe(before);
+    expect(consoleLogSpy.mock.calls.flat().join("\n")).toContain(
+      "Retire cancelled.",
+    );
+  });
+
+  test("interactive confirmation retires the assistant", async () => {
+    const entry = makeEntry("assistant-1", { name: "Example Assistant" });
+    writeLockfile([entry]);
+    setInteractiveTerminal();
+    process.argv = ["bun", "vellum", "retire", "Example", "Assistant"];
+
+    const pending = retire();
+    queueMicrotask(() => {
+      process.stdin.emit("data", Buffer.from([13]));
+    });
+
+    await pending;
+    expect(retireLocalMock).toHaveBeenCalledWith("assistant-1", entry);
+    expect(loadAllAssistants()).toEqual([]);
+  });
+
+  test("ambiguous display names fail before deleting", async () => {
+    writeLockfile([
+      makeEntry("assistant-1", { name: "Example Assistant" }),
+      makeEntry("assistant-2", { name: "Example Assistant" }),
+    ]);
+    const before = readLockfile();
+    process.argv = ["bun", "vellum", "retire", "Example", "Assistant", "--yes"];
+
+    await expect(retire()).rejects.toThrow("process.exit:1");
+
+    expect(retireLocalMock).not.toHaveBeenCalled();
+    expect(readLockfile()).toBe(before);
+    const output = consoleErrorSpy.mock.calls.flat().join("\n");
+    expect(output).toContain("Multiple assistants match 'Example Assistant'");
+    expect(output).toContain("assistant-1");
+    expect(output).toContain("assistant-2");
+  });
+});

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");
+  });
+});