@vellumai/cli 0.11.6 → 0.11.7-staging.2

package/src/__tests__/detached-process.test.ts

@@ -0,0 +1,152 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+import * as childProcess from "node:child_process";
+import type { ChildProcess } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const realChildProcess = { ...childProcess };
+
+function makeFakeChild(pid: number): ChildProcess {
+  const emitter = new EventEmitter();
+  return Object.assign(emitter, {
+    stdout: null,
+    stderr: null,
+    killed: false,
+    kill: () => true,
+    unref: () => {},
+    pid,
+  }) as unknown as ChildProcess;
+}
+
+const spawnMock = mock((..._args: unknown[]) => makeFakeChild(1111));
+
+beforeAll(() => {
+  mock.module("node:child_process", () => ({
+    ...realChildProcess,
+    spawn: spawnMock,
+  }));
+});
+
+afterAll(() => {
+  mock.module("node:child_process", () => realChildProcess);
+});
+
+const { relaunchDetached } = await import("../lib/detached-process.js");
+
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const tempDirs: string[] = [];
+
+describe("relaunchDetached", () => {
+  beforeEach(() => {
+    spawnMock.mockClear();
+    const configHome = mkdtempSync(join(tmpdir(), "vellum-detached-xdg-"));
+    tempDirs.push(configHome);
+    process.env.XDG_CONFIG_HOME = configHome;
+  });
+
+  afterEach(() => {
+    if (originalXdgConfigHome === undefined) {
+      delete process.env.XDG_CONFIG_HOME;
+    } else {
+      process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+    }
+    for (const dir of tempDirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("spawns the current binary detached with the given args and reports readiness", async () => {
+    spawnMock.mockImplementationOnce(() => makeFakeChild(2222));
+
+    const result = await relaunchDetached({
+      args: ["tunnel", "--provider", "ngrok"],
+      logFile: "relaunch-ready.log",
+      timeoutMs: 1000,
+      pollIntervalMs: 10,
+      isReady: () => true,
+    });
+
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const [cmd, args, opts] = spawnMock.mock.calls[0] as unknown as [
+      string,
+      string[],
+      Record<string, unknown>,
+    ];
+    expect(cmd).toBe(process.execPath);
+    expect(args).toContain("tunnel");
+    expect(args).toContain("--provider");
+    expect(args).toContain("ngrok");
+    expect(opts.detached).toBe(true);
+
+    expect(result.ready).toBe(true);
+    expect(result.exitCode).toBeUndefined();
+    expect(result.child.pid).toBe(2222);
+    expect(result.logPath.endsWith("relaunch-ready.log")).toBe(true);
+  });
+
+  test("passes the resolved log path into isReady", async () => {
+    spawnMock.mockImplementationOnce(() => makeFakeChild(3333));
+    const seenPaths: string[] = [];
+
+    const result = await relaunchDetached({
+      args: ["tunnel"],
+      logFile: "relaunch-logpath.log",
+      timeoutMs: 1000,
+      pollIntervalMs: 10,
+      isReady: (logPath) => {
+        seenPaths.push(logPath);
+        return true;
+      },
+    });
+
+    expect(seenPaths).toEqual([result.logPath]);
+  });
+
+  test("stops polling and reports the exit code once the child exits before readiness", async () => {
+    spawnMock.mockImplementationOnce(() => {
+      const child = makeFakeChild(4444);
+      // Listeners attach synchronously right after spawn() returns; defer the
+      // exit so they're in place before it fires.
+      setTimeout(() => (child as unknown as EventEmitter).emit("exit", 7), 0);
+      return child;
+    });
+
+    const result = await relaunchDetached({
+      args: ["tunnel"],
+      logFile: "relaunch-exit.log",
+      timeoutMs: 1000,
+      pollIntervalMs: 10,
+      isReady: () => false,
+    });
+
+    expect(result.ready).toBe(false);
+    expect(result.exitCode).toBe(7);
+  });
+
+  test("gives up once timeoutMs elapses with no readiness and no exit", async () => {
+    spawnMock.mockImplementationOnce(() => makeFakeChild(5555));
+
+    const result = await relaunchDetached({
+      args: ["tunnel"],
+      logFile: "relaunch-timeout.log",
+      timeoutMs: 60,
+      pollIntervalMs: 10,
+      isReady: () => false,
+    });
+
+    expect(result.ready).toBe(false);
+    expect(result.exitCode).toBeUndefined();
+    expect(result.child.pid).toBe(5555);
+  });
+});

package/src/__tests__/devices.test.ts

@@ -147,6 +147,8 @@ describe("vellum devices", () => {
               issuedAt: 1_700_000_000_000,
               expiresAt: 1_800_000_000_000,
               lastUsedAt: 1_750_000_000_000,
+              clientReportedName: "Alice's Laptop",
+              pairingUserAgent: "vellum-cli/1.2.3 (darwin)",
             },
             {
               hashedDeviceId: "hashBBB222",
@@ -171,6 +173,13 @@ describe("vellum devices", () => {
     expect(logs).toContain("cli");
     expect(logs).toContain("webview");
     expect(logs).toContain("never");
+    // Reported name + user agent print verbatim when present.
+    expect(logs).toContain("Alice's Laptop");
+    expect(logs).toContain("vellum-cli/1.2.3 (darwin)");
+    // Missing fields print plain-word placeholders, not a dash or "undefined".
+    expect(logs).toContain("not reported");
+    expect(logs).toContain("not recorded");
+    expect(logs).not.toContain("undefined");
 
     expect(fetchCalls).toHaveLength(1);
     const call = fetchCalls[0];
@@ -377,6 +386,8 @@ describe("vellum devices", () => {
         issuedAt: 1_700_000_000_000,
         expiresAt: 1_800_000_000_000,
         lastUsedAt: null,
+        clientReportedName: "Alice's Laptop",
+        pairingUserAgent: "vellum-cli/1.2.3 (darwin)",
       },
     ];
     stubFetch((url) =>
@@ -392,6 +403,7 @@ describe("vellum devices", () => {
     expect(errors).toBe("");
     // Exactly one line on stdout, parseable, and zero prose.
     expect(logs).not.toContain("\n");
+    // Round-trips clientReportedName/pairingUserAgent with no writer change.
     expect(JSON.parse(logs)).toEqual({ devices: records });
     expect(logs).not.toContain("Devices paired to");
   });

package/src/__tests__/hatch-provider-secrets.test.ts

@@ -2,7 +2,12 @@ import { describe, expect, test } from "bun:test";
 
 import {
   configureHatchProviderApiKey,
+  formatProviderName,
+  hasExplicitHatchProvider,
+  HATCH_PROVIDER_CHOICES,
+  isSupportedLlmProvider,
   resolveHatchProvider,
+  shouldPromptForHatchProvider,
   type ProviderSecretFetch,
 } from "../lib/provider-secrets.js";
 
@@ -281,4 +286,94 @@ describe("hatch provider secrets", () => {
     expect(output).toContain("vellum setup --provider anthropic");
     expect(output).not.toContain("test-anthropic-key");
   });
+
+  test("formats the LiteLLM and OpenCode labels", () => {
+    expect(formatProviderName("litellm")).toBe("LiteLLM");
+    expect(formatProviderName("opencode")).toBe("OpenCode");
+  });
+
+  test("HATCH_PROVIDER_CHOICES only lists supported providers with a label", () => {
+    for (const provider of HATCH_PROVIDER_CHOICES) {
+      expect(isSupportedLlmProvider(provider)).toBe(true);
+      expect(formatProviderName(provider)).toBeTruthy();
+    }
+  });
+
+  test("HATCH_PROVIDER_CHOICES excludes endpoint-supplied providers that cannot back llm.defaultProvider", () => {
+    expect(HATCH_PROVIDER_CHOICES).not.toContain("litellm");
+    expect(HATCH_PROVIDER_CHOICES).not.toContain("opencode");
+  });
+
+  describe("hasExplicitHatchProvider", () => {
+    test("is false for an empty config", () => {
+      expect(hasExplicitHatchProvider({})).toBe(false);
+    });
+
+    test("is true when llm.default.provider is set", () => {
+      expect(
+        hasExplicitHatchProvider({ "llm.default.provider": "openai" }),
+      ).toBe(true);
+    });
+
+    test("is true for an active-profile provider", () => {
+      expect(
+        hasExplicitHatchProvider({
+          "llm.activeProfile": "work",
+          "llm.profiles.work.provider": "openai",
+        }),
+      ).toBe(true);
+    });
+
+    test("is true when a model implies the provider", () => {
+      expect(
+        hasExplicitHatchProvider({ "llm.default.model": "gpt-5.4" }),
+      ).toBe(true);
+    });
+  });
+
+  describe("shouldPromptForHatchProvider", () => {
+    const base = {
+      configValues: {},
+      setupProviderCredentials: true,
+      hasProviderApiKey: false,
+      stdinIsTTY: true,
+    };
+
+    test("prompts when nothing is configured and stdin is a TTY", () => {
+      expect(shouldPromptForHatchProvider(base)).toBe(true);
+    });
+
+    test("does not prompt when provider credential setup is disabled", () => {
+      expect(
+        shouldPromptForHatchProvider({
+          ...base,
+          setupProviderCredentials: false,
+        }),
+      ).toBe(false);
+    });
+
+    test("does not prompt when an API key is already present", () => {
+      expect(
+        shouldPromptForHatchProvider({ ...base, hasProviderApiKey: true }),
+      ).toBe(false);
+    });
+
+    test("does not prompt when the provider is explicitly configured", () => {
+      expect(
+        shouldPromptForHatchProvider({
+          ...base,
+          configValues: { "llm.default.provider": "openai" },
+        }),
+      ).toBe(false);
+    });
+
+    test("does not prompt outside an interactive terminal", () => {
+      expect(
+        shouldPromptForHatchProvider({ ...base, stdinIsTTY: false }),
+      ).toBe(false);
+      expect(
+        shouldPromptForHatchProvider({ ...base, stdinIsTTY: undefined }),
+      ).toBe(false);
+    });
+  });
 });