@vellumai/cli 0.11.2 → 0.11.3-staging.2

package/node_modules/@vellumai/local-mode/src/__tests__/guardian-token.test.ts

@@ -0,0 +1,203 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  getGuardianAccessToken,
+  PAIRED_GUARDIAN_TARGET_MISMATCH_ERROR,
+  PAIRED_GUARDIAN_TOKEN_HOST_ONLY_ERROR,
+  saveGuardianToken,
+  type GuardianTokenData,
+} from "../guardian-token";
+import type { CliInvocation } from "../util";
+
+// An invocation that would fail loudly if any tested branch spawned the CLI.
+const invocation: CliInvocation = { command: "false", baseArgs: [] };
+
+const FUTURE = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+const PAST = new Date(Date.now() - 60_000).toISOString();
+
+function makeTokenData(over: Partial<GuardianTokenData>): GuardianTokenData {
+  return {
+    guardianPrincipalId: "principal",
+    accessToken: "access",
+    accessTokenExpiresAt: FUTURE,
+    refreshToken: "refresh",
+    refreshTokenExpiresAt: FUTURE,
+    refreshAfter: FUTURE,
+    isNew: false,
+    deviceId: "device",
+    leasedAt: new Date().toISOString(),
+    ...over,
+  };
+}
+
+describe("getGuardianAccessToken", () => {
+  let configDir: string;
+
+  beforeEach(() => {
+    configDir = fs.mkdtempSync(path.join(os.tmpdir(), "guardian-token-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(configDir, { recursive: true, force: true });
+  });
+
+  test("returns the stored token while the access token is fresh", async () => {
+    saveGuardianToken(configDir, "asst-1", makeTokenData({}));
+
+    expect(
+      await getGuardianAccessToken("asst-1", configDir, invocation, true),
+    ).toEqual({ ok: true, accessToken: "access" });
+  });
+
+  test("returns a structured 404 when no token file exists", async () => {
+    expect(
+      await getGuardianAccessToken("missing", configDir, invocation, true),
+    ).toEqual({ ok: false, status: 404, error: "Guardian token not found" });
+  });
+
+  test("expired refresh token yields hatch/wake guidance by default", async () => {
+    saveGuardianToken(
+      configDir,
+      "asst-1",
+      makeTokenData({ accessTokenExpiresAt: PAST, refreshTokenExpiresAt: PAST }),
+    );
+
+    const result = await getGuardianAccessToken(
+      "asst-1",
+      configDir,
+      invocation,
+      true,
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      status: 401,
+      error: "Guardian token expired. Re-run `vellum hatch` or `vellum wake`.",
+    });
+  });
+
+  test("expired refresh token yields re-pair guidance for a paired entry", async () => {
+    saveGuardianToken(
+      configDir,
+      "asst-1",
+      makeTokenData({ accessTokenExpiresAt: PAST, refreshTokenExpiresAt: PAST }),
+    );
+
+    const result = await getGuardianAccessToken(
+      "asst-1",
+      configDir,
+      invocation,
+      true,
+      undefined,
+      {
+        paired: true,
+        pairedGatewayUrl: "https://gateway.example.com",
+      },
+    );
+
+    expect(result).toEqual({
+      ok: false,
+      status: 401,
+      error:
+        "Guardian token expired. Run `vellum pair` on the assistant's machine, then re-import it from the app's connect flow or with `vellum connect import`.",
+    });
+  });
+
+  test("an explicit paired: false keeps the hatch/wake guidance", async () => {
+    saveGuardianToken(
+      configDir,
+      "asst-1",
+      makeTokenData({ accessTokenExpiresAt: PAST, refreshTokenExpiresAt: PAST }),
+    );
+
+    const result = await getGuardianAccessToken(
+      "asst-1",
+      configDir,
+      invocation,
+      true,
+      undefined,
+      { paired: false },
+    );
+
+    expect(result.ok).toBe(false);
+    if (result.ok) {
+      return;
+    }
+    expect(result.error).toContain("vellum hatch");
+  });
+
+  test("returns a paired token only for its stored gateway target", async () => {
+    saveGuardianToken(
+      configDir,
+      "paired-1",
+      makeTokenData({ pairedGatewayUrl: "https://gateway.example.com" }),
+    );
+
+    expect(
+      await getGuardianAccessToken("paired-1", configDir, invocation, true),
+    ).toEqual({
+      ok: false,
+      status: 403,
+      error: PAIRED_GUARDIAN_TOKEN_HOST_ONLY_ERROR,
+    });
+    expect(
+      await getGuardianAccessToken(
+        "paired-1",
+        configDir,
+        invocation,
+        true,
+        undefined,
+        {
+          paired: true,
+          pairedGatewayUrl: "https://attacker.example.com",
+        },
+      ),
+    ).toEqual({
+      ok: false,
+      status: 403,
+      error: PAIRED_GUARDIAN_TARGET_MISMATCH_ERROR,
+    });
+    expect(
+      await getGuardianAccessToken(
+        "paired-1",
+        configDir,
+        invocation,
+        true,
+        undefined,
+        {
+          paired: true,
+          pairedGatewayUrl: "https://gateway.example.com",
+        },
+      ),
+    ).toEqual({ ok: true, accessToken: "access" });
+  });
+
+  test("binds a legacy paired token before returning it", async () => {
+    saveGuardianToken(configDir, "paired-1", makeTokenData({}));
+
+    expect(
+      await getGuardianAccessToken(
+        "paired-1",
+        configDir,
+        invocation,
+        true,
+        undefined,
+        {
+          paired: true,
+          pairedGatewayUrl: "https://gateway.example.com",
+        },
+      ),
+    ).toEqual({ ok: true, accessToken: "access" });
+
+    const stored = JSON.parse(
+      fs.readFileSync(
+        path.join(configDir, "assistants", "paired-1", "guardian-token.json"),
+        "utf-8",
+      ),
+    ) as GuardianTokenData;
+    expect(stored.pairedGatewayUrl).toBe("https://gateway.example.com");
+  });
+});

package/node_modules/@vellumai/local-mode/src/__tests__/loopback-auth.test.ts

@@ -3,7 +3,11 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, test } from "bun:test";
 
-import { headerHostIsLoopback, originIsAllowed } from "../util";
+import {
+  hasSameOriginCredentialProof,
+  headerHostIsLoopback,
+  originIsAllowed,
+} from "../util";
 import { isActiveAssistant } from "../lockfile";
 
 describe("headerHostIsLoopback", () => {
@@ -41,6 +45,47 @@ describe("originIsAllowed", () => {
   });
 });
 
+describe("hasSameOriginCredentialProof", () => {
+  test("requires an Origin or explicit same-origin Fetch Metadata", () => {
+    expect(
+      hasSameOriginCredentialProof("127.0.0.1:3000", undefined, undefined),
+    ).toBe(false);
+    expect(
+      hasSameOriginCredentialProof("127.0.0.1:3000", undefined, "same-origin"),
+    ).toBe(true);
+    expect(
+      hasSameOriginCredentialProof(undefined, undefined, "same-origin"),
+    ).toBe(false);
+  });
+
+  test("accepts only the exact loopback HTTP origin named by Host", () => {
+    expect(
+      hasSameOriginCredentialProof(
+        "127.0.0.1:3000",
+        "http://127.0.0.1:3000",
+        undefined,
+      ),
+    ).toBe(true);
+    expect(
+      hasSameOriginCredentialProof(
+        "127.0.0.1:3000",
+        "http://127.0.0.1:9999",
+        undefined,
+      ),
+    ).toBe(false);
+  });
+
+  test("rejects conflicting Fetch Metadata", () => {
+    expect(
+      hasSameOriginCredentialProof(
+        "127.0.0.1:3000",
+        "http://127.0.0.1:3000",
+        "same-site",
+      ),
+    ).toBe(false);
+  });
+});
+
 describe("isActiveAssistant", () => {
   const tempDirs: string[] = [];
 

package/node_modules/@vellumai/local-mode/src/__tests__/package-boundary.test.ts

@@ -7,8 +7,9 @@
  *
  * Enforces that the package:
  * 1. Imports only node builtins, its own relative modules, `@vellumai/environments`,
- *    and `zod` (the lockfile contract's schema library) — nothing else.
- * 2. Declares exactly those two runtime dependencies.
+ *    `zod` (the lockfile contract's schema library), and `nanoid` (pair's
+ *    fallback local-id generator); nothing else.
+ * 2. Declares exactly those runtime dependencies.
  * 3. Is marked `private`.
  */
 
@@ -19,7 +20,7 @@ import { join, resolve } from "node:path";
 const PACKAGE_ROOT = resolve(import.meta.dirname, "../..");
 const SRC_DIR = join(PACKAGE_ROOT, "src");
 
-const ALLOWED_PACKAGES = new Set(["@vellumai/environments", "zod"]);
+const ALLOWED_PACKAGES = new Set(["@vellumai/environments", "zod", "nanoid"]);
 
 function collectSourceFiles(dir: string): string[] {
   const files: string[] = [];
@@ -91,13 +92,14 @@ describe("package boundary", () => {
     }
   });
 
-  test("package.json declares it as private with only its environments and zod dependencies", () => {
+  test("package.json declares it as private with only its allowed dependencies", () => {
     const pkg = JSON.parse(
       readFileSync(join(PACKAGE_ROOT, "package.json"), "utf-8"),
     );
     expect(pkg.private).toBe(true);
     expect(pkg.dependencies ?? {}).toEqual({
       "@vellumai/environments": "file:../environments",
+      nanoid: "5.1.7",
       zod: "4.3.6",
     });
   });