@vellumai/cli 0.8.9-staging.2 → 0.8.9-staging.4

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

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { headerHostIsLoopback, originIsAllowed } from "../util";
+import { isActiveAssistant } from "../lockfile";
+
+describe("headerHostIsLoopback", () => {
+  test("rejects DNS-rebound hosts", () => {
+    expect(headerHostIsLoopback("attacker.example")).toBe(false);
+    expect(headerHostIsLoopback("evil.com:3000")).toBe(false);
+  });
+
+  test("accepts loopback hosts", () => {
+    expect(headerHostIsLoopback("127.0.0.1:3000")).toBe(true);
+    expect(headerHostIsLoopback("localhost:3000")).toBe(true);
+    expect(headerHostIsLoopback("localhost")).toBe(true);
+    expect(headerHostIsLoopback("[::1]:3000")).toBe(true);
+  });
+
+  test("rejects undefined/empty", () => {
+    expect(headerHostIsLoopback(undefined)).toBe(false);
+    expect(headerHostIsLoopback("")).toBe(false);
+  });
+});
+
+describe("originIsAllowed", () => {
+  test("rejects cross-origin requests", () => {
+    expect(originIsAllowed("https://attacker.example")).toBe(false);
+    expect(originIsAllowed("http://evil.com")).toBe(false);
+  });
+
+  test("accepts localhost origins", () => {
+    expect(originIsAllowed("http://localhost:3000")).toBe(true);
+    expect(originIsAllowed("http://127.0.0.1:3000")).toBe(true);
+  });
+
+  test("allows absent origin (non-browser clients)", () => {
+    expect(originIsAllowed(undefined)).toBe(true);
+  });
+});
+
+describe("isActiveAssistant", () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  function makeTempDir(): string {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "vellum-local-mode-test-"));
+    tempDirs.push(dir);
+    return dir;
+  }
+
+  test("returns true for the active assistant", () => {
+    const dir = makeTempDir();
+    const lockfilePath = path.join(dir, "lockfile.json");
+    fs.writeFileSync(
+      lockfilePath,
+      JSON.stringify({
+        assistants: [{ assistantId: "active" }, { assistantId: "inactive" }],
+        activeAssistant: "active",
+      }),
+    );
+    expect(isActiveAssistant([lockfilePath], "active")).toBe(true);
+  });
+
+  test("returns false for a non-active assistant", () => {
+    const dir = makeTempDir();
+    const lockfilePath = path.join(dir, "lockfile.json");
+    fs.writeFileSync(
+      lockfilePath,
+      JSON.stringify({
+        assistants: [{ assistantId: "active" }, { assistantId: "inactive" }],
+        activeAssistant: "active",
+      }),
+    );
+    expect(isActiveAssistant([lockfilePath], "inactive")).toBe(false);
+  });
+
+  test("returns false when lockfile does not exist", () => {
+    expect(isActiveAssistant(["/nonexistent/lockfile.json"], "any")).toBe(false);
+  });
+});

package/node_modules/@vellumai/local-mode/src/index.ts

@@ -9,6 +9,8 @@
 export {
   stripSensitiveFields,
   isLoopbackAddr,
+  headerHostIsLoopback,
+  originIsAllowed,
   resolveDevCliInvocation,
 } from "./util";
 export type { CliInvocation } from "./util";
@@ -19,6 +21,7 @@ export {
   getLockfileData,
   upsertLockfileAssistant,
   replacePlatformAssistants,
+  isActiveAssistant,
 } from "./lockfile";
 export type { LockfileResult, WriteResult } from "./lockfile";
 export { parseLockfile } from "./lockfile-contract";

package/node_modules/@vellumai/local-mode/src/lockfile.ts

@@ -88,6 +88,21 @@ export function upsertLockfileAssistant(
   return { ok: true, lockfile: parseLockfile(stripped) };
 }
 
+export function isActiveAssistant(
+  lockfilePaths: string[],
+  assistantId: string,
+): boolean {
+  for (const candidate of lockfilePaths) {
+    try {
+      const data = JSON.parse(fs.readFileSync(candidate, "utf-8")) as Record<string, unknown>;
+      return data.activeAssistant === assistantId;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
 export function replacePlatformAssistants(
   lockfilePaths: string[],
   platformAssistants: Array<Record<string, unknown>>,

package/node_modules/@vellumai/local-mode/src/util.ts

@@ -42,6 +42,39 @@ export function stripSensitiveFields(data: Record<string, unknown>): void {
   }
 }
 
+function isLoopbackHostname(hostname: string): boolean {
+  const normalized = hostname.toLowerCase();
+  return (
+    normalized === "localhost" ||
+    normalized === "[::1]" ||
+    normalized === "::1" ||
+    normalized === "0:0:0:0:0:0:0:1" ||
+    /^127(?:\.\d{1,3}){3}$/.test(normalized)
+  );
+}
+
+export function headerHostIsLoopback(hostHeader: string | undefined): boolean {
+  if (!hostHeader) return false;
+  try {
+    return isLoopbackHostname(new URL(`http://${hostHeader}`).hostname);
+  } catch {
+    return false;
+  }
+}
+
+export function originIsAllowed(originHeader: string | undefined): boolean {
+  if (!originHeader) return true;
+  try {
+    const origin = new URL(originHeader);
+    return (
+      (origin.protocol === "http:" || origin.protocol === "https:") &&
+      isLoopbackHostname(origin.hostname)
+    );
+  } catch {
+    return false;
+  }
+}
+
 export function isLoopbackAddr(addr: string): boolean {
   const v4Mapped = addr.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/i);
   const normalized = v4Mapped ? v4Mapped[1]! : addr;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/cli",
-  "version": "0.8.9-staging.2",
+  "version": "0.8.9-staging.4",
   "description": "CLI tools for vellum-assistant",
   "type": "module",
   "exports": {

package/src/__tests__/assistant-client-refresh.test.ts

@@ -25,10 +25,17 @@ import { AssistantClient } from "../lib/assistant-client.js";
 import { saveAssistantEntry } from "../lib/assistant-config.js";
 import { loadGuardianToken, saveGuardianToken } from "../lib/guardian-token.js";
 
-const RUNTIME = "http://10.0.0.9:7830";
+const RUNTIME = "https://gw.example.com";
 const FUTURE = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toISOString();
+const PAST = new Date(Date.now() - 60_000).toISOString();
 
-function seedPaired(refreshToken: string): void {
+/**
+ * Seed a paired assistant + guardian token. `due` (default true) controls
+ * whether the access token has reached its renewal point — the reactive
+ * 401-refresh only fires for a due token.
+ */
+function seedPaired(refreshToken: string, opts?: { due?: boolean }): void {
+  const due = opts?.due ?? true;
   saveAssistantEntry({
     assistantId: "px",
     name: "Paired",
@@ -40,10 +47,10 @@ function seedPaired(refreshToken: string): void {
   saveGuardianToken("px", {
     guardianPrincipalId: "imported",
     accessToken: "old-acc",
-    accessTokenExpiresAt: FUTURE,
+    accessTokenExpiresAt: due ? PAST : FUTURE,
     refreshToken,
     refreshTokenExpiresAt: refreshToken ? FUTURE : 0,
-    refreshAfter: "",
+    refreshAfter: due ? PAST : FUTURE,
     isNew: false,
     deviceId: "dev",
     leasedAt: new Date().toISOString(),
@@ -179,4 +186,58 @@ describe("AssistantClient 401 -> refresh -> retry", () => {
     expect(assistantAttempts).toBe(2); // original + one retry, no more
     expect(calls.filter((c) => isRefresh(c.url))).toHaveLength(1);
   });
+
+  test("does NOT refresh on a 401 when the stored token is not due for renewal", async () => {
+    // A forged/synthetic 401 on a still-valid token must not coax out the
+    // long-lived refresh credential.
+    seedPaired("refresh-tok", { due: false });
+    let assistantAttempts = 0;
+    const calls = stubFetch((url) => {
+      if (isRefresh(url)) return refreshResponse();
+      assistantAttempts++;
+      return new Response("", { status: 401 });
+    });
+
+    const client = new AssistantClient({ assistantId: "px" });
+    const res = await client.get("/messages/");
+
+    expect(res.status).toBe(401);
+    expect(assistantAttempts).toBe(1); // no retry
+    expect(calls.filter((c) => isRefresh(c.url))).toHaveLength(0); // refresh not attempted
+  });
+
+  test("adopts a token rotated by another process on a 401 (no refresh sent)", async () => {
+    // Construct the client capturing the current ("old-acc") token, then
+    // simulate a concurrent process (e.g. `vellum events`) rotating + persisting
+    // a fresh, not-due token. A 401 must pick up the fresh local token and retry
+    // WITHOUT sending the refresh credential.
+    seedPaired("refresh-tok", { due: false });
+    const client = new AssistantClient({ assistantId: "px" });
+    saveGuardianToken("px", {
+      guardianPrincipalId: "imported",
+      accessToken: "fresh-acc",
+      accessTokenExpiresAt: FUTURE,
+      refreshToken: "refresh-tok",
+      refreshTokenExpiresAt: FUTURE,
+      refreshAfter: FUTURE, // fresh — not due for renewal
+      isNew: false,
+      deviceId: "dev",
+      leasedAt: new Date().toISOString(),
+    });
+
+    const calls = stubFetch((url, log) => {
+      if (isRefresh(url)) return refreshResponse();
+      const auth = log[log.length - 1].headers["Authorization"];
+      return new Response("", {
+        status: auth === "Bearer fresh-acc" ? 200 : 401,
+      });
+    });
+
+    const res = await client.get("/messages/");
+
+    expect(res.status).toBe(200);
+    expect(calls.filter((c) => isRefresh(c.url))).toHaveLength(0); // no refresh sent
+    const assistantCalls = calls.filter((c) => !isRefresh(c.url));
+    expect(assistantCalls[1].headers["Authorization"]).toBe("Bearer fresh-acc");
+  });
 });

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

@@ -10,15 +10,30 @@ 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 { resolveFreshBearerToken } from "../commands/client.js";
+import { saveAssistantEntry } from "../lib/assistant-config.js";
 import { saveGuardianToken } from "../lib/guardian-token.js";
 
-const RUNTIME = "http://10.0.0.9:7830";
+const RUNTIME = "https://gw.example.com";
 const past = () => new Date(Date.now() - 60_000).toISOString();
 const future = () => new Date(Date.now() + 60 * 60 * 1000).toISOString();
 
+/** Persist a lockfile entry so the refresh URL-binding check has a trusted
+ *  runtimeUrl to compare against (refresh is bound to the persisted entry). */
+function seedEntry(cloud: string): void {
+  saveAssistantEntry({
+    assistantId: "px",
+    name: "Paired",
+    runtimeUrl: RUNTIME,
+    cloud,
+    paired: cloud === "paired",
+    species: "vellum",
+  });
+}
+
 function seed(opts: {
   accessToken: string;
   refreshToken: string;
@@ -37,12 +52,15 @@ function seed(opts: {
   });
 }
 
-/** Stub global fetch; returns whether the refresh endpoint was hit. */
-function stubRefresh(ok: boolean): { hit: () => boolean } {
-  let called = false;
+/** Stub global fetch; returns whether the refresh endpoint was hit and where. */
+function stubRefresh(ok: boolean): {
+  hit: () => boolean;
+  url: () => string | undefined;
+} {
+  let calledUrl: string | undefined;
   globalThis.fetch = (async (url: unknown, _init?: RequestInit) => {
     if (String(url).includes("/v1/guardian/refresh")) {
-      called = true;
+      calledUrl = String(url);
       return new Response(
         ok ? JSON.stringify({ accessToken: "new-acc" }) : "nope",
         {
@@ -53,7 +71,7 @@ function stubRefresh(ok: boolean): { hit: () => boolean } {
     }
     return new Response("", { status: 200 });
   }) as typeof fetch;
-  return { hit: () => called };
+  return { hit: () => calledUrl !== undefined, url: () => calledUrl };
 }
 
 describe("resolveFreshBearerToken", () => {
@@ -62,6 +80,9 @@ describe("resolveFreshBearerToken", () => {
   beforeEach(() => {
     tempHome = mkdtempSync(join(tmpdir(), "client-tui-refresh-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.
+    process.env.VELLUM_LOCKFILE_DIR = tempHome;
     delete process.env.VELLUM_ENVIRONMENT; // prod config dir
   });
 
@@ -69,12 +90,16 @@ describe("resolveFreshBearerToken", () => {
     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 stale stored token and returns the new access token", async () => {
+    seedEntry("paired");
     seed({ accessToken: "old-acc", refreshToken: "ref", refreshAfter: past() });
     const refresh = stubRefresh(true);
 
@@ -89,6 +114,24 @@ describe("resolveFreshBearerToken", () => {
     expect(refresh.hit()).toBe(true);
   });
 
+  test("does NOT refresh against an overridden/poisoned runtime URL (no credential leak)", async () => {
+    // --url can override the runtime URL while still reusing the stored guardian
+    // token; a stale token must NOT be refreshed against an attacker origin.
+    seedEntry("paired"); // persisted runtimeUrl = RUNTIME
+    seed({ accessToken: "old-acc", refreshToken: "ref", refreshAfter: past() });
+    const refresh = stubRefresh(true);
+
+    const token = await resolveFreshBearerToken(
+      "http://attacker.example:7830",
+      "px",
+      "old-acc",
+      "paired",
+    );
+
+    expect(token).toBe("old-acc"); // unchanged
+    expect(refresh.hit()).toBe(false); // no refresh POST anywhere
+  });
+
   test("leaves a still-fresh stored token unchanged (no refresh)", async () => {
     seed({
       accessToken: "old-acc",
@@ -140,6 +183,7 @@ describe("resolveFreshBearerToken", () => {
   });
 
   test("falls back to the existing token when refresh fails", async () => {
+    seedEntry("paired");
     seed({ accessToken: "old-acc", refreshToken: "ref", refreshAfter: past() });
     stubRefresh(false); // refresh endpoint returns non-ok
 

package/src/__tests__/guardian-token.test.ts

@@ -13,6 +13,7 @@ import { dirname, join } from "node:path";
 
 import {
   getOrCreatePersistedDeviceId,
+  guardianTokenDueForRenewal,
   loadGuardianToken,
   refreshGuardianToken,
   saveGuardianToken,
@@ -293,7 +294,7 @@ describe("refreshGuardianToken", () => {
       );
     }) as typeof fetch;
 
-    const result = await refreshGuardianToken("http://10.0.0.9:7830", "px");
+    const result = await refreshGuardianToken("https://gw.example.com", "px");
 
     expect(result?.accessToken).toBe("new-acc");
     expect(loadGuardianToken("px")?.accessToken).toBe("new-acc");
@@ -309,7 +310,9 @@ describe("refreshGuardianToken", () => {
       return new Response("", { status: 200 });
     }) as typeof fetch;
 
-    expect(await refreshGuardianToken("http://10.0.0.9:7830", "px")).toBeNull();
+    expect(
+      await refreshGuardianToken("https://gw.example.com", "px"),
+    ).toBeNull();
     expect(called).toBe(false);
   });
 
@@ -321,7 +324,7 @@ describe("refreshGuardianToken", () => {
     }) as typeof fetch;
 
     expect(
-      await refreshGuardianToken("http://10.0.0.9:7830", "missing"),
+      await refreshGuardianToken("https://gw.example.com", "missing"),
     ).toBeNull();
     expect(called).toBe(false);
   });
@@ -342,8 +345,131 @@ describe("refreshGuardianToken", () => {
         headers: { "content-type": "application/json" },
       })) as typeof fetch;
 
-    const result = await refreshGuardianToken("http://10.0.0.9:7830", "px");
+    const result = await refreshGuardianToken("https://gw.example.com", "px");
     expect(result?.accessToken).toBe("new-acc");
     expect(existsSync(lp)).toBe(false); // stolen lock cleaned up after release
   });
+
+  // The refresh token is long-lived and replayable, so it must only travel over
+  // a confidential channel: https, or a loopback host. These guard the
+  // plaintext-interception vector flagged in the security review.
+
+  test("sends the refresh token over loopback http (127.0.0.1 / localhost / [::1])", async () => {
+    for (const url of [
+      "http://127.0.0.1:7830",
+      "http://localhost:7830",
+      "http://[::1]:7830",
+    ]) {
+      seed(future());
+      let called = false;
+      globalThis.fetch = (async (_url: unknown, _init?: RequestInit) => {
+        called = true;
+        return new Response(JSON.stringify({ accessToken: "new-acc" }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        });
+      }) as typeof fetch;
+
+      expect(await refreshGuardianToken(url, "px")).not.toBeNull();
+      expect(called).toBe(true); // loopback http is allowed
+    }
+  });
+
+  test("refuses a non-loopback plaintext http URL: no fetch, returns null, warns", async () => {
+    seed(future());
+    let called = false;
+    globalThis.fetch = (async (_url: unknown, _init?: RequestInit) => {
+      called = true;
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    const origWarn = console.warn;
+    let warned = false;
+    console.warn = () => {
+      warned = true;
+    };
+    try {
+      expect(
+        await refreshGuardianToken("http://10.0.0.5:7830", "px"),
+      ).toBeNull();
+    } finally {
+      console.warn = origWarn;
+    }
+    expect(called).toBe(false); // the refresh token is never sent
+    expect(warned).toBe(true);
+  });
+
+  test("refuses a malformed gateway URL: no fetch, returns null", async () => {
+    seed(future());
+    let called = false;
+    globalThis.fetch = (async (_url: unknown, _init?: RequestInit) => {
+      called = true;
+      return new Response("", { status: 200 });
+    }) as typeof fetch;
+
+    const origWarn = console.warn;
+    console.warn = () => {};
+    try {
+      expect(await refreshGuardianToken("not-a-url", "px")).toBeNull();
+    } finally {
+      console.warn = origWarn;
+    }
+    expect(called).toBe(false);
+  });
+});
+
+describe("guardianTokenDueForRenewal", () => {
+  const FUTURE = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+  const PAST = new Date(Date.now() - 60_000).toISOString();
+
+  function token(over: Partial<GuardianTokenData>): GuardianTokenData {
+    return {
+      guardianPrincipalId: "p",
+      accessToken: "a",
+      accessTokenExpiresAt: FUTURE,
+      refreshToken: "r",
+      refreshTokenExpiresAt: FUTURE,
+      refreshAfter: "",
+      isNew: false,
+      deviceId: "d",
+      leasedAt: new Date().toISOString(),
+      ...over,
+    };
+  }
+
+  test("past refreshAfter → due", () => {
+    expect(guardianTokenDueForRenewal(token({ refreshAfter: PAST }))).toBe(
+      true,
+    );
+  });
+
+  test("future refreshAfter → not due", () => {
+    expect(guardianTokenDueForRenewal(token({ refreshAfter: FUTURE }))).toBe(
+      false,
+    );
+  });
+
+  test("empty refreshAfter falls back to accessTokenExpiresAt (past → due)", () => {
+    expect(
+      guardianTokenDueForRenewal(
+        token({ refreshAfter: "", accessTokenExpiresAt: PAST }),
+      ),
+    ).toBe(true);
+  });
+
+  test("empty refreshAfter falls back to accessTokenExpiresAt (future → not due)", () => {
+    expect(
+      guardianTokenDueForRenewal(
+        token({ refreshAfter: "", accessTokenExpiresAt: FUTURE }),
+      ),
+    ).toBe(false);
+  });
+
+  test("unparseable timestamp → not due", () => {
+    expect(
+      guardianTokenDueForRenewal(
+        token({ refreshAfter: "not-a-date", accessTokenExpiresAt: "nope" }),
+      ),
+    ).toBe(false);
+  });
 });

package/src/__tests__/message.test.ts

@@ -0,0 +1,86 @@
+import { describe, test, expect } from "bun:test";
+
+import { parseMessageArgs } from "../commands/message.js";
+
+describe("parseMessageArgs", () => {
+  test("parses an inline message with the active assistant", () => {
+    const r = parseMessageArgs(["hello"]);
+    expect(r).toEqual({
+      ok: true,
+      value: {
+        conversationKey: undefined,
+        jsonOutput: false,
+        inlineMessage: "hello",
+      },
+    });
+  });
+
+  test("parses an explicit assistant plus inline message", () => {
+    const r = parseMessageArgs(["my-assistant", "ping"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.assistantId).toBe("my-assistant");
+    expect(r.value.inlineMessage).toBe("ping");
+    expect(r.value.filePath).toBeUndefined();
+  });
+
+  test("requires message content when nothing is provided", () => {
+    const r = parseMessageArgs([]);
+    expect(r).toEqual({ ok: false, error: "message content is required." });
+  });
+
+  test("reads content from --file with the active assistant", () => {
+    const r = parseMessageArgs(["--file", "prompt.txt"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.filePath).toBe("prompt.txt");
+    expect(r.value.assistantId).toBeUndefined();
+    expect(r.value.inlineMessage).toBeUndefined();
+  });
+
+  test("reads content from --file with an explicit assistant", () => {
+    const r = parseMessageArgs(["my-assistant", "--file", "prompt.txt"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.assistantId).toBe("my-assistant");
+    expect(r.value.filePath).toBe("prompt.txt");
+  });
+
+  test("supports stdin via --file -", () => {
+    const r = parseMessageArgs(["--file", "-"]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.filePath).toBe("-");
+  });
+
+  test("rejects combining --file with an inline message", () => {
+    const r = parseMessageArgs(["my-assistant", "extra", "--file", "p.txt"]);
+    expect(r).toEqual({
+      ok: false,
+      error: "--file cannot be combined with an inline message argument.",
+    });
+  });
+
+  test("rejects --file without a path argument", () => {
+    const r = parseMessageArgs(["my-assistant", "--file"]);
+    expect(r).toEqual({
+      ok: false,
+      error: "--file requires a path argument.",
+    });
+  });
+
+  test("preserves --conversation-key and --json alongside --file", () => {
+    const r = parseMessageArgs([
+      "--json",
+      "--conversation-key",
+      "thread-1",
+      "--file",
+      "prompt.txt",
+    ]);
+    expect(r.ok).toBe(true);
+    if (!r.ok) return;
+    expect(r.value.jsonOutput).toBe(true);
+    expect(r.value.conversationKey).toBe("thread-1");
+    expect(r.value.filePath).toBe("prompt.txt");
+  });
+});

package/src/__tests__/teleport.test.ts

@@ -779,6 +779,7 @@ describe("resolveOrHatchTarget", () => {
       "new-one",
       false,
       {},
+      {},
       { setupProviderCredentials: false },
     );
     expect(result).toBe(newEntry);