@cursor/july 0.1.26 → 0.1.28

package/src/internal/approvals.integration.test.ts

@@ -1,383 +0,0 @@
-/**
- * Integration: mock AgentRunner parks on needsApproval; resolve unblocks.
- */
-
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { httpChannel } from "../channels.js";
-import { defineTool } from "../tools.js";
-import type { AgentProject, RunnerTurnRequest, ToolContext } from "../types.js";
-import type { AgentRunner } from "./sdk-runner.js";
-import { SessionAuthError, SessionEngine } from "./session-engine.js";
-
-function makeHitlProject(executeFlag: { called: boolean }): AgentProject {
-  const definition = defineTool({
-    description: "A risky tool that needs approval",
-    needsApproval: true,
-    async execute(input: { note?: string }, _ctx: ToolContext) {
-      executeFlag.called = true;
-      return { ok: true, note: input.note ?? "" };
-    },
-  });
-
-  return {
-    rootDir: "/tmp/hitl-fixture",
-    agentDir: "/tmp/hitl-fixture/agent",
-    name: "hitl-fixture",
-    agent: {
-      name: "hitl-fixture",
-      runtime: "local",
-      tools: [
-        {
-          name: "risky_action",
-          description: definition.description,
-          execution: "server",
-          needsApproval: true,
-          inputSchema: {
-            type: "object",
-            properties: { note: { type: "string" } },
-            additionalProperties: false,
-          },
-          definition,
-        },
-      ],
-      skills: [],
-      connections: [],
-      subagents: [],
-      seedFiles: [],
-    },
-    httpChannel: httpChannel(),
-    channels: [],
-    schedules: [],
-    hooks: [],
-    abs: [],
-    diagnostics: [],
-  };
-}
-
-describe("human-in-the-loop approvals (integration)", () => {
-  let stateRoot: string | undefined;
-
-  afterEach(async () => {
-    if (stateRoot !== undefined) {
-      await rm(stateRoot, { recursive: true, force: true });
-      stateRoot = undefined;
-    }
-  });
-
-  it("parks risky_action until approve, then finishes the turn", async () => {
-    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-hitl-"));
-    const executeFlag = { called: false };
-    const project = makeHitlProject(executeFlag);
-
-    const runner: AgentRunner = {
-      async runTurn(request: RunnerTurnRequest) {
-        const tool = request.customTools.risky_action;
-        if (tool === undefined) {
-          throw new Error("risky_action not registered");
-        }
-        const result = await tool.execute(
-          { note: "ship it" },
-          { toolCallId: "call_alert_1" }
-        );
-        expect(result).toMatchObject({ ok: true, note: "ship it" });
-        return {
-          status: "finished",
-          result: "done",
-        };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project,
-      stateRoot,
-      runner,
-    });
-
-    const auth = {
-      authenticator: "local-dev",
-      principalId: "loopback",
-      principalType: "user" as const,
-    };
-
-    const sessionPromise = engine.send("http", "please run risky action", {
-      auth,
-    });
-
-    let callId: string | undefined;
-    let sessionId: string | undefined;
-    for (let i = 0; i < 100; i++) {
-      const sessions = await engine.sessions.list();
-      if (sessions.length > 0) {
-        sessionId = sessions[0]!.sessionId;
-        const pending = await engine.listPendingApprovals(sessionId);
-        if (pending.length > 0) {
-          callId = pending[0]!.callId;
-          break;
-        }
-      }
-      await new Promise((r) => setTimeout(r, 20));
-    }
-
-    expect(sessionId).toBeDefined();
-    expect(callId).toBe("call_alert_1");
-    expect(executeFlag.called).toBe(false);
-
-    await engine.resolveApproval(sessionId!, callId!, "approve", auth);
-
-    const session = await sessionPromise;
-    await session.waitForCompletion();
-
-    expect(executeFlag.called).toBe(true);
-
-    const events = await engine.listEvents(session.id);
-    const types = events.map((e) => e.type);
-    expect(types).toContain("action.approval_requested");
-    expect(types).toContain("action.approval_resolved");
-    expect(types).toContain("session.waiting");
-
-    await engine.close();
-  });
-
-  it("rejects approval resolution from a different principal", async () => {
-    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-hitl-"));
-    const executeFlag = { called: false };
-    const project = makeHitlProject(executeFlag);
-
-    const runner: AgentRunner = {
-      async runTurn(request: RunnerTurnRequest) {
-        const tool = request.customTools.risky_action;
-        if (tool === undefined) {
-          throw new Error("risky_action not registered");
-        }
-        await tool.execute({ note: "ship it" }, { toolCallId: "call_alert_2" });
-        return { status: "finished", result: "done" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project,
-      stateRoot,
-      runner,
-    });
-
-    const ownerAuth = {
-      authenticator: "local-dev",
-      principalId: "owner",
-      principalType: "user" as const,
-    };
-    const otherAuth = {
-      authenticator: "local-dev",
-      principalId: "other",
-      principalType: "user" as const,
-    };
-
-    void engine.send("http", "please run risky action", { auth: ownerAuth });
-
-    let callId: string | undefined;
-    let sessionId: string | undefined;
-    for (let i = 0; i < 100; i++) {
-      const sessions = await engine.sessions.list();
-      if (sessions.length > 0) {
-        sessionId = sessions[0]!.sessionId;
-        const pending = await engine.listPendingApprovals(sessionId);
-        if (pending.length > 0) {
-          callId = pending[0]!.callId;
-          break;
-        }
-      }
-      await new Promise((r) => setTimeout(r, 20));
-    }
-
-    expect(sessionId).toBeDefined();
-    expect(callId).toBeDefined();
-
-    await expect(
-      engine.resolveApproval(sessionId!, callId!, "approve", otherAuth)
-    ).rejects.toThrow(SessionAuthError);
-
-    // Deny as owner so the parked turn can finish before close().
-    await engine.resolveApproval(sessionId!, callId!, "deny", ownerAuth);
-    await engine.close();
-  });
-
-  it("asSessionOwner bridge lets a non-owner resolve Slack-owned approvals", async () => {
-    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-hitl-"));
-    const executeFlag = { called: false };
-    const project = makeHitlProject(executeFlag);
-
-    const runner: AgentRunner = {
-      async runTurn(request: RunnerTurnRequest) {
-        const tool = request.customTools.risky_action;
-        if (tool === undefined) {
-          throw new Error("risky_action not registered");
-        }
-        await tool.execute({ note: "bridge" }, { toolCallId: "call_bridge_1" });
-        return { status: "finished", result: "done" };
-      },
-    };
-
-    const engine = new SessionEngine({
-      project,
-      stateRoot,
-      runner,
-    });
-
-    const slackAuth = {
-      authenticator: "slack",
-      principalId: "slack:T:C:123.456",
-      principalType: "user" as const,
-      attributes: {
-        channel_id: "C",
-        thread_ts: "123.456",
-        user_id: "U_OWNER",
-      },
-    };
-    const playgroundAuth = {
-      authenticator: "allow-all",
-      principalId: "anonymous",
-      principalType: "user" as const,
-    };
-
-    const sessionPromise = engine.send("http", "please run risky action", {
-      auth: slackAuth,
-    });
-
-    let callId: string | undefined;
-    let sessionId: string | undefined;
-    for (let i = 0; i < 100; i++) {
-      const sessions = await engine.sessions.list();
-      if (sessions.length > 0) {
-        sessionId = sessions[0]!.sessionId;
-        const pending = await engine.listPendingApprovals(sessionId);
-        if (pending.length > 0) {
-          callId = pending[0]!.callId;
-          break;
-        }
-      }
-      await new Promise((r) => setTimeout(r, 20));
-    }
-
-    expect(sessionId).toBeDefined();
-    expect(callId).toBeDefined();
-
-    await expect(
-      engine.resolveApproval(sessionId!, callId!, "approve", playgroundAuth)
-    ).rejects.toThrow(SessionAuthError);
-
-    await engine.resolveApproval(
-      sessionId!,
-      callId!,
-      "approve",
-      playgroundAuth,
-      { asSessionOwner: true }
-    );
-
-    const session = await sessionPromise;
-    await session.waitForCompletion();
-
-    expect(executeFlag.called).toBe(true);
-
-    const events = await engine.listEvents(session.id);
-    const resolved = events.find((e) => e.type === "action.approval_resolved");
-    expect(resolved?.type).toBe("action.approval_resolved");
-    if (resolved?.type === "action.approval_resolved") {
-      expect(resolved.data.by).toBe("anonymous");
-      expect(resolved.data.decision).toBe("approve");
-    }
-
-    await engine.close();
-  });
-
-  it("parks when needsApproval predicate returns true (input-only)", async () => {
-    stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-hitl-"));
-    const executeFlag = { called: false };
-    const definition = defineTool({
-      description: "Conditional risky tool",
-      needsApproval: (input: { urgent?: boolean }) => input.urgent === true,
-      async execute(_input: { urgent?: boolean }, _ctx: ToolContext) {
-        executeFlag.called = true;
-        return { ok: true };
-      },
-    });
-    const project: AgentProject = {
-      rootDir: "/tmp/hitl-fixture",
-      agentDir: "/tmp/hitl-fixture/agent",
-      name: "hitl-fixture",
-      agent: {
-        name: "hitl-fixture",
-        runtime: "local",
-        tools: [
-          {
-            name: "conditional_risky",
-            description: definition.description,
-            execution: "server",
-            needsApproval: true,
-            inputSchema: {
-              type: "object",
-              properties: { urgent: { type: "boolean" } },
-              additionalProperties: false,
-            },
-            definition,
-          },
-        ],
-        skills: [],
-        connections: [],
-        subagents: [],
-        seedFiles: [],
-      },
-      httpChannel: httpChannel(),
-      channels: [],
-      schedules: [],
-      hooks: [],
-      abs: [],
-      diagnostics: [],
-    };
-
-    const runner: AgentRunner = {
-      async runTurn(request: RunnerTurnRequest) {
-        const tool = request.customTools.conditional_risky;
-        if (tool === undefined) {
-          throw new Error("conditional_risky not registered");
-        }
-        await tool.execute({ urgent: true }, { toolCallId: "call_pred_1" });
-        return { status: "finished", result: "done" };
-      },
-    };
-
-    const engine = new SessionEngine({ project, stateRoot, runner });
-    const auth = {
-      authenticator: "local-dev",
-      principalId: "loopback",
-      principalType: "user" as const,
-    };
-
-    const sessionPromise = engine.send("http", "urgent action", { auth });
-
-    let callId: string | undefined;
-    let sessionId: string | undefined;
-    for (let i = 0; i < 100; i++) {
-      const sessions = await engine.sessions.list();
-      if (sessions.length > 0) {
-        sessionId = sessions[0]!.sessionId;
-        const pending = await engine.listPendingApprovals(sessionId);
-        if (pending.length > 0) {
-          callId = pending[0]!.callId;
-          break;
-        }
-      }
-      await new Promise((r) => setTimeout(r, 20));
-    }
-
-    expect(callId).toBe("call_pred_1");
-    expect(executeFlag.called).toBe(false);
-
-    await engine.resolveApproval(sessionId!, callId!, "approve", auth);
-    const session = await sessionPromise;
-    await session.waitForCompletion();
-    expect(executeFlag.called).toBe(true);
-    await engine.close();
-  });
-});

package/src/internal/artifacts-store.test.ts

@@ -1,283 +0,0 @@
-import { 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 { z } from "zod";
-import { defineArtifacts } from "../artifacts.js";
-import { defineStorage, storageKeys } from "../storage.js";
-import type { JsonValue } from "../types.js";
-import { ArtifactsStore, artifactIdForKey } from "./artifacts-store.js";
-import { StorageCoordinator } from "./storage-coordinator.js";
-
-const AGENT = "artifacts-test";
-
-const cleanups: Array<() => Promise<void>> = [];
-
-afterEach(async () => {
-  while (cleanups.length > 0) {
-    await cleanups.pop()?.();
-  }
-});
-
-async function tempStateRoot(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "agent-serve-artifacts-"));
-  cleanups.push(() => rm(dir, { recursive: true, force: true }));
-  return dir;
-}
-
-/** Distinct-millisecond updatedAt stamps for eviction/order assertions. */
-function tick(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 3));
-}
-
-describe("ArtifactsStore", () => {
-  it("upserts by key: same key ⇒ same id, replaced row, preserved createdAt", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-    });
-
-    const first = await store.tag({
-      kind: "report",
-      key: "weekly",
-      data: { rev: 1 },
-    });
-    await tick();
-    const second = await store.tag({
-      kind: "report",
-      key: "weekly",
-      data: { rev: 2 },
-      title: "Weekly report",
-    });
-
-    expect(second.id).toBe(first.id);
-    expect(second.id).toBe(artifactIdForKey("weekly"));
-    expect(second.createdAt).toBe(first.createdAt);
-    expect(second.updatedAt > first.updatedAt).toBe(true);
-
-    const rows = await store.list();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]?.data).toEqual({ rev: 2 });
-    expect(rows[0]?.title).toBe("Weekly report");
-  });
-
-  it("gives keyless tags fresh random ids", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-    });
-    const a = await store.tag({ data: 1 });
-    const b = await store.tag({ data: 2 });
-    expect(a.id).not.toBe(b.id);
-    expect(await store.list()).toHaveLength(2);
-  });
-
-  it("validates data against the declared kind schema", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      config: defineArtifacts({
-        kinds: {
-          "reviewed-pr": {
-            description: "A reviewed PR.",
-            schema: z.object({ url: z.string() }),
-          },
-          note: { description: "Schemaless note." },
-        },
-      }),
-    });
-
-    const ok = await store.tag({
-      kind: "reviewed-pr",
-      data: { url: "https://github.com/org/repo/pull/1" },
-    });
-    expect(ok.kind).toBe("reviewed-pr");
-
-    await expect(
-      store.tag({ kind: "reviewed-pr", data: { nope: true } })
-    ).rejects.toThrow(/does not match the "reviewed-pr" schema/);
-
-    // A kind without a schema accepts any payload.
-    await expect(
-      store.tag({ kind: "note", data: "free text" })
-    ).resolves.toMatchObject({ kind: "note" });
-  });
-
-  it("persists the schema's parsed output (defaults applied)", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      config: defineArtifacts({
-        kinds: {
-          report: {
-            description: "Report.",
-            schema: z.object({
-              name: z.string(),
-              status: z.string().default("draft"),
-            }),
-          },
-        },
-      }),
-    });
-    const record = await store.tag({ kind: "report", data: { name: "q3" } });
-    expect(record.data).toEqual({ name: "q3", status: "draft" });
-    expect((await store.list())[0]?.data).toEqual({
-      name: "q3",
-      status: "draft",
-    });
-  });
-
-  it("rejects unknown kinds when kinds are declared", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      config: defineArtifacts({
-        kinds: { note: { description: "Note." } },
-      }),
-    });
-    await expect(store.tag({ kind: "mystery", data: 1 })).rejects.toThrow(
-      /unknown kind "mystery" \(declared: note\)/
-    );
-  });
-
-  it('accepts freeform kinds (default "artifact") with zero config', async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-    });
-    const defaulted = await store.tag({ data: { anything: true } });
-    expect(defaulted.kind).toBe("artifact");
-    expect(defaulted.source).toBe("host");
-    const custom = await store.tag({ kind: "whatever", data: null });
-    expect(custom.kind).toBe("whatever");
-  });
-
-  it("evicts the oldest-updated row past the max cap", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      config: defineArtifacts({ max: 2 }),
-    });
-
-    await store.tag({ key: "a", data: "a" });
-    await tick();
-    await store.tag({ key: "b", data: "b" });
-    await tick();
-    // Refreshing "a" makes "b" the oldest-updated row.
-    await store.tag({ key: "a", data: "a2" });
-    await tick();
-    await store.tag({ key: "c", data: "c" });
-
-    const keys = (await store.list()).map((row) => row.key);
-    expect(keys.sort()).toEqual(["a", "c"]);
-  });
-
-  it("keeps exactly max rows under concurrent inserts", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      config: defineArtifacts({ max: 3 }),
-    });
-    await Promise.all(
-      Array.from({ length: 8 }, (_, i) => store.tag({ data: i }))
-    );
-    expect(await store.list()).toHaveLength(3);
-  });
-
-  it("skips corrupt row files instead of failing list", async () => {
-    const stateRoot = await tempStateRoot();
-    const store = new ArtifactsStore({ stateRoot });
-    await store.tag({ key: "good", data: 1 });
-    await writeFile(
-      join(stateRoot, "artifacts", "corrupt.json"),
-      "{not json",
-      "utf8"
-    );
-
-    const rows = await store.list();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]?.key).toBe("good");
-    // Inserts (and their eviction scan) keep working too.
-    await expect(store.tag({ key: "more", data: 2 })).resolves.toBeDefined();
-  });
-
-  it("filters list by kind and sessionId, newest-updated first", async () => {
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-    });
-    await store.tag({ kind: "report", data: 1, sessionId: "ses_1" });
-    await tick();
-    await store.tag({ kind: "report", data: 2, sessionId: "ses_2" });
-    await tick();
-    await store.tag({ kind: "note", data: 3, sessionId: "ses_1" });
-
-    expect(await store.list({ kind: "report" })).toHaveLength(2);
-    expect(await store.list({ sessionId: "ses_1" })).toHaveLength(2);
-    expect(
-      await store.list({ kind: "report", sessionId: "ses_1" })
-    ).toHaveLength(1);
-
-    const all = await store.list();
-    expect(all.map((row) => row.data)).toEqual([3, 2, 1]);
-  });
-
-  it("persists rows through defineStorage under storageKeys.artifact", async () => {
-    const backing = new Map<string, JsonValue>();
-    const coordinator = new StorageCoordinator({
-      definition: defineStorage({
-        put: (key, value) => {
-          backing.set(key, structuredClone(value));
-        },
-        get: (key) => backing.get(key),
-        delete: (key) => {
-          backing.delete(key);
-        },
-        list: (prefix) =>
-          [...backing.entries()]
-            .filter(([key]) => key.startsWith(prefix))
-            .sort(([a], [b]) => (a < b ? -1 : 1))
-            .map(([key, value]) => ({ key, value })),
-      }),
-      agentName: AGENT,
-      projectRoot: "/tmp",
-      logger: () => {},
-    });
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      storage: coordinator,
-    });
-
-    const record = await store.tag({ key: "pr-1", data: { url: "u" } });
-    expect(backing.get(storageKeys.artifact(AGENT, record.id))).toMatchObject({
-      id: record.id,
-      key: "pr-1",
-    });
-
-    await tick();
-    await store.tag({ key: "pr-1", data: { url: "u2" } });
-    expect([...backing.keys()]).toHaveLength(1);
-    expect((await store.list())[0]?.data).toEqual({ url: "u2" });
-  });
-
-  it("falls back to filesystem rows when the sink cannot delete", async () => {
-    const backing = new Map<string, JsonValue>();
-    // No `delete`: the sink could never evict past the cap, so artifact
-    // rows must not land there.
-    const coordinator = new StorageCoordinator({
-      definition: defineStorage({
-        put: (key, value) => {
-          backing.set(key, structuredClone(value));
-        },
-        get: (key) => backing.get(key),
-        list: (prefix) =>
-          [...backing.entries()]
-            .filter(([key]) => key.startsWith(prefix))
-            .map(([key, value]) => ({ key, value })),
-      }),
-      agentName: AGENT,
-      projectRoot: "/tmp",
-      logger: () => {},
-    });
-    expect(coordinator.supportsArtifacts).toBe(false);
-
-    const store = new ArtifactsStore({
-      stateRoot: await tempStateRoot(),
-      storage: coordinator,
-    });
-    await store.tag({ key: "local", data: 1 });
-    expect(backing.size).toBe(0);
-    expect(await store.list()).toHaveLength(1);
-  });
-});

package/src/internal/authored-loaders.test.ts

@@ -1,31 +0,0 @@
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-import { AUTHORING_ENTRY_FILES } from "./distribution.js";
-
-describe("AUTHORING_ENTRY_FILES", () => {
-  it("mirrors the package exports map (the runtime alias hooks derive their targets from it)", () => {
-    const pkg = JSON.parse(
-      readFileSync(new URL("../../package.json", import.meta.url), "utf8")
-    ) as {
-      exports: Record<string, string | { import?: string }>;
-    };
-    const fromExports = Object.entries(pkg.exports)
-      .filter(
-        ([exportPath, conditions]) =>
-          typeof conditions !== "string" && exportPath !== "./package.json"
-      )
-      .map(([exportPath, conditions]) => {
-        const subpath =
-          exportPath === "." ? "" : exportPath.replace(/^\.\//, "");
-        const importTarget = (conditions as { import?: string }).import;
-        expect(
-          importTarget,
-          `exports["${exportPath}"] must have an import condition`
-        ).toBeDefined();
-        return [subpath, importTarget?.replace(/^\.\/dist\//, "")];
-      });
-    expect(AUTHORING_ENTRY_FILES.map((entry) => [...entry])).toEqual(
-      fromExports
-    );
-  });
-});