@cursor/july 0.1.22 → 0.1.24

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

@@ -1,485 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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);
-  });
-});