@vellumai/cli 0.10.10 → 0.10.11-dev.202607212222.fe33210

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.10",
+  "version": "0.10.11-dev.202607212222.fe33210",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/clean.test.ts

@@ -19,6 +19,13 @@ const stopProcessMock = mock(
   async (_pid: number, _label: string): Promise<boolean> => true,
 );
 
+// Snapshot the real modules so the afterAll below can restore them. Bun runs
+// every test file in one process with a shared loader, and `mock.restore()`
+// does not undo `mock.module()`; without restoring, these mocks (notably the
+// partial `process.js` mock) leak into sibling test files.
+const realOrphanDetection = { ...(await import("../lib/orphan-detection.js")) };
+const realProcess = { ...(await import("../lib/process.js")) };
+
 beforeAll(() => {
   mock.module("../lib/orphan-detection.js", () => ({
     detectOrphanedProcesses: detectOrphansMock,
@@ -65,6 +72,9 @@ afterEach(() => {
 
 afterAll(() => {
   process.argv = [...originalArgv];
+  // Restore the real modules so the mocks do not leak into sibling test files.
+  mock.module("../lib/orphan-detection.js", () => realOrphanDetection);
+  mock.module("../lib/process.js", () => realProcess);
 });
 
 // ── Tests ─────────────────────────────────────────────────────────────────────

package/src/__tests__/nginx-ingress.test.ts

@@ -10,8 +10,9 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
 
+const realChildProcess = { ...childProcess };
 const execFileSyncMock = mock(childProcess.execFileSync);
 
 mock.module("node:child_process", () => ({
@@ -19,6 +20,12 @@ mock.module("node:child_process", () => ({
   execFileSync: execFileSyncMock,
 }));
 
+// Restore the real module once this file finishes so the mock does not leak
+// into sibling test files in the same `bun test` run.
+afterAll(() => {
+  mock.module("node:child_process", () => realChildProcess);
+});
+
 import {
   buildIngressNginxConfig,
   buildRemoteWebIndexHtml,

package/src/__tests__/preload.ts

@@ -25,7 +25,14 @@ afterAll(() => {
     /* best-effort cleanup */
   }
 
-  // Reset all module mocks so mock.module() calls in one test file
-  // don't leak into the next file in the same bun test run.
+  // Restore spies created via spyOn()/mock() at the end of the run.
+  //
+  // NOTE: this does NOT prevent inter-file leaks of `mock.module()`. This
+  // `afterAll` runs once, after ALL files complete (a preload's afterAll wraps
+  // the whole run, not each file), and `mock.restore()` does not undo
+  // `mock.module()` registrations anyway. A file that calls `mock.module()`
+  // must restore the real module itself in its own `afterAll` by re-registering
+  // the captured real exports (see e.g. teleport.test.ts / recover.test.ts),
+  // otherwise the mock leaks into whichever file Bun runs next.
   mock.restore();
 });

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

@@ -17,10 +17,22 @@ import type { AssistantEntry } from "../lib/assistant-config.js";
 const testDir = mkdtempSync(join(tmpdir(), "retire-local-test-"));
 const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
 
+// Snapshot the real modules before mocking so the module-scoped `afterAll`
+// below can restore them. Bun runs every test file in one process with a
+// shared loader, and `mock.restore()` does not undo `mock.module()`. Without
+// restoring, the `retire-archive.js` mock in particular leaks its hardcoded
+// `test-assistant.*` paths into sibling files (e.g. `recover.test.ts`), which
+// then fail to find their own archives.
+const realProcess = { ...(await import("../lib/process.js")) };
+const realNginxIngress = { ...(await import("../lib/nginx-ingress.js")) };
+const realRetireArchive = { ...(await import("../lib/retire-archive.js")) };
+
 const stopProcessByPidFileMock = mock(
   async (_pidFile: string, _label: string): Promise<boolean> => true,
 );
-const stopOrphanedDaemonProcessesMock = mock(async (): Promise<boolean> => false);
+const stopOrphanedDaemonProcessesMock = mock(
+  async (): Promise<boolean> => false,
+);
 const stopIngressNginxMock = mock(async (): Promise<boolean> => false);
 
 mock.module("../lib/process.js", () => ({
@@ -40,6 +52,14 @@ mock.module("../lib/retire-archive.js", () => ({
   getMetadataPath: () => join(retiredStagingDir, "test-assistant.meta.json"),
 }));
 
+// Restore the real modules once this file finishes so the mocks above do not
+// leak into other test files in the same `bun test` run.
+afterAll(() => {
+  mock.module("../lib/process.js", () => realProcess);
+  mock.module("../lib/nginx-ingress.js", () => realNginxIngress);
+  mock.module("../lib/retire-archive.js", () => realRetireArchive);
+});
+
 import { retireLocal } from "../lib/retire-local.js";
 
 const instanceDir = join(testDir, "test-instance");

package/src/__tests__/sleep.test.ts

@@ -23,11 +23,19 @@ const isProcessAliveMock = mock((): { alive: boolean; pid: number | null } => ({
   pid: null,
 }));
 
+const realProcess = { ...(await import("../lib/process.js")) };
+
 mock.module("../lib/process.js", () => ({
   isProcessAlive: isProcessAliveMock,
   stopProcessByPidFile: stopProcessByPidFileMock,
 }));
 
+// Restore the real module once this file finishes so the mock does not leak
+// into other test files in the same `bun test` run.
+afterAll(() => {
+  mock.module("../lib/process.js", () => realProcess);
+});
+
 import { sleep } from "../commands/sleep.js";
 import {
   DEFAULT_DAEMON_PORT,

package/src/__tests__/teleport.test.ts

@@ -282,6 +282,17 @@ mock.module("../lib/local-runtime-client.js", () => ({
   localRuntimePreflightFromGcs: localRuntimePreflightFromGcsMock,
 }));
 
+// Snapshot the remaining real modules before mocking so `afterAll` can
+// restore them too — otherwise these mocks leak into sibling test files that
+// import the same modules in the same `bun test` run.
+const realHatchLocal = { ...(await import("../lib/hatch-local.js")) };
+const realDocker = { ...(await import("../lib/docker.js")) };
+const realProcess = { ...(await import("../lib/process.js")) };
+const realRetireLocal = { ...(await import("../lib/retire-local.js")) };
+const realUpgradeLifecycle = {
+  ...(await import("../lib/upgrade-lifecycle.js")),
+};
+
 const hatchLocalMock = mock(async () => {});
 
 mock.module("../lib/hatch-local.js", () => ({
@@ -350,6 +361,11 @@ afterAll(() => {
   mock.module("../lib/guardian-token.js", () => realGuardianToken);
   mock.module("../lib/platform-client.js", () => realPlatformClient);
   mock.module("../lib/local-runtime-client.js", () => realLocalRuntimeClient);
+  mock.module("../lib/hatch-local.js", () => realHatchLocal);
+  mock.module("../lib/docker.js", () => realDocker);
+  mock.module("../lib/process.js", () => realProcess);
+  mock.module("../lib/retire-local.js", () => realRetireLocal);
+  mock.module("../lib/upgrade-lifecycle.js", () => realUpgradeLifecycle);
   rmSync(testDir, { recursive: true, force: true });
   delete process.env.VELLUM_LOCKFILE_DIR;
 });

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

@@ -15,6 +15,15 @@ import { startCes } from "../local.js";
 // Mocks
 // ---------------------------------------------------------------------------
 
+// Snapshot the real modules before any `mock.module()` call so we can
+// re-register them in a module-scoped `afterAll` below. Bun runs every test
+// file in one process with a shared loader; without restoring, these mocks
+// leak into sibling files (e.g. `step-runner.test.ts`, whose real `spawn`
+// then returns this file's fake child with no `stdin` and a no-op `on`).
+const realChildProcess = { ...(await import("node:child_process")) };
+const realXdgLog = { ...(await import("../xdg-log.js")) };
+const realProcess = { ...(await import("../process.js")) };
+
 // Capture spawn calls so we can assert on cmd/env.
 let lastSpawnCall: {
   cmd: string[];
@@ -55,6 +64,15 @@ mock.module("../process.js", () => ({
   stopProcessGracefully: mock(async () => {}),
 }));
 
+// Restore the real modules once this file finishes so the mocks above do not
+// leak into other test files in the same `bun test` run. `mock.restore()` does
+// not undo `mock.module()`, so we re-register the captured real exports.
+afterAll(() => {
+  mock.module("node:child_process", () => realChildProcess);
+  mock.module("../xdg-log.js", () => realXdgLog);
+  mock.module("../process.js", () => realProcess);
+});
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------

package/src/lib/environments/__tests__/paths.test.ts

@@ -1,4 +1,12 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
 import { join } from "path";
 
 const TEST_HOME = "/test/home";
@@ -18,6 +26,13 @@ mock.module("os", () => ({
   homedir: () => TEST_HOME,
 }));
 
+// Restore the real `os` module once this file finishes so the `homedir()`
+// override does not leak into other test files in the same `bun test` run.
+afterAll(() => {
+  mock.module("node:os", () => realOs);
+  mock.module("os", () => realOs);
+});
+
 // Imports that depend on the mocked `os` module must come after the
 // mock.module() calls above.
 const {

package/src/lib/local.ts

@@ -42,8 +42,8 @@ const _require = createRequire(import.meta.url);
 const DARWIN_UNIX_SOCKET_MAX_PATH_BYTES = 103;
 
 // The longest socket filename we place in the workspace directory.
-// assistant-skill.sock = 20 chars, plus 1 for the "/" separator = 21 overhead.
-const LONGEST_SOCKET_FILENAME = "assistant-skill.sock";
+// assistant.sock = 14 chars, plus 1 for the "/" separator = 15 overhead.
+const LONGEST_SOCKET_FILENAME = "assistant.sock";
 const LOCAL_RUNTIME_PACKAGE = "vellum";
 
 export interface LocalRuntimeInstall {
@@ -300,7 +300,7 @@ function warnIfLegacyWorkspaceFallbackDetected(
 }
 
 /**
- * On macOS, if `{workspaceDir}/assistant-skill.sock` would exceed the
+ * On macOS, if `{workspaceDir}/assistant.sock` would exceed the
  * 103-byte AF_UNIX path limit, compute a short tmpdir-based IPC socket
  * directory and return it.  Returns `undefined` when no override is needed
  * (the workspace path is short enough, or we're not on macOS).
@@ -340,7 +340,6 @@ function applyIpcSocketDirOverride(
   mkdirSync(override, { recursive: true });
   env.GATEWAY_IPC_SOCKET_DIR = override;
   env.ASSISTANT_IPC_SOCKET_DIR = override;
-  env.ASSISTANT_SKILL_IPC_SOCKET_DIR = override;
 }
 
 function isAssistantSourceDir(dir: string): boolean {

package/src/shared/provider-env-vars.ts

@@ -30,6 +30,7 @@ export const LLM_PROVIDER_ENV_VAR_NAMES: Record<string, string> = {
   minimax: "MINIMAX_API_KEY",
   atlascloud: "ATLASCLOUD_API_KEY",
   together: "TOGETHER_API_KEY",
+  litellm: "LITELLM_API_KEY",
   baseten: "BASETEN_API_KEY",
 };