@vellumai/cli 0.10.6-dev.202607071937.200b337 → 0.10.6-dev.202607072040.fb971ce

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.6-dev.202607071937.200b337",
+  "version": "0.10.6-dev.202607072040.fb971ce",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/recover.test.ts

@@ -30,12 +30,14 @@ const realLocal = {
   generateLocalSigningKey: localModule.generateLocalSigningKey,
   startLocalDaemon: localModule.startLocalDaemon,
   startGateway: localModule.startGateway,
+  startCes: localModule.startCes,
 };
 const realExec = stepRunnerModule.exec;
 
-// Prevent real daemon / gateway from starting
+// Prevent real daemon / gateway / CES from starting
 const startLocalDaemonMock = mock(async () => {});
 const startGatewayMock = mock(async () => {});
+const startCesMock = mock(async () => {});
 
 // Capture exec calls without running real tar
 const execMock = mock(async (_cmd: string, _args: string[]) => {});
@@ -45,6 +47,7 @@ beforeAll(() => {
     generateLocalSigningKey: () => "deadbeefdeadbeefdeadbeefdeadbeef",
     startLocalDaemon: startLocalDaemonMock,
     startGateway: startGatewayMock,
+    startCes: startCesMock,
   }));
   mock.module("../lib/step-runner.js", () => ({ exec: execMock }));
 });
@@ -128,6 +131,7 @@ beforeEach(() => {
   execMock.mockClear();
   startLocalDaemonMock.mockClear();
   startGatewayMock.mockClear();
+  startCesMock.mockClear();
 });
 
 afterEach(() => {

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

@@ -119,6 +119,7 @@ const startGatewayMock = mock<typeof local.startGateway>(
 const stopLocalProcessesMock = mock<typeof local.stopLocalProcesses>(
   async () => {},
 );
+const startCesMock = mock<typeof local.startCes>(async () => {});
 
 mock.module("../lib/local.js", () => ({
   ...realLocal,
@@ -127,6 +128,7 @@ mock.module("../lib/local.js", () => ({
   startLocalDaemon: startLocalDaemonMock,
   startGateway: startGatewayMock,
   stopLocalProcesses: stopLocalProcessesMock,
+  startCes: startCesMock,
 }));
 
 const loopbackSafeFetchMock = mock<typeof loopbackFetch.loopbackSafeFetch>(
@@ -256,6 +258,8 @@ beforeEach(() => {
   startGatewayMock.mockResolvedValue("http://127.0.0.1:7830");
   stopLocalProcessesMock.mockReset();
   stopLocalProcessesMock.mockResolvedValue(undefined);
+  startCesMock.mockReset();
+  startCesMock.mockResolvedValue(undefined);
   loopbackSafeFetchMock.mockReset();
   loopbackSafeFetchMock.mockResolvedValue({
     ok: true,

package/src/lib/__tests__/local-ces.test.ts

@@ -0,0 +1,104 @@
+import { mkdtempSync, rmSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
+
+import { startCes } from "../local.js";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+// Capture spawn calls so we can assert on cmd/env.
+let lastSpawnCall: {
+  cmd: string[];
+  options: { detached?: boolean; env?: Record<string, string | undefined>; cwd?: string };
+} | null = null;
+
+mock.module("node:child_process", () => ({
+  spawn: mock((cmd: string, args: string[], options: object) => {
+    lastSpawnCall = { cmd: [cmd, ...args], options };
+    // Return a fake subprocess with a pid and no-op methods.
+    return {
+      pid: 42,
+      unref: () => {},
+      stdout: { on: () => {} },
+      stderr: { on: () => {} },
+      on: () => {},
+    };
+  }),
+  execSync: () => "",
+  execFileSync: () => "",
+  spawnSync: () => ({ status: 0, stdout: "", stderr: "" }),
+}));
+
+// Mock xdg-log so we don't open real log files.
+mock.module("../xdg-log.js", () => ({
+  openLogFile: mock(() => 42),
+  pipeToLogFile: mock(() => {}),
+}));
+
+// Mock process helpers so stopProcessByPidFile is a no-op.
+mock.module("../process.js", () => ({
+  stopProcessByPidFile: mock(async () => {}),
+  isProcessAlive: mock(() => false),
+  stopProcessGracefully: mock(async () => {}),
+}));
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("startCes", () => {
+  let tempDir: string;
+
+  beforeAll(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "ces-test-"));
+  });
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("spawns CES with correct env vars and writes PID file", async () => {
+    // Create the socket path before calling startCes so the wait loop exits.
+    // startCes unlinks it first, then waits for it to reappear. We create it
+    // after a short delay to simulate CES binding the socket.
+    const resources = {
+      instanceDir: tempDir,
+      name: "test-assistant",
+    } as unknown as Parameters<typeof startCes>[1];
+
+    // Create the socket file asynchronously after startCes unlinks it.
+    // We use a small setTimeout to create it during the wait loop.
+    const vellumDir = join(tempDir, ".vellum");
+    mkdirSync(vellumDir, { recursive: true });
+
+    // Pre-create the socket so it exists when startCes checks after unlinking.
+    // startCes unlinks the stale socket, then polls for it. We create it with
+    // a slight delay so the poll catches it.
+    setTimeout(() => {
+      const socketDir = join(vellumDir, "workspace");
+      mkdirSync(socketDir, { recursive: true });
+      writeFileSync(join(socketDir, "ces.sock"), "");
+    }, 50);
+
+    lastSpawnCall = null;
+    await startCes(false, resources);
+
+    // Verify spawn was called
+    expect(lastSpawnCall).not.toBeNull();
+    expect(lastSpawnCall!.options.detached).toBe(true);
+
+    // Verify env vars
+    const env = lastSpawnCall!.options.env!;
+    expect(env["CES_STANDALONE"]).toBe("1");
+    expect(env["CES_LOCAL_SOCKET"]).toBeDefined();
+    expect(env["CREDENTIAL_SECURITY_DIR"]).toBeDefined();
+    expect(env["VELLUM_WORKSPACE_DIR"]).toBeDefined();
+
+    // Verify PID file was written
+    const cesPidFile = join(vellumDir, "ces.pid");
+    expect(existsSync(cesPidFile)).toBe(true);
+  }, 15_000);
+});

package/src/lib/local.ts

@@ -573,14 +573,12 @@ function applyDaemonEnvOverrides(
     env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH =
       options.defaultWorkspaceConfigPath;
   }
-  // When the CLI launches CES as a sibling (CES_STANDALONE), pin the daemon to
-  // the exact socket the sibling binds so the two agree regardless of any stale
-  // CES_LOCAL_SOCKET inherited from the parent environment. The assistant then
-  // connects to the sibling instead of spawning its own CES.
-  if (isCesSiblingOptIn()) {
-    env.CES_STANDALONE = "1";
-    env.CES_LOCAL_SOCKET = resolveCesSocketPath(resources);
-  }
+  // Pin the daemon to the exact socket the sibling binds so the two agree
+  // regardless of any stale CES_LOCAL_SOCKET inherited from the parent
+  // environment. The assistant connects to the sibling instead of spawning
+  // its own CES.
+  env.CES_STANDALONE = "1";
+  env.CES_LOCAL_SOCKET = resolveCesSocketPath(resources);
   applyIpcSocketDirOverride(env);
 }
 
@@ -850,19 +848,9 @@ function resolveCesSocketPath(resources?: LocalInstanceResources): string {
 }
 
 /**
- * Whether the CLI should launch CES as an independent sibling process instead
- * of leaving the assistant to spawn it as an stdio child. Temporary opt-in
- * (`CES_STANDALONE=1`) while local CES converges onto the sibling model that
- * containerized homes already use.
- */
-function isCesSiblingOptIn(): boolean {
-  return process.env.CES_STANDALONE === "1";
-}
-
-/**
- * Launch the local CES sibling over a Unix socket (opted into via
- * `CES_STANDALONE=1`). No-op unless the opt-in is set, in which case the
- * assistant continues to spawn CES itself as today.
+ * Launch the local CES sibling over a Unix socket. The sibling model is now
+ * the default topology for local (non-containerized) instances, matching how
+ * containerized homes already run CES.
  *
  * The sibling runs with `CES_STANDALONE=1` so its lifecycle is anchored to
  * SIGTERM rather than stdin EOF, mirroring the gateway: a CLI-owned process
@@ -873,8 +861,6 @@ export async function startCes(
   watch: boolean = false,
   resources?: LocalInstanceResources,
 ): Promise<void> {
-  if (!isCesSiblingOptIn()) return;
-
   const vellumDir = resources
     ? join(resources.instanceDir, ".vellum")
     : join(homedir(), ".vellum");