@vellumai/cli 0.10.4-dev.202607010028.1a4efcc → 0.10.4-dev.202607010146.a37a2fa

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.4-dev.202607010028.1a4efcc",
+  "version": "0.10.4-dev.202607010146.a37a2fa",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/retire.test.ts

@@ -341,6 +341,67 @@ describe("vellum retire", () => {
     expect(retireLocalMock).toHaveBeenCalledWith("assistant-1", entry);
   });
 
+  test("local retire uses saved platform registration when local credentials are unreachable", async () => {
+    const entry = makeEntry("assistant-1", {
+      name: "Example Assistant",
+      platformAssistantId: "platform-assistant-1",
+      platformBaseUrl: "https://platform.example.test",
+      platformOrganizationId: "org-123",
+    });
+    writeLockfile([entry]);
+    readPlatformTokenMock.mockReturnValue("session-token");
+    getPlatformUrlMock.mockReturnValue("https://platform.example.test");
+    readGatewayCredentialMock.mockResolvedValue({
+      value: null,
+      unreachable: true,
+    });
+    process.argv = ["bun", "vellum", "retire", "assistant-1", "--yes"];
+
+    await retire();
+
+    expect(readGatewayCredentialMock).toHaveBeenCalledWith(
+      entry.localUrl ?? entry.runtimeUrl,
+      "vellum:platform_assistant_id",
+      entry.bearerToken,
+    );
+    expect(loopbackSafeFetchMock).toHaveBeenCalledWith(
+      "https://platform.example.test/v1/assistants/platform-assistant-1/retire/",
+      {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Session-Token": "session-token",
+          "Vellum-Organization-Id": "org-123",
+        },
+      },
+    );
+    expect(consoleWarnSpy.mock.calls.flat().join("\n")).toContain(
+      "using saved platform registration",
+    );
+    expect(retireLocalMock).toHaveBeenCalledWith("assistant-1", entry);
+    expect(loadAllAssistants()).toEqual([]);
+  });
+
+  test("local retire continues when local credentials are unreachable and no saved platform registration exists", async () => {
+    const entry = makeEntry("assistant-1", { name: "Example Assistant" });
+    writeLockfile([entry]);
+    readPlatformTokenMock.mockReturnValue("session-token");
+    readGatewayCredentialMock.mockResolvedValue({
+      value: null,
+      unreachable: true,
+    });
+    process.argv = ["bun", "vellum", "retire", "assistant-1", "--yes"];
+
+    await retire();
+
+    expect(loopbackSafeFetchMock).not.toHaveBeenCalled();
+    expect(consoleWarnSpy.mock.calls.flat().join("\n")).toContain(
+      "no saved platform registration is available",
+    );
+    expect(retireLocalMock).toHaveBeenCalledWith("assistant-1", entry);
+    expect(loadAllAssistants()).toEqual([]);
+  });
+
   test("local retire skips platform unregister when stored platform URL origin mismatches", async () => {
     const entry = makeEntry("assistant-1", { name: "Example Assistant" });
     writeLockfile([entry]);

package/src/__tests__/teleport.test.ts

@@ -2266,6 +2266,14 @@ describe("platform credential injection", () => {
         userId: "user-1",
         webhookSecret: "webhook-secret-123",
       });
+      expect(saveAssistantEntryMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          assistantId: "my-local",
+          platformAssistantId: "platform-assistant-1",
+          platformBaseUrl: "https://platform.vellum.ai",
+          platformOrganizationId: "org-1",
+        }),
+      );
     } finally {
       restoreFetch();
     }

package/src/commands/login.ts

@@ -7,6 +7,7 @@ import {
   loadAllAssistants,
   removeAssistantEntry,
   resolveAssistant,
+  saveAssistantEntry,
   setActiveAssistant,
 } from "../lib/assistant-config";
 import { computeDeviceId } from "../lib/guardian-token";
@@ -383,6 +384,7 @@ export async function login(): Promise<void> {
           fetchCurrentVersion(entry.runtimeUrl),
           fetchAssistantIngressUrl(entry.runtimeUrl, entry.bearerToken),
         ]);
+        const platformUrl = getPlatformUrl();
         const registration = await ensureSelfHostedLocalRegistration(
           token,
           orgId,
@@ -390,9 +392,15 @@ export async function login(): Promise<void> {
           entry.assistantId,
           "cli",
           assistantVersion,
-          getPlatformUrl(),
+          platformUrl,
           ingressUrl,
         );
+        saveAssistantEntry({
+          ...entry,
+          platformAssistantId: registration.assistant.id,
+          platformBaseUrl: platformUrl,
+          platformOrganizationId: orgId,
+        });
         console.log(
           `Registered assistant: ${registration.assistant.name} (${registration.assistant.id})`,
         );
@@ -433,7 +441,7 @@ export async function login(): Promise<void> {
           bearerToken: entry.bearerToken,
           assistantApiKey,
           platformAssistantId: registration.assistant.id,
-          platformBaseUrl: getPlatformUrl(),
+          platformBaseUrl: platformUrl,
           organizationId: orgId,
           userId: user.id,
           webhookSecret: registration.webhook_secret,

package/src/commands/retire.ts

@@ -47,6 +47,12 @@ interface RetireArgs {
   yes: boolean;
 }
 
+interface SelfHostedPlatformRegistration {
+  platformAssistantId: string;
+  platformBaseUrl: string | null;
+  organizationId: string | null;
+}
+
 const PLATFORM_TOKEN_ENV = "VELLUM_PLATFORM_TOKEN";
 
 function readPlatformRetireToken(): string | null {
@@ -81,6 +87,24 @@ function resolveTrustedSelfHostedPlatformUrl(
   return null;
 }
 
+function nonEmptyString(value: string | null | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function lockfileSelfHostedPlatformRegistration(
+  entry: AssistantEntry,
+): SelfHostedPlatformRegistration | null {
+  const platformAssistantId = nonEmptyString(entry.platformAssistantId);
+  if (!platformAssistantId) return null;
+
+  return {
+    platformAssistantId,
+    platformBaseUrl: nonEmptyString(entry.platformBaseUrl),
+    organizationId: nonEmptyString(entry.platformOrganizationId),
+  };
+}
+
 async function deletePlatformAssistant(
   assistantId: string,
   options: {
@@ -115,12 +139,10 @@ async function deletePlatformAssistant(
   }
 }
 
-async function unregisterSelfHostedLocalPlatformRecord(
+async function readSelfHostedPlatformRegistration(
   entry: AssistantEntry,
-): Promise<void> {
-  const token = readPlatformRetireToken();
-  if (!token) return;
-
+): Promise<SelfHostedPlatformRegistration | null> {
+  const fallback = lockfileSelfHostedPlatformRegistration(entry);
   const gatewayUrl = entry.localUrl ?? entry.runtimeUrl;
   const platformAssistant = await readGatewayCredential(
     gatewayUrl,
@@ -128,12 +150,21 @@ async function unregisterSelfHostedLocalPlatformRecord(
     entry.bearerToken,
   );
   if (platformAssistant.unreachable) {
+    if (fallback) {
+      console.warn(
+        "\u26a0\ufe0f  Could not read platform registration from the local assistant; using saved platform registration.",
+      );
+      return fallback;
+    }
     console.warn(
-      "\u26a0\ufe0f  Could not read platform registration from the local assistant; skipping platform unregister.",
+      "\u26a0\ufe0f  Could not read platform registration from the local assistant and no saved platform registration is available; skipping platform unregister.",
     );
-    return;
+    return null;
   }
-  if (!platformAssistant.value) return;
+
+  const platformAssistantId =
+    nonEmptyString(platformAssistant.value) ?? fallback?.platformAssistantId;
+  if (!platformAssistantId) return null;
 
   const [platformBaseUrl, organizationId] = await Promise.all([
     readGatewayCredential(
@@ -147,21 +178,42 @@ async function unregisterSelfHostedLocalPlatformRecord(
       entry.bearerToken,
     ),
   ]);
+
+  return {
+    platformAssistantId,
+    platformBaseUrl:
+      nonEmptyString(platformBaseUrl.value) ??
+      fallback?.platformBaseUrl ??
+      null,
+    organizationId:
+      nonEmptyString(organizationId.value) ?? fallback?.organizationId ?? null,
+  };
+}
+
+async function unregisterSelfHostedLocalPlatformRecord(
+  entry: AssistantEntry,
+): Promise<void> {
+  const token = readPlatformRetireToken();
+  if (!token) return;
+
+  const registration = await readSelfHostedPlatformRegistration(entry);
+  if (!registration) return;
+
   const platformUrl = resolveTrustedSelfHostedPlatformUrl(
-    platformBaseUrl.value,
+    registration.platformBaseUrl,
   );
   if (!platformUrl) return;
-  if (!organizationId.value) {
+  if (!registration.organizationId) {
     console.warn(
       "⚠️  Could not read platform organization ID from the local assistant; skipping platform unregister.",
     );
     return;
   }
 
-  await deletePlatformAssistant(platformAssistant.value, {
+  await deletePlatformAssistant(registration.platformAssistantId, {
     token,
     platformUrl,
-    organizationId: organizationId.value,
+    organizationId: registration.organizationId,
     label: "Platform self-hosted unregister",
     successMessage: "\u2705 Platform self-hosted registration unregistered.",
     alreadyGoneMessage:

package/src/commands/teleport.ts

@@ -1123,6 +1123,7 @@ async function tryInjectPlatformCredentials(
       fetchCurrentVersion(entry.runtimeUrl),
       fetchAssistantIngressUrl(entry.runtimeUrl, entry.bearerToken),
     ]);
+    const platformUrl = getPlatformUrl();
     const registration = await ensureSelfHostedLocalRegistration(
       token,
       orgId,
@@ -1130,9 +1131,15 @@ async function tryInjectPlatformCredentials(
       entry.assistantId,
       "cli",
       assistantVersion,
-      getPlatformUrl(),
+      platformUrl,
       ingressUrl,
     );
+    saveAssistantEntry({
+      ...entry,
+      platformAssistantId: registration.assistant.id,
+      platformBaseUrl: platformUrl,
+      platformOrganizationId: orgId,
+    });
 
     // Resolve the API key: 1) fresh from registration, 2) existing from
     // daemon credential store, 3) reprovision as last resort (revokes old key).
@@ -1164,7 +1171,7 @@ async function tryInjectPlatformCredentials(
       bearerToken: entry.bearerToken,
       assistantApiKey,
       platformAssistantId: registration.assistant.id,
-      platformBaseUrl: getPlatformUrl(),
+      platformBaseUrl: platformUrl,
       organizationId: orgId,
       userId: user.id,
       webhookSecret: registration.webhook_secret,