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

package/node_modules/@vellumai/local-mode/node_modules/zod/src/v4/classic/tests/tuple.test.ts

@@ -1,183 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-test("successful validation", () => {
-  const testTuple = z.tuple([z.string(), z.number()]);
-  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
-
-  const val = testTuple.parse(["asdf", 1234]);
-  expect(val).toEqual(val);
-
-  const r1 = testTuple.safeParse(["asdf", "asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected number, received string"
-      }
-    ]]
-  `);
-
-  const r2 = testTuple.safeParse(["asdf", 1234, true]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "too_big",
-        "maximum": 2,
-        "inclusive": true,
-        "origin": "array",
-        "path": [],
-        "message": "Too big: expected array to have <=2 items"
-      }
-    ]]
-  `);
-
-  const r3 = testTuple.safeParse({});
-  expect(r3.success).toEqual(false);
-  expect(r3.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "tuple",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected tuple, received object"
-      }
-    ]]
-  `);
-});
-
-test("async validation", async () => {
-  const testTuple = z
-    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
-    .refine(async () => true);
-  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
-
-  const val = await testTuple.parseAsync(["asdf", 1234]);
-  expect(val).toEqual(val);
-
-  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
-  expect(r1.success).toEqual(false);
-  expect(r1.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "number",
-        "code": "invalid_type",
-        "path": [
-          1
-        ],
-        "message": "Invalid input: expected number, received string"
-      }
-    ]]
-  `);
-
-  const r2 = await testTuple.safeParseAsync(["asdf", 1234, true]);
-  expect(r2.success).toEqual(false);
-  expect(r2.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "code": "too_big",
-        "maximum": 2,
-        "inclusive": true,
-        "origin": "array",
-        "path": [],
-        "message": "Too big: expected array to have <=2 items"
-      }
-    ]]
-  `);
-
-  const r3 = await testTuple.safeParseAsync({});
-  expect(r3.success).toEqual(false);
-  expect(r3.error!).toMatchInlineSnapshot(`
-    [ZodError: [
-      {
-        "expected": "tuple",
-        "code": "invalid_type",
-        "path": [],
-        "message": "Invalid input: expected tuple, received object"
-      }
-    ]]
-  `);
-});
-
-test("tuple with optional elements", () => {
-  const myTuple = z.tuple([z.string(), z.number().optional(), z.string().optional()]).rest(z.boolean());
-  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number?, string?, ...boolean[]]>();
-
-  const goodData = [["asdf"], ["asdf", 1234], ["asdf", 1234, "asdf"], ["asdf", 1234, "asdf", true, false, true]];
-  for (const data of goodData) {
-    expect(myTuple.parse(data)).toEqual(data);
-  }
-
-  const badData = [
-    ["asdf", "asdf"],
-    ["asdf", 1234, "asdf", "asdf"],
-    ["asdf", 1234, "asdf", true, false, "asdf"],
-  ];
-  for (const data of badData) {
-    expect(() => myTuple.parse(data)).toThrow();
-  }
-});
-
-test("tuple with optional elements followed by required", () => {
-  const myTuple = z.tuple([z.string(), z.number().optional(), z.string()]).rest(z.boolean());
-  expectTypeOf<typeof myTuple._output>().toEqualTypeOf<[string, number | undefined, string, ...boolean[]]>();
-
-  const goodData = [
-    ["asdf", 1234, "asdf"],
-    ["asdf", 1234, "asdf", true, false, true],
-  ];
-  for (const data of goodData) {
-    expect(myTuple.parse(data)).toEqual(data);
-  }
-
-  const badData = [
-    ["asdf"],
-    ["asdf", 1234],
-    ["asdf", 1234, "asdf", "asdf"],
-    ["asdf", 1234, "asdf", true, false, "asdf"],
-  ];
-  for (const data of badData) {
-    expect(() => myTuple.parse(data)).toThrow();
-  }
-});
-
-test("tuple with all optional elements", () => {
-  const allOptionalTuple = z.tuple([z.string().optional(), z.number().optional(), z.boolean().optional()]);
-  expectTypeOf<typeof allOptionalTuple._output>().toEqualTypeOf<[string?, number?, boolean?]>();
-
-  // Empty array should be valid (all items optional)
-  expect(allOptionalTuple.parse([])).toEqual([]);
-
-  // Partial arrays should be valid
-  expect(allOptionalTuple.parse(["hello"])).toEqual(["hello"]);
-  expect(allOptionalTuple.parse(["hello", 42])).toEqual(["hello", 42]);
-
-  // Full array should be valid
-  expect(allOptionalTuple.parse(["hello", 42, true])).toEqual(["hello", 42, true]);
-
-  // Array that's too long should fail
-  expect(() => allOptionalTuple.parse(["hello", 42, true, "extra"])).toThrow();
-});
-
-test("tuple with rest schema", () => {
-  const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
-  expect(myTuple.parse(["asdf", 1234, true, false, true])).toEqual(["asdf", 1234, true, false, true]);
-
-  expect(myTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
-
-  expect(() => myTuple.parse(["asdf", 1234, "asdf"])).toThrow();
-  type t1 = z.output<typeof myTuple>;
-
-  expectTypeOf<t1>().toEqualTypeOf<[string, number, ...boolean[]]>();
-});
-
-test("sparse array input", () => {
-  const schema = z.tuple([z.string(), z.number()]);
-  expect(() => schema.parse(new Array(2))).toThrow();
-});

package/node_modules/@vellumai/local-mode/node_modules/zod/v4/classic/package.json

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

package/node_modules/@vellumai/local-mode/node_modules/zod/v4/core/package.json

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

package/node_modules/@vellumai/local-mode/node_modules/zod/v4/locales/package.json

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

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

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

package/node_modules/@vellumai/local-mode/node_modules/zod/v4/package.json

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

package/src/__tests__/daemon-readiness-probe.test.ts

@@ -1,158 +0,0 @@
-/**
- * Tests for the CLI's migration-aware daemon readiness probe.
- *
- * `/readyz` keeps its HTTP status at 200 while DB migrations run (the k8s
- * contract — the pod must stay in service), so the CLI classifies readiness
- * from the response BODY instead: ready / migrating / failed / unreachable.
- * The `failed` state is terminal for the daemon process, so the polling wait
- * must return immediately instead of burning its full deadline.
- */
-
-import { afterEach, describe, expect, test } from "bun:test";
-
-import {
-  probeDaemonReadiness,
-  waitForDaemonMigrationsReady,
-} from "../lib/http-client.js";
-
-type ReadyzResponder = () => Response;
-
-let server: ReturnType<typeof Bun.serve> | null = null;
-
-function serveReadyz(responder: ReadyzResponder): number {
-  server = Bun.serve({
-    port: 0,
-    hostname: "127.0.0.1",
-    fetch(req) {
-      if (new URL(req.url).pathname === "/readyz") return responder();
-      return new Response("not found", { status: 404 });
-    },
-  });
-  const { port } = server;
-  if (port === undefined) throw new Error("test server did not bind a port");
-  return port;
-}
-
-afterEach(() => {
-  server?.stop(true);
-  server = null;
-});
-
-describe("probeDaemonReadiness", () => {
-  test("classifies the ready body as ready", async () => {
-    const port = serveReadyz(() =>
-      Response.json({ status: "ok", ready: true }),
-    );
-    expect(await probeDaemonReadiness(port)).toBe("ready");
-  });
-
-  test("classifies a 200 migrating body as migrating", async () => {
-    const port = serveReadyz(() =>
-      Response.json({
-        status: "migrating",
-        ready: false,
-        dbMigrations: { ready: false, state: "running" },
-      }),
-    );
-    expect(await probeDaemonReadiness(port)).toBe("migrating");
-  });
-
-  test("classifies the 503 failed body as failed", async () => {
-    const port = serveReadyz(() =>
-      Response.json(
-        {
-          status: "error",
-          ready: false,
-          reason: "db_migrations_failed",
-          dbMigrations: { ready: false, state: "failed" },
-        },
-        { status: 503 },
-      ),
-    );
-    expect(await probeDaemonReadiness(port)).toBe("failed");
-  });
-
-  test("treats a legacy 200 body without a ready field as ready", async () => {
-    // Daemons that predate the migration-state body return { status: "ok" }.
-    const port = serveReadyz(() => Response.json({ status: "ok" }));
-    expect(await probeDaemonReadiness(port)).toBe("ready");
-  });
-
-  test("classifies a legacy strict-503 startup body as migrating, not unreachable", async () => {
-    // Pre-migration-body daemons return 503 { status, ready, notReady }
-    // throughout startup. The daemon ANSWERED, so it is alive — classifying
-    // it unreachable would make callers treat a starting daemon as dead.
-    const port = serveReadyz(() =>
-      Response.json(
-        { status: "unready", ready: false, notReady: ["startup", "db"] },
-        { status: 503 },
-      ),
-    );
-    expect(await probeDaemonReadiness(port)).toBe("migrating");
-  });
-
-  test("reports unreachable when nothing is listening", async () => {
-    const port = serveReadyz(() => Response.json({ ready: true }));
-    server?.stop(true);
-    server = null;
-    expect(await probeDaemonReadiness(port)).toBe("unreachable");
-  });
-});
-
-describe("waitForDaemonMigrationsReady", () => {
-  test("returns failed immediately without waiting out the deadline", async () => {
-    const port = serveReadyz(() =>
-      Response.json(
-        {
-          status: "error",
-          ready: false,
-          dbMigrations: { ready: false, state: "failed" },
-        },
-        { status: 503 },
-      ),
-    );
-    const started = Date.now();
-    const readiness = await waitForDaemonMigrationsReady(
-      port,
-      Date.now() + 60_000,
-    );
-    expect(readiness).toBe("failed");
-    // Terminal state short-circuits: nowhere near the 60s deadline.
-    expect(Date.now() - started).toBeLessThan(5_000);
-  });
-
-  test("keeps polling through migrating and resolves ready", async () => {
-    let calls = 0;
-    const port = serveReadyz(() => {
-      calls++;
-      return calls < 3
-        ? Response.json({
-            status: "migrating",
-            ready: false,
-            dbMigrations: { ready: false, state: "running" },
-          })
-        : Response.json({ status: "ok", ready: true });
-    });
-    const readiness = await waitForDaemonMigrationsReady(
-      port,
-      Date.now() + 10_000,
-    );
-    expect(readiness).toBe("ready");
-    expect(calls).toBeGreaterThanOrEqual(3);
-  });
-
-  test("returns migrating when the deadline passes mid-migration", async () => {
-    const port = serveReadyz(() =>
-      Response.json({
-        status: "migrating",
-        ready: false,
-        dbMigrations: { ready: false, state: "running" },
-      }),
-    );
-    const readiness = await waitForDaemonMigrationsReady(
-      port,
-      Date.now() + 600,
-    );
-    expect(readiness).toBe("migrating");
-  });
-});

package/src/__tests__/upgrade-wait-for-ready.test.ts

@@ -1,103 +0,0 @@
-/**
- * Tests for the docker upgrade/rollback readiness gate.
- *
- * `waitForReady` classifies readiness from the gateway `/readyz` BODY, not
- * the status code: the forwarded assistant body is 200 with `ready: false`
- * while DB migrations run (the k8s keep-the-pod contract) and while the
- * gateway's own startup gate is closed. Simplifying this back to
- * `if (resp.ok) return true` would make `vellum upgrade` commit and report
- * success mid-migration and make the rollback/restore path unreachable —
- * these tests pin the body semantics.
- */
-
-import { afterEach, describe, expect, test } from "bun:test";
-
-import { waitForReady } from "../lib/upgrade-lifecycle.js";
-
-type ReadyzResponder = () => Response;
-
-let server: ReturnType<typeof Bun.serve> | null = null;
-
-function serveReadyz(responder: ReadyzResponder): string {
-  server = Bun.serve({
-    port: 0,
-    hostname: "127.0.0.1",
-    fetch(req) {
-      if (new URL(req.url).pathname === "/readyz") return responder();
-      return new Response("not found", { status: 404 });
-    },
-  });
-  const { port } = server;
-  if (port === undefined) throw new Error("test server did not bind a port");
-  return `http://127.0.0.1:${port}`;
-}
-
-afterEach(() => {
-  server?.stop(true);
-  server = null;
-});
-
-describe("waitForReady", () => {
-  test("returns true when the stack reports ready", async () => {
-    const url = serveReadyz(() => Response.json({ status: "ok", ready: true }));
-    expect(await waitForReady(url)).toBe(true);
-  });
-
-  test("does NOT return true on a bare 200 while migrations run", async () => {
-    // 200 { ready: false } is the migrating body — resp.ok alone must not
-    // count as ready. The responder flips to ready after a few polls so the
-    // test proves waitForReady kept waiting rather than returning early.
-    let polls = 0;
-    const url = serveReadyz(() => {
-      polls++;
-      return polls < 3
-        ? Response.json({
-            status: "migrating",
-            ready: false,
-            dbMigrations: { ready: false, state: "running" },
-          })
-        : Response.json({ status: "ok", ready: true });
-    });
-
-    expect(await waitForReady(url)).toBe(true);
-    expect(polls).toBeGreaterThanOrEqual(3);
-  });
-
-  test("keeps waiting through the gateway's starting gate body", async () => {
-    let polls = 0;
-    const url = serveReadyz(() => {
-      polls++;
-      return polls < 2
-        ? Response.json({ status: "starting", ready: false })
-        : Response.json({ status: "ok", ready: true });
-    });
-
-    expect(await waitForReady(url)).toBe(true);
-    expect(polls).toBeGreaterThanOrEqual(2);
-  });
-
-  test("fails fast on terminally failed migrations so rollback can run", async () => {
-    const url = serveReadyz(() =>
-      Response.json(
-        {
-          status: "upstream_unhealthy",
-          upstream: 503,
-          ready: false,
-          dbMigrations: { ready: false, state: "failed" },
-        },
-        { status: 503 },
-      ),
-    );
-
-    const started = Date.now();
-    expect(await waitForReady(url)).toBe(false);
-    // Terminal state short-circuits — nowhere near the 5-minute timeout.
-    expect(Date.now() - started).toBeLessThan(5_000);
-  });
-
-  test("treats a legacy 200 body without a ready field as ready", async () => {
-    // Pre-migration-body gateways returned a fixed { status: "ok" }.
-    const url = serveReadyz(() => Response.json({ status: "ok" }));
-    expect(await waitForReady(url)).toBe(true);
-  });
-});

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

@@ -1,104 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, mock, test } from "bun:test";
-
-import { startCes } from "../local.js";
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-// Capture spawn calls so we can assert on cmd/env.
-let lastSpawnCall: {
-  cmd: string[];
-  options: { detached?: boolean; env?: Record<string, string | undefined>; cwd?: string };
-} | null = null;
-
-mock.module("node:child_process", () => ({
-  spawn: mock((cmd: string, args: string[], options: object) => {
-    lastSpawnCall = { cmd: [cmd, ...args], options };
-    // Return a fake subprocess with a pid and no-op methods.
-    return {
-      pid: 42,
-      unref: () => {},
-      stdout: { on: () => {} },
-      stderr: { on: () => {} },
-      on: () => {},
-    };
-  }),
-  execSync: () => "",
-  execFileSync: () => "",
-  spawnSync: () => ({ status: 0, stdout: "", stderr: "" }),
-}));
-
-// Mock xdg-log so we don't open real log files.
-mock.module("../xdg-log.js", () => ({
-  openLogFile: mock(() => 42),
-  pipeToLogFile: mock(() => {}),
-}));
-
-// Mock process helpers so stopProcessByPidFile is a no-op.
-mock.module("../process.js", () => ({
-  stopProcessByPidFile: mock(async () => {}),
-  isProcessAlive: mock(() => false),
-  stopProcessGracefully: mock(async () => {}),
-}));
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("startCes", () => {
-  let tempDir: string;
-
-  beforeAll(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "ces-test-"));
-  });
-
-  afterAll(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  test("spawns CES with correct env vars and writes PID file", async () => {
-    // Create the socket path before calling startCes so the wait loop exits.
-    // startCes unlinks it first, then waits for it to reappear. We create it
-    // after a short delay to simulate CES binding the socket.
-    const resources = {
-      instanceDir: tempDir,
-      name: "test-assistant",
-    } as unknown as Parameters<typeof startCes>[1];
-
-    // Create the socket file asynchronously after startCes unlinks it.
-    // We use a small setTimeout to create it during the wait loop.
-    const vellumDir = join(tempDir, ".vellum");
-    mkdirSync(vellumDir, { recursive: true });
-
-    // Pre-create the socket so it exists when startCes checks after unlinking.
-    // startCes unlinks the stale socket, then polls for it. We create it with
-    // a slight delay so the poll catches it.
-    setTimeout(() => {
-      const socketDir = join(vellumDir, "workspace");
-      mkdirSync(socketDir, { recursive: true });
-      writeFileSync(join(socketDir, "ces.sock"), "");
-    }, 50);
-
-    lastSpawnCall = null;
-    await startCes(false, resources);
-
-    // Verify spawn was called
-    expect(lastSpawnCall).not.toBeNull();
-    expect(lastSpawnCall!.options.detached).toBe(true);
-
-    // Verify env vars
-    const env = lastSpawnCall!.options.env!;
-    expect(env["CES_STANDALONE"]).toBe("1");
-    expect(env["CES_LOCAL_SOCKET"]).toBeDefined();
-    expect(env["CREDENTIAL_SECURITY_DIR"]).toBeDefined();
-    expect(env["VELLUM_WORKSPACE_DIR"]).toBeDefined();
-
-    // Verify PID file was written
-    const cesPidFile = join(vellumDir, "ces.pid");
-    expect(existsSync(cesPidFile)).toBe(true);
-  }, 15_000);
-});