@vellumai/cli 0.4.42 → 0.4.44

package/package.json

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

package/src/__tests__/assistant-config.test.ts

@@ -1,11 +1,11 @@
 import { describe, test, expect, beforeEach, afterAll } from "bun:test";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 // Point lockfile operations at a temp directory
 const testDir = mkdtempSync(join(tmpdir(), "cli-assistant-config-test-"));
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_LOCKFILE_DIR = testDir;
 
 import {
   loadLatestAssistant,
@@ -13,12 +13,14 @@ import {
   removeAssistantEntry,
   loadAllAssistants,
   saveAssistantEntry,
+  getActiveAssistant,
+  migrateLegacyEntry,
   type AssistantEntry,
 } from "../lib/assistant-config.js";
 
 afterAll(() => {
   rmSync(testDir, { recursive: true, force: true });
-  delete process.env.BASE_DATA_DIR;
+  delete process.env.VELLUM_LOCKFILE_DIR;
 });
 
 function writeLockfile(data: unknown): void {
@@ -100,6 +102,36 @@ describe("assistant-config", () => {
     expect(all.map((e) => e.assistantId)).toEqual(["a", "c"]);
   });
 
+  test("removeAssistantEntry reassigns activeAssistant to remaining entry", () => {
+    writeLockfile({
+      assistants: [makeEntry("a"), makeEntry("b")],
+      activeAssistant: "a",
+    });
+    removeAssistantEntry("a");
+    expect(getActiveAssistant()).toBe("b");
+    expect(loadAllAssistants()).toHaveLength(1);
+  });
+
+  test("removeAssistantEntry clears activeAssistant when no entries remain", () => {
+    writeLockfile({
+      assistants: [makeEntry("only")],
+      activeAssistant: "only",
+    });
+    removeAssistantEntry("only");
+    expect(getActiveAssistant()).toBeNull();
+    expect(loadAllAssistants()).toHaveLength(0);
+  });
+
+  test("removeAssistantEntry preserves activeAssistant when removing a different entry", () => {
+    writeLockfile({
+      assistants: [makeEntry("a"), makeEntry("b"), makeEntry("c")],
+      activeAssistant: "a",
+    });
+    removeAssistantEntry("b");
+    expect(getActiveAssistant()).toBe("a");
+    expect(loadAllAssistants()).toHaveLength(2);
+  });
+
   test("loadLatestAssistant returns null when empty", () => {
     expect(loadLatestAssistant()).toBeNull();
   });
@@ -149,3 +181,250 @@ describe("assistant-config", () => {
     expect(all[0].assistantId).toBe("valid");
   });
 });
+
+describe("migrateLegacyEntry", () => {
+  test("rewrites baseDataDir as resources.instanceDir", () => {
+    /**
+     * Tests that a legacy entry with top-level baseDataDir gets migrated
+     * to the current resources.instanceDir format.
+     */
+
+    // GIVEN a legacy entry with baseDataDir set at the top level
+    const entry: Record<string, unknown> = {
+      assistantId: "my-assistant",
+      runtimeUrl: "http://localhost:7830",
+      cloud: "local",
+      baseDataDir: "/home/user/.local/share/vellum/assistants/my-assistant",
+    };
+
+    // WHEN we migrate the entry
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN the entry should be mutated
+    expect(changed).toBe(true);
+
+    // AND baseDataDir should be removed
+    expect(entry.baseDataDir).toBeUndefined();
+
+    // AND resources.instanceDir should contain the old baseDataDir value
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.instanceDir).toBe(
+      "/home/user/.local/share/vellum/assistants/my-assistant",
+    );
+  });
+
+  test("synthesises full resources when none exist", () => {
+    /**
+     * Tests that a legacy local entry with no resources object gets a
+     * complete resources object synthesised with default ports and pidFile.
+     */
+
+    // GIVEN a local entry with no resources
+    const entry: Record<string, unknown> = {
+      assistantId: "old-assistant",
+      runtimeUrl: "http://localhost:7830",
+      cloud: "local",
+    };
+
+    // WHEN we migrate the entry
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN the entry should be mutated
+    expect(changed).toBe(true);
+
+    // AND resources should be fully populated
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.instanceDir).toContain("old-assistant");
+    expect(resources.daemonPort).toBe(7821);
+    expect(resources.gatewayPort).toBe(7830);
+    expect(resources.qdrantPort).toBe(6333);
+    expect(resources.pidFile).toContain("vellum.pid");
+  });
+
+  test("infers gateway port from runtimeUrl", () => {
+    /**
+     * Tests that the gateway port is extracted from the runtimeUrl when
+     * synthesising resources for a legacy entry.
+     */
+
+    // GIVEN a local entry with a non-default gateway port in the runtimeUrl
+    const entry: Record<string, unknown> = {
+      assistantId: "custom-port",
+      runtimeUrl: "http://localhost:9999",
+      cloud: "local",
+    };
+
+    // WHEN we migrate the entry
+    migrateLegacyEntry(entry);
+
+    // THEN the gateway port should match the runtimeUrl port
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.gatewayPort).toBe(9999);
+  });
+
+  test("skips non-local entries", () => {
+    /**
+     * Tests that remote (non-local) entries are left untouched.
+     */
+
+    // GIVEN a GCP entry without resources
+    const entry: Record<string, unknown> = {
+      assistantId: "gcp-assistant",
+      runtimeUrl: "https://example.com",
+      cloud: "gcp",
+    };
+
+    // WHEN we attempt to migrate it
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN nothing should change
+    expect(changed).toBe(false);
+    expect(entry.resources).toBeUndefined();
+  });
+
+  test("backfills missing fields on partial resources", () => {
+    /**
+     * Tests that an entry with a partial resources object (e.g. only
+     * instanceDir) gets the remaining fields backfilled.
+     */
+
+    // GIVEN an entry with partial resources (only instanceDir)
+    const entry: Record<string, unknown> = {
+      assistantId: "partial",
+      runtimeUrl: "http://localhost:7830",
+      cloud: "local",
+      resources: {
+        instanceDir: "/custom/path",
+      },
+    };
+
+    // WHEN we migrate the entry
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN the entry should be mutated
+    expect(changed).toBe(true);
+
+    // AND all missing resources fields should be filled in
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.instanceDir).toBe("/custom/path");
+    expect(resources.daemonPort).toBe(7821);
+    expect(resources.gatewayPort).toBe(7830);
+    expect(resources.qdrantPort).toBe(6333);
+    expect(resources.pidFile).toBe("/custom/path/.vellum/vellum.pid");
+  });
+
+  test("does not overwrite existing resources fields", () => {
+    /**
+     * Tests that an entry with a complete resources object is left untouched.
+     */
+
+    // GIVEN an entry with a complete resources object
+    const entry: Record<string, unknown> = {
+      assistantId: "complete",
+      runtimeUrl: "http://localhost:7830",
+      cloud: "local",
+      resources: {
+        instanceDir: "/my/path",
+        daemonPort: 8000,
+        gatewayPort: 8001,
+        qdrantPort: 8002,
+        pidFile: "/my/path/.vellum/vellum.pid",
+      },
+    };
+
+    // WHEN we migrate the entry
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN nothing should change
+    expect(changed).toBe(false);
+
+    // AND existing values should be preserved
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.daemonPort).toBe(8000);
+    expect(resources.gatewayPort).toBe(8001);
+    expect(resources.qdrantPort).toBe(8002);
+  });
+
+  test("baseDataDir does not overwrite existing resources.instanceDir", () => {
+    /**
+     * Tests that when both baseDataDir and resources.instanceDir exist,
+     * the existing instanceDir is preserved and baseDataDir is removed.
+     */
+
+    // GIVEN an entry with both baseDataDir and resources.instanceDir
+    const entry: Record<string, unknown> = {
+      assistantId: "conflict",
+      runtimeUrl: "http://localhost:7830",
+      cloud: "local",
+      baseDataDir: "/old/path",
+      resources: {
+        instanceDir: "/new/path",
+        daemonPort: 7821,
+        gatewayPort: 7830,
+        qdrantPort: 6333,
+        pidFile: "/new/path/.vellum/vellum.pid",
+      },
+    };
+
+    // WHEN we migrate the entry
+    const changed = migrateLegacyEntry(entry);
+
+    // THEN baseDataDir should be removed
+    expect(changed).toBe(true);
+    expect(entry.baseDataDir).toBeUndefined();
+
+    // AND the existing instanceDir should be preserved
+    const resources = entry.resources as Record<string, unknown>;
+    expect(resources.instanceDir).toBe("/new/path");
+  });
+});
+
+describe("legacy migration via loadAllAssistants", () => {
+  beforeEach(() => {
+    try {
+      rmSync(join(testDir, ".vellum.lock.json"));
+    } catch {
+      // file may not exist
+    }
+  });
+
+  test("migrates legacy entries and persists to disk on read", () => {
+    /**
+     * Tests that reading assistants from a lockfile with legacy entries
+     * triggers migration and persists the updated format to disk.
+     */
+
+    // GIVEN a lockfile with a legacy entry containing baseDataDir
+    writeLockfile({
+      assistants: [
+        {
+          assistantId: "legacy-bot",
+          runtimeUrl: "http://localhost:7830",
+          cloud: "local",
+          baseDataDir: "/home/user/.local/share/vellum/assistants/legacy-bot",
+        },
+      ],
+    });
+
+    // WHEN we load assistants
+    const all = loadAllAssistants();
+
+    // THEN the entry should have resources populated
+    expect(all).toHaveLength(1);
+    expect(all[0].resources).toBeDefined();
+    expect(all[0].resources!.instanceDir).toBe(
+      "/home/user/.local/share/vellum/assistants/legacy-bot",
+    );
+    expect(all[0].resources!.gatewayPort).toBe(7830);
+
+    // AND the lockfile on disk should reflect the migration
+    const rawDisk = JSON.parse(
+      readFileSync(join(testDir, ".vellum.lock.json"), "utf-8"),
+    );
+    const diskEntry = rawDisk.assistants[0];
+    expect(diskEntry.baseDataDir).toBeUndefined();
+    expect(diskEntry.resources.instanceDir).toBe(
+      "/home/user/.local/share/vellum/assistants/legacy-bot",
+    );
+  });
+});

package/src/__tests__/multi-local.test.ts

@@ -4,9 +4,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 // Create a temp directory that acts as a fake home, so allocateLocalResources()
-// and defaultLocalResources() never touch the real ~/.vellum directory.
+// never touches the real ~/.vellum directory.
 const testDir = mkdtempSync(join(tmpdir(), "cli-multi-local-test-"));
-process.env.BASE_DATA_DIR = testDir;
+process.env.VELLUM_LOCKFILE_DIR = testDir;
 
 // Mock homedir() to return testDir — this isolates allocateLocalResources()
 // which uses homedir() directly for instance directory creation.
@@ -31,7 +31,6 @@ mock.module("../lib/port-probe.js", () => ({
 
 import {
   allocateLocalResources,
-  defaultLocalResources,
   resolveTargetAssistant,
   setActiveAssistant,
   getActiveAssistant,
@@ -47,7 +46,7 @@ import {
 
 afterAll(() => {
   rmSync(testDir, { recursive: true, force: true });
-  delete process.env.BASE_DATA_DIR;
+  delete process.env.VELLUM_LOCKFILE_DIR;
 });
 
 function writeLockfile(data: unknown): void {
@@ -95,17 +94,22 @@ describe("multi-local", () => {
   });
 
   describe("allocateLocalResources() produces non-conflicting ports", () => {
-    test("first instance returns default legacy resources", async () => {
+    test("first instance gets home directory and default ports", async () => {
       // GIVEN no local assistants exist in the lockfile
 
       // WHEN we allocate resources for the first instance
       const res = await allocateLocalResources("instance-a");
 
-      // THEN it returns the default legacy layout (home dir, default ports)
+      // THEN it gets the home directory as its instance root
       expect(res.instanceDir).toBe(testDir);
+
+      // AND it gets the default ports since no other instances exist
       expect(res.daemonPort).toBe(DEFAULT_DAEMON_PORT);
       expect(res.gatewayPort).toBe(DEFAULT_GATEWAY_PORT);
       expect(res.qdrantPort).toBe(DEFAULT_QDRANT_PORT);
+
+      // AND the PID file is under ~/.vellum/
+      expect(res.pidFile).toBe(join(testDir, ".vellum", "vellum.pid"));
     });
 
     test("second instance gets distinct ports and dir when first instance is saved", async () => {
@@ -156,18 +160,6 @@ describe("multi-local", () => {
     });
   });
 
-  describe("defaultLocalResources() returns legacy paths", () => {
-    test("instanceDir is homedir", () => {
-      const res = defaultLocalResources();
-      expect(res.instanceDir).toBe(testDir);
-    });
-
-    test("daemonPort is DEFAULT_DAEMON_PORT", () => {
-      const res = defaultLocalResources();
-      expect(res.daemonPort).toBe(DEFAULT_DAEMON_PORT);
-    });
-  });
-
   describe("resolveTargetAssistant() priority chain", () => {
     test("explicit name returns that entry", () => {
       writeLockfile({
@@ -243,14 +235,14 @@ describe("multi-local", () => {
     });
   });
 
-  describe("removeAssistantEntry() clears matching activeAssistant", () => {
-    test("set active to foo, remove foo, verify active is null", () => {
+  describe("removeAssistantEntry() reassigns activeAssistant on removal", () => {
+    test("set active to foo, remove foo, verify active is reassigned to bar", () => {
       writeLockfile({
         assistants: [makeEntry("foo"), makeEntry("bar")],
         activeAssistant: "foo",
       });
       removeAssistantEntry("foo");
-      expect(getActiveAssistant()).toBeNull();
+      expect(getActiveAssistant()).toBe("bar");
     });
 
     test("set active to foo, remove bar, verify active is still foo", () => {

package/src/__tests__/sleep.test.ts

@@ -0,0 +1,172 @@
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Create a temp directory and set VELLUM_LOCKFILE_DIR so the real
+// assistant-config module reads/writes the lockfile here instead of ~/.
+const testDir = mkdtempSync(join(tmpdir(), "sleep-command-test-"));
+const assistantRootDir = join(testDir, ".vellum");
+process.env.VELLUM_LOCKFILE_DIR = testDir;
+
+const stopProcessByPidFileMock = mock(async () => true);
+const isProcessAliveMock = mock((): { alive: boolean; pid: number | null } => ({
+  alive: false,
+  pid: null,
+}));
+
+mock.module("../lib/process.js", () => ({
+  isProcessAlive: isProcessAliveMock,
+  stopProcessByPidFile: stopProcessByPidFileMock,
+}));
+
+import { sleep } from "../commands/sleep.js";
+import {
+  DEFAULT_DAEMON_PORT,
+  DEFAULT_GATEWAY_PORT,
+  DEFAULT_QDRANT_PORT,
+} from "../lib/constants.js";
+
+// Write a lockfile entry so the real resolveTargetAssistant() finds our test
+// assistant without needing to mock the entire assistant-config module.
+function writeLockfile(): void {
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify(
+      {
+        assistants: [
+          {
+            assistantId: "sleep-test",
+            runtimeUrl: `http://127.0.0.1:${DEFAULT_DAEMON_PORT}`,
+            cloud: "local",
+            resources: {
+              instanceDir: testDir,
+              daemonPort: DEFAULT_DAEMON_PORT,
+              gatewayPort: DEFAULT_GATEWAY_PORT,
+              qdrantPort: DEFAULT_QDRANT_PORT,
+              pidFile: join(assistantRootDir, "vellum.pid"),
+            },
+          },
+        ],
+        activeAssistant: "sleep-test",
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+function writeLeaseFile(callSessionIds: string[]): void {
+  mkdirSync(assistantRootDir, { recursive: true });
+  writeFileSync(
+    join(assistantRootDir, "active-call-leases.json"),
+    JSON.stringify(
+      {
+        version: 1,
+        leases: callSessionIds.map((callSessionId) => ({
+          callSessionId,
+          providerCallSid: null,
+          updatedAt: Date.now(),
+        })),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+describe("sleep command", () => {
+  let originalArgv: string[];
+
+  beforeEach(() => {
+    originalArgv = [...process.argv];
+    isProcessAliveMock.mockReset();
+    isProcessAliveMock.mockReturnValue({ alive: false, pid: null });
+    stopProcessByPidFileMock.mockReset();
+    stopProcessByPidFileMock.mockResolvedValue(true);
+    rmSync(assistantRootDir, { recursive: true, force: true });
+    writeLockfile();
+  });
+
+  afterAll(() => {
+    process.argv = originalArgv;
+    rmSync(testDir, { recursive: true, force: true });
+    delete process.env.VELLUM_LOCKFILE_DIR;
+  });
+
+  test("refuses normal sleep while an active call lease exists", async () => {
+    isProcessAliveMock.mockReturnValue({ alive: true, pid: 12345 });
+    writeLeaseFile(["call-active-1", "call-active-2"]);
+    process.argv = ["bun", "vellum", "sleep", "sleep-test"];
+
+    const consoleError = spyOn(console, "error").mockImplementation(() => {});
+    const exitMock = mock((code?: number) => {
+      throw new Error(`process.exit:${code}`);
+    });
+    const originalExit = process.exit;
+    process.exit = exitMock as unknown as typeof process.exit;
+
+    try {
+      await expect(sleep()).rejects.toThrow("process.exit:1");
+      expect(consoleError).toHaveBeenCalledWith(
+        expect.stringContaining("vellum sleep --force"),
+      );
+    } finally {
+      process.exit = originalExit;
+      consoleError.mockRestore();
+    }
+
+    expect(stopProcessByPidFileMock).not.toHaveBeenCalled();
+  });
+
+  test("proceeds when assistant is not running even with stale lease file", async () => {
+    isProcessAliveMock.mockReturnValue({ alive: false, pid: null });
+    writeLeaseFile(["call-stale-1"]);
+    process.argv = ["bun", "vellum", "sleep", "sleep-test"];
+
+    const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+
+    try {
+      await sleep();
+    } finally {
+      consoleLog.mockRestore();
+    }
+
+    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(2);
+  });
+
+  test("force stops the assistant even when an active call lease exists", async () => {
+    writeLeaseFile(["call-active-1"]);
+    process.argv = ["bun", "vellum", "sleep", "sleep-test", "--force"];
+
+    const consoleLog = spyOn(console, "log").mockImplementation(() => {});
+
+    try {
+      await sleep();
+    } finally {
+      consoleLog.mockRestore();
+    }
+
+    expect(stopProcessByPidFileMock).toHaveBeenCalledTimes(2);
+    expect(stopProcessByPidFileMock).toHaveBeenNthCalledWith(
+      1,
+      join(assistantRootDir, "vellum.pid"),
+      "assistant",
+    );
+    expect(stopProcessByPidFileMock).toHaveBeenNthCalledWith(
+      2,
+      join(assistantRootDir, "gateway.pid"),
+      "gateway",
+      undefined,
+      7000,
+    );
+  });
+});