@cursor/july 0.1.26 → 0.1.28

package/src/internal/discovery.artifact-tool.test.ts

@@ -1,136 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineArtifacts } from "../artifacts.js";
-import { defineAgent } from "../index.js";
-import { defineTool } from "../tools.js";
-import type { AgentConfig, ArtifactsConfig } from "../types.js";
-import { loadAgentProject, projectInfo } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-const TAGGABLE: ArtifactsConfig = {
-  kinds: {
-    "reviewed-pr": { description: "A reviewed PR." },
-    report: { description: "A report." },
-  },
-  agentTool: true,
-};
-
-async function scaffold(options: {
-  agent?: AgentConfig;
-  artifacts?: ArtifactsConfig;
-  authoredTools?: string[];
-}) {
-  const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-artifact-tool-"));
-  cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-  const agentDir = join(rootDir, "agent");
-  await mkdir(agentDir, { recursive: true });
-  await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-  await writeFile(join(agentDir, "instructions.md"), "Be brief.\n");
-  if (options.artifacts !== undefined) {
-    await writeFile(join(agentDir, "artifacts.ts"), "export default {};\n");
-  }
-  for (const name of options.authoredTools ?? []) {
-    await mkdir(join(agentDir, "tools"), { recursive: true });
-    await writeFile(
-      join(agentDir, "tools", `${name}.ts`),
-      "export default {};\n"
-    );
-  }
-  return loadAgentProject(rootDir, {
-    importModule: async (path) => {
-      if (path.endsWith("artifacts.ts")) {
-        return { default: defineArtifacts(options.artifacts ?? {}) };
-      }
-      if (path.includes(join("agent", "tools"))) {
-        return {
-          default: defineTool({
-            description: "Authored tool.",
-            execute: () => "authored",
-          }),
-        };
-      }
-      return { default: defineAgent(options.agent ?? {}) };
-    },
-  });
-}
-
-describe("loadAgentProject tag_artifact built-in", () => {
-  it("materializes tag_artifact when agentTool is true", async () => {
-    const project = await scaffold({ artifacts: TAGGABLE });
-    const tool = project.agent.tools.find((t) => t.name === "tag_artifact");
-    expect(tool).toMatchObject({
-      name: "tag_artifact",
-      execution: "server",
-      needsApproval: false,
-    });
-    expect(tool?.description).toContain("- reviewed-pr: A reviewed PR.");
-    expect(project.diagnostics).toEqual([]);
-
-    // Info/manifest surface it exactly like authored tools.
-    const info = projectInfo(project);
-    const infoTool = info.tools.find((t) => t.name === "tag_artifact");
-    expect(infoTool?.execution).toBe("server");
-    expect(infoTool?.inputSchema).toBeDefined();
-    expect(info.artifacts?.agentTool).toBe(true);
-  });
-
-  it("stays absent without agentTool", async () => {
-    const withoutFlag = await scaffold({
-      artifacts: { kinds: { report: { description: "A report." } } },
-    });
-    expect(withoutFlag.agent.tools.some((t) => t.name === "tag_artifact")).toBe(
-      false
-    );
-
-    const unauthored = await scaffold({});
-    expect(unauthored.agent.tools.some((t) => t.name === "tag_artifact")).toBe(
-      false
-    );
-  });
-
-  it("skips the tool on cloud runtime, with a warning", async () => {
-    const project = await scaffold({
-      agent: {
-        runtime: "cloud",
-        cloud: { repos: [{ url: "https://github.com/org/repo" }] },
-      },
-      artifacts: TAGGABLE,
-    });
-    expect(project.agent.tools.some((t) => t.name === "tag_artifact")).toBe(
-      false
-    );
-    expect(
-      project.diagnostics.some(
-        (d) =>
-          d.severity === "warning" &&
-          d.message.includes("tag_artifact") &&
-          d.message.includes("not available on cloud agents")
-      )
-    ).toBe(true);
-  });
-
-  it("lets an authored tag_artifact shadow the built-in, with a warning", async () => {
-    const project = await scaffold({
-      artifacts: TAGGABLE,
-      authoredTools: ["tag_artifact"],
-    });
-    const tools = project.agent.tools.filter((t) => t.name === "tag_artifact");
-    expect(tools).toHaveLength(1);
-    expect(tools[0]?.description).toBe("Authored tool.");
-    expect(project.diagnostics).toEqual([
-      expect.objectContaining({
-        severity: "warning",
-        message: expect.stringContaining("shadows the built-in tool"),
-      }),
-    ]);
-  });
-});

package/src/internal/discovery.artifacts.test.ts

@@ -1,119 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineArtifacts } from "../artifacts.js";
-import { defineAgent } from "../index.js";
-import type { ArtifactsConfig } from "../types.js";
-import { loadAgentProject, projectInfo } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function scaffold(options: {
-  artifacts?: ArtifactsConfig;
-  subagentArtifacts?: boolean;
-}) {
-  const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-artifacts-disc-"));
-  cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-  const agentDir = join(rootDir, "agent");
-  await mkdir(agentDir, { recursive: true });
-  await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-  await writeFile(join(agentDir, "instructions.md"), "Be brief.\n");
-  if (options.artifacts !== undefined) {
-    await writeFile(join(agentDir, "artifacts.ts"), "export default {};\n");
-  }
-  if (options.subagentArtifacts === true) {
-    const subagentDir = join(agentDir, "subagents", "helper");
-    await mkdir(subagentDir, { recursive: true });
-    await writeFile(join(subagentDir, "agent.ts"), "export default {};\n");
-    await writeFile(join(subagentDir, "instructions.md"), "Help.\n");
-    await writeFile(join(subagentDir, "artifacts.ts"), "export default {};\n");
-  }
-  return loadAgentProject(rootDir, {
-    importModule: async (path) => {
-      if (path.endsWith("artifacts.ts")) {
-        return { default: defineArtifacts(options.artifacts ?? {}) };
-      }
-      if (path.includes("subagents")) {
-        return { default: defineAgent({ description: "Helper." }) };
-      }
-      return { default: defineAgent({}) };
-    },
-  });
-}
-
-describe("loadAgentProject artifacts", () => {
-  it("discovers agent/artifacts.ts and surfaces it on the manifest and info", async () => {
-    const project = await scaffold({
-      artifacts: {
-        kinds: {
-          "reviewed-pr": { description: "A reviewed PR." },
-          report: { description: "A report." },
-        },
-        max: 50,
-      },
-    });
-    expect(project.artifacts).toBeDefined();
-    expect(project.diagnostics).toEqual([]);
-    expect(projectInfo(project).artifacts).toEqual({
-      kinds: ["reviewed-pr", "report"],
-      agentTool: false,
-      max: 50,
-    });
-  });
-
-  it("defaults max to 1000 on info and stays absent when unauthored", async () => {
-    const withDefaults = await scaffold({ artifacts: { kinds: {} } });
-    expect(projectInfo(withDefaults).artifacts).toEqual({
-      kinds: [],
-      agentTool: false,
-      max: 1000,
-    });
-
-    const without = await scaffold({});
-    expect(without.artifacts).toBeUndefined();
-    expect(projectInfo(without).artifacts).toBeUndefined();
-  });
-
-  it("errors when agentTool is set without declared kinds", async () => {
-    const project = await scaffold({ artifacts: { agentTool: true } });
-    expect(project.diagnostics).toEqual([
-      expect.objectContaining({
-        severity: "error",
-        message: expect.stringContaining(
-          "the tag_artifact tool needs at least one declared kind"
-        ),
-      }),
-    ]);
-  });
-
-  it("accepts agentTool with at least one kind (schema optional)", async () => {
-    const project = await scaffold({
-      artifacts: {
-        kinds: { note: { description: "A note." } },
-        agentTool: true,
-      },
-    });
-    expect(project.diagnostics).toEqual([]);
-    expect(projectInfo(project).artifacts?.agentTool).toBe(true);
-  });
-
-  it("warns and ignores artifacts on subagents", async () => {
-    const project = await scaffold({ subagentArtifacts: true });
-    expect(project.diagnostics).toEqual([
-      expect.objectContaining({
-        severity: "warning",
-        message: expect.stringContaining(
-          "artifacts are not supported on subagents"
-        ),
-      }),
-    ]);
-    expect(project.artifacts).toBeUndefined();
-  });
-});

package/src/internal/discovery.builtin-tools.test.ts

@@ -1,94 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineAgent } from "../index.js";
-import { defineTool } from "../tools.js";
-import type { AgentConfig } from "../types.js";
-import { loadAgentProject } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function scaffold(config: AgentConfig, authoredTools: string[] = []) {
-  const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-builtin-disc-"));
-  cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-  const agentDir = join(rootDir, "agent");
-  await mkdir(agentDir, { recursive: true });
-  await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-  await writeFile(join(agentDir, "instructions.md"), "Be brief.\n");
-  for (const name of authoredTools) {
-    await mkdir(join(agentDir, "tools"), { recursive: true });
-    await writeFile(
-      join(agentDir, "tools", `${name}.ts`),
-      "export default {};\n"
-    );
-  }
-  return loadAgentProject(rootDir, {
-    importModule: async (path) => {
-      if (path.endsWith(join("agent", "agent.ts"))) {
-        return { default: defineAgent(config) };
-      }
-      return {
-        default: defineTool({
-          description: "Authored tool.",
-          execute: () => "authored",
-        }),
-      };
-    },
-  });
-}
-
-describe("loadAgentProject builtinTools", () => {
-  it("materializes reminder tools as server tools", async () => {
-    const project = await scaffold({ builtinTools: { reminders: true } });
-    const names = project.agent.tools.map((t) => t.name);
-    expect(names).toEqual([
-      "reminders_create",
-      "reminders_list",
-      "reminders_cancel",
-    ]);
-    expect(project.agent.tools.every((t) => t.execution === "server")).toBe(
-      true
-    );
-    expect(project.diagnostics).toEqual([]);
-  });
-
-  it("lets authored tools shadow built-ins, with a warning", async () => {
-    const project = await scaffold({ builtinTools: { reminders: true } }, [
-      "reminders_create",
-    ]);
-    const create = project.agent.tools.find(
-      (t) => t.name === "reminders_create"
-    );
-    expect(create?.description).toBe("Authored tool.");
-    expect(
-      project.agent.tools.filter((t) => t.name === "reminders_create")
-    ).toHaveLength(1);
-    expect(project.diagnostics).toEqual([
-      expect.objectContaining({
-        severity: "warning",
-        message: expect.stringContaining("shadows the built-in tool"),
-      }),
-    ]);
-  });
-
-  it("skips built-ins on cloud runtime, with a warning", async () => {
-    const project = await scaffold({
-      runtime: "cloud",
-      cloud: { repos: [{ url: "https://github.com/org/repo" }] },
-      builtinTools: { reminders: true },
-    });
-    expect(project.agent.tools).toEqual([]);
-    expect(
-      project.diagnostics.some((d) =>
-        d.message.includes("builtinTools are in-process server tools")
-      )
-    ).toBe(true);
-  });
-});

package/src/internal/discovery.concurrency.test.ts

@@ -1,60 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineAgent } from "../index.js";
-import type { AgentConcurrencyOptions } from "../types.js";
-import { loadAgentProject, projectInfo } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function loadWithConcurrency(concurrency: AgentConcurrencyOptions) {
-  const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-conc-disc-"));
-  cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-  const agentDir = join(rootDir, "agent");
-  await mkdir(agentDir, { recursive: true });
-  await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-  await writeFile(join(agentDir, "instructions.md"), "hi\n");
-  return loadAgentProject(rootDir, {
-    importModule: async () => ({
-      default: defineAgent({ model: "composer-2.5", concurrency }),
-    }),
-  });
-}
-
-describe("loadAgentProject concurrency", () => {
-  it("resolves the concurrency block and surfaces it in projectInfo", async () => {
-    const project = await loadWithConcurrency({ maxRunningTurns: 3 });
-    expect(project.diagnostics).toEqual([]);
-    expect(project.agent.concurrency).toEqual({ maxRunningTurns: 3 });
-    expect(projectInfo(project).concurrency).toEqual({ maxRunningTurns: 3 });
-  });
-
-  it("rejects a non-positive maxRunningTurns with an error diagnostic", async () => {
-    const project = await loadWithConcurrency({ maxRunningTurns: 0 });
-    expect(project.agent.concurrency).toBeUndefined();
-    expect(
-      project.diagnostics.some(
-        (d) =>
-          d.severity === "error" &&
-          d.message.includes("concurrency.maxRunningTurns")
-      )
-    ).toBe(true);
-  });
-
-  it("rejects a maxRunningTurns above the hard limit", async () => {
-    const project = await loadWithConcurrency({ maxRunningTurns: 10_000 });
-    expect(project.agent.concurrency).toBeUndefined();
-    expect(
-      project.diagnostics.some(
-        (d) => d.severity === "error" && d.message.includes("hard limit")
-      )
-    ).toBe(true);
-  });
-});

package/src/internal/discovery.cursor-account.test.ts

@@ -1,133 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineConnection } from "../connections.js";
-import { defineAgent } from "../index.js";
-import { loadAgentProject } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function loadWithCursorAccountConnection(
-  connectionSource: string
-): Promise<Awaited<ReturnType<typeof loadAgentProject>>> {
-  const rootDir = await mkdtemp(
-    join(tmpdir(), "agent-serve-cursor-account-disc-")
-  );
-  cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-  const agentDir = join(rootDir, "agent");
-  const connectionsDir = join(agentDir, "mcp-connections");
-  await mkdir(connectionsDir, { recursive: true });
-  await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-  await writeFile(join(agentDir, "instructions.md"), "hi\n");
-  await writeFile(join(connectionsDir, "cursor.ts"), connectionSource);
-  return loadAgentProject(rootDir, {
-    importModule: async (absolutePath) => {
-      if (absolutePath.endsWith(`${join("mcp-connections", "cursor.ts")}`)) {
-        // Evaluate the authored source shape without a full TS transpile.
-        if (connectionSource.includes('servers: ["*", "Linear"]')) {
-          return {
-            default: defineConnection({
-              cursorAccount: true,
-              servers: ["*", "Linear"],
-            }),
-          };
-        }
-        if (connectionSource.includes('servers: "*"')) {
-          return {
-            default: defineConnection({
-              cursorAccount: true,
-              servers: "*",
-            }),
-          };
-        }
-        if (connectionSource.includes('servers: ["*"]')) {
-          return {
-            default: defineConnection({
-              cursorAccount: true,
-              servers: ["*"],
-            }),
-          };
-        }
-        if (connectionSource.includes("servers: []")) {
-          return {
-            default: defineConnection({
-              cursorAccount: true,
-              servers: [],
-            }),
-          };
-        }
-        return {
-          default: defineConnection({ cursorAccount: true }),
-        };
-      }
-      return { default: defineAgent({ model: "composer-2.5" }) };
-    },
-  });
-}
-
-describe("loadAgentProject cursorAccount servers", () => {
-  it("omits servers when forwarding every account connector", async () => {
-    const project = await loadWithCursorAccountConnection(
-      `export default { cursorAccount: true };\n`
-    );
-    expect(project.diagnostics).toEqual([]);
-    expect(project.agent.connections).toEqual([
-      { name: "cursor", transport: { cursorAccount: true } },
-    ]);
-  });
-
-  it('normalizes servers: "*" to every connected server', async () => {
-    const project = await loadWithCursorAccountConnection(
-      `export default { cursorAccount: true, servers: "*" };\n`
-    );
-    expect(project.diagnostics).toEqual([]);
-    expect(project.agent.connections[0]?.transport).toEqual({
-      cursorAccount: true,
-    });
-  });
-
-  it('normalizes servers: ["*"] to every connected server', async () => {
-    const project = await loadWithCursorAccountConnection(
-      `export default { cursorAccount: true, servers: ["*"] };\n`
-    );
-    expect(project.diagnostics).toEqual([]);
-    expect(project.agent.connections[0]?.transport).toEqual({
-      cursorAccount: true,
-    });
-  });
-
-  it("rejects an empty servers allowlist", async () => {
-    const project = await loadWithCursorAccountConnection(
-      `export default { cursorAccount: true, servers: [] };\n`
-    );
-    expect(project.agent.connections).toEqual([]);
-    expect(
-      project.diagnostics.some(
-        (d) =>
-          d.severity === "error" &&
-          d.message.includes("non-empty list of connector names")
-      )
-    ).toBe(true);
-  });
-
-  it('rejects mixing "*" with concrete connector names', async () => {
-    const project = await loadWithCursorAccountConnection(
-      `export default { cursorAccount: true, servers: ["*", "Linear"] };\n`
-    );
-    expect(project.agent.connections).toEqual([]);
-    expect(
-      project.diagnostics.some(
-        (d) =>
-          d.severity === "error" &&
-          d.message.includes('cannot mix `"*"` with connector names')
-      )
-    ).toBe(true);
-  });
-});

package/src/internal/discovery.cwd.test.ts

@@ -1,83 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defineAgent } from "../index.js";
-import { loadAgentProject } from "./discovery.js";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-describe("loadAgentProject cwd", () => {
-  it("resolves relative cwd against the project root and keeps absolute cwd", async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-cwd-disc-"));
-    cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-    const agentDir = join(rootDir, "agent");
-    await mkdir(agentDir, { recursive: true });
-    await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-    await writeFile(join(agentDir, "instructions.md"), "hi\n");
-
-    const relative = await loadAgentProject(rootDir, {
-      importModule: async () => ({
-        default: defineAgent({
-          model: "composer-2.5",
-          local: { cwd: "./harness-out" },
-        }),
-      }),
-    });
-    expect(relative.agent.local?.cwd).toBe(join(rootDir, "harness-out"));
-
-    const absolutePath = join(tmpdir(), "agent-serve-abs-cwd");
-    const absolute = await loadAgentProject(rootDir, {
-      importModule: async () => ({
-        default: defineAgent({
-          model: "composer-2.5",
-          local: { cwd: absolutePath },
-        }),
-      }),
-    });
-    expect(absolute.agent.local?.cwd).toBe(absolutePath);
-  });
-
-  it("resolves workspaceDir the same way and warns when cwd is also set", async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), "agent-serve-ws-disc-"));
-    cleanups.push(() => rm(rootDir, { recursive: true, force: true }));
-    const agentDir = join(rootDir, "agent");
-    await mkdir(agentDir, { recursive: true });
-    await writeFile(join(agentDir, "agent.ts"), "export default {};\n");
-    await writeFile(join(agentDir, "instructions.md"), "hi\n");
-
-    const pinned = await loadAgentProject(rootDir, {
-      importModule: async () => ({
-        default: defineAgent({
-          model: "composer-2.5",
-          local: { workspaceDir: "./checkout" },
-        }),
-      }),
-    });
-    expect(pinned.agent.local?.workspaceDir).toBe(join(rootDir, "checkout"));
-    expect(pinned.agent.local?.cwd).toBeUndefined();
-    expect(pinned.diagnostics).toEqual([]);
-
-    const both = await loadAgentProject(rootDir, {
-      importModule: async () => ({
-        default: defineAgent({
-          model: "composer-2.5",
-          local: { cwd: "./harness-out", workspaceDir: "./checkout" },
-        }),
-      }),
-    });
-    expect(both.agent.local?.workspaceDir).toBe(join(rootDir, "checkout"));
-    expect(both.diagnostics).toContainEqual(
-      expect.objectContaining({
-        severity: "warning",
-        message: expect.stringContaining("local.cwd is unused"),
-      })
-    );
-  });
-});