@vellumai/cli 0.10.3 → 0.10.4-dev.202607010119.ad15dbb

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.3",
+  "version": "0.10.4-dev.202607010119.ad15dbb",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/flags.test.ts

@@ -83,10 +83,10 @@ describe("vellum flags --assistant routing", () => {
       fetchCalls.push({ url, method });
       if (method === "PATCH") {
         return jsonResponse({
-          key: "external-plugins",
+          key: "voice-mode",
           enabled: true,
           defaultEnabled: false,
-          label: "External Plugins",
+          label: "Voice Mode",
           description: "test",
         });
       }
@@ -133,7 +133,7 @@ describe("vellum flags --assistant routing", () => {
       "vellum",
       "flags",
       "set",
-      "external-plugins",
+      "voice-mode",
       "true",
       "--assistant",
       "Bob",
@@ -146,7 +146,7 @@ describe("vellum flags --assistant routing", () => {
     // bob-2 has assistantId.length === 5, so port = 7800 + 5 = 7805.
     expect(fetchCalls[0].url).toContain("http://127.0.0.1:7805");
     expect(fetchCalls[0].url).toContain(
-      "/v1/assistants/bob-2/feature-flags/external-plugins",
+      "/v1/assistants/bob-2/feature-flags/voice-mode",
     );
   });
 
@@ -166,7 +166,7 @@ describe("vellum flags --assistant routing", () => {
       "--assistant",
       "Bob",
       "set",
-      "external-plugins",
+      "voice-mode",
       "true",
     ];
 
@@ -174,7 +174,7 @@ describe("vellum flags --assistant routing", () => {
 
     expect(fetchCalls.length).toBe(1);
     expect(fetchCalls[0].url).toContain(
-      "/v1/assistants/bob-2/feature-flags/external-plugins",
+      "/v1/assistants/bob-2/feature-flags/voice-mode",
     );
   });
 
@@ -193,7 +193,7 @@ describe("vellum flags --assistant routing", () => {
       "vellum",
       "flags",
       "set",
-      "external-plugins",
+      "voice-mode",
       "true",
     ];
 
@@ -203,7 +203,7 @@ describe("vellum flags --assistant routing", () => {
     // alice-1 has assistantId.length === 7, so port = 7800 + 7 = 7807.
     expect(fetchCalls[0].url).toContain("http://127.0.0.1:7807");
     expect(fetchCalls[0].url).toContain(
-      "/v1/assistants/alice-1/feature-flags/external-plugins",
+      "/v1/assistants/alice-1/feature-flags/voice-mode",
     );
   });
 
@@ -214,7 +214,7 @@ describe("vellum flags --assistant routing", () => {
       "vellum",
       "flags",
       "set",
-      "external-plugins",
+      "voice-mode",
       "true",
       "--assistant",
       "Ghost",
@@ -234,7 +234,7 @@ describe("vellum flags --assistant routing", () => {
       "vellum",
       "flags",
       "set",
-      "external-plugins",
+      "voice-mode",
       "true",
       "--assistant",
     ];

package/src/__tests__/recover.test.ts

@@ -13,6 +13,7 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
+  renameSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -220,37 +221,43 @@ describe("recover error cases", () => {
 describe("recover extraction path — default instance (instanceDir === homedir())", () => {
   test("extracts to retiredDir and renames staging dir to instanceDir/.vellum", async () => {
     const name = "default-instance";
-    // Default instance: instanceDir is the real home directory
     const entry = makeEntry(name, homedir());
     const { archivePath, extractedPath } = writeArchiveFixtures(name, entry);
 
     const expectedTargetDir = join(homedir(), ".vellum");
-
-    process.argv = ["bun", "vellum", "recover", name];
-    await recover();
-
-    // exec must have been called with -C retiredDir, NOT -C homedir()
-    expect(execMock).toHaveBeenCalledTimes(1);
-    const [cmd, args] = execMock.mock.calls[0] as [string, string[]];
-    expect(cmd).toBe("tar");
-    expect(args).toContain("-C");
-    const cIndex = args.indexOf("-C");
-    expect(args[cIndex + 1]).toBe(retiredDir);
-    expect(args[cIndex + 1]).not.toBe(homedir());
-
-    // Staging dir was renamed to the correct target
-    expect(existsSync(extractedPath)).toBe(false);
-    expect(existsSync(expectedTargetDir)).toBe(true);
-
-    // Archive and metadata were cleaned up
-    expect(existsSync(archivePath)).toBe(false);
-
-    // Daemon and gateway were started
-    expect(startLocalDaemonMock).toHaveBeenCalledTimes(1);
-    expect(startGatewayMock).toHaveBeenCalledTimes(1);
-
-    // Clean up so we don't leave a .vellum dir in the real home dir
-    rmSync(expectedTargetDir, { recursive: true, force: true });
+    // If a real ~/.vellum exists (e.g. the machine runs a live assistant),
+    // temporarily move it aside so the collision guard doesn't fire.
+    const backupDir = join(homedir(), ".vellum-recover-test-bak");
+    const hadExisting = existsSync(expectedTargetDir);
+    if (hadExisting) renameSync(expectedTargetDir, backupDir);
+
+    try {
+      process.argv = ["bun", "vellum", "recover", name];
+      await recover();
+
+      // exec must have been called with -C retiredDir, NOT -C homedir()
+      expect(execMock).toHaveBeenCalledTimes(1);
+      const [cmd, args] = execMock.mock.calls[0] as [string, string[]];
+      expect(cmd).toBe("tar");
+      expect(args).toContain("-C");
+      const cIndex = args.indexOf("-C");
+      expect(args[cIndex + 1]).toBe(retiredDir);
+      expect(args[cIndex + 1]).not.toBe(homedir());
+
+      // Staging dir was renamed to the correct target
+      expect(existsSync(extractedPath)).toBe(false);
+      expect(existsSync(expectedTargetDir)).toBe(true);
+
+      // Archive and metadata were cleaned up
+      expect(existsSync(archivePath)).toBe(false);
+
+      // Daemon and gateway were started
+      expect(startLocalDaemonMock).toHaveBeenCalledTimes(1);
+      expect(startGatewayMock).toHaveBeenCalledTimes(1);
+    } finally {
+      rmSync(expectedTargetDir, { recursive: true, force: true });
+      if (hadExisting) renameSync(backupDir, expectedTargetDir);
+    }
   });
 });