@vellumai/cli 0.8.6 → 0.8.7-dev.202606052135.3e62c5a

package/src/__tests__/paired-lifecycle.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for the `cloud: "paired"` lifecycle guards: `vellum wake`/`vellum sleep`
+ * must refuse a remote pairing with a clear "managed on its host machine"
+ * message instead of treating it as an on-machine process.
+ */
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const testDir = mkdtempSync(join(tmpdir(), "paired-lifecycle-test-"));
+const ORIGINAL_LOCKFILE_DIR = process.env.VELLUM_LOCKFILE_DIR;
+const ORIGINAL_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
+const ORIGINAL_ARGV = [...process.argv];
+
+import { saveAssistantEntry } from "../lib/assistant-config.js";
+import { retire } from "../commands/retire.js";
+import { sleep } from "../commands/sleep.js";
+import { wake } from "../commands/wake.js";
+
+function seedPairedEntry(): void {
+  saveAssistantEntry({
+    assistantId: "px",
+    name: "Paired Box",
+    runtimeUrl: "http://10.0.0.9:7830",
+    cloud: "paired",
+    paired: true,
+    species: "vellum",
+  });
+}
+
+/** Run `fn` with console.error + process.exit spied; return {exited, errors}. */
+async function runGuarded(
+  fn: () => Promise<void>,
+): Promise<{ exited: boolean; errors: string }> {
+  const errors: string[] = [];
+  const errSpy = spyOn(console, "error").mockImplementation(
+    (...a: unknown[]) => {
+      errors.push(a.join(" "));
+    },
+  );
+  const exitSpy = spyOn(process, "exit").mockImplementation(((c?: number) => {
+    throw new Error(`exit:${c}`);
+  }) as never);
+  let exited = false;
+  try {
+    await fn();
+  } catch (e) {
+    exited = (e as Error).message === "exit:1";
+  } finally {
+    errSpy.mockRestore();
+    exitSpy.mockRestore();
+  }
+  return { exited, errors: errors.join("\n") };
+}
+
+describe("paired lifecycle guards", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    process.env.XDG_CONFIG_HOME = testDir;
+    seedPairedEntry();
+  });
+
+  afterEach(() => {
+    process.argv = [...ORIGINAL_ARGV];
+    if (ORIGINAL_LOCKFILE_DIR === undefined)
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    else process.env.VELLUM_LOCKFILE_DIR = ORIGINAL_LOCKFILE_DIR;
+    if (ORIGINAL_CONFIG_HOME === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = ORIGINAL_CONFIG_HOME;
+  });
+
+  afterAll(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("wake refuses a paired entry with a host-machine message", async () => {
+    process.argv = ["bun", "vellum", "wake", "px"];
+    const { exited, errors } = await runGuarded(wake);
+
+    expect(exited).toBe(true);
+    expect(errors).toContain("paired from another machine");
+    expect(errors).toContain("vellum client px");
+    // It must NOT fall through to the generic local/docker guard.
+    expect(errors).not.toContain("only works with local and docker");
+  });
+
+  test("sleep refuses a paired entry with a host-machine message", async () => {
+    process.argv = ["bun", "vellum", "sleep", "px"];
+    const { exited, errors } = await runGuarded(sleep);
+
+    expect(exited).toBe(true);
+    expect(errors).toContain("paired from another machine");
+    expect(errors).toContain("vellum client px");
+    expect(errors).not.toContain("only works with local and docker");
+  });
+
+  test("retire refuses a paired entry and points to unpair", async () => {
+    process.argv = ["bun", "vellum", "retire", "px", "--yes"];
+    const { exited, errors } = await runGuarded(retire);
+
+    expect(exited).toBe(true);
+    expect(errors).toContain("paired from another machine");
+    expect(errors).toContain("vellum unpair");
+    // It must NOT fall through to the generic "Unknown cloud type" path.
+    expect(errors).not.toContain("Unknown cloud type");
+  });
+});

package/src/__tests__/segments-to-plain-text.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, expect } from "bun:test";
+import { segmentsToPlainText } from "../lib/segments-to-plain-text.js";
+
+describe("segmentsToPlainText", () => {
+  test("returns empty string for missing or empty segments", () => {
+    // GIVEN a message whose history payload carries no text segments
+    // WHEN deriving its flat body
+    // THEN it is the empty string (matching the daemon's old empty `content`)
+    expect(segmentsToPlainText(undefined)).toBe("");
+    expect(segmentsToPlainText([])).toBe("");
+  });
+
+  test("returns a single segment unchanged", () => {
+    // GIVEN a plain-text message with one segment
+    // WHEN deriving its flat body
+    // THEN the segment is returned verbatim
+    expect(segmentsToPlainText(["Real reply."])).toBe("Real reply.");
+  });
+
+  test("joins adjacent segments with a single inserted space", () => {
+    // GIVEN segments split at a tool_use boundary with no surrounding whitespace
+    // WHEN deriving the flat body
+    // THEN a single space is inserted between them
+    expect(segmentsToPlainText(["before", "after"])).toBe("before after");
+  });
+
+  test("does not double-space when either side already has whitespace", () => {
+    // GIVEN segments where one side already ends/starts with whitespace
+    // WHEN deriving the flat body
+    // THEN no extra space is inserted (mirrors daemon joinWithSpacing)
+    expect(segmentsToPlainText(["before ", "after"])).toBe("before after");
+    expect(segmentsToPlainText(["before", " after"])).toBe("before after");
+    expect(segmentsToPlainText(["line one\n", "line two"])).toBe(
+      "line one\nline two",
+    );
+  });
+});

package/src/__tests__/tui-midsession-refresh.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Tests for maybeRefreshAuthHeaders: the TUI's mid-session 401 -> refresh of a
+ * PAIRED assistant's guardian token, mutating the shared auth headers in place.
+ * Scoped to cloud:"paired"; skips local/docker, platform session auth, ephemeral
+ * --token, and access-only tokens.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const ORIGINAL_XDG = process.env.XDG_CONFIG_HOME;
+const ORIGINAL_ENV = process.env.VELLUM_ENVIRONMENT;
+const ORIGINAL_LOCKFILE_DIR = process.env.VELLUM_LOCKFILE_DIR;
+const ORIGINAL_FETCH = globalThis.fetch;
+
+import { maybeRefreshAuthHeaders } from "../components/DefaultMainScreen";
+import { saveAssistantEntry } from "../lib/assistant-config";
+import { saveGuardianToken } from "../lib/guardian-token";
+
+const RUNTIME = "http://10.0.0.9:7830";
+const future = () => new Date(Date.now() + 60 * 60 * 1000).toISOString();
+
+function seedEntry(cloud: string): void {
+  saveAssistantEntry({
+    assistantId: "px",
+    name: "Paired",
+    runtimeUrl: RUNTIME,
+    cloud,
+    paired: cloud === "paired",
+    species: "vellum",
+  });
+}
+
+function seedToken(accessToken: string, refreshToken: string): void {
+  saveGuardianToken("px", {
+    guardianPrincipalId: "imported",
+    accessToken,
+    accessTokenExpiresAt: future(),
+    refreshToken,
+    refreshTokenExpiresAt: refreshToken ? future() : 0,
+    refreshAfter: "",
+    isNew: false,
+    deviceId: "dev",
+    leasedAt: new Date().toISOString(),
+  });
+}
+
+function stubRefresh(ok: boolean): { hit: () => boolean } {
+  let called = false;
+  globalThis.fetch = (async (url: unknown, _init?: RequestInit) => {
+    if (String(url).includes("/v1/guardian/refresh")) {
+      called = true;
+      return new Response(
+        ok ? JSON.stringify({ accessToken: "new-acc" }) : "x",
+        {
+          status: ok ? 200 : 401,
+          headers: { "content-type": "application/json" },
+        },
+      );
+    }
+    return new Response("", { status: 200 });
+  }) as typeof fetch;
+  return { hit: () => called };
+}
+
+describe("maybeRefreshAuthHeaders", () => {
+  let tempHome: string;
+
+  beforeEach(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "tui-midsession-test-"));
+    process.env.XDG_CONFIG_HOME = tempHome;
+    // Isolate the lockfile too — saveAssistantEntry writes the prod lockfile
+    // (~/.vellum.lock.json) unless VELLUM_LOCKFILE_DIR is set, which would
+    // mutate the real user/CI lockfile.
+    process.env.VELLUM_LOCKFILE_DIR = tempHome;
+    delete process.env.VELLUM_ENVIRONMENT;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = ORIGINAL_FETCH;
+    if (ORIGINAL_XDG === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = ORIGINAL_XDG;
+    if (ORIGINAL_LOCKFILE_DIR === undefined)
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    else process.env.VELLUM_LOCKFILE_DIR = ORIGINAL_LOCKFILE_DIR;
+    if (ORIGINAL_ENV === undefined) delete process.env.VELLUM_ENVIRONMENT;
+    else process.env.VELLUM_ENVIRONMENT = ORIGINAL_ENV;
+    rmSync(tempHome, { recursive: true, force: true });
+  });
+
+  test("refreshes a paired assistant and mutates the auth header in place", async () => {
+    seedEntry("paired");
+    seedToken("old-acc", "ref");
+    const refresh = stubRefresh(true);
+    const auth = { Authorization: "Bearer old-acc" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(true);
+    expect(auth.Authorization).toBe("Bearer new-acc");
+    expect(refresh.hit()).toBe(true);
+  });
+
+  test("does NOT refresh a local assistant (scoped to paired only)", async () => {
+    seedEntry("local");
+    seedToken("old-acc", "ref"); // even with a refreshable token
+    const refresh = stubRefresh(true);
+    const auth = { Authorization: "Bearer old-acc" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(false);
+    expect(auth.Authorization).toBe("Bearer old-acc");
+    expect(refresh.hit()).toBe(false);
+  });
+
+  test("skips platform session auth (no Authorization header)", async () => {
+    seedEntry("paired");
+    seedToken("old-acc", "ref");
+    const refresh = stubRefresh(true);
+    const auth = { "X-Session-Token": "sess" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(false);
+    expect(refresh.hit()).toBe(false);
+  });
+
+  test("skips an ephemeral token that does not match the store", async () => {
+    seedEntry("paired");
+    seedToken("stored-acc", "ref");
+    const refresh = stubRefresh(true);
+    const auth = { Authorization: "Bearer ephemeral-acc" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(false);
+    expect(auth.Authorization).toBe("Bearer ephemeral-acc");
+    expect(refresh.hit()).toBe(false);
+  });
+
+  test("skips an access-only token (no refresh credential)", async () => {
+    seedEntry("paired");
+    seedToken("old-acc", ""); // no refresh token
+    const refresh = stubRefresh(true);
+    const auth = { Authorization: "Bearer old-acc" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(false);
+    expect(refresh.hit()).toBe(false);
+  });
+
+  test("returns false and leaves auth unchanged when refresh fails", async () => {
+    seedEntry("paired");
+    seedToken("old-acc", "ref");
+    stubRefresh(false); // refresh endpoint returns non-ok
+    const auth = { Authorization: "Bearer old-acc" };
+
+    const ok = await maybeRefreshAuthHeaders(RUNTIME, "px", auth);
+
+    expect(ok).toBe(false);
+    expect(auth.Authorization).toBe("Bearer old-acc");
+  });
+});

package/src/__tests__/unpair.test.ts

@@ -0,0 +1,163 @@
+/**
+ * Tests for `vellum unpair <name>`: forget a paired (cloud:"paired") assistant
+ * by removing its lockfile entry + guardian token. Refuses non-paired entries.
+ */
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const testDir = mkdtempSync(join(tmpdir(), "unpair-test-"));
+const ORIGINAL_LOCKFILE_DIR = process.env.VELLUM_LOCKFILE_DIR;
+const ORIGINAL_CONFIG_HOME = process.env.XDG_CONFIG_HOME;
+const ORIGINAL_ARGV = [...process.argv];
+
+import { unpair } from "../commands/unpair.js";
+import {
+  findAssistantByName,
+  saveAssistantEntry,
+} from "../lib/assistant-config.js";
+import {
+  deleteGuardianToken,
+  loadGuardianToken,
+  saveGuardianToken,
+} from "../lib/guardian-token.js";
+
+function seedToken(assistantId: string): void {
+  saveGuardianToken(assistantId, {
+    guardianPrincipalId: "imported",
+    accessToken: "acc",
+    accessTokenExpiresAt: Date.now() + 3_600_000,
+    refreshToken: "ref",
+    refreshTokenExpiresAt: Date.now() + 3_600_000,
+    refreshAfter: "",
+    isNew: false,
+    deviceId: "dev",
+    leasedAt: new Date().toISOString(),
+  });
+}
+
+/** Run unpair with console.error + process.exit spied. */
+async function runUnpair(): Promise<{ exited: boolean; errors: string }> {
+  const errors: string[] = [];
+  const logSpy = spyOn(console, "log").mockImplementation(() => {});
+  const errSpy = spyOn(console, "error").mockImplementation(
+    (...a: unknown[]) => {
+      errors.push(a.join(" "));
+    },
+  );
+  const exitSpy = spyOn(process, "exit").mockImplementation(((c?: number) => {
+    throw new Error(`exit:${c}`);
+  }) as never);
+  let exited = false;
+  try {
+    await unpair();
+  } catch (e) {
+    exited = (e as Error).message === "exit:1";
+  } finally {
+    logSpy.mockRestore();
+    errSpy.mockRestore();
+    exitSpy.mockRestore();
+  }
+  return { exited, errors: errors.join("\n") };
+}
+
+describe("vellum unpair", () => {
+  beforeEach(() => {
+    process.env.VELLUM_LOCKFILE_DIR = testDir;
+    process.env.XDG_CONFIG_HOME = testDir;
+  });
+
+  afterEach(() => {
+    process.argv = [...ORIGINAL_ARGV];
+    if (ORIGINAL_LOCKFILE_DIR === undefined)
+      delete process.env.VELLUM_LOCKFILE_DIR;
+    else process.env.VELLUM_LOCKFILE_DIR = ORIGINAL_LOCKFILE_DIR;
+    if (ORIGINAL_CONFIG_HOME === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = ORIGINAL_CONFIG_HOME;
+  });
+
+  afterAll(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("removes a paired entry's lockfile entry and guardian token", async () => {
+    saveAssistantEntry({
+      assistantId: "px",
+      name: "Paired Box",
+      runtimeUrl: "http://10.0.0.9:7830",
+      cloud: "paired",
+      paired: true,
+      species: "vellum",
+    });
+    seedToken("px");
+    expect(findAssistantByName("px")).not.toBeNull();
+    expect(loadGuardianToken("px")).not.toBeNull();
+
+    // Non-interactive test env → use --yes to bypass the confirmation prompt.
+    process.argv = ["bun", "vellum", "unpair", "px", "--yes"];
+    const { exited } = await runUnpair();
+
+    expect(exited).toBe(false);
+    expect(findAssistantByName("px")).toBeNull();
+    expect(loadGuardianToken("px")).toBeNull();
+  });
+
+  test("refuses to unpair without --yes in a non-interactive terminal", async () => {
+    saveAssistantEntry({
+      assistantId: "py",
+      name: "Paired Two",
+      runtimeUrl: "http://10.0.0.9:7830",
+      cloud: "paired",
+      paired: true,
+      species: "vellum",
+    });
+    seedToken("py");
+
+    process.argv = ["bun", "vellum", "unpair", "py"]; // no --yes
+    const { exited, errors } = await runUnpair();
+
+    expect(exited).toBe(true);
+    expect(errors).toContain("--yes");
+    // Not removed — confirmation was required.
+    expect(findAssistantByName("py")).not.toBeNull();
+    expect(loadGuardianToken("py")).not.toBeNull();
+  });
+
+  test("refuses a non-paired (local) assistant and leaves it intact", async () => {
+    saveAssistantEntry({
+      assistantId: "desk",
+      name: "Desk",
+      runtimeUrl: "http://127.0.0.1:7830",
+      cloud: "local",
+      species: "vellum",
+    });
+
+    process.argv = ["bun", "vellum", "unpair", "desk"];
+    const { exited, errors } = await runUnpair();
+
+    expect(exited).toBe(true);
+    expect(errors).toContain("vellum retire");
+    expect(findAssistantByName("desk")).not.toBeNull(); // untouched
+  });
+
+  test("errors on an unknown name", async () => {
+    process.argv = ["bun", "vellum", "unpair", "nope"];
+    const { exited } = await runUnpair();
+    expect(exited).toBe(true);
+  });
+
+  test("deleteGuardianToken is a no-op when the token is absent", () => {
+    // No token seeded for this id; calling (twice) must not throw.
+    expect(() => deleteGuardianToken("ghost")).not.toThrow();
+    expect(() => deleteGuardianToken("ghost")).not.toThrow();
+  });
+});