@cursor/july 0.1.23 → 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,207 +0,0 @@
-import {
-  lstat,
-  mkdir,
-  mkdtemp,
-  readlink,
-  rm,
-  writeFile,
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import type { ResolvedAgent } from "../types.js";
-import {
-  buildIdentityPreamble,
-  isNestedInGitRepo,
-  materializeWorkspace,
-  withIdentityPreamble,
-  writeWorkspaceFiles,
-} 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);
-  });
-});
-
-describe("materializeWorkspace memory link", () => {
-  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-workspace-"));
-    cleanups.push(() => rm(dir, { recursive: true, force: true }));
-    return dir;
-  }
-
-  const agent: ResolvedAgent = {
-    name: "test-agent",
-    runtime: "local",
-    tools: [],
-    skills: [],
-    connections: [],
-    subagents: [],
-    seedFiles: [],
-  };
-
-  it("symlinks <stateRoot>/memory into the workspace", async () => {
-    const root = await makeTempDir();
-    const workspaceDir = join(root, "workspace");
-    const stateRoot = join(root, "state");
-    await materializeWorkspace({ agent, workspaceDir, seed: true, stateRoot });
-
-    const link = join(workspaceDir, "memory");
-    expect((await lstat(link)).isSymbolicLink()).toBe(true);
-    expect(await readlink(link)).toBe(join(stateRoot, "memory"));
-    // The target directory is created eagerly so first sessions can read it.
-    expect((await lstat(join(stateRoot, "memory"))).isDirectory()).toBe(true);
-  });
-
-  it("is idempotent and leaves an existing memory entry alone", async () => {
-    const root = await makeTempDir();
-    const workspaceDir = join(root, "workspace");
-    const stateRoot = join(root, "state");
-    await mkdir(workspaceDir, { recursive: true });
-    await writeFile(join(workspaceDir, "memory"), "not a link", "utf8");
-
-    await materializeWorkspace({ agent, workspaceDir, seed: true, stateRoot });
-    await materializeWorkspace({ agent, workspaceDir, seed: false, stateRoot });
-
-    expect((await lstat(join(workspaceDir, "memory"))).isFile()).toBe(true);
-  });
-
-  it("re-points a stale link when the state root moved", async () => {
-    const root = await makeTempDir();
-    const workspaceDir = join(root, "workspace");
-    await materializeWorkspace({
-      agent,
-      workspaceDir,
-      seed: true,
-      stateRoot: join(root, "old-state"),
-    });
-    const stateRoot = join(root, "new-state");
-    await materializeWorkspace({ agent, workspaceDir, seed: true, stateRoot });
-
-    expect(await readlink(join(workspaceDir, "memory"))).toBe(
-      join(stateRoot, "memory")
-    );
-  });
-
-  it("refuses workspace writes into the reserved memory path", async () => {
-    const root = await makeTempDir();
-    const workspaceDir = join(root, "workspace");
-    const stateRoot = join(root, "state");
-    await materializeWorkspace({ agent, workspaceDir, seed: true, stateRoot });
-
-    await expect(
-      writeWorkspaceFiles(workspaceDir, {
-        "memory/journal.jsonl": "poisoned",
-      })
-    ).rejects.toThrow(/reserved/);
-    await expect(
-      writeWorkspaceFiles(workspaceDir, { memory: "clobbered" })
-    ).rejects.toThrow(/reserved/);
-    // Normalized relatives must not slip past the reservation.
-    await expect(
-      writeWorkspaceFiles(workspaceDir, { "./memory/x": "poisoned" })
-    ).rejects.toThrow(/reserved/);
-    await expect(
-      writeWorkspaceFiles(workspaceDir, { "foo/../memory/x": "poisoned" })
-    ).rejects.toThrow(/reserved/);
-
-    await expect(
-      materializeWorkspace({
-        agent: {
-          ...agent,
-          seedFiles: [
-            { relativePath: "memory/seed.txt", sourcePath: "/dev/null" },
-          ],
-        },
-        workspaceDir,
-        seed: true,
-        stateRoot,
-      })
-    ).rejects.toThrow(/reserved/);
-  });
-
-  it("only links on seed turns", async () => {
-    const root = await makeTempDir();
-    const workspaceDir = join(root, "workspace");
-    const stateRoot = join(root, "state");
-    await materializeWorkspace({ agent, workspaceDir, seed: false, stateRoot });
-    await expect(lstat(join(workspaceDir, "memory"))).rejects.toMatchObject({
-      code: "ENOENT",
-    });
-  });
-});