@cursor/july 0.1.20 → 0.1.21

package/src/internal/session-engine.interrupt.test.ts

@@ -0,0 +1,577 @@
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { httpChannel } from "../channels.js";
+import { defineTool } from "../tools.js";
+import type {
+  AgentProject,
+  AuthContext,
+  DiscoveredTool,
+  RunnerTurnRequest,
+  ToolDefinition,
+  TurnOutcome,
+} from "../types.js";
+import { toolInputJsonSchema } from "./json-schema.js";
+import type { AgentRunner, RunnerPrewarmRequest } from "./sdk-runner.js";
+import { SessionAuthError, SessionEngine } from "./session-engine.js";
+
+function discovered(name: string, definition: ToolDefinition): DiscoveredTool {
+  return {
+    name,
+    description: definition.description,
+    execution: definition.execution ?? "server",
+    needsApproval: definition.needsApproval !== undefined,
+    inputSchema: toolInputJsonSchema(definition.inputSchema),
+    definition,
+  };
+}
+
+function testProject(
+  rootDir: string,
+  options: {
+    cwd?: string;
+    workspaceDir?: string;
+    sandbox?: boolean;
+    tools?: DiscoveredTool[];
+  } = {}
+): AgentProject {
+  return {
+    rootDir,
+    agentDir: join(rootDir, "agent"),
+    name: "interrupt-test",
+    agent: {
+      name: "interrupt-test",
+      runtime: "local",
+      instructions: "Test agent.",
+      ...(options.cwd === undefined &&
+      options.workspaceDir === undefined &&
+      options.sandbox === undefined
+        ? {}
+        : {
+            local: {
+              cwd: options.cwd,
+              workspaceDir: options.workspaceDir,
+              sandbox: options.sandbox,
+            },
+          }),
+      tools: options.tools ?? [],
+      skills: [],
+      connections: [],
+      subagents: [],
+      seedFiles: [],
+    },
+    httpChannel: httpChannel(),
+    channels: [],
+    schedules: [],
+    hooks: [],
+    abs: [],
+    diagnostics: [],
+  };
+}
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  while (cleanups.length > 0) {
+    await cleanups.pop()?.();
+  }
+});
+
+describe("SessionEngine follow-up interrupts the running turn", () => {
+  it("cancels the in-flight turn and runs the follow-up", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-interrupt-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const seen: Array<{ prompt: string; forced: boolean }> = [];
+    let firstAborted = false;
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push({
+          prompt: request.prompt,
+          forced: request.forceExpireActiveRun === true,
+        });
+        // First turns carry the framework session-context block before the
+        // channel message.
+        if (request.prompt.endsWith("first")) {
+          // Block until the follow-up preempts this turn (mirrors the SDK
+          // wiring the runner's abort signal to run.cancel()).
+          await new Promise<void>((resolve) => {
+            if (request.signal?.aborted === true) {
+              resolve();
+              return;
+            }
+            request.signal?.addEventListener("abort", () => resolve(), {
+              once: true,
+            });
+          });
+          firstAborted = true;
+          return { status: "cancelled" };
+        }
+        return { status: "finished", result: "second-done" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    // Turn one blocks inside runTurn awaiting its abort signal.
+    const session = await engine.send("http", "first", { auth: null });
+    // A follow-up on the same session must interrupt turn one and run.
+    const follow = await engine.send("http", "second", {
+      auth: null,
+      continuationToken: session.continuationToken ?? undefined,
+    });
+    const outcome = await follow.waitForCompletion();
+
+    expect(firstAborted).toBe(true);
+    expect(outcome.status).toBe("finished");
+    expect(outcome.result).toBe("second-done");
+    expect(seen[0]?.prompt).toMatch(/^<agentkit_context>\n/);
+    expect(seen[0]?.prompt.endsWith("\n\nfirst")).toBe(true);
+    expect(seen[1]?.prompt).toBe("second");
+    // The first turn creates the agent; the follow-up force-expires any run
+    // still marked active so it is never blocked by the preempted one.
+    expect(seen[0]?.forced).toBe(false);
+    expect(seen[1]?.forced).toBe(true);
+
+    const events = await engine.listEvents(session.id, 0);
+    const failed = events.find((event) => event.type === "turn.failed");
+    expect((failed?.data as { message?: string } | undefined)?.message).toBe(
+      "turn interrupted"
+    );
+    expect(events.some((event) => event.type === "turn.completed")).toBe(true);
+  });
+
+  it("interrupt() cancels the in-flight turn without a follow-up", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-stop-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        await new Promise<void>((resolve) => {
+          if (request.signal?.aborted === true) {
+            resolve();
+            return;
+          }
+          request.signal?.addEventListener("abort", () => resolve(), {
+            once: true,
+          });
+        });
+        return { status: "cancelled" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const session = await engine.send("http", "running", { auth: null });
+    expect(await engine.interrupt(session.id)).toBe(true);
+    const outcome = await session.waitForCompletion();
+    expect(outcome.status).toBe("cancelled");
+    expect(await engine.interrupt(session.id)).toBe(false);
+
+    const events = await engine.listEvents(session.id, 0);
+    const failed = events.find((event) => event.type === "turn.failed");
+    expect((failed?.data as { message?: string } | undefined)?.message).toBe(
+      "turn interrupted"
+    );
+  });
+});
+
+describe("SessionEngine agent cwd", () => {
+  it("uses <agent.local.cwd>/<sessionId> as the harness cwd", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-state-"));
+    const harnessRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+    cleanups.push(() => rm(harnessRoot, { recursive: true, force: true }));
+
+    const seen: string[] = [];
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push(request.workspaceDir);
+        return { status: "finished", result: "ok" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { cwd: harnessRoot }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const session = await engine.send("http", "hi", { auth: null });
+    await session.waitForCompletion();
+    expect(seen).toEqual([join(harnessRoot, session.id)]);
+  });
+
+  it("passes agent.local.sandbox through to the runner", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-sandbox-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const seen: (boolean | undefined)[] = [];
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push(request.sandbox);
+        return { status: "finished", result: "ok" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { sandbox: true }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const session = await engine.send("http", "hi", { auth: null });
+    await session.waitForCompletion();
+    expect(seen).toEqual([true]);
+  });
+
+  it("lets SendMessageOptions.workspaceDir override agent cwd", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-ov-"));
+    const harnessRoot = await mkdtemp(join(tmpdir(), "agent-serve-cwd-base-"));
+    const override = await mkdtemp(join(tmpdir(), "agent-serve-cwd-override-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+    cleanups.push(() => rm(harnessRoot, { recursive: true, force: true }));
+    cleanups.push(() => rm(override, { recursive: true, force: true }));
+
+    const seen: string[] = [];
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push(request.workspaceDir);
+        return { status: "finished", result: "ok" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { cwd: harnessRoot }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const session = await engine.send("http", "hi", {
+      auth: null,
+      workspaceDir: override,
+    });
+    await session.waitForCompletion();
+    expect(seen).toEqual([override]);
+  });
+});
+
+describe("SessionEngine shared harness workspace", () => {
+  async function runSessions(
+    options: { workspaceDir?: string; cwd?: string },
+    count: number
+  ): Promise<{ stateRoot: string; seen: string[]; prompts: string[] }> {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-shared-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const seen: string[] = [];
+    const prompts: string[] = [];
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push(request.workspaceDir);
+        prompts.push(request.prompt);
+        return { status: "finished", result: "ok" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, options),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    for (let i = 0; i < count; i++) {
+      const session = await engine.send("http", `hi ${i}`, { auth: null });
+      await session.waitForCompletion();
+    }
+    return { stateRoot, seen, prompts };
+  }
+
+  it("gives every session the same harness cwd", async () => {
+    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-"));
+    cleanups.push(() => rm(shared, { recursive: true, force: true }));
+
+    const { seen } = await runSessions({ workspaceDir: shared }, 3);
+
+    // One cwd across sessions is the whole point: the SDK keys its local
+    // executor on it, so a stable path resolves rules and skills once.
+    expect(seen).toEqual([shared, shared, shared]);
+  });
+
+  it("takes precedence over cwd but yields to a per-send workspaceDir", async () => {
+    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-pri-"));
+    const perSend = await mkdtemp(join(tmpdir(), "agent-serve-checkout-send-"));
+    const cwd = await mkdtemp(join(tmpdir(), "agent-serve-checkout-cwd-"));
+    cleanups.push(() => rm(shared, { recursive: true, force: true }));
+    cleanups.push(() => rm(perSend, { recursive: true, force: true }));
+    cleanups.push(() => rm(cwd, { recursive: true, force: true }));
+
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-shared-pri-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const seen: string[] = [];
+    const runner: AgentRunner = {
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        seen.push(request.workspaceDir);
+        return { status: "finished", result: "ok" };
+      },
+    };
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { cwd, workspaceDir: shared }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    await (await engine.send("http", "a", { auth: null })).waitForCompletion();
+    await (
+      await engine.send("http", "b", { auth: null, workspaceDir: perSend })
+    ).waitForCompletion();
+
+    expect(seen).toEqual([shared, perSend]);
+  });
+
+  it("warms the shared workspace with the same inputs a turn will use", async () => {
+    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-warm-"));
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-warm-state-"));
+    cleanups.push(() => rm(shared, { recursive: true, force: true }));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    let warmed: RunnerPrewarmRequest | undefined;
+    let turn: RunnerTurnRequest | undefined;
+    const runner: AgentRunner = {
+      prewarm: async (request) => {
+        warmed = request;
+        return { warmed: true };
+      },
+      runTurn: async (request: RunnerTurnRequest): Promise<TurnOutcome> => {
+        turn = request;
+        return { status: "finished", result: "ok" };
+      },
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { workspaceDir: shared }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    await engine.prewarmSharedWorkspace();
+    await (await engine.send("http", "hi", { auth: null })).waitForCompletion();
+
+    // Warming a workspace the turn will not land on is silent waste, so every
+    // field the executor is keyed on has to agree.
+    expect(warmed).toBeDefined();
+    expect(turn).toBeDefined();
+    expect(warmed?.workspaceDir).toBe(turn?.workspaceDir);
+    expect(warmed?.runnerStateDir).toBe(turn?.runnerStateDir);
+    expect(warmed?.sandbox).toBe(turn?.sandbox);
+    expect(warmed?.mcpServers).toEqual(turn?.mcpServers);
+    expect(warmed?.subagents).toEqual(turn?.subagents);
+    expect(warmed?.model).toEqual(turn?.model);
+  });
+
+  it("does not warm when each session gets its own cwd", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "agent-serve-nowarm-"));
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-nowarm-st-"));
+    cleanups.push(() => rm(cwd, { recursive: true, force: true }));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const prewarm = vi.fn(async () => ({ warmed: true }) as const);
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { cwd }),
+      stateRoot,
+      runner: {
+        prewarm,
+        runTurn: async (): Promise<TurnOutcome> => ({ status: "finished" }),
+      },
+    });
+    cleanups.push(() => engine.close());
+
+    await engine.prewarmSharedWorkspace();
+
+    expect(prewarm).not.toHaveBeenCalled();
+  });
+
+  it("says so instead of claiming success when the runner cannot warm", async () => {
+    const shared = await mkdtemp(join(tmpdir(), "agent-serve-cold-"));
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-cold-st-"));
+    cleanups.push(() => rm(shared, { recursive: true, force: true }));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    // What an older @cursor/sdk produces: the call resolves, nothing warms.
+    const lines: string[] = [];
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, { workspaceDir: shared }),
+      stateRoot,
+      logger: (line) => lines.push(line),
+      runner: {
+        prewarm: async () => ({ warmed: false, reason: "sdk too old" }),
+        runTurn: async (): Promise<TurnOutcome> => ({ status: "finished" }),
+      },
+    });
+    cleanups.push(() => engine.close());
+
+    await engine.prewarmSharedWorkspace();
+
+    // An operator reading "warmed" over a cold workspace is worse than no log.
+    expect(lines).toContainEqual(
+      `[agentkit] did not warm ${shared}: sdk too old`
+    );
+    expect(lines.some((line) => line.includes("] warmed "))).toBe(false);
+  });
+
+  it("keeps agent scaffold out of the shared directory and inlines it instead", async () => {
+    const shared = await mkdtemp(join(tmpdir(), "agent-serve-checkout-safe-"));
+    cleanups.push(() => rm(shared, { recursive: true, force: true }));
+
+    const { prompts } = await runSessions({ workspaceDir: shared }, 1);
+
+    // Writing AGENTS.md into a borrowed checkout would dirty the user's tree.
+    expect(await readdir(shared)).toEqual([]);
+    expect(prompts[0]).toContain("Test agent.");
+  });
+});
+
+describe("ToolContext.send auth default", () => {
+  it("passes the calling session principal when auth is omitted", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-tool-auth-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const owner: AuthContext = {
+      authenticator: "local-dev",
+      principalId: "loopback",
+      principalType: "runtime",
+    };
+
+    const handoff = defineTool({
+      description: "Resume a drive session.",
+      inputSchema: z.object({ token: z.string() }),
+      async execute({ token }, ctx) {
+        const session = await ctx.send("drive", "from-tool", {
+          continuationToken: token,
+        });
+        return { sessionId: session.id };
+      },
+    });
+
+    const runner: AgentRunner = {
+      runTurn: async (): Promise<TurnOutcome> => ({
+        status: "finished",
+        result: "ok",
+      }),
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, {
+        tools: [discovered("handoff", handoff)],
+      }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const drive = await engine.send("drive", "seed", {
+      auth: owner,
+      continuationToken: "sticky-pr",
+    });
+    await drive.waitForCompletion();
+
+    const chat = await engine.send("http", "chat", { auth: owner });
+    await chat.waitForCompletion();
+
+    const outcome = await engine.callTool(
+      "handoff",
+      { token: "sticky-pr" },
+      { auth: owner, sessionId: chat.id }
+    );
+    expect(outcome.isError).toBe(false);
+  });
+
+  it("rejects when the sticky session belongs to another principal", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-tool-auth2-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+
+    const owner: AuthContext = {
+      authenticator: "local-dev",
+      principalId: "owner",
+      principalType: "runtime",
+    };
+    const other: AuthContext = {
+      authenticator: "local-dev",
+      principalId: "other",
+      principalType: "runtime",
+    };
+
+    const handoff = defineTool({
+      description: "Resume a drive session.",
+      inputSchema: z.object({ token: z.string() }),
+      async execute({ token }, ctx) {
+        try {
+          await ctx.send("drive", "from-tool", {
+            continuationToken: token,
+          });
+          return { ok: true };
+        } catch (error) {
+          return {
+            ok: false,
+            error: error instanceof Error ? error.name : String(error),
+          };
+        }
+      },
+    });
+
+    const runner: AgentRunner = {
+      runTurn: async (): Promise<TurnOutcome> => ({
+        status: "finished",
+        result: "ok",
+      }),
+    };
+
+    const engine = new SessionEngine({
+      project: testProject(stateRoot, {
+        tools: [discovered("handoff", handoff)],
+      }),
+      stateRoot,
+      runner,
+    });
+    cleanups.push(() => engine.close());
+
+    const drive = await engine.send("drive", "seed", {
+      auth: owner,
+      continuationToken: "sticky-pr",
+    });
+    await drive.waitForCompletion();
+
+    const chat = await engine.send("http", "chat", { auth: other });
+    await chat.waitForCompletion();
+
+    const outcome = await engine.callTool(
+      "handoff",
+      { token: "sticky-pr" },
+      { auth: other, sessionId: chat.id }
+    );
+    expect(outcome.isError).toBe(false);
+    expect(outcome.result).toEqual({
+      ok: false,
+      error: SessionAuthError.name,
+    });
+  });
+});