@vellumai/cli 0.10.6-dev.202607072040.fb971ce → 0.10.6-staging.1

package/node_modules/{@vellumai/local-mode/node_modules/zod → zod}/v4/mini/schemas.js

@@ -16,7 +16,11 @@ export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst,
             ...def,
             checks: [
                 ...(def.checks ?? []),
-                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
+                ...checks.map((ch) => typeof ch === "function"
+                    ? {
+                        _zod: { check: ch, def: { check: "custom" }, onattach: [] },
+                    }
+                    : ch),
             ],
         }, { parent: true });
     };
@@ -90,7 +94,7 @@ export function url(params) {
 // @__NO_SIDE_EFFECTS__
 export function httpUrl(params) {
     return core._url(ZodMiniURL, {
-        protocol: /^https?$/,
+        protocol: core.regexes.httpProtocol,
         hostname: core.regexes.domain,
         ...util.normalizeParams(params),
     });
@@ -111,10 +115,22 @@ export const ZodMiniNanoID = /*@__PURE__*/ core.$constructor("ZodMiniNanoID", (i
 export function nanoid(params) {
     return core._nanoid(ZodMiniNanoID, params);
 }
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link ZodMiniCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
 export const ZodMiniCUID = /*@__PURE__*/ core.$constructor("ZodMiniCUID", (inst, def) => {
     core.$ZodCUID.init(inst, def);
     ZodMiniStringFormat.init(inst, def);
 });
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
 // @__NO_SIDE_EFFECTS__
 export function cuid(params) {
     return core._cuid(ZodMiniCUID, params);
@@ -543,6 +559,15 @@ export const ZodMiniRecord = /*@__PURE__*/ core.$constructor("ZodMiniRecord", (i
 });
 // @__NO_SIDE_EFFECTS__
 export function record(keyType, valueType, params) {
+    // v3-compat: z.record(valueType, params?) — defaults keyType to z.string()
+    if (!valueType || !valueType._zod) {
+        return new ZodMiniRecord({
+            type: "record",
+            keyType: string(),
+            valueType: keyType,
+            ...util.normalizeParams(valueType),
+        });
+    }
     return new ZodMiniRecord({
         type: "record",
         keyType,
@@ -792,6 +817,17 @@ export function codec(in_, out, params) {
         reverseTransform: params.encode,
     });
 }
+// @__NO_SIDE_EFFECTS__
+export function invertCodec(codec) {
+    const def = codec._zod.def;
+    return new ZodMiniCodec({
+        type: "pipe",
+        in: def.out,
+        out: def.in,
+        transform: def.reverseTransform,
+        reverseTransform: def.transform,
+    });
+}
 export const ZodMiniReadonly = /*@__PURE__*/ core.$constructor("ZodMiniReadonly", (inst, def) => {
     core.$ZodReadonly.init(inst, def);
     ZodMiniType.init(inst, def);
@@ -868,8 +904,8 @@ export function refine(fn, _params = {}) {
 }
 // superRefine
 // @__NO_SIDE_EFFECTS__
-export function superRefine(fn) {
-    return core._superRefine(fn);
+export function superRefine(fn, params) {
+    return core._superRefine(fn, params);
 }
 // Re-export describe and meta from core
 export const describe = core.describe;

package/node_modules/zod/v4/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/node_modules/{@vellumai/local-mode/node_modules/zod → zod}/v4-mini/package.json

@@ -2,5 +2,6 @@
   "type": "module",
   "main": "./index.cjs",
   "module": "./index.js",
-  "types": "./index.d.cts" 
+  "types": "./index.d.cts",
+  "sideEffects": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.10.6-dev.202607072040.fb971ce",
+  "version": "0.10.6-staging.1",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {
@@ -22,6 +22,7 @@
     "format:check": "prettier --check .",
     "lint": "eslint",
     "lint:unused": "knip --include files,dependencies,unlisted",
+    "prepack": "node ../scripts/prepack-bundled-deps.mjs",
     "compile:check": "bun build --compile --external react-devtools-core src/index.ts --outfile /dev/null",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit"

package/src/__tests__/recover.test.ts

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

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

@@ -119,7 +119,6 @@ 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,
@@ -128,7 +127,6 @@ mock.module("../lib/local.js", () => ({
   startLocalDaemon: startLocalDaemonMock,
   startGateway: startGatewayMock,
   stopLocalProcesses: stopLocalProcessesMock,
-  startCes: startCesMock,
 }));
 
 const loopbackSafeFetchMock = mock<typeof loopbackFetch.loopbackSafeFetch>(
@@ -258,8 +256,6 @@ 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/commands/restore.ts

@@ -695,18 +695,15 @@ export async function restore(): Promise<void> {
 
     let response: Response;
     try {
-      response = await loopbackSafeFetch(
-        `${entry.runtimeUrl}/v1/migrations/import`,
-        {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${accessToken}`,
-            "Content-Type": "application/octet-stream",
-          },
-          body: bundleData,
-          signal: AbortSignal.timeout(120_000),
+      response = await loopbackSafeFetch(`${entry.runtimeUrl}/v1/migrations/import`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/octet-stream",
         },
-      );
+        body: bundleData,
+        signal: AbortSignal.timeout(120_000),
+      });
     } catch (err) {
       if (err instanceof Error && err.name === "TimeoutError") {
         console.error("Error: Import request timed out after 2 minutes.");
@@ -755,26 +752,6 @@ export async function restore(): Promise<void> {
     console.log(`  Files skipped:     ${summary.files_skipped}`);
     console.log(`  Backups created:   ${summary.backups_created}`);
 
-    // A daemon in the terminal failed-migrations state accepts this import
-    // (the migration-repair exemption), but its readiness latch only clears
-    // on restart — without one it keeps refusing DB-backed routes.
-    try {
-      const readyz = await loopbackSafeFetch(`${entry.runtimeUrl}/readyz`, {
-        signal: AbortSignal.timeout(3_000),
-      });
-      const readyzBody = (await readyz.json().catch(() => null)) as {
-        dbMigrations?: { state?: string };
-      } | null;
-      if (readyzBody?.dbMigrations?.state === "failed") {
-        console.warn(
-          "\n⚠️  The assistant is in a failed-migrations state; the restored data takes effect after a restart:",
-        );
-        console.warn(`   vellum sleep ${name} && vellum wake ${name}`);
-      }
-    } catch {
-      // Best-effort advisory — never fail a completed restore over it.
-    }
-
     // Print warnings if any
     const warnings = result.warnings ?? [];
     if (warnings.length > 0) {

package/src/commands/upgrade.ts

@@ -45,7 +45,6 @@ import { emitCliError, categorizeUpgradeError } from "../lib/cli-error.js";
 import { exec } from "../lib/step-runner.js";
 import {
   broadcastUpgradeEvent,
-  attemptFailedStateRestore,
   buildCompleteEvent,
   buildProgressEvent,
   buildStartingEvent,
@@ -606,43 +605,13 @@ async function upgradeDocker(
           (msg) => console.log(msg),
         );
 
-        let rollbackReady = await waitForReady(entry.runtimeUrl);
-        let restoredViaFailedState = false;
-        if (!rollbackReady && backupPath) {
-          const recovery = await attemptFailedStateRestore({
-            runtimeUrl: entry.runtimeUrl,
-            assistantId: entry.assistantId,
-            backupPath,
-            backupLabel: "pre-upgrade",
-            res,
-            containerOptions: {
-              signingKey,
-              bootstrapSecret,
-              cesServiceToken,
-              extraAssistantEnv,
-              extraGatewayEnv,
-              gatewayPort,
-              assistantPort,
-              imageTags: previousImageRefs,
-              instanceName,
-              res,
-            },
-          });
-          restoredViaFailedState = recovery.restored;
-          if (recovery.restored) {
-            rollbackReady = recovery.ready;
-          }
-        }
+        const rollbackReady = await waitForReady(entry.runtimeUrl);
         if (rollbackReady) {
           // Restore data from the backup created for THIS upgrade attempt.
           // Only use the specific backupPath — never scan for the latest
           // backup on disk, which could be from a previous upgrade cycle
           // and contain stale data.
-          if (restoredViaFailedState) {
-            console.log(
-              "   ✅ Data restored during failed-state recovery above\n",
-            );
-          } else if (backupPath) {
+          if (backupPath) {
             await broadcastUpgradeEvent(
               entry.runtimeUrl,
               entry.assistantId,

package/src/commands/wake.ts

@@ -12,15 +12,7 @@ import {
   resetGuardianBootstrap,
   seedGuardianTokenFromSiblingEnv,
 } from "../lib/guardian-token.js";
-import {
-  probeDaemonReadinessWithRetry,
-  waitForDaemonMigrationsReady,
-} from "../lib/http-client.js";
-import {
-  isProcessAlive,
-  resolveProcessState,
-  stopProcessByPidFile,
-} from "../lib/process";
+import { resolveProcessState, stopProcessByPidFile, isProcessAlive } from "../lib/process";
 import {
   generateLocalSigningKey,
   isAssistantWatchModeAvailable,
@@ -117,23 +109,13 @@ export async function wake(): Promise<void> {
 
   const pidFile = getDaemonPidPath(resources);
 
-  // Budget anchor for the migration-coordination wait below: the host
-  // wrapper (packages/local-mode/src/wake.ts WAKE_TIMEOUT_MS) SIGTERMs wake
-  // after 180s, and the hung-daemon health wait + post-spawn wait + gateway
-  // start can already consume most of that.
-  const wakeStartedAt = Date.now();
-
   let daemonRunning = false;
-  let daemonUnready = false;
-  let daemonMigrationsFailed = false;
   const daemonState = await resolveProcessState(
     pidFile,
     resources.daemonPort,
     "Assistant",
-    60_000,
-    "readyz",
   );
-  if (daemonState.status !== "needs_start") {
+  if (daemonState.status === "healthy") {
     if (watch && isAssistantWatchModeAvailable()) {
       console.log(
         `Assistant running (pid ${daemonState.pid}) — restarting in watch mode...`,
@@ -141,20 +123,10 @@ export async function wake(): Promise<void> {
       await stopProcessByPidFile(pidFile, "assistant");
     } else {
       daemonRunning = true;
-      daemonUnready = daemonState.status !== "healthy";
-      daemonMigrationsFailed = daemonState.status === "migration_failed";
       if (watch) {
         console.log(
           `Assistant running (pid ${daemonState.pid}) — watch mode not available (no source files). Keeping existing process.`,
         );
-      } else if (daemonMigrationsFailed) {
-        console.log(
-          `Assistant running (pid ${daemonState.pid}) but its database migrations failed.`,
-        );
-      } else if (daemonUnready) {
-        console.log(
-          `Assistant running (pid ${daemonState.pid}) — database migrations still running.`,
-        );
       } else {
         console.log(`Assistant already running (pid ${daemonState.pid}).`);
       }
@@ -217,13 +189,6 @@ export async function wake(): Promise<void> {
       startCes(watch, resources),
       startLocalDaemon(watch, resources, { foreground, signingKey }),
     ]);
-    // startLocalDaemon's post-spawn wait is bounded (60s) — a longer
-    // migration outlives it. Classify the fresh spawn the same way the
-    // attach path does, so the gateway-coordination wait below applies to
-    // both paths and wake's closing summary stays honest.
-    const readiness = await probeDaemonReadinessWithRetry(resources.daemonPort);
-    daemonUnready = readiness === "migrating";
-    daemonMigrationsFailed = readiness === "failed";
   } else {
     // Self-heal: the daemon is already healthy, but the CES sibling may have
     // died independently (crash, OOM kill). A dead ces.pid under a live daemon
@@ -240,7 +205,6 @@ export async function wake(): Promise<void> {
   }
 
   // Start gateway
-  let gatewayStarted = false;
   {
     const vellumDir = join(resources.instanceDir, ".vellum");
     const gatewayPidFile = join(vellumDir, "gateway.pid");
@@ -267,7 +231,6 @@ export async function wake(): Promise<void> {
         signingKey,
         bootstrapSecret,
       });
-      gatewayStarted = true;
     } else if (gatewayAlive) {
       if (watch && isGatewayWatchModeAvailable()) {
         console.log(
@@ -275,7 +238,6 @@ export async function wake(): Promise<void> {
         );
         await stopProcessByPidFile(gatewayPidFile, "gateway");
         await startGateway(watch, resources, { signingKey, bootstrapSecret });
-        gatewayStarted = true;
       } else {
         if (watch) {
           console.log(
@@ -287,32 +249,6 @@ export async function wake(): Promise<void> {
       }
     } else {
       await startGateway(watch, resources, { signingKey, bootstrapSecret });
-      gatewayStarted = true;
-    }
-  }
-
-  // A freshly-(re)started gateway refuses all non-probe traffic until the
-  // daemon reports migration readiness, so consumers that act right after
-  // wake (the web connect-repair retry, the guardian re-provision below)
-  // would hit its closed gate. When the daemon is migrating AND the gateway
-  // was just started (or a guardian repair was requested), wait out the
-  // migration — capped at 60s and at whatever budget remains before the
-  // 180s host-wrapper SIGTERM (30s headroom kept), since earlier bounded
-  // waits may already have consumed most of it. Fast path (gateway already
-  // serving, no repair) stays ~1s.
-  if (
-    daemonUnready &&
-    !daemonMigrationsFailed &&
-    (gatewayStarted || repairGuardian)
-  ) {
-    const waitBudgetMs = Math.min(60_000, wakeStartedAt + 150_000 - Date.now());
-    if (waitBudgetMs > 0) {
-      const readiness = await waitForDaemonMigrationsReady(
-        resources.daemonPort,
-        Date.now() + waitBudgetMs,
-      );
-      daemonUnready = readiness !== "ready";
-      daemonMigrationsFailed = readiness === "failed";
     }
   }
 
@@ -359,11 +295,6 @@ export async function wake(): Promise<void> {
           console.warn(
             `   Guardian token re-provision failed after ${maxAttempts} attempts: ${err}`,
           );
-          // The user explicitly confirmed this destructive repair — a
-          // success exit here would make callers (the web recovery flow)
-          // treat a repair that never ran as done and drop their cached
-          // gateway token. Surface the failure through the exit code.
-          process.exitCode = 1;
         }
       }
     }
@@ -380,15 +311,6 @@ export async function wake(): Promise<void> {
     writeFileSync(ngrokPidFile, String(ngrokChild.pid));
   }
 
-  if (daemonMigrationsFailed) {
-    console.log(
-      "Assistant database migrations FAILED — DB-backed routes will return 503 until the assistant is restarted. Check the daemon logs.",
-    );
-  } else if (daemonUnready) {
-    console.log(
-      "Assistant is still running database migrations; DB-backed routes return 503 until they finish.",
-    );
-  }
   console.log("Wake complete.");
 
   if (foreground) {

package/src/lib/backup-ops.ts

@@ -9,7 +9,10 @@ import {
 import { homedir } from "os";
 import { dirname, join } from "path";
 
-import { loadGuardianToken, refreshGuardianToken } from "./guardian-token.js";
+import {
+  loadGuardianToken,
+  refreshGuardianToken,
+} from "./guardian-token.js";
 import { loopbackSafeFetch } from "./loopback-fetch.js";
 
 /** Default backup directory following XDG convention */
@@ -60,35 +63,28 @@ export async function createBackup(
   try {
     let accessToken = await getGuardianAccessToken(runtimeUrl, assistantId);
     if (!accessToken) {
-      console.warn(
-        "Warning: backup skipped — no valid guardian token available",
-      );
+      console.warn("Warning: backup skipped — no valid guardian token available");
       return null;
     }
 
-    let response = await loopbackSafeFetch(
-      `${runtimeUrl}/v1/migrations/export`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          description: options?.description ?? "CLI backup",
-        }),
-        signal: AbortSignal.timeout(120_000),
+    let response = await loopbackSafeFetch(`${runtimeUrl}/v1/migrations/export`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
       },
-    );
+      body: JSON.stringify({
+        description: options?.description ?? "CLI backup",
+      }),
+      signal: AbortSignal.timeout(120_000),
+    });
 
     // Retry once with a refreshed token on 401 — the cached token may be
     // stale after a container restart that regenerated the gateway signing key.
     if (response.status === 401) {
       const refreshed = await refreshGuardianToken(runtimeUrl, assistantId);
       if (!refreshed) {
-        console.warn(
-          `Warning: backup export failed (401) and token refresh failed`,
-        );
+        console.warn(`Warning: backup export failed (401) and token refresh failed`);
         return null;
       }
       accessToken = refreshed.accessToken;
@@ -153,24 +149,19 @@ export async function restoreBackup(
     const bundleData = readFileSync(backupPath);
     let accessToken = await getGuardianAccessToken(runtimeUrl, assistantId);
     if (!accessToken) {
-      console.warn(
-        "Warning: restore skipped — no valid guardian token available",
-      );
+      console.warn("Warning: restore skipped — no valid guardian token available");
       return false;
     }
 
-    const postImport = () =>
-      loopbackSafeFetch(`${runtimeUrl}/v1/migrations/import`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/octet-stream",
-        },
-        body: bundleData,
-        signal: AbortSignal.timeout(120_000),
-      });
-
-    let response = await postImport();
+    let response = await loopbackSafeFetch(`${runtimeUrl}/v1/migrations/import`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/octet-stream",
+      },
+      body: bundleData,
+      signal: AbortSignal.timeout(120_000),
+    });
 
     // Retry once with a refreshed token on 401 — the cached token may be
     // stale after a container restart that regenerated the gateway signing key.
@@ -181,33 +172,19 @@ export async function restoreBackup(
         return false;
       }
       accessToken = refreshed.accessToken;
-      response = await postImport();
+      response = await loopbackSafeFetch(`${runtimeUrl}/v1/migrations/import`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/octet-stream",
+        },
+        body: bundleData,
+        signal: AbortSignal.timeout(120_000),
+      });
     }
 
-    // A freshly-(re)started gateway 503s {status:"starting"} for a couple of
-    // seconds until its own assistant poll observes the migration state and
-    // opens the traffic gate — retry through that window rather than failing
-    // the recovery. The daemon's running-migrations 503 carries a `reason`
-    // field and is excluded: the import must not race an in-flight migration.
-    const startingGateDeadline = Date.now() + 15_000;
-    while (!response.ok) {
+    if (!response.ok) {
       const body = await response.text();
-      let gatewayStarting = false;
-      try {
-        const parsed = JSON.parse(body) as {
-          status?: string;
-          reason?: string;
-        };
-        gatewayStarting =
-          parsed.status === "starting" && parsed.reason === undefined;
-      } catch {
-        // Non-JSON error body — not the starting gate.
-      }
-      if (gatewayStarting && Date.now() < startingGateDeadline) {
-        await new Promise((r) => setTimeout(r, 1_000));
-        response = await postImport();
-        continue;
-      }
       console.warn(`Warning: restore failed (${response.status}): ${body}`);
       return false;
     }