@vellumai/cli 0.10.5-dev.202607031934.26016be → 0.10.5-dev.202607032030.d15600c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.5-dev.202607031934.26016be",
+  "version": "0.10.5-dev.202607032030.d15600c",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

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

@@ -0,0 +1,157 @@
+import {
+  afterAll,
+  beforeAll,
+  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";
+
+import type { AssistantEntry } from "../lib/assistant-config.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "retire-local-test-"));
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+
+const stopProcessByPidFileMock = mock(
+  async (_pidFile: string, _label: string): Promise<boolean> => true,
+);
+const stopOrphanedDaemonProcessesMock = mock(async (): Promise<boolean> => false);
+const stopIngressNginxMock = mock(async (): Promise<boolean> => false);
+
+mock.module("../lib/process.js", () => ({
+  stopProcessByPidFile: stopProcessByPidFileMock,
+  stopOrphanedDaemonProcesses: stopOrphanedDaemonProcessesMock,
+}));
+
+mock.module("../lib/nginx-ingress.js", () => ({
+  stopIngressNginx: stopIngressNginxMock,
+}));
+
+// Keep archive paths on the same filesystem as the test dir so rename doesn't
+// hit EXDEV (cross-device link).
+const retiredStagingDir = join(testDir, "retired");
+mock.module("../lib/retire-archive.js", () => ({
+  getArchivePath: () => join(retiredStagingDir, "test-assistant.tar.gz"),
+  getMetadataPath: () => join(retiredStagingDir, "test-assistant.meta.json"),
+}));
+
+import { retireLocal } from "../lib/retire-local.js";
+
+const instanceDir = join(testDir, "test-instance");
+const vellumDir = join(instanceDir, ".vellum");
+
+function makeEntry(assistantId: string): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: "http://127.0.0.1:7801",
+    cloud: "local",
+    resources: {
+      instanceDir,
+      daemonPort: 7801,
+      gatewayPort: 7831,
+      qdrantPort: 6334,
+      cesPort: 7790,
+    },
+  };
+}
+
+function writeLockfile(entries: AssistantEntry[]): void {
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify({ assistants: entries }, null, 2) + "\n",
+  );
+}
+
+describe("retireLocal — CES sibling stop", () => {
+  beforeAll(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+  });
+
+  beforeEach(() => {
+    stopProcessByPidFileMock.mockReset();
+    stopProcessByPidFileMock.mockResolvedValue(true);
+    stopOrphanedDaemonProcessesMock.mockReset();
+    stopOrphanedDaemonProcessesMock.mockResolvedValue(false);
+    stopIngressNginxMock.mockReset();
+    stopIngressNginxMock.mockResolvedValue(false);
+
+    rmSync(instanceDir, { recursive: true, force: true });
+    rmSync(join(testDir, "retired"), { recursive: true, force: true });
+    mkdirSync(vellumDir, { recursive: true });
+    writeLockfile([makeEntry("test-assistant")]);
+
+    // Suppress console output from the lifecycle reporter.
+    spyOn(console, "log").mockImplementation(() => {});
+    spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterAll(() => {
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("stops the CES sibling alongside daemon and gateway", async () => {
+    const entry = makeEntry("test-assistant");
+    await retireLocal("test-assistant", entry, {
+      progress: () => {},
+      log: () => {},
+      warn: () => {},
+      error: () => {},
+    });
+
+    // Verify CES PID file is among the stop calls.
+    const cesStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([pidFile, label]) =>
+        pidFile === join(vellumDir, "ces.pid") &&
+        label === "credential-executor",
+    );
+    expect(cesStopCall).toBeDefined();
+
+    // Also verify daemon and gateway are still stopped (sanity).
+    const daemonStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([, label]) => label === "daemon",
+    );
+    expect(daemonStopCall).toBeDefined();
+
+    const gatewayStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([, label]) => label === "gateway",
+    );
+    expect(gatewayStopCall).toBeDefined();
+  });
+
+  test("CES stop is a no-op when ces.pid is absent", async () => {
+    // stopProcessByPidFile returns false when the PID file doesn't exist.
+    // retireLocal should still complete successfully — the CES stop is best-effort.
+    stopProcessByPidFileMock.mockImplementation(
+      async (pidFile: string): Promise<boolean> => {
+        if (pidFile.includes("ces.pid")) return false;
+        return true;
+      },
+    );
+
+    const entry = makeEntry("test-assistant");
+    await retireLocal("test-assistant", entry, {
+      progress: () => {},
+      log: () => {},
+      warn: () => {},
+      error: () => {},
+    });
+
+    // The CES stop was attempted (PID file checked) but returned false.
+    const cesStopCall = stopProcessByPidFileMock.mock.calls.find(
+      ([pidFile, label]) =>
+        pidFile === join(vellumDir, "ces.pid") &&
+        label === "credential-executor",
+    );
+    expect(cesStopCall).toBeDefined();
+  });
+});

package/src/lib/docker.ts

@@ -1626,7 +1626,45 @@ async function waitForGatewayAndLease(opts: {
     log(`  Container: ${containerName}`);
     log("");
     log(`Stop with: vellum retire ${instanceName}`);
-    return { ready: true };
+
+    // Lease a guardian token even in detached mode so that `vellum ps`,
+    // `vellum exec`, and other CLI commands can authenticate to the
+    // gateway. Skip the /readyz readiness poll (the caller asked to detach
+    // and not block) but retry the lease itself since the gateway may need
+    // a moment to accept connections after the container starts.
+    const leaseStart = Date.now();
+    const leaseDeadline = containersUpAt + DOCKER_READY_TIMEOUT_MS;
+    let guardianAccessToken: string | undefined;
+    while (Date.now() < leaseDeadline) {
+      try {
+        const tokenData = await leaseGuardianToken(
+          runtimeUrl,
+          instanceName,
+          bootstrapSecret,
+        );
+        guardianAccessToken = tokenData.accessToken;
+        const leaseElapsed = ((Date.now() - leaseStart) / 1000).toFixed(1);
+        log(
+          `Guardian token lease: success after ${leaseElapsed}s (principalId=${tokenData.guardianPrincipalId})`,
+        );
+        break;
+      } catch (err) {
+        const elapsed = ((Date.now() - leaseStart) / 1000).toFixed(0);
+        const msg = err instanceof Error ? err.message : String(err);
+        log(
+          `Guardian token lease: attempt failed after ${elapsed}s (${msg.split("\n")[0]}), retrying...`,
+        );
+        await new Promise((r) => setTimeout(r, 2000));
+      }
+    }
+    if (!guardianAccessToken) {
+      log(
+        `⚠️  Guardian token lease failed after ${DOCKER_READY_TIMEOUT_MS / 1000}s.\n` +
+          `   The assistant is running but CLI commands (vellum ps, vellum exec) will not authenticate.\n` +
+          `   Re-hatch or run \`vellum setup\` to recover.`,
+      );
+    }
+    return { ready: true, guardianAccessToken };
   }
 
   log(`  Container: ${containerName}`);

package/src/lib/retire-local.ts

@@ -66,6 +66,18 @@ export async function retireLocal(
   const gatewayPidFile = join(vellumDir, "gateway.pid");
   await stopProcessByPidFile(gatewayPidFile, "gateway", undefined, 7000);
 
+  // Stop the CES sibling if one was launched (CES_STANDALONE). No-op when the
+  // PID file is absent — on the default topology the assistant owns CES as an
+  // stdio child and it exits with the daemon.
+  const cesPidFile = join(vellumDir, "ces.pid");
+  const cesStopped = await stopProcessByPidFile(
+    cesPidFile,
+    "credential-executor",
+  );
+  if (cesStopped) {
+    reporter.log("credential-executor stopped.");
+  }
+
   // Stop Qdrant — the daemon's graceful shutdown tries to stop it via
   // qdrantManager.stop(), but if the daemon was SIGKILL'd (after 2s timeout)
   // Qdrant may still be running as an orphan. Check both the current PID file