@cursor/july 0.1.24 → 0.1.25

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

@@ -0,0 +1,201 @@
+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 type { AgentProject, ReminderInfo, SessionRecord } from "../../types.js";
+import { ReminderRunner } from "../reminder-runner.js";
+import { SessionEngine } from "../session-engine.js";
+import { builtinTools } from "./index.js";
+
+function testProject(rootDir: string): AgentProject {
+  return {
+    rootDir,
+    agentDir: join(rootDir, "agent"),
+    name: "builtin-reminders-test",
+    agent: {
+      name: "builtin-reminders-test",
+      runtime: "local",
+      instructions: "Test agent instructions.",
+      tools: builtinTools({ reminders: true }),
+      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()?.();
+  }
+});
+
+async function makeEngine(): Promise<SessionEngine> {
+  const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-builtin-rem-"));
+  cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+  const engine = new SessionEngine({
+    project: testProject(stateRoot),
+    stateRoot,
+    runner: {
+      runTurn: () => {
+        throw new Error("no model turns in this test");
+      },
+    },
+  });
+  engine.setReminders(new ReminderRunner(engine));
+  return engine;
+}
+
+async function saveSession(
+  engine: SessionEngine,
+  sessionId: string,
+  continuationKey: string | null
+): Promise<void> {
+  const record: SessionRecord = {
+    sessionId,
+    channelId: "http",
+    mode: "chat",
+    continuationKey,
+    auth: null,
+    turnCount: 0,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  await engine.sessions.save(record);
+}
+
+describe("built-in reminder tools", () => {
+  it("creates, lists, and cancels a reminder bound to the conversation", async () => {
+    const engine = await makeEngine();
+    await saveSession(engine, "ses_a", "conv:a");
+
+    const created = await engine.callTool(
+      "reminders_create",
+      {
+        prompt: "Re-check CI.",
+        every: "30m",
+        until: "Cancel once CI is green.",
+      },
+      { sessionId: "ses_a" }
+    );
+    expect(created.isError).toBe(false);
+    const reminder = created.result as { reminderId: string; until: string };
+    expect(reminder.reminderId).toMatch(/^rem_/);
+    expect(reminder.until).toBe("Cancel once CI is green.");
+
+    const listed = await engine.callTool(
+      "reminders_list",
+      {},
+      { sessionId: "ses_a" }
+    );
+    const list = listed.result as { reminders: Array<{ reminderId: string }> };
+    expect(list.reminders.map((r) => r.reminderId)).toEqual([
+      reminder.reminderId,
+    ]);
+
+    const cancelled = await engine.callTool(
+      "reminders_cancel",
+      { id: reminder.reminderId },
+      { sessionId: "ses_a" }
+    );
+    expect(cancelled.isError).toBe(false);
+    expect(cancelled.result).toEqual({
+      reminderId: reminder.reminderId,
+      status: "cancelled",
+    });
+
+    const after = await engine.callTool(
+      "reminders_list",
+      {},
+      { sessionId: "ses_a" }
+    );
+    expect((after.result as { reminders: unknown[] }).reminders).toEqual([]);
+  });
+
+  it("refuses to cancel another conversation's reminder", async () => {
+    const engine = await makeEngine();
+    await saveSession(engine, "ses_a", "conv:a");
+    await saveSession(engine, "ses_b", "conv:b");
+
+    const created = await engine.callTool(
+      "reminders_create",
+      { prompt: "wake", delay: "5m" },
+      { sessionId: "ses_a" }
+    );
+    const { reminderId } = created.result as { reminderId: string };
+
+    const foreign = await engine.callTool(
+      "reminders_cancel",
+      { id: reminderId },
+      { sessionId: "ses_b" }
+    );
+    expect(foreign.isError).toBe(true);
+    expect(foreign.errorMessage).toContain("in this conversation");
+
+    const mine = await engine.host.reminders?.list({ status: "armed" });
+    expect((mine as ReminderInfo[]).map((r) => r.id)).toEqual([reminderId]);
+  });
+
+  it("keeps reminders addressed across HTTP continuation rotation", async () => {
+    const engine = await makeEngine();
+    await saveSession(engine, "ses_a", "conv:a");
+
+    const created = await engine.callTool(
+      "reminders_create",
+      { prompt: "wake", delay: "5m" },
+      { sessionId: "ses_a" }
+    );
+    const { reminderId } = created.result as { reminderId: string };
+
+    // The built-in HTTP channel rotates the token after every follow-up.
+    await engine.setContinuationToken("ses_a", "conv:rotated");
+
+    const listed = await engine.callTool(
+      "reminders_list",
+      {},
+      { sessionId: "ses_a" }
+    );
+    const list = listed.result as { reminders: Array<{ reminderId: string }> };
+    expect(list.reminders.map((r) => r.reminderId)).toEqual([reminderId]);
+
+    // Fire path must still resolve the session (no session_gone disarm).
+    const dispatched = await engine.host.reminders?.dispatch(reminderId);
+    expect(dispatched).toMatchObject({ outcome: "fired", reason: "delivered" });
+  });
+
+  it("rejects sub-minute recurring reminders", async () => {
+    const engine = await makeEngine();
+    await saveSession(engine, "ses_a", "conv:a");
+
+    const outcome = await engine.callTool(
+      "reminders_create",
+      { prompt: "wake", every: "5s" },
+      { sessionId: "ses_a" }
+    );
+    expect(outcome.isError).toBe(true);
+    expect(outcome.errorMessage).toContain('every >= "1m"');
+  });
+
+  it("rejects creates from sessions without a continuation key", async () => {
+    const engine = await makeEngine();
+    await saveSession(engine, "ses_nokey", null);
+
+    const outcome = await engine.callTool(
+      "reminders_create",
+      { prompt: "wake", delay: "5m" },
+      { sessionId: "ses_nokey" }
+    );
+    expect(outcome.isError).toBe(true);
+    expect(outcome.errorMessage).toContain("followable");
+  });
+});

package/src/internal/channel-route-schema.test.ts

@@ -0,0 +1,294 @@
+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 { z } from "zod";
+import { defineChannel, GET, httpChannel, POST } from "../channels.js";
+import type { AgentProject } from "../types.js";
+import { projectInfo } from "./discovery.js";
+import { toolInputJsonSchema, validateToolInput } from "./json-schema.js";
+import { type AgentMount, startServer } from "./server.js";
+
+const cleanups: Array<() => Promise<void>> = [];
+
+afterEach(async () => {
+  while (cleanups.length > 0) {
+    const cleanup = cleanups.pop();
+    if (cleanup !== undefined) await cleanup();
+  }
+});
+
+describe("channel route schemas", () => {
+  it("requires bodySchema on POST and querySchema on GET", () => {
+    const bodySchema = z.object({ pr: z.string() });
+    const querySchema = z.object({ status: z.string().optional() });
+    const channel = defineChannel({
+      routes: [
+        POST("/", {
+          description: "start",
+          bodySchema,
+          handler: async () => Response.json({ ok: true }),
+        }),
+        GET("/findings", {
+          querySchema,
+          handler: async () => Response.json({ ok: true }),
+        }),
+      ],
+    });
+
+    const post = channel.routes?.[0];
+    const get = channel.routes?.[1];
+    expect(post?.method).toBe("POST");
+    expect(post?.description).toBe("start");
+    expect(post?.bodySchema).toBe(bodySchema);
+    expect(get?.querySchema).toBe(querySchema);
+  });
+
+  it("converts Zod bodySchema to JSON Schema like tools", () => {
+    const schema = z.object({
+      pr: z.string(),
+      mode: z.enum(["suggest", "apply"]).optional(),
+    });
+    const json = toolInputJsonSchema(schema);
+    expect(json.type).toBe("object");
+    expect(json.properties).toMatchObject({
+      pr: { type: "string" },
+    });
+  });
+
+  it("validateToolInput rejects invalid channel bodies", () => {
+    const schema = z.object({ pr: z.string() });
+    const bad = validateToolInput(schema, { mode: "suggest" });
+    expect(bad.ok).toBe(false);
+    if (!bad.ok) {
+      expect(bad.message).toContain("pr");
+    }
+    const good = validateToolInput(schema, { pr: "acme/repo#1" });
+    expect(good.ok).toBe(true);
+  });
+
+  it("projectInfo exposes bodySchema and querySchema on channel routes", () => {
+    const bodySchema = z.object({ pr: z.string() });
+    const querySchema = z.object({ status: z.string().optional() });
+    const channel = defineChannel({
+      routes: [
+        POST("/", {
+          bodySchema,
+          handler: async () => Response.json({ ok: true }),
+        }),
+        GET("/items", {
+          querySchema,
+          handler: async () => Response.json({ ok: true }),
+        }),
+      ],
+    });
+    const project: AgentProject = {
+      rootDir: "/tmp/demo",
+      agentDir: "/tmp/demo/agent",
+      name: "demo",
+      agent: {
+        name: "demo",
+        runtime: "local",
+        instructions: "test",
+        tools: [],
+        skills: [],
+        connections: [],
+        subagents: [],
+        seedFiles: [],
+      },
+      httpChannel: httpChannel(),
+      channels: [{ id: "demo", definition: channel }],
+      schedules: [],
+      hooks: [],
+      abs: [],
+      diagnostics: [],
+    };
+    const info = projectInfo(project);
+    const demo = info.channels.find((c) => c.id === "demo");
+    expect(demo?.routes).toEqual([
+      expect.objectContaining({
+        method: "POST",
+        url: "/v1/channels/demo/",
+        bodySchema: toolInputJsonSchema(bodySchema),
+      }),
+      expect.objectContaining({
+        method: "GET",
+        url: "/v1/channels/demo/items",
+        querySchema: toolInputJsonSchema(querySchema),
+      }),
+    ]);
+  });
+
+  it("projectInfo surfaces channel meta (kind, slackChannelPosts)", () => {
+    const channel = defineChannel({
+      meta: { kind: "slack", slackChannelPosts: ["#issues-glass"] },
+    });
+    const project: AgentProject = {
+      rootDir: "/tmp/demo",
+      agentDir: "/tmp/demo/agent",
+      name: "demo",
+      agent: {
+        name: "demo",
+        runtime: "local",
+        instructions: "test",
+        tools: [],
+        skills: [],
+        connections: [],
+        subagents: [],
+        seedFiles: [],
+      },
+      httpChannel: httpChannel(),
+      channels: [{ id: "slack", definition: channel }],
+      schedules: [],
+      hooks: [],
+      abs: [],
+      diagnostics: [],
+    };
+    const info = projectInfo(project);
+    const slack = info.channels.find((c) => c.id === "slack");
+    expect(slack?.kind).toBe("slack");
+    expect(slack?.slackChannelPosts).toEqual(["#issues-glass"]);
+  });
+});
+
+describe("channel route HTTP validation", () => {
+  async function startSchemaChannelServer(): Promise<{ url: string }> {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-chschema-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+    const bodySchema = z.object({ pr: z.string().min(1) });
+    const querySchema = z.object({ status: z.string().optional() });
+    const channel = defineChannel({
+      routes: [
+        POST("/", {
+          bodySchema,
+          handler: async (_req, args) =>
+            Response.json({ body: args.body ?? null }),
+        }),
+        GET("/items", {
+          querySchema,
+          handler: async (_req, args) =>
+            Response.json({ query: args.query ?? null }),
+        }),
+      ],
+    });
+    const project: AgentProject = {
+      rootDir: stateRoot,
+      agentDir: join(stateRoot, "agent"),
+      name: "schema-test",
+      agent: {
+        name: "schema-test",
+        runtime: "local",
+        instructions: "test",
+        tools: [],
+        skills: [],
+        connections: [],
+        subagents: [],
+        seedFiles: [],
+      },
+      httpChannel: httpChannel(),
+      channels: [{ id: "schema", definition: channel }],
+      schedules: [],
+      hooks: [],
+      abs: [],
+      diagnostics: [],
+    };
+    const mounts: AgentMount[] = [{ slug: "", project }];
+    const handle = await startServer(mounts, {
+      port: 0,
+      stateRoot,
+      playground: false,
+      schedules: false,
+      logger: () => {},
+    });
+    cleanups.push(() => handle.close());
+    return { url: handle.url };
+  }
+
+  it("returns 400 for invalid body before the handler runs", async () => {
+    const { url } = await startSchemaChannelServer();
+    const response = await fetch(`${url}/v1/channels/schema/`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    expect(response.status).toBe(400);
+    const body = (await response.json()) as { error: string };
+    expect(body.error).toContain("pr");
+  });
+
+  it("accepts an empty request body for z.object({}) routes", async () => {
+    const stateRoot = await mkdtemp(join(tmpdir(), "agent-serve-empty-body-"));
+    cleanups.push(() => rm(stateRoot, { recursive: true, force: true }));
+    const emptyBodySchema = z.object({});
+    const channel = defineChannel({
+      routes: [
+        POST("/noop", {
+          bodySchema: emptyBodySchema,
+          handler: async (_req, args) =>
+            Response.json({ body: args.body ?? null }),
+        }),
+      ],
+    });
+    const project: AgentProject = {
+      rootDir: stateRoot,
+      agentDir: join(stateRoot, "agent"),
+      name: "empty-body-test",
+      agent: {
+        name: "empty-body-test",
+        runtime: "local",
+        instructions: "test",
+        tools: [],
+        skills: [],
+        connections: [],
+        subagents: [],
+        seedFiles: [],
+      },
+      httpChannel: httpChannel(),
+      channels: [{ id: "noop", definition: channel }],
+      schedules: [],
+      hooks: [],
+      abs: [],
+      diagnostics: [],
+    };
+    const handle = await startServer([{ slug: "", project }], {
+      port: 0,
+      stateRoot,
+      playground: false,
+      schedules: false,
+      logger: () => {},
+    });
+    cleanups.push(() => handle.close());
+
+    const response = await fetch(`${handle.url}/v1/channels/noop/noop`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+    });
+    expect(response.status).toBe(200);
+    expect(
+      ((await response.json()) as { body: Record<string, never> }).body
+    ).toEqual({});
+  });
+
+  it("passes validated body and query to the handler", async () => {
+    const { url } = await startSchemaChannelServer();
+    const post = await fetch(`${url}/v1/channels/schema/`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ pr: "acme/repo#1" }),
+    });
+    expect(post.status).toBe(200);
+    expect(((await post.json()) as { body: { pr: string } }).body).toEqual({
+      pr: "acme/repo#1",
+    });
+
+    const get = await fetch(
+      `${url}/v1/channels/schema/items?status=OPEN&ignored=1`
+    );
+    expect(get.status).toBe(200);
+    expect(((await get.json()) as { query: { status: string } }).query).toEqual(
+      {
+        status: "OPEN",
+      }
+    );
+  });
+});