@vellumai/cli 0.7.3 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/orphan-detection.test.ts

@@ -0,0 +1,287 @@
+import { describe, test, expect, beforeEach, afterAll } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Point lockfile operations at a temp directory before importing anything that
+// would otherwise resolve real on-host paths.
+const testDir = mkdtempSync(join(tmpdir(), "cli-orphan-detection-test-"));
+process.env.VELLUM_LOCKFILE_DIR = testDir;
+
+import {
+  detectOrphanedProcesses,
+  getKnownPidsFromAssistants,
+} from "../lib/orphan-detection.js";
+import {
+  loadAllAssistantsAcrossEnvs,
+  type AssistantEntry,
+} from "../lib/assistant-config.js";
+import type { EnvironmentDefinition } from "../lib/environments/types.js";
+
+afterAll(() => {
+  rmSync(testDir, { recursive: true, force: true });
+  delete process.env.VELLUM_LOCKFILE_DIR;
+});
+
+function makeLocalEntry(
+  id: string,
+  instanceDir: string,
+  pids: {
+    daemon?: string;
+    gateway?: string;
+    qdrant?: string;
+    embed?: string;
+  } = {},
+): AssistantEntry {
+  const vellumDir = join(instanceDir, ".vellum");
+  mkdirSync(join(vellumDir, "workspace", "data", "qdrant"), {
+    recursive: true,
+  });
+  if (pids.daemon !== undefined) {
+    writeFileSync(join(vellumDir, "workspace", "vellum.pid"), pids.daemon);
+  }
+  if (pids.gateway !== undefined) {
+    writeFileSync(join(vellumDir, "gateway.pid"), pids.gateway);
+  }
+  if (pids.qdrant !== undefined) {
+    writeFileSync(
+      join(vellumDir, "workspace", "data", "qdrant", "qdrant.pid"),
+      pids.qdrant,
+    );
+  }
+  if (pids.embed !== undefined) {
+    writeFileSync(join(vellumDir, "workspace", "embed-worker.pid"), pids.embed);
+  }
+  return {
+    assistantId: id,
+    runtimeUrl: "http://localhost:7821",
+    cloud: "local",
+    resources: {
+      instanceDir,
+      daemonPort: 7821,
+      gatewayPort: 7830,
+      qdrantPort: 6333,
+      cesPort: 8090,
+    },
+  };
+}
+
+describe("getKnownPidsFromAssistants", () => {
+  let perTestDir: string;
+
+  beforeEach(() => {
+    perTestDir = mkdtempSync(join(testDir, "case-"));
+  });
+
+  test("collects daemon, gateway, qdrant, and embed-worker PIDs", () => {
+    const entry = makeLocalEntry(
+      "alpha",
+      join(perTestDir, "alpha"),
+      { daemon: "100", gateway: "200", qdrant: "300", embed: "400" },
+    );
+    const pids = getKnownPidsFromAssistants([entry]);
+    expect(pids).toEqual(new Set(["100", "200", "300", "400"]));
+  });
+
+  test("skips missing PID files without throwing", () => {
+    const entry = makeLocalEntry("beta", join(perTestDir, "beta"), {
+      daemon: "100",
+    });
+    const pids = getKnownPidsFromAssistants([entry]);
+    expect(pids).toEqual(new Set(["100"]));
+  });
+
+  test("includes docker watcherPid when present", () => {
+    const entry: AssistantEntry = {
+      assistantId: "docker-1",
+      runtimeUrl: "http://localhost:18100",
+      cloud: "docker",
+      watcherPid: 555,
+    };
+    const pids = getKnownPidsFromAssistants([entry]);
+    expect(pids).toEqual(new Set(["555"]));
+  });
+
+  test("ignores non-local entries without watcherPid", () => {
+    const entry: AssistantEntry = {
+      assistantId: "managed-1",
+      runtimeUrl: "https://platform.vellum.ai/foo",
+      cloud: "vellum",
+    };
+    const pids = getKnownPidsFromAssistants([entry]);
+    expect(pids.size).toBe(0);
+  });
+
+  test("local entry without resources contributes no PIDs", () => {
+    const entry: AssistantEntry = {
+      assistantId: "legacy",
+      runtimeUrl: "http://localhost:7821",
+      cloud: "local",
+    };
+    const pids = getKnownPidsFromAssistants([entry]);
+    expect(pids.size).toBe(0);
+  });
+
+  test("aggregates PIDs across multiple assistants", () => {
+    const a = makeLocalEntry("a", join(perTestDir, "a"), {
+      daemon: "100",
+      gateway: "200",
+    });
+    const b = makeLocalEntry("b", join(perTestDir, "b"), {
+      daemon: "101",
+      gateway: "201",
+    });
+    const pids = getKnownPidsFromAssistants([a, b]);
+    expect(pids).toEqual(new Set(["100", "200", "101", "201"]));
+  });
+});
+
+describe("loadAllAssistantsAcrossEnvs", () => {
+  function makeEnv(name: string, lockfileDir: string): EnvironmentDefinition {
+    return {
+      name,
+      platformUrl: "https://example.invalid",
+      webUrl: "https://example.invalid",
+      lockfileDirOverride: lockfileDir,
+    };
+  }
+
+  test("aggregates entries from every provided environment's lockfile", () => {
+    const envADir = mkdtempSync(join(testDir, "envA-"));
+    const envBDir = mkdtempSync(join(testDir, "envB-"));
+
+    writeFileSync(
+      join(envADir, "lockfile.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "alpha",
+            runtimeUrl: "http://localhost:7821",
+            cloud: "local",
+          },
+        ],
+      }),
+    );
+    writeFileSync(
+      join(envBDir, "lockfile.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "beta",
+            runtimeUrl: "http://localhost:18100",
+            cloud: "docker",
+            watcherPid: 777,
+          },
+        ],
+      }),
+    );
+
+    const all = loadAllAssistantsAcrossEnvs([
+      makeEnv("envA", envADir),
+      makeEnv("envB", envBDir),
+    ]);
+    const ids = all.map((e) => e.assistantId).sort();
+    expect(ids).toEqual(["alpha", "beta"]);
+  });
+
+  test("returns empty list when no envs have lockfiles", () => {
+    const envDir = mkdtempSync(join(testDir, "empty-"));
+    const all = loadAllAssistantsAcrossEnvs([makeEnv("missing", envDir)]);
+    expect(all).toEqual([]);
+  });
+
+  test("skips malformed JSON without throwing", () => {
+    const envDir = mkdtempSync(join(testDir, "malformed-"));
+    writeFileSync(join(envDir, "lockfile.json"), "{not json");
+    const all = loadAllAssistantsAcrossEnvs([makeEnv("bad", envDir)]);
+    expect(all).toEqual([]);
+  });
+
+  test("skips entries missing required fields", () => {
+    const envDir = mkdtempSync(join(testDir, "partial-"));
+    writeFileSync(
+      join(envDir, "lockfile.json"),
+      JSON.stringify({
+        assistants: [
+          { assistantId: "no-url" }, // missing runtimeUrl
+          { runtimeUrl: "http://x" }, // missing assistantId
+          {
+            assistantId: "good",
+            runtimeUrl: "http://localhost:7821",
+            cloud: "local",
+          },
+        ],
+      }),
+    );
+    const all = loadAllAssistantsAcrossEnvs([makeEnv("partial", envDir)]);
+    expect(all.map((e) => e.assistantId)).toEqual(["good"]);
+  });
+
+  test("end-to-end: dev env's daemon is not flagged as orphan from local env", () => {
+    // Simulate Vargas's reported bug: `local` env has no assistants, but a
+    // `dev` env assistant is running with a recorded daemon PID. The orphan
+    // filter must treat that PID as known.
+    const devDir = mkdtempSync(join(testDir, "dev-"));
+    const instanceDir = join(devDir, "instances", "quiet-finch");
+    makeLocalEntry("quiet-finch", instanceDir, {
+      daemon: "19067",
+      gateway: "19087",
+      qdrant: "19167",
+    });
+
+    writeFileSync(
+      join(devDir, "lockfile.json"),
+      JSON.stringify({
+        assistants: [
+          {
+            assistantId: "quiet-finch",
+            runtimeUrl: "http://127.0.0.1:18100",
+            cloud: "local",
+            resources: {
+              instanceDir,
+              daemonPort: 18000,
+              gatewayPort: 18100,
+              qdrantPort: 18200,
+              cesPort: 18300,
+            },
+          },
+        ],
+      }),
+    );
+
+    const devEntries = loadAllAssistantsAcrossEnvs([makeEnv("dev", devDir)]);
+    expect(devEntries).toHaveLength(1);
+
+    const knownPids = getKnownPidsFromAssistants(devEntries);
+    expect(knownPids).toEqual(new Set(["19067", "19087", "19167"]));
+  });
+});
+
+describe("detectOrphanedProcesses", () => {
+  test("excludes PIDs passed via excludePids", async () => {
+    // The orphan detector calls `ps ax` and filters by regex. The process
+    // running this test (bun) is itself a node-family process whose pid will
+    // not match the vellum/qdrant/openclaw regex, so the natural result of
+    // the scan is "no rows". To assert exclusion semantics deterministically,
+    // we just confirm the function accepts an excludePids option and returns
+    // an array — the meaningful behavior assertion lives in the integration
+    // path (the function's `knownPids.has(p.pid)` short-circuit), which we
+    // exercise indirectly by passing our own PID (guaranteed to never be
+    // double-counted).
+    const ownPid = String(process.pid);
+    const result = await detectOrphanedProcesses({
+      excludePids: new Set([ownPid]),
+    });
+    expect(Array.isArray(result)).toBe(true);
+    for (const orphan of result) {
+      expect(orphan.pid).not.toBe(ownPid);
+    }
+  });
+
+  test("returns an array (smoke)", async () => {
+    const result = await detectOrphanedProcesses({
+      excludePids: new Set(),
+    });
+    expect(Array.isArray(result)).toBe(true);
+  });
+});

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

@@ -0,0 +1,182 @@
+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";
+
+// ---------------------------------------------------------------------------
+// Temp directory for lockfile isolation
+// ---------------------------------------------------------------------------
+
+const testDir = mkdtempSync(join(tmpdir(), "cli-ps-platform-status-test-"));
+process.env.VELLUM_LOCKFILE_DIR = testDir;
+
+// ---------------------------------------------------------------------------
+// Mocks — set up before importing the command under test. All spies are
+// restored in afterAll so we don't leak module state to neighbouring suites.
+// ---------------------------------------------------------------------------
+
+import * as assistantConfig from "../lib/assistant-config.js";
+import * as orphanDetection from "../lib/orphan-detection.js";
+import * as platformClient from "../lib/platform-client.js";
+
+const loadAllAssistantsMock = spyOn(
+  assistantConfig,
+  "loadAllAssistants",
+).mockReturnValue([]);
+const getActiveAssistantMock = spyOn(
+  assistantConfig,
+  "getActiveAssistant",
+).mockReturnValue(null);
+const detectOrphanedProcessesMock = spyOn(
+  orphanDetection,
+  "detectOrphanedProcesses",
+).mockResolvedValue([]);
+const getPlatformUrlMock = spyOn(
+  platformClient,
+  "getPlatformUrl",
+).mockReturnValue("http://platform.test");
+
+// Per-test toggle for `readPlatformToken`.
+const readPlatformTokenMock = spyOn(
+  platformClient,
+  "readPlatformToken",
+).mockReturnValue(null);
+
+// `fetchCurrentUser` + `fetchPlatformAssistants` are spied so we can assert
+// they're never invoked on the no-token path, and re-shaped per-test for the
+// token-but-unreachable path.
+const fetchCurrentUserMock = spyOn(
+  platformClient,
+  "fetchCurrentUser",
+).mockResolvedValue({
+  id: "u1",
+  email: "test@example.com",
+  display: "Test",
+});
+const fetchPlatformAssistantsMock = spyOn(
+  platformClient,
+  "fetchPlatformAssistants",
+).mockResolvedValue([]);
+
+// ---------------------------------------------------------------------------
+// stdout / stderr capture
+// ---------------------------------------------------------------------------
+
+let stdout: string[];
+let stderr: string[];
+let originalLog: typeof console.log;
+let originalError: typeof console.error;
+
+beforeEach(() => {
+  stdout = [];
+  stderr = [];
+  originalLog = console.log;
+  originalError = console.error;
+  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;
+});
+
+afterEach(() => {
+  console.log = originalLog;
+  console.error = originalError;
+  readPlatformTokenMock.mockReturnValue(null);
+  fetchCurrentUserMock.mockReset();
+  fetchCurrentUserMock.mockResolvedValue({
+    id: "u1",
+    email: "test@example.com",
+    display: "Test",
+  });
+  fetchPlatformAssistantsMock.mockReset();
+  fetchPlatformAssistantsMock.mockResolvedValue([]);
+});
+
+afterAll(() => {
+  loadAllAssistantsMock.mockRestore();
+  getActiveAssistantMock.mockRestore();
+  detectOrphanedProcessesMock.mockRestore();
+  getPlatformUrlMock.mockRestore();
+  readPlatformTokenMock.mockRestore();
+  fetchCurrentUserMock.mockRestore();
+  fetchPlatformAssistantsMock.mockRestore();
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// Import the command under test AFTER mocks are wired up
+// ---------------------------------------------------------------------------
+
+import { listAllAssistants } from "../commands/ps.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("vellum ps — platform status line", () => {
+  test("no local token: prints 'Platform: not logged in' and skips ALL network fetches", async () => {
+    readPlatformTokenMock.mockReturnValue(null);
+
+    await listAllAssistants(false);
+
+    // The status line is present, exactly once, with no redundant error log.
+    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);
+
+    // Structural guarantee: we never even tried to talk to the platform.
+    expect(fetchCurrentUserMock).not.toHaveBeenCalled();
+    expect(fetchPlatformAssistantsMock).not.toHaveBeenCalled();
+  });
+
+  test("local token present but platform is unreachable: still shows 'Platform: not logged in' with no leaked org-fetch error", async () => {
+    readPlatformTokenMock.mockReturnValue("session_abc123");
+    // Simulate the exact Bun connect failure the user reported:
+    //   "Unable to connect. Is the computer able to access the url?"
+    const connectError = new Error(
+      "Unable to connect. Is the computer able to access the url?",
+    );
+    fetchCurrentUserMock.mockRejectedValue(connectError);
+    fetchPlatformAssistantsMock.mockRejectedValue(connectError);
+
+    await listAllAssistants(false);
+
+    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);
+  });
+
+  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",
+    });
+    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);
+  });
+});

package/src/__tests__/search-provider-env-var-parity.test.ts

@@ -0,0 +1,48 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+
+import { SEARCH_PROVIDER_ENV_VAR_NAMES } from "../shared/provider-env-vars.js";
+
+/**
+ * Drift guard for the CLI-side search provider env-var mirror.
+ *
+ * `cli/src/shared/provider-env-vars.ts` hardcodes the search env-var names so
+ * the CLI doesn't need to import the assistant's
+ * `SEARCH_PROVIDER_CATALOG` (no CLI → assistant cross-package imports exist).
+ * This test pulls the catalog JSON at `meta/web-search-provider-catalog.json`
+ * — which is kept in sync with `SEARCH_PROVIDER_CATALOG` by
+ * `assistant/src/__tests__/web-search-catalog-parity.test.ts` — and asserts
+ * the CLI's mirror matches the catalog's `envVar` entries.
+ *
+ * Mirrors `llm-provider-env-var-parity.test.ts`.
+ */
+
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+interface SearchCatalogEntry {
+  id: string;
+  kind: "managed" | "byok";
+  envVar?: string;
+}
+
+interface SearchCatalog {
+  version: number;
+  providers: SearchCatalogEntry[];
+}
+
+function loadSearchCatalog(): SearchCatalog {
+  const path = join(REPO_ROOT, "meta", "web-search-provider-catalog.json");
+  return JSON.parse(readFileSync(path, "utf-8"));
+}
+
+describe("CLI search provider env-var parity", () => {
+  test("SEARCH_PROVIDER_ENV_VAR_NAMES matches meta/web-search-provider-catalog.json entries with envVar", () => {
+    const catalog = loadSearchCatalog();
+    const expected: Record<string, string> = {};
+    for (const provider of catalog.providers) {
+      if (provider.envVar) expected[provider.id] = provider.envVar;
+    }
+    expect(SEARCH_PROVIDER_ENV_VAR_NAMES).toEqual(expected);
+  });
+});

package/src/__tests__/sync-events.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, spyOn, test } from "bun:test";
+
+import { renderMarkdown } from "../commands/events.js";
+
+type AssistantEvent = Parameters<typeof renderMarkdown>[0];
+
+function makeEvent(message: AssistantEvent["message"]): AssistantEvent {
+  return {
+    id: "event-123",
+    assistantId: "assistant-123",
+    emittedAt: "2026-01-01T00:00:00.000Z",
+    message,
+  };
+}
+
+describe("sync_changed events", () => {
+  test("renders sync tags clearly in vellum events markdown output", () => {
+    const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+    try {
+      renderMarkdown(
+        makeEvent({
+          type: "sync_changed",
+          tags: ["assistant:self:avatar", "conversations:list"],
+        }),
+      );
+
+      expect(consoleLog).toHaveBeenCalledWith(
+        "\n> **Sync changed:** `assistant:self:avatar`, `conversations:list`",
+      );
+    } finally {
+      consoleLog.mockRestore();
+    }
+  });
+
+  test("tolerates malformed sync tags without throwing", () => {
+    const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+    try {
+      expect(() =>
+        renderMarkdown(
+          makeEvent({
+            type: "sync_changed",
+            tags: ["assistant:self:avatar", 42, null],
+          }),
+        ),
+      ).not.toThrow();
+
+      expect(consoleLog).toHaveBeenCalledWith(
+        "\n> **Sync changed:** `assistant:self:avatar`",
+      );
+    } finally {
+      consoleLog.mockRestore();
+    }
+  });
+});