@vellumai/cli 0.8.4 → 0.8.6

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

@@ -0,0 +1,215 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import * as assistantConfig from "../lib/assistant-config.js";
+import * as docker from "../lib/docker.js";
+import * as guardianToken from "../lib/guardian-token.js";
+import * as local from "../lib/local.js";
+import * as ngrok from "../lib/ngrok.js";
+import * as processLib from "../lib/process.js";
+import type { AssistantEntry } from "../lib/assistant-config.js";
+
+const realAssistantConfig = { ...assistantConfig };
+const realDocker = { ...docker };
+const realGuardianToken = { ...guardianToken };
+const realLocal = { ...local };
+const realNgrok = { ...ngrok };
+const realProcessLib = { ...processLib };
+
+const resolveTargetAssistantMock = mock<
+  typeof assistantConfig.resolveTargetAssistant
+>();
+const saveAssistantEntryMock = mock<typeof assistantConfig.saveAssistantEntry>(
+  () => {},
+);
+const getDaemonPidPathMock = mock<typeof assistantConfig.getDaemonPidPath>(
+  (resources) => join(resources!.instanceDir, ".vellum", "daemon.pid"),
+);
+
+mock.module("../lib/assistant-config.js", () => ({
+  ...realAssistantConfig,
+  resolveTargetAssistant: resolveTargetAssistantMock,
+  saveAssistantEntry: saveAssistantEntryMock,
+  getDaemonPidPath: getDaemonPidPathMock,
+}));
+
+const dockerResourceNamesMock = mock<typeof docker.dockerResourceNames>(
+  realDocker.dockerResourceNames,
+);
+const wakeContainersMock = mock<typeof docker.wakeContainers>(async () => {});
+
+mock.module("../lib/docker.js", () => ({
+  ...realDocker,
+  dockerResourceNames: dockerResourceNamesMock,
+  wakeContainers: wakeContainersMock,
+}));
+
+const seedGuardianTokenFromSiblingEnvMock = mock<
+  typeof guardianToken.seedGuardianTokenFromSiblingEnv
+>(() => false);
+
+mock.module("../lib/guardian-token.js", () => ({
+  ...realGuardianToken,
+  seedGuardianTokenFromSiblingEnv: seedGuardianTokenFromSiblingEnvMock,
+}));
+
+const resolveProcessStateMock = mock<typeof processLib.resolveProcessState>(
+  async (_pidFile, _port, label) => ({
+    status: "healthy",
+    pid: label === "Gateway" ? 456 : 123,
+  }),
+);
+const stopProcessByPidFileMock = mock<typeof processLib.stopProcessByPidFile>(
+  async () => true,
+);
+
+mock.module("../lib/process", () => ({
+  ...realProcessLib,
+  resolveProcessState: resolveProcessStateMock,
+  stopProcessByPidFile: stopProcessByPidFileMock,
+}));
+
+const generateLocalSigningKeyMock = mock<typeof local.generateLocalSigningKey>(
+  () => "generated-bootstrap-secret",
+);
+const isAssistantWatchModeAvailableMock = mock<
+  typeof local.isAssistantWatchModeAvailable
+>(() => false);
+const isGatewayWatchModeAvailableMock = mock<
+  typeof local.isGatewayWatchModeAvailable
+>(() => false);
+const startLocalDaemonMock = mock<typeof local.startLocalDaemon>(async () => {});
+const startGatewayMock = mock<typeof local.startGateway>(
+  async () => "http://127.0.0.1:7830",
+);
+
+mock.module("../lib/local", () => ({
+  ...realLocal,
+  generateLocalSigningKey: generateLocalSigningKeyMock,
+  isAssistantWatchModeAvailable: isAssistantWatchModeAvailableMock,
+  isGatewayWatchModeAvailable: isGatewayWatchModeAvailableMock,
+  startLocalDaemon: startLocalDaemonMock,
+  startGateway: startGatewayMock,
+}));
+
+const maybeStartNgrokTunnelMock = mock<typeof ngrok.maybeStartNgrokTunnel>(
+  async () => null,
+);
+
+mock.module("../lib/ngrok", () => ({
+  ...realNgrok,
+  maybeStartNgrokTunnel: maybeStartNgrokTunnelMock,
+}));
+
+const { wake } = await import("../commands/wake.js");
+
+let tempDir: string;
+let originalArgv: string[];
+let logSpy: ReturnType<typeof spyOn>;
+
+function makeLocalEntry(): AssistantEntry {
+  tempDir = mkdtempSync(join(tmpdir(), "vellum-wake-test-"));
+  mkdirSync(join(tempDir, ".vellum"), { recursive: true });
+  return {
+    assistantId: "local-assistant",
+    runtimeUrl: "http://127.0.0.1:7830",
+    cloud: "local",
+    resources: {
+      instanceDir: tempDir,
+      daemonPort: 7821,
+      gatewayPort: 7830,
+      qdrantPort: 6333,
+      cesPort: 7822,
+      signingKey: "existing-signing-key",
+    },
+  };
+}
+
+beforeEach(() => {
+  originalArgv = [...process.argv];
+  tempDir = "";
+  process.argv = ["bun", "vellum", "wake", "--watch", "local-assistant"];
+  logSpy = spyOn(console, "log").mockImplementation(() => {});
+
+  const entry = makeLocalEntry();
+  resolveTargetAssistantMock.mockReset();
+  resolveTargetAssistantMock.mockReturnValue(entry);
+  saveAssistantEntryMock.mockReset();
+  getDaemonPidPathMock.mockReset();
+  getDaemonPidPathMock.mockImplementation((resources) =>
+    join(resources!.instanceDir, ".vellum", "daemon.pid"),
+  );
+  resolveProcessStateMock.mockReset();
+  resolveProcessStateMock.mockImplementation(async (_pidFile, _port, label) => ({
+    status: "healthy",
+    pid: label === "Gateway" ? 456 : 123,
+  }));
+  stopProcessByPidFileMock.mockReset();
+  stopProcessByPidFileMock.mockResolvedValue(true);
+  generateLocalSigningKeyMock.mockReset();
+  generateLocalSigningKeyMock.mockReturnValue("generated-bootstrap-secret");
+  isAssistantWatchModeAvailableMock.mockReset();
+  isAssistantWatchModeAvailableMock.mockReturnValue(false);
+  isGatewayWatchModeAvailableMock.mockReset();
+  isGatewayWatchModeAvailableMock.mockReturnValue(false);
+  startLocalDaemonMock.mockReset();
+  startLocalDaemonMock.mockResolvedValue(undefined);
+  startGatewayMock.mockReset();
+  startGatewayMock.mockResolvedValue("http://127.0.0.1:7830");
+  seedGuardianTokenFromSiblingEnvMock.mockReset();
+  seedGuardianTokenFromSiblingEnvMock.mockReturnValue(false);
+  maybeStartNgrokTunnelMock.mockReset();
+  maybeStartNgrokTunnelMock.mockResolvedValue(null);
+});
+
+afterEach(() => {
+  process.argv = originalArgv;
+  logSpy.mockRestore();
+  if (tempDir) {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+afterAll(() => {
+  mock.module("../lib/assistant-config.js", () => realAssistantConfig);
+  mock.module("../lib/docker.js", () => realDocker);
+  mock.module("../lib/guardian-token.js", () => realGuardianToken);
+  mock.module("../lib/process", () => realProcessLib);
+  mock.module("../lib/local", () => realLocal);
+  mock.module("../lib/ngrok", () => realNgrok);
+});
+
+describe("vellum wake", () => {
+  test("restarts a running gateway without watch mode when backfilling the bootstrap secret", async () => {
+    await wake();
+
+    expect(saveAssistantEntryMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        guardianBootstrapSecret: "generated-bootstrap-secret",
+      }),
+    );
+    expect(stopProcessByPidFileMock).toHaveBeenCalledWith(
+      join(tempDir, ".vellum", "gateway.pid"),
+      "gateway",
+    );
+    expect(startGatewayMock).toHaveBeenCalledWith(
+      false,
+      expect.objectContaining({ instanceDir: tempDir }),
+      {
+        signingKey: "existing-signing-key",
+        bootstrapSecret: "generated-bootstrap-secret",
+      },
+    );
+  });
+});

package/src/commands/backup.ts

@@ -93,6 +93,7 @@ export async function backup(): Promise<void> {
       const freshToken = await leaseGuardianToken(
         entry.runtimeUrl,
         entry.assistantId,
+        entry.guardianBootstrapSecret,
       );
       accessToken = freshToken.accessToken;
     } catch (err) {
@@ -129,6 +130,7 @@ export async function backup(): Promise<void> {
         const freshToken = await leaseGuardianToken(
           entry.runtimeUrl,
           entry.assistantId,
+          entry.guardianBootstrapSecret,
         );
         refreshedToken = freshToken.accessToken;
       } catch {

package/src/commands/client.ts

@@ -278,18 +278,29 @@ async function maybeHydratePlatformAssistantName(
   }
 }
 
+const SPA_BASE = "/assistant/";
+
 /**
- * Walk up from this file's location to find a sibling `clients/web` package.
+ * Locate the pre-built @vellumai/web dist directory.
  *
- * Returns the absolute path to its directory, or null when not found —
- * e.g. when the CLI is installed via npm/bunx, where the `clients/web`
- * source isn't shipped alongside `@vellumai/cli`. For now we treat the
- * `--interface web` path as source-checkout-only.
+ * Resolution order:
+ *   1. npm-installed package — require.resolve('@vellumai/web/package.json')
+ *   2. Source checkout — walk up from cli/ to find apps/web/dist/
  */
-function findClientsWebDir(): string | null {
+function findWebDistDir(): string | null {
+  try {
+    const pkgPath = require.resolve("@vellumai/web/package.json");
+    const distDir = path.join(path.dirname(pkgPath), "dist");
+    if (existsSync(path.join(distDir, "index.html"))) {
+      return distDir;
+    }
+  } catch {
+    // Package not installed; try source checkout.
+  }
+
   let dir = import.meta.dir;
   for (let depth = 0; depth < 8; depth++) {
-    const candidate = path.join(dir, "clients", "web", "package.json");
+    const candidate = path.join(dir, "apps", "web", "dist", "index.html");
     if (existsSync(candidate)) {
       return path.dirname(candidate);
     }
@@ -300,42 +311,61 @@ function findClientsWebDir(): string | null {
   return null;
 }
 
-/**
- * Spawn the `clients/web` package's `local` script and proxy its lifecycle.
- *
- * The web client is deliberately not declared as a dependency of `@vellumai/cli`:
- * the CLI is published, the web package is not. Locating it on disk and
- * shelling out keeps the two packages independent.
- */
 async function runWebInterface(): Promise<void> {
-  const webDir = findClientsWebDir();
-  if (!webDir) {
+  const distDir = findWebDistDir();
+  if (!distDir) {
     console.error(
       `${ANSI.bold}--interface web${ANSI.reset}: unable to locate ` +
-        `clients/web. This interface currently requires running ` +
-        `vellum from a source checkout of vellum-assistant.`,
+        `@vellumai/web assets.\n\n` +
+        `  npm/bunx install:   npm install @vellumai/web\n` +
+        `  source checkout:    cd apps/web && VITE_PLATFORM_MODE=false bun run build`,
     );
     process.exit(1);
   }
 
-  const child = Bun.spawn({
-    cmd: ["bun", "run", "local"],
-    cwd: webDir,
-    stdio: ["inherit", "inherit", "inherit"],
+  const indexHtml = await Bun.file(path.join(distDir, "index.html")).text();
+
+  const server = Bun.serve({
+    port: 3000,
+    hostname: "127.0.0.1",
+    fetch: async (req) => {
+      const url = new URL(req.url);
+      const { pathname } = url;
+
+      if (pathname === "/") {
+        return Response.redirect(SPA_BASE, 302);
+      }
+
+      if (pathname.startsWith(SPA_BASE)) {
+        const relPath = pathname.slice(SPA_BASE.length);
+        if (relPath) {
+          const filePath = path.join(distDir, relPath);
+          const file = Bun.file(filePath);
+          if (await file.exists()) {
+            return new Response(file);
+          }
+        }
+        return new Response(indexHtml, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+
+      return new Response("Not Found", { status: 404 });
+    },
   });
 
-  const forward = (signal: "SIGINT" | "SIGTERM"): void => {
-    try {
-      child.kill(signal);
-    } catch {
-      // Child already exited; nothing to forward.
-    }
+  console.log(
+    `Vellum web interface: http://${server.hostname}:${server.port}${SPA_BASE}`,
+  );
+
+  const shutdown = (): void => {
+    server.stop();
+    process.exit(0);
   };
-  process.on("SIGINT", () => forward("SIGINT"));
-  process.on("SIGTERM", () => forward("SIGTERM"));
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
 
-  const exitCode = await child.exited;
-  process.exit(typeof exitCode === "number" ? exitCode : 0);
+  await new Promise(() => {});
 }
 
 export async function client(): Promise<void> {