@vellumai/cli 0.8.5 → 0.8.7

package/src/__tests__/env-drift.test.ts

@@ -2,64 +2,52 @@ import { describe, expect, test } from "bun:test";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { SEEDS } from "../lib/environments/seeds.js";
+import { SEEDS } from "@vellumai/environments";
 
-// Drift guard for the TypeScript sites that hardcode the set of known
-// environment names:
+// Drift guard between the two language-level sources of truth for the set of
+// known environment names:
 //
-//   1. cli/src/lib/environments/seeds.ts  — SEEDS record (source of truth)
-//   2. assistant/src/util/platform.ts     — KNOWN_ENVIRONMENTS set
+//   1. packages/environments/src/seeds.ts       — SEEDS record (TS source of truth)
+//   2. clients/shared/App/VellumEnvironment.swift — Swift `VellumEnvironment` enum
 //
-// Cross-package relative imports don't work here: assistant's tsconfig
-// restricts `include` to its own src tree. So this test parses the literal
-// set out of the external file and asserts it agrees with CLI's SEEDS.
-//
-// FOLLOW-UP: split the env name list into a shared `packages/environments`
-// package (mirroring `packages/service-contracts`, `credential-storage`) so
-// both sites can `import { KNOWN_ENVIRONMENTS }` from one place and this
-// drift guard becomes a compile-time check. Planned alongside CLI-driven
-// context support — see the "Environments" design doc.
+// The Swift client can't import the TypeScript package, so the two lists are
+// maintained independently and must be kept in lockstep by hand. This test
+// parses the enum cases out of the Swift source and asserts they agree with
+// SEEDS. Adding an environment means updating both sites.
 
 const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
-const ASSISTANT_PLATFORM = join(
+const SWIFT_ENVIRONMENT = join(
   REPO_ROOT,
-  "assistant",
-  "src",
-  "util",
-  "platform.ts",
+  "clients",
+  "shared",
+  "App",
+  "VellumEnvironment.swift",
 );
 
 /**
- * Extract the string literals from a Set constructor body in a TS source
- * file. Looks for `<setName>: ReadonlySet<string> = new Set([ ... ])` and
- * pulls out every `"..."` entry within the array. The match is anchored to
- * the `setName` to avoid picking up unrelated sets that happen to live in
- * the same file.
+ * Extract the case names declared in the `VellumEnvironment` enum. Matches
+ * standalone `case <name>` declaration lines (one identifier, nothing else),
+ * which is the enum's own declaration syntax. Switch-statement arms like
+ * `case .local:` carry a leading dot and a trailing colon, so they're
+ * excluded — the match is anchored to a bare identifier at end of line.
  */
-function extractSetLiterals(source: string, setName: string): string[] {
-  const pattern = new RegExp(
-    `${setName}\\s*:\\s*ReadonlySet<string>\\s*=\\s*new Set\\(\\[([^\\]]*)\\]`,
-    "m",
-  );
-  const match = source.match(pattern);
-  if (!match) {
-    throw new Error(
-      `Could not find Set literal for ${setName}. Update the drift-guard regex in env-drift.test.ts.`,
-    );
+function extractSwiftEnumCases(source: string): string[] {
+  const names: string[] = [];
+  for (const line of source.split("\n")) {
+    const match = line.match(/^\s*case\s+([a-zA-Z][a-zA-Z0-9]*)\s*$/);
+    if (match) names.push(match[1]!);
   }
-  const body = match[1];
-  const literals = body.match(/"([^"]+)"/g) ?? [];
-  return literals.map((lit) => lit.slice(1, -1));
+  return names;
 }
 
-describe("KNOWN_ENVIRONMENTS drift guard (TS-side)", () => {
+describe("environment name drift guard (TS ↔ Swift)", () => {
   const seedNames = new Set(Object.keys(SEEDS));
 
-  test("assistant/src/util/platform.ts KNOWN_ENVIRONMENTS matches CLI SEEDS", () => {
-    const source = readFileSync(ASSISTANT_PLATFORM, "utf8");
-    const assistantNames = new Set(
-      extractSetLiterals(source, "KNOWN_ENVIRONMENTS"),
-    );
-    expect([...assistantNames].sort()).toEqual([...seedNames].sort());
+  test("clients/shared/App/VellumEnvironment.swift matches SEEDS", () => {
+    const source = readFileSync(SWIFT_ENVIRONMENT, "utf8");
+    const swiftNames = new Set(extractSwiftEnumCases(source));
+
+    expect(swiftNames.size).toBeGreaterThan(0);
+    expect([...swiftNames].sort()).toEqual([...seedNames].sort());
   });
 });

package/src/__tests__/flags.test.ts

@@ -0,0 +1,248 @@
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { type AssistantEntry } from "../lib/assistant-config.js";
+import { flags } from "../commands/flags.js";
+
+const testDir = mkdtempSync(join(tmpdir(), "cli-flags-test-"));
+const originalArgv = [...process.argv];
+const originalExit = process.exit;
+const originalFetch = globalThis.fetch;
+const originalLockfileDir = process.env.VELLUM_LOCKFILE_DIR;
+
+let consoleLogSpy: ReturnType<typeof spyOn>;
+let consoleErrorSpy: ReturnType<typeof spyOn>;
+let fetchCalls: Array<{ url: string; method: string }>;
+
+function makeEntry(
+  assistantId: string,
+  extra: Partial<AssistantEntry> = {},
+): AssistantEntry {
+  return {
+    assistantId,
+    runtimeUrl: `http://127.0.0.1:${7800 + assistantId.length}`,
+    cloud: "local",
+    ...extra,
+  };
+}
+
+function writeLockfile(
+  entries: AssistantEntry[],
+  activeAssistant?: string,
+): void {
+  mkdirSync(testDir, { recursive: true });
+  writeFileSync(
+    join(testDir, ".vellum.lock.json"),
+    JSON.stringify(
+      {
+        assistants: entries,
+        ...(activeAssistant ? { activeAssistant } : {}),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+/**
+ * Build a Response stub that callers shape per subcommand. `setFlag` needs
+ * a 200 OK with the gateway's updated flag payload; `getFlag`/`listFlags`
+ * need a flag list. Body content is the minimal valid shape — the tests
+ * exercise URL routing, not response parsing.
+ */
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+describe("vellum flags --assistant routing", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    rmSync(join(testDir, ".vellum.lock.json"), { force: true });
+    fetchCalls = [];
+    // Capture every outgoing fetch and respond with a stub matching the
+    // subcommand's expected shape. The URL is what the test asserts on.
+    globalThis.fetch = (async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ) => {
+      const url = typeof input === "string" ? input : input.toString();
+      const method = init?.method ?? "GET";
+      fetchCalls.push({ url, method });
+      if (method === "PATCH") {
+        return jsonResponse({
+          key: "external-plugins",
+          enabled: true,
+          defaultEnabled: false,
+          label: "External Plugins",
+          description: "test",
+        });
+      }
+      return jsonResponse({ flags: [] });
+    }) as typeof globalThis.fetch;
+    process.exit = ((code?: number) => {
+      throw new Error(`process.exit:${code}`);
+    }) as typeof process.exit;
+    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
+    process.exit = originalExit;
+    globalThis.fetch = originalFetch;
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  afterAll(() => {
+    if (originalLockfileDir === undefined) {
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    } else {
+      process.env.VELLUM_LOCKFILE_DIR = originalLockfileDir;
+    }
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("set --assistant <id> routes to the explicit instance's runtime URL, not the active one", async () => {
+    // Two assistants on different ports. The active one is "alice"; the
+    // explicit --assistant target is "bob". A correct routing impl hits
+    // bob's URL — a regression that silently uses the active assistant
+    // would hit alice's URL.
+    writeLockfile(
+      [
+        makeEntry("alice-1", { name: "Alice" }),
+        makeEntry("bob-2", { name: "Bob" }),
+      ],
+      "alice-1",
+    );
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+      "Bob",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    expect(fetchCalls[0].method).toBe("PATCH");
+    // 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",
+    );
+  });
+
+  test("set --assistant <id> placed BEFORE positional args still parses correctly", async () => {
+    // Eval harness composes `vellum flags set <key> <value> --assistant <id>`
+    // but human users might write `--assistant <id> set <key> <value>`.
+    // The extractor strips --assistant from anywhere in argv so positional
+    // parsing downstream sees the same shape either way.
+    writeLockfile([
+      makeEntry("alice-1", { name: "Alice" }),
+      makeEntry("bob-2", { name: "Bob" }),
+    ]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "--assistant",
+      "Bob",
+      "set",
+      "external-plugins",
+      "true",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    expect(fetchCalls[0].url).toContain(
+      "/v1/assistants/bob-2/feature-flags/external-plugins",
+    );
+  });
+
+  test("set without --assistant uses the active assistant", async () => {
+    // Backwards-compat: behavior unchanged for invocations that don't
+    // pass --assistant. The active assistant ("alice-1") wins.
+    writeLockfile(
+      [
+        makeEntry("alice-1", { name: "Alice" }),
+        makeEntry("bob-2", { name: "Bob" }),
+      ],
+      "alice-1",
+    );
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+    ];
+
+    await flags();
+
+    expect(fetchCalls.length).toBe(1);
+    // 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",
+    );
+  });
+
+  test("set --assistant <name> exits with a lookup error when no assistant matches", async () => {
+    writeLockfile([makeEntry("alice-1", { name: "Alice" })]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+      "Ghost",
+    ];
+
+    // The Error thrown by createClient propagates out of flags().
+    // No fetch should ever fire because lookup fails before the
+    // AssistantClient is constructed.
+    await expect(flags()).rejects.toThrow(/Ghost/);
+    expect(fetchCalls.length).toBe(0);
+  });
+
+  test("--assistant without a value exits via the explicit missing-value branch", async () => {
+    writeLockfile([makeEntry("alice-1", { name: "Alice" })]);
+    process.argv = [
+      "bun",
+      "vellum",
+      "flags",
+      "set",
+      "external-plugins",
+      "true",
+      "--assistant",
+    ];
+
+    await expect(flags()).rejects.toThrow(/process\.exit:1/);
+    expect(consoleErrorSpy.mock.calls.flat().join("\n")).toContain(
+      "Missing value for --assistant <name>",
+    );
+    expect(fetchCalls.length).toBe(0);
+  });
+});

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

@@ -156,7 +156,7 @@ describe("multi-local", () => {
 
     test("allocation picks env-specific port bases for non-prod envs", async () => {
       // Each non-prod env sits in its own 1000-port window (see
-      // environments/seeds.ts). Hatching under VELLUM_ENVIRONMENT=dev should
+      // @vellumai/environments seeds). Hatching under VELLUM_ENVIRONMENT=dev should
       // produce ports in the dev block (18000+), not the production defaults.
       const prevEnv = process.env.VELLUM_ENVIRONMENT;
       const prevXdg = process.env.XDG_DATA_HOME;

package/src/__tests__/orphan-detection.test.ts

@@ -3,6 +3,8 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import type { EnvironmentDefinition } from "@vellumai/environments";
+
 // Point lockfile operations at a temp directory before importing anything that
 // would otherwise resolve real on-host paths.
 const testDir = mkdtempSync(join(tmpdir(), "cli-orphan-detection-test-"));
@@ -16,7 +18,6 @@ import {
   loadAllAssistantsAcrossEnvs,
   type AssistantEntry,
 } from "../lib/assistant-config.js";
-import type { EnvironmentDefinition } from "../lib/environments/types.js";
 
 afterAll(() => {
   rmSync(testDir, { recursive: true, force: true });
@@ -74,11 +75,12 @@ describe("getKnownPidsFromAssistants", () => {
   });
 
   test("collects daemon, gateway, qdrant, and embed-worker PIDs", () => {
-    const entry = makeLocalEntry(
-      "alpha",
-      join(perTestDir, "alpha"),
-      { daemon: "100", gateway: "200", qdrant: "300", embed: "400" },
-    );
+    const entry = makeLocalEntry("alpha", join(perTestDir, "alpha"), {
+      daemon: "100",
+      gateway: "200",
+      qdrant: "300",
+      embed: "400",
+    });
     const pids = getKnownPidsFromAssistants([entry]);
     expect(pids).toEqual(new Set(["100", "200", "300", "400"]));
   });