@cursor/july 0.1.20 → 0.1.21

package/src/internal/update-check.test.ts

@@ -0,0 +1,485 @@
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import {
+  cmdUpdate,
+  compareVersions,
+  detectUpdateCommand,
+  fetchLatestPublishedVersion,
+  readUpdateCheckCache,
+  type UpdateCommand,
+  updateCheckCachePath,
+  warnIfOutdated,
+  writeUpdateCheckCache,
+} from "./update-check.js";
+
+async function makeTempDir(prefix: string): Promise<string> {
+  return mkdtemp(join(tmpdir(), prefix));
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function fetchReturning(version: string): typeof fetch {
+  return vi.fn(async () => jsonResponse({ version }));
+}
+
+describe("compareVersions", () => {
+  it("orders release triples numerically", () => {
+    expect(compareVersions("0.1.3", "0.1.3")).toBe(0);
+    expect(compareVersions("0.1.3", "0.1.4")).toBeLessThan(0);
+    expect(compareVersions("0.1.10", "0.1.9")).toBeGreaterThan(0);
+    expect(compareVersions("0.2.0", "0.10.0")).toBeLessThan(0);
+    expect(compareVersions("1.0.0", "0.99.99")).toBeGreaterThan(0);
+  });
+
+  it("ranks a release above its prereleases", () => {
+    expect(compareVersions("1.0.0-alpha", "1.0.0")).toBeLessThan(0);
+    expect(compareVersions("1.0.0", "1.0.0-rc.1")).toBeGreaterThan(0);
+  });
+
+  it("orders prerelease identifiers per semver", () => {
+    expect(compareVersions("1.0.0-alpha", "1.0.0-alpha.1")).toBeLessThan(0);
+    expect(compareVersions("1.0.0-alpha.2", "1.0.0-alpha.10")).toBeLessThan(0);
+    expect(compareVersions("1.0.0-1", "1.0.0-alpha")).toBeLessThan(0);
+    expect(compareVersions("1.0.0-beta", "1.0.0-alpha")).toBeGreaterThan(0);
+    expect(compareVersions("1.0.0-rc.1", "1.0.0-rc.1")).toBe(0);
+  });
+
+  it("treats unparseable versions as equal (never warns on garbage)", () => {
+    expect(compareVersions("not-a-version", "1.0.0")).toBe(0);
+    expect(compareVersions("1.0.0", "")).toBe(0);
+  });
+
+  it("ignores build metadata and a leading v", () => {
+    expect(compareVersions("v1.2.3", "1.2.3+build.5")).toBe(0);
+  });
+});
+
+describe("fetchLatestPublishedVersion", () => {
+  it("returns the latest dist-tag version", async () => {
+    const fetchImpl = fetchReturning("0.2.0");
+    await expect(fetchLatestPublishedVersion({ fetchImpl })).resolves.toBe(
+      "0.2.0"
+    );
+    expect(fetchImpl).toHaveBeenCalledWith(
+      "https://registry.npmjs.org/@cursor%2Fjuly/latest",
+      expect.anything()
+    );
+  });
+
+  it("returns undefined on non-2xx, bad bodies, and thrown errors", async () => {
+    await expect(
+      fetchLatestPublishedVersion({
+        fetchImpl: async () => jsonResponse({ error: "Not found" }, 404),
+      })
+    ).resolves.toBeUndefined();
+    await expect(
+      fetchLatestPublishedVersion({
+        fetchImpl: async () => jsonResponse({ version: 42 }),
+      })
+    ).resolves.toBeUndefined();
+    await expect(
+      fetchLatestPublishedVersion({
+        fetchImpl: async () => jsonResponse({ version: "not semver" }),
+      })
+    ).resolves.toBeUndefined();
+    await expect(
+      fetchLatestPublishedVersion({
+        fetchImpl: async () => {
+          throw new Error("offline");
+        },
+      })
+    ).resolves.toBeUndefined();
+  });
+});
+
+describe("update-check cache", () => {
+  it("round-trips and survives corrupt files", async () => {
+    const configDir = await makeTempDir("agentkit-update-cache-");
+    await expect(readUpdateCheckCache(configDir)).resolves.toBeUndefined();
+
+    await writeUpdateCheckCache(
+      { checkedAt: 123, latestVersion: "0.2.0" },
+      configDir
+    );
+    await expect(readUpdateCheckCache(configDir)).resolves.toEqual({
+      checkedAt: 123,
+      latestVersion: "0.2.0",
+    });
+
+    await writeFile(updateCheckCachePath(configDir), "not json{");
+    await expect(readUpdateCheckCache(configDir)).resolves.toBeUndefined();
+  });
+});
+
+describe("warnIfOutdated", () => {
+  const NOW = 1_700_000_000_000;
+  const cleanEnv = {};
+
+  it("warns from a fresh cache without touching the network", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    await writeUpdateCheckCache(
+      { checkedAt: NOW - 1000, latestVersion: "0.2.0" },
+      configDir
+    );
+    const fetchImpl = vi.fn();
+    let stderr = "";
+    await warnIfOutdated({
+      currentVersion: "0.1.3",
+      configDir,
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      now: NOW,
+      env: cleanEnv,
+      err: (text) => {
+        stderr += text;
+      },
+      force: true,
+    });
+    expect(fetchImpl).not.toHaveBeenCalled();
+    expect(stderr).toContain("0.1.3 is outdated (latest is 0.2.0)");
+    expect(stderr).toContain("update` to upgrade");
+  });
+
+  it("refreshes a stale cache, then warns and records the lookup", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    await writeUpdateCheckCache(
+      { checkedAt: NOW - 48 * 60 * 60 * 1000, latestVersion: "0.1.3" },
+      configDir
+    );
+    let stderr = "";
+    await warnIfOutdated({
+      currentVersion: "0.1.3",
+      configDir,
+      fetchImpl: fetchReturning("0.3.0"),
+      now: NOW,
+      env: cleanEnv,
+      err: (text) => {
+        stderr += text;
+      },
+      force: true,
+    });
+    expect(stderr).toContain("latest is 0.3.0");
+    await expect(readUpdateCheckCache(configDir)).resolves.toEqual({
+      checkedAt: NOW,
+      latestVersion: "0.3.0",
+    });
+  });
+
+  it("stays quiet when up to date or newer", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    let stderr = "";
+    const err = (text: string): void => {
+      stderr += text;
+    };
+    const base = {
+      configDir,
+      now: NOW,
+      env: cleanEnv,
+      err,
+      force: true,
+    };
+    await warnIfOutdated({
+      ...base,
+      currentVersion: "0.2.0",
+      fetchImpl: fetchReturning("0.2.0"),
+    });
+    await warnIfOutdated({
+      ...base,
+      currentVersion: "0.3.0-dev.1",
+      fetchImpl: fetchReturning("0.2.0"),
+    });
+    expect(stderr).toBe("");
+  });
+
+  it("backs off after a failed lookup instead of retrying every run", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    const failing = vi.fn(async () => {
+      throw new Error("offline");
+    });
+    let stderr = "";
+    const opts = {
+      currentVersion: "0.1.3",
+      configDir,
+      fetchImpl: failing as unknown as typeof fetch,
+      env: cleanEnv,
+      err: (text: string): void => {
+        stderr += text;
+      },
+      force: true,
+    };
+    await warnIfOutdated({ ...opts, now: NOW });
+    expect(stderr).toBe("");
+    expect(failing).toHaveBeenCalledTimes(1);
+    // Second run inside the interval: cache says "checked", no new attempt.
+    await warnIfOutdated({ ...opts, now: NOW + 1000 });
+    expect(failing).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps warning from a stale cached version when the registry is down", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    await writeUpdateCheckCache(
+      { checkedAt: NOW - 48 * 60 * 60 * 1000, latestVersion: "0.2.0" },
+      configDir
+    );
+    let stderr = "";
+    await warnIfOutdated({
+      currentVersion: "0.1.3",
+      configDir,
+      fetchImpl: async () => {
+        throw new Error("offline");
+      },
+      now: NOW,
+      env: cleanEnv,
+      err: (text) => {
+        stderr += text;
+      },
+      force: true,
+    });
+    expect(stderr).toContain("latest is 0.2.0");
+  });
+
+  it("respects CI and the opt-out env vars", async () => {
+    const configDir = await makeTempDir("agentkit-warn-");
+    await writeUpdateCheckCache(
+      { checkedAt: NOW, latestVersion: "9.9.9" },
+      configDir
+    );
+    for (const env of [
+      { CI: "true" },
+      { NO_UPDATE_NOTIFIER: "1" },
+      { AGENT_SERVE_NO_UPDATE_CHECK: "1" },
+    ]) {
+      let stderr = "";
+      await warnIfOutdated({
+        currentVersion: "0.1.3",
+        configDir,
+        now: NOW,
+        env,
+        err: (text) => {
+          stderr += text;
+        },
+        force: true,
+      });
+      expect(stderr).toBe("");
+    }
+  });
+});
+
+describe("detectUpdateCommand", () => {
+  const pkg = "@cursor/july";
+
+  it("recognizes global stores by path shape", async () => {
+    const cases: Array<[string, string]> = [
+      ["/home/u/.local/share/pnpm/global/5/node_modules/@cursor/july", "pnpm"],
+      ["/home/u/.bun/install/global/node_modules/@cursor/july", "bun"],
+      ["/home/u/.config/yarn/global/node_modules/@cursor/july", "yarn"],
+      ["/usr/local/lib/node_modules/@cursor/july", "npm"],
+    ];
+    for (const [packageRoot, cmd] of cases) {
+      const command = await detectUpdateCommand({ packageRoot });
+      expect(command?.cmd).toBe(cmd);
+      expect(command?.args.join(" ")).toContain(`${pkg}@latest`);
+      expect(command?.args.join(" ")).toMatch(/(^|\s)(-g|global)(\s|$)/);
+    }
+  });
+
+  it("refuses npx cache installs", async () => {
+    await expect(
+      detectUpdateCommand({
+        packageRoot: "/home/u/.npm/_npx/abc123/node_modules/@cursor/july",
+      })
+    ).resolves.toBeUndefined();
+  });
+
+  it("upgrades a depending project with its own package manager", async () => {
+    const project = await makeTempDir("agentkit-project-");
+    await writeFile(
+      join(project, "package.json"),
+      JSON.stringify({ name: "my-agent", dependencies: { [pkg]: "^0.1.0" } })
+    );
+    await writeFile(join(project, "pnpm-lock.yaml"), "lockfileVersion: 9\n");
+    const packageRoot = join(project, "node_modules", "@cursor", "july");
+    await mkdir(packageRoot, { recursive: true });
+
+    const command = await detectUpdateCommand({ packageRoot });
+    expect(command).toEqual({
+      cmd: "pnpm",
+      args: ["add", `${pkg}@latest`],
+      cwd: project,
+      reason: `project dependency in ${project}`,
+    });
+  });
+
+  it("falls back to npm for a project without a recognized lockfile", async () => {
+    const project = await makeTempDir("agentkit-project-");
+    await writeFile(
+      join(project, "package.json"),
+      JSON.stringify({ name: "my-agent", devDependencies: { [pkg]: "*" } })
+    );
+    const packageRoot = join(project, "node_modules", "@cursor", "july");
+    await mkdir(packageRoot, { recursive: true });
+
+    const command = await detectUpdateCommand({ packageRoot });
+    expect(command?.cmd).toBe("npm");
+    expect(command?.args).toEqual(["install", `${pkg}@latest`]);
+    expect(command?.cwd).toBe(project);
+  });
+
+  it("finds the project through pnpm's virtual store", async () => {
+    const project = await makeTempDir("agentkit-project-");
+    await writeFile(
+      join(project, "package.json"),
+      JSON.stringify({ name: "my-agent", dependencies: { [pkg]: "^0.1.0" } })
+    );
+    await writeFile(join(project, "pnpm-lock.yaml"), "lockfileVersion: 9\n");
+    // Node resolves the bin through the symlink to the virtual store.
+    const packageRoot = join(
+      project,
+      "node_modules",
+      ".pnpm",
+      "@cursor+july@0.1.3",
+      "node_modules",
+      "@cursor",
+      "july"
+    );
+    await mkdir(packageRoot, { recursive: true });
+    // The virtual-store entry has its own package.json; it must be skipped.
+    await writeFile(
+      join(packageRoot, "package.json"),
+      JSON.stringify({ name: pkg, version: "0.1.3" })
+    );
+
+    const command = await detectUpdateCommand({ packageRoot });
+    expect(command?.cmd).toBe("pnpm");
+    expect(command?.cwd).toBe(project);
+  });
+
+  it("returns undefined for unrecognized layouts", async () => {
+    await expect(
+      detectUpdateCommand({ packageRoot: "/opt/some/copy/of/the/package" })
+    ).resolves.toBeUndefined();
+  });
+});
+
+describe("cmdUpdate", () => {
+  function capture(): {
+    out: (text: string) => void;
+    err: (text: string) => void;
+    stdout: () => string;
+    stderr: () => string;
+  } {
+    let stdout = "";
+    let stderr = "";
+    return {
+      out: (text) => {
+        stdout += text;
+      },
+      err: (text) => {
+        stderr += text;
+      },
+      stdout: () => stdout,
+      stderr: () => stderr,
+    };
+  }
+
+  it("refuses to update a source checkout", async () => {
+    const io = capture();
+    const code = await cmdUpdate({ compiled: false, ...io });
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("source checkout");
+  });
+
+  it("reports already-latest without running anything", async () => {
+    const io = capture();
+    const configDir = await makeTempDir("agentkit-update-");
+    const runCommand = vi.fn();
+    const code = await cmdUpdate({
+      compiled: true,
+      currentVersion: "0.2.0",
+      fetchImpl: fetchReturning("0.2.0"),
+      configDir,
+      runCommand,
+      ...io,
+    });
+    expect(code).toBe(0);
+    expect(runCommand).not.toHaveBeenCalled();
+    expect(io.stdout()).toContain("already the latest version");
+  });
+
+  it("fails cleanly when the registry is unreachable", async () => {
+    const io = capture();
+    const code = await cmdUpdate({
+      compiled: true,
+      currentVersion: "0.1.3",
+      fetchImpl: async () => {
+        throw new Error("offline");
+      },
+      ...io,
+    });
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("Could not reach the npm registry");
+  });
+
+  it("runs the detected command and refreshes the warning cache", async () => {
+    const io = capture();
+    const configDir = await makeTempDir("agentkit-update-");
+    const ran: UpdateCommand[] = [];
+    const code = await cmdUpdate({
+      compiled: true,
+      currentVersion: "0.1.3",
+      fetchImpl: fetchReturning("0.2.0"),
+      packageRoot: "/usr/local/lib/node_modules/@cursor/july",
+      configDir,
+      runCommand: async (command) => {
+        ran.push(command);
+        return 0;
+      },
+      ...io,
+    });
+    expect(code).toBe(0);
+    expect(ran).toHaveLength(1);
+    expect(ran[0]?.cmd).toBe("npm");
+    expect(ran[0]?.args).toEqual(["install", "-g", "@cursor/july@latest"]);
+    expect(io.stderr()).toContain("npm install -g @cursor/july@latest");
+    expect(io.stdout()).toContain("Updated");
+    // The next run must not keep warning about 0.2.0.
+    const cache = JSON.parse(
+      await readFile(updateCheckCachePath(configDir), "utf8")
+    ) as { latestVersion?: string };
+    expect(cache.latestVersion).toBe("0.2.0");
+  });
+
+  it("propagates a failing install command's exit code", async () => {
+    const io = capture();
+    const code = await cmdUpdate({
+      compiled: true,
+      currentVersion: "0.1.3",
+      fetchImpl: fetchReturning("0.2.0"),
+      packageRoot: "/usr/local/lib/node_modules/@cursor/july",
+      configDir: await makeTempDir("agentkit-update-"),
+      runCommand: async () => 7,
+      ...io,
+    });
+    expect(code).toBe(7);
+    expect(io.stderr()).toContain("exited with code 7");
+  });
+
+  it("prints manual instructions for unrecognized layouts", async () => {
+    const io = capture();
+    const code = await cmdUpdate({
+      compiled: true,
+      currentVersion: "0.1.3",
+      fetchImpl: fetchReturning("0.2.0"),
+      packageRoot: "/opt/some/copy/of/the/package",
+      ...io,
+    });
+    expect(code).toBe(1);
+    expect(io.stderr()).toContain("npm install -g @cursor/july@latest");
+  });
+});

package/src/internal/workspace.test.ts

@@ -0,0 +1,81 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  buildIdentityPreamble,
+  isNestedInGitRepo,
+  withIdentityPreamble,
+} from "./workspace.js";
+
+describe("buildIdentityPreamble", () => {
+  it("names the agent for the model", () => {
+    expect(buildIdentityPreamble("Benny")).toBe(
+      "You are Benny. That is your name; use it when people ask who you are."
+    );
+  });
+
+  it("returns empty for blank names", () => {
+    expect(buildIdentityPreamble("")).toBe("");
+    expect(buildIdentityPreamble("   ")).toBe("");
+  });
+});
+
+describe("withIdentityPreamble", () => {
+  it("prepends identity to authored instructions", () => {
+    expect(
+      withIdentityPreamble("Approval Buddy", "Stamp PRs for the crew.")
+    ).toBe(
+      [
+        "You are Approval Buddy. That is your name; use it when people ask who you are.",
+        "Stamp PRs for the crew.",
+      ].join("\n\n")
+    );
+  });
+
+  it("returns identity alone when instructions are missing", () => {
+    expect(withIdentityPreamble("Weatherbot", undefined)).toBe(
+      "You are Weatherbot. That is your name; use it when people ask who you are."
+    );
+  });
+
+  it("returns undefined when both name and instructions are blank", () => {
+    expect(withIdentityPreamble("", undefined)).toBeUndefined();
+    expect(withIdentityPreamble("   ", "  ")).toBeUndefined();
+  });
+});
+
+describe("isNestedInGitRepo", () => {
+  const cleanups: Array<() => Promise<void>> = [];
+
+  afterEach(async () => {
+    while (cleanups.length > 0) {
+      await cleanups.pop()?.();
+    }
+  });
+
+  async function makeTempDir(): Promise<string> {
+    const dir = await mkdtemp(join(tmpdir(), "agent-serve-git-nesting-"));
+    cleanups.push(() => rm(dir, { recursive: true, force: true }));
+    return dir;
+  }
+
+  it("is true for a workspace below a git root", async () => {
+    const repo = await makeTempDir();
+    await mkdir(join(repo, ".git"));
+    const workspace = join(repo, "state", "harness", "ses_1");
+    await mkdir(workspace, { recursive: true });
+    expect(await isNestedInGitRepo(workspace)).toBe(true);
+  });
+
+  it("is false when the workspace is itself the git root", async () => {
+    const repo = await makeTempDir();
+    await mkdir(join(repo, ".git"));
+    expect(await isNestedInGitRepo(repo)).toBe(false);
+  });
+
+  it("is false outside any git repo", async () => {
+    const dir = await makeTempDir();
+    expect(await isNestedInGitRepo(dir)).toBe(false);
+  });
+});

package/src/storage-backends/cursor-hosted.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { defineStorage, type StorageContext } from "../storage.js";
+import {
+  AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR,
+  AGENT_SERVE_HOSTED_STORAGE_DATABASE_URL_ENV_VAR,
+  CURSOR_HOSTED_STORAGE,
+  CURSOR_HOSTED_STORAGE_ENV_VARS,
+  cursorHostedStorage,
+  isCursorHostedStorage,
+} from "./cursor-hosted.js";
+
+const storageCtx: StorageContext = {
+  agentName: "test-agent",
+  projectRoot: "/tmp/test-agent",
+  reason: "policy",
+};
+
+describe("cursorHostedStorage", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("exports the platform-managed env names", () => {
+    expect(AGENT_SERVE_HOSTED_STORAGE_DATABASE_URL_ENV_VAR).toBe(
+      "BUGBOTDB_URL"
+    );
+    expect(AGENT_SERVE_DEPLOYMENT_ID_ENV_VAR).toBe("AGENT_SERVE_DEPLOYMENT_ID");
+    expect(CURSOR_HOSTED_STORAGE_ENV_VARS).toEqual([
+      "BUGBOTDB_URL",
+      "AGENT_SERVE_DEPLOYMENT_ID",
+    ]);
+  });
+
+  it("requires CURSOR_API_KEY", async () => {
+    vi.stubEnv("CURSOR_API_KEY", "");
+    const methods = cursorHostedStorage({
+      baseUrl: "https://api.cursor.com",
+    });
+    await expect(methods.put("k", 1, storageCtx)).rejects.toThrow(
+      /CURSOR_API_KEY/
+    );
+  });
+
+  it("calls the control-plane storage proxy with the pod credential", async () => {
+    const fetchMock = vi.fn(
+      async (input: RequestInfo | URL, init?: RequestInit) => {
+        expect(String(input)).toBe(
+          "https://api.cursor.com/internal/agent-serve/storage/kv/put"
+        );
+        expect(init?.method).toBe("POST");
+        expect(init?.headers).toMatchObject({
+          Authorization: "Bearer key_pod",
+          "Content-Type": "application/json",
+        });
+        expect(JSON.parse(String(init?.body))).toEqual({
+          key: "session/1",
+          value: { ok: true },
+        });
+        return new Response(JSON.stringify({ ok: true }), { status: 200 });
+      }
+    );
+
+    const methods = cursorHostedStorage({
+      baseUrl: "https://api.cursor.com",
+      apiKey: "key_pod",
+      fetch: fetchMock as typeof fetch,
+    });
+
+    await methods.put("session/1", { ok: true }, storageCtx);
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
+
+  it("maps get misses to undefined", async () => {
+    const methods = cursorHostedStorage({
+      baseUrl: "https://api.cursor.com",
+      apiKey: "key_pod",
+      fetch: (async () =>
+        new Response(JSON.stringify({ found: false, value: null }), {
+          status: 200,
+        })) as typeof fetch,
+    });
+    await expect(methods.get("missing", storageCtx)).resolves.toBeUndefined();
+  });
+
+  it("exposes evals and abs surfaces", () => {
+    const methods = cursorHostedStorage({
+      baseUrl: "https://api.cursor.com",
+      apiKey: "key_pod",
+      fetch: (async () =>
+        new Response(JSON.stringify({ ok: true }), {
+          status: 200,
+        })) as typeof fetch,
+    });
+    expect(typeof methods.evals.put).toBe("function");
+    expect(typeof methods.abs.putSample).toBe("function");
+    expect(typeof methods.abs.getSnapshot).toBe("function");
+  });
+
+  it("marks the sink so defineStorage preserves cursor-hosted detection", () => {
+    const methods = cursorHostedStorage({
+      baseUrl: "https://api.cursor.com",
+      apiKey: "key_pod",
+      fetch: (async () =>
+        new Response(JSON.stringify({ ok: true }), {
+          status: 200,
+        })) as typeof fetch,
+    });
+    expect(methods[CURSOR_HOSTED_STORAGE]).toBe(true);
+    expect(isCursorHostedStorage(methods)).toBe(true);
+    expect(
+      isCursorHostedStorage(
+        defineStorage({
+          name: "cursor-hosted",
+          ...methods,
+        })
+      )
+    ).toBe(true);
+    expect(isCursorHostedStorage(defineStorage({ put: () => {} }))).toBe(false);
+  });
+});

package/src/types.ts

@@ -693,6 +693,18 @@ export function cursorAccountServersHasMixedWildcard(
   return trimmed.includes("*") && trimmed.some((server) => server !== "*");
 }
 
+/**
+ * True for an HTTP/SSE transport authorized with host PKCE OAuth
+ * (`defineConnection({ url, oauth: true })`). The tokens live on the serve
+ * host (`mcp-auth.json` / `MCP_OAUTH_*`), so only host-side MCP clients can
+ * use them.
+ */
+export function isHostOauthConnectionTransport(
+  transport: ConnectionTransport
+): boolean {
+  return "url" in transport && transport.oauth === true;
+}
+
 /**
  * True for transports that stay symbolic at discovery time and are resolved
  * by the serve host once it is listening (peers and the Cursor account