@vellumai/cli 0.10.4-staging.2 → 0.10.5-dev.202607022248.91fa053

package/node_modules/@vellumai/local-mode/src/__tests__/retire.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+import { EventEmitter } from "node:events";
+
+import type { CliInvocation } from "../util";
+
+class FakeChild extends EventEmitter {
+  stdout = new EventEmitter();
+  stderr = new EventEmitter();
+  kill = mock(() => true);
+}
+
+let lastChild: FakeChild;
+const spawnArgs: Array<
+  [string, string[], { env?: NodeJS.ProcessEnv; stdio?: unknown }]
+> = [];
+const spawnMock = mock(
+  (
+    command: string,
+    args: string[],
+    options: { env?: NodeJS.ProcessEnv; stdio?: unknown },
+  ) => {
+    spawnArgs.push([command, args, options]);
+    lastChild = new FakeChild();
+    return lastChild;
+  },
+);
+
+mock.module("node:child_process", () => ({ spawn: spawnMock }));
+
+let runRetire: typeof import("../retire").runRetire;
+
+beforeAll(async () => {
+  ({ runRetire } = await import("../retire"));
+});
+
+afterEach(() => {
+  spawnArgs.length = 0;
+  spawnMock.mockClear();
+  delete process.env.VELLUM_PLATFORM_TOKEN;
+});
+
+const invocation: CliInvocation = { command: "bun", baseArgs: ["run", "cli"] };
+
+describe("runRetire", () => {
+  test("spawns the CLI retire command", async () => {
+    const pending = runRetire(invocation, "asst-42");
+    lastChild.emit("close", 0);
+
+    expect(await pending).toEqual({ ok: true });
+    expect(spawnArgs[0]).toEqual([
+      "bun",
+      ["run", "cli", "retire", "asst-42", "--yes"],
+      { stdio: ["ignore", "pipe", "pipe"] },
+    ]);
+  });
+
+  test("passes a host platform token to the CLI subprocess", async () => {
+    const pending = runRetire(invocation, "asst-42", {
+      platformToken: "session-token",
+    });
+    lastChild.emit("close", 0);
+
+    expect(await pending).toEqual({ ok: true });
+    expect(spawnArgs[0]?.[2].env?.VELLUM_PLATFORM_TOKEN).toBe("session-token");
+    expect(process.env.VELLUM_PLATFORM_TOKEN).toBeUndefined();
+  });
+
+  test("a non-zero exit resolves to a failure carrying the CLI output", async () => {
+    const pending = runRetire(invocation, "asst-42");
+    lastChild.stderr.emit("data", Buffer.from("retire failed"));
+    lastChild.emit("close", 1);
+
+    expect(await pending).toEqual({
+      ok: false,
+      status: 500,
+      error: "retire failed",
+    });
+  });
+});

package/node_modules/@vellumai/local-mode/src/index.ts

@@ -14,9 +14,18 @@ export {
   resolveDevCliInvocation,
 } from "./util";
 export type { CliInvocation } from "./util";
-export { resolveLocalConfigFromEnv, resolveLockfilePaths, resolveConfigDir, guardianTokenPath } from "./config";
+export {
+  resolveLocalConfigFromEnv,
+  resolveLockfilePaths,
+  resolveConfigDir,
+  guardianTokenPath,
+} from "./config";
 export type { LocalEndpointConfig } from "./config";
-export { defaultEnvironmentFilePath, readDefaultEnvironment, resolveEnvironmentName } from "./environment";
+export {
+  defaultEnvironmentFilePath,
+  readDefaultEnvironment,
+  resolveEnvironmentName,
+} from "./environment";
 export {
   getLockfileData,
   upsertLockfileAssistant,
@@ -34,7 +43,7 @@ export type {
 export { runHatch } from "./hatch";
 export type { HatchResult } from "./hatch";
 export { runRetire } from "./retire";
-export type { RetireResult } from "./retire";
+export type { RetireOptions, RetireResult } from "./retire";
 export { runSleep } from "./sleep";
 export type { SleepResult } from "./sleep";
 export { runWake } from "./wake";

package/node_modules/@vellumai/local-mode/src/lockfile-contract.test.ts

@@ -21,6 +21,9 @@ describe("parseLockfile", () => {
           species: "vellum",
           hatchedAt: "2026-01-01T00:00:00.000Z",
           organizationId: "org_1",
+          platformAssistantId: "platform-assistant-1",
+          platformBaseUrl: "https://platform.example.com",
+          platformOrganizationId: "org_1",
           resources: { gatewayPort: 7777, daemonPort: 7778 },
         },
       ],
@@ -274,13 +277,19 @@ describe("parseLockfile", () => {
     expect(parseLockfile(raw).assistants).toEqual([
       { assistantId: "gcp_1", cloud: "gcp", runtimeUrl: "https://a" },
       { assistantId: "ssh_1", cloud: "custom", runtimeUrl: "https://b" },
-      { assistantId: "local_1", cloud: "local", runtimeUrl: "http://localhost:7830" },
+      {
+        assistantId: "local_1",
+        cloud: "local",
+        runtimeUrl: "http://localhost:7830",
+      },
     ]);
   });
 
   test("prefers an explicit cloud over legacy remote markers", () => {
     const raw = {
-      assistants: [{ assistantId: "a", cloud: "vellum", project: "stale-proj" }],
+      assistants: [
+        { assistantId: "a", cloud: "vellum", project: "stale-proj" },
+      ],
       activeAssistant: null,
     };
     expect(parseLockfile(raw).assistants).toEqual([

package/node_modules/@vellumai/local-mode/src/lockfile-contract.ts

@@ -109,6 +109,12 @@ export const LockfileAssistantSchema = z.object({
   hatchedAt: z.string().optional(),
   /** Owning org for platform assistants; absent for local ones. */
   organizationId: z.string().optional(),
+  /** Platform assistant UUID for a self-hosted local assistant registration. */
+  platformAssistantId: z.string().optional(),
+  /** Platform base URL used for a self-hosted local assistant registration. */
+  platformBaseUrl: z.string().optional(),
+  /** Platform organization UUID used for a self-hosted local assistant registration. */
+  platformOrganizationId: z.string().optional(),
   resources: LocalAssistantResourcesSchema.optional(),
 });
 

package/node_modules/@vellumai/local-mode/src/lockfile.test.ts

@@ -171,6 +171,32 @@ describe("upsertLockfileAssistant", () => {
       name: "Renamed",
     });
   });
+
+  test("preserves activeAssistant when no active id is provided", () => {
+    writeOnDisk({
+      activeAssistant: "asst_active",
+      assistants: [
+        {
+          assistantId: "asst_active",
+          cloud: "local",
+          runtimeUrl: "http://active",
+        },
+        { assistantId: "asst_1", cloud: "local", runtimeUrl: "http://a" },
+      ],
+    });
+
+    const result = upsertLockfileAssistant(
+      [lockfilePath],
+      { assistantId: "asst_1", name: "Renamed" },
+      undefined,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(readOnDisk().activeAssistant).toBe("asst_active");
+    if (result.ok) {
+      expect(result.lockfile.activeAssistant).toBe("asst_active");
+    }
+  });
 });
 
 describe("replacePlatformAssistants", () => {
@@ -270,7 +296,9 @@ describe("replacePlatformAssistants", () => {
       "org_a",
     );
 
-    const assistants = readOnDisk().assistants as Array<Record<string, unknown>>;
+    const assistants = readOnDisk().assistants as Array<
+      Record<string, unknown>
+    >;
     expect(assistants).toHaveLength(1);
     expect(assistants[0]).toMatchObject({
       assistantId: "asst_dup",

package/node_modules/@vellumai/local-mode/src/retire.ts

@@ -5,18 +5,32 @@ import type { CliInvocation } from "./util";
 const RETIRE_TIMEOUT_MS = 60_000;
 
 export type RetireResult =
-  | { ok: true }
-  | { ok: false; status: number; error: string };
+  { ok: true } | { ok: false; status: number; error: string };
+
+export interface RetireOptions {
+  platformToken?: string;
+}
 
 export function runRetire(
   invocation: CliInvocation,
   assistantId: string,
+  options: RetireOptions = {},
 ): Promise<RetireResult> {
   return new Promise((resolve) => {
     const child = spawn(
       invocation.command,
       [...invocation.baseArgs, "retire", assistantId, "--yes"],
-      { stdio: ["ignore", "pipe", "pipe"] },
+      {
+        ...(options.platformToken
+          ? {
+              env: {
+                ...process.env,
+                VELLUM_PLATFORM_TOKEN: options.platformToken,
+              },
+            }
+          : {}),
+        stdio: ["ignore", "pipe", "pipe"],
+      },
     );
 
     let stdout = "";
@@ -32,7 +46,11 @@ export function runRetire(
 
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      finish({ ok: false, status: 500, error: "Retire timed out after 60 seconds" });
+      finish({
+        ok: false,
+        status: 500,
+        error: "Retire timed out after 60 seconds",
+      });
     }, RETIRE_TIMEOUT_MS);
 
     child.stdout.on("data", (data: Buffer) => {
@@ -52,7 +70,11 @@ export function runRetire(
     });
 
     child.on("error", (err) => {
-      finish({ ok: false, status: 500, error: `Failed to spawn CLI: ${err.message}` });
+      finish({
+        ok: false,
+        status: 500,
+        error: `Failed to spawn CLI: ${err.message}`,
+      });
     });
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.4-staging.2",
+  "version": "0.10.5-dev.202607022248.91fa053",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/platform-releases.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import {
+  fetchLatestVersion,
   fetchReleases,
   resolveImageRefsDetailed,
 } from "../lib/platform-releases.js";
@@ -114,4 +115,45 @@ describe("resolveImageRefsDetailed", () => {
     const result = await resolveImageRefsDetailed("0.7.0");
     expect(result.status).toBe("dockerhub-fallback");
   });
+
+  test("requests the preview channel when channel=preview", async () => {
+    const fetchMock = mockFetchJson([RELEASE]);
+    await resolveImageRefsDetailed("v0.7.0", undefined, "preview");
+    const url = String(fetchMock.mock.calls[0][0]);
+    expect(url).toContain("channel=preview");
+    expect(url).not.toContain("stable=true");
+  });
+
+  test("keeps the stable filter when channel=stable (default)", async () => {
+    const fetchMock = mockFetchJson([RELEASE]);
+    await resolveImageRefsDetailed("v0.7.0", undefined, "stable");
+    const url = String(fetchMock.mock.calls[0][0]);
+    expect(url).toContain("stable=true");
+    expect(url).not.toContain("channel=");
+  });
+});
+
+describe("fetchLatestVersion", () => {
+  test("defaults to the stable channel", async () => {
+    const fetchMock = mockFetchJson([RELEASE]);
+    const version = await fetchLatestVersion();
+    expect(version).toBe("0.7.0");
+    const url = String(fetchMock.mock.calls[0][0]);
+    expect(url).toContain("stable=true");
+    expect(url).not.toContain("channel=");
+  });
+
+  test("requests the preview channel when asked", async () => {
+    const preview = { ...RELEASE, version: "0.8.0-preview.3" };
+    const fetchMock = mockFetchJson([preview]);
+    const version = await fetchLatestVersion("preview");
+    expect(version).toBe("0.8.0-preview.3");
+    const url = String(fetchMock.mock.calls[0][0]);
+    expect(url).toContain("channel=preview");
+  });
+
+  test("returns null when the channel has no releases", async () => {
+    mockFetchJson([]);
+    expect(await fetchLatestVersion("preview")).toBeNull();
+  });
 });