@cursor/july 0.1.19 → 0.1.21

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",
+      }
+    );
+  });
+});

package/src/internal/chat-attach.test.ts

@@ -0,0 +1,262 @@
+import { once } from "node:events";
+import { createServer, type Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { runChat } from "./chat-client.js";
+
+interface StubAgent {
+  url: string;
+  close: () => Promise<void>;
+  followUps: Array<{ message: string; continuationToken: unknown }>;
+}
+
+async function startStub(opts: {
+  sessions: Array<{
+    sessionId: string;
+    continuationToken: string | null;
+    mode?: string;
+  }>;
+  events: unknown[];
+}): Promise<StubAgent> {
+  const followUps: StubAgent["followUps"] = [];
+  const server: Server = createServer((req, res) => {
+    let raw = "";
+    req.on("data", (chunk: Buffer) => {
+      raw += chunk.toString("utf8");
+    });
+    req.on("end", () => {
+      const url = new URL(req.url ?? "/", "http://localhost");
+      const send = (status: number, body: unknown): void => {
+        res.writeHead(status, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+      };
+      const sendNdjson = (lines: unknown[]): void => {
+        res.writeHead(200, { "content-type": "application/x-ndjson" });
+        res.end(`${lines.map((line) => JSON.stringify(line)).join("\n")}\n`);
+      };
+
+      if (req.method === "GET" && url.pathname === "/v1/health") {
+        send(200, { ok: true, name: "stub" });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/v1/info") {
+        send(200, { name: "stub", model: "composer-2", tools: [] });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/v1/sessions") {
+        send(200, { sessions: opts.sessions });
+        return;
+      }
+      if (
+        req.method === "GET" &&
+        url.pathname === "/v1/session/ses_attach/events"
+      ) {
+        if (url.searchParams.get("format") === "json") {
+          send(200, { events: opts.events });
+          return;
+        }
+        sendNdjson(opts.events);
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/v1/session/ses_attach") {
+        const body = JSON.parse(raw || "{}") as {
+          message?: string;
+          continuationToken?: string;
+        };
+        followUps.push({
+          message: body.message ?? "",
+          continuationToken: body.continuationToken,
+        });
+        send(200, {
+          ok: true,
+          sessionId: "ses_attach",
+          continuationToken: "http:rotated",
+        });
+        return;
+      }
+      if (
+        req.method === "GET" &&
+        url.pathname === "/v1/session/ses_attach/stream"
+      ) {
+        const start = Number(url.searchParams.get("startIndex") ?? "0");
+        sendNdjson([
+          {
+            index: start,
+            sessionId: "ses_attach",
+            turnId: "turn_2",
+            type: "turn.started",
+            data: {},
+          },
+          {
+            index: start + 1,
+            sessionId: "ses_attach",
+            turnId: "turn_2",
+            type: "message.completed",
+            data: { text: "follow-up reply", finishReason: "stop" },
+          },
+          {
+            index: start + 2,
+            sessionId: "ses_attach",
+            turnId: "turn_2",
+            type: "turn.completed",
+            data: { result: "follow-up reply" },
+          },
+          {
+            index: start + 3,
+            sessionId: "ses_attach",
+            type: "session.waiting",
+            data: {},
+          },
+        ]);
+        return;
+      }
+      send(404, { ok: false, error: "not_found" });
+    });
+  });
+
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  const { port } = server.address() as AddressInfo;
+  return {
+    url: `http://127.0.0.1:${port}`,
+    followUps,
+    close: () =>
+      new Promise<void>((resolvePromise, reject) =>
+        server.close((error) => (error ? reject(error) : resolvePromise()))
+      ),
+  };
+}
+
+const priorEvents = [
+  {
+    index: 0,
+    sessionId: "ses_attach",
+    type: "session.started",
+    data: { channelId: "http" },
+  },
+  {
+    index: 1,
+    sessionId: "ses_attach",
+    turnId: "turn_1",
+    type: "message.received",
+    data: { text: "hello prior" },
+  },
+  {
+    index: 2,
+    sessionId: "ses_attach",
+    turnId: "turn_1",
+    type: "message.completed",
+    data: { text: "hi from prior turn", finishReason: "stop" },
+  },
+  {
+    index: 3,
+    sessionId: "ses_attach",
+    turnId: "turn_1",
+    type: "turn.completed",
+    data: { result: "hi from prior turn" },
+  },
+  {
+    index: 4,
+    sessionId: "ses_attach",
+    type: "session.waiting",
+    data: {},
+  },
+];
+
+describe("chat --session reattach", () => {
+  let stub: StubAgent | undefined;
+  const writes: string[] = [];
+
+  afterEach(async () => {
+    await stub?.close();
+    stub = undefined;
+    writes.length = 0;
+    vi.restoreAllMocks();
+  });
+
+  it("looks up the continuation token and sends a follow-up", async () => {
+    stub = await startStub({
+      sessions: [
+        {
+          sessionId: "ses_attach",
+          continuationToken: "http:prior",
+          mode: "chat",
+        },
+      ],
+      events: priorEvents,
+    });
+
+    const stdoutWrite = vi.spyOn(process.stdout, "write").mockImplementation(((
+      chunk: string | Uint8Array
+    ) => {
+      writes.push(typeof chunk === "string" ? chunk : chunk.toString());
+      return true;
+    }) as typeof process.stdout.write);
+
+    await runChat({
+      baseUrl: stub.url,
+      sessionId: "ses_attach",
+      message: "follow up please",
+      oneShot: true,
+      noColor: true,
+    });
+
+    stdoutWrite.mockRestore();
+    const out = writes.join("");
+    expect(out).toContain("reattached ses_attach");
+    expect(out).toContain("hello prior");
+    expect(out).toContain("hi from prior turn");
+    expect(stub.followUps).toEqual([
+      { message: "follow up please", continuationToken: "http:prior" },
+    ]);
+  });
+
+  it("uses an explicit --continuation-token without listing", async () => {
+    stub = await startStub({
+      sessions: [], // empty — lookup would fail
+      events: priorEvents,
+    });
+
+    await runChat({
+      baseUrl: stub.url,
+      sessionId: "ses_attach",
+      continuationToken: "http:explicit",
+      message: "again",
+      oneShot: true,
+      noColor: true,
+    });
+
+    expect(stub.followUps).toEqual([
+      { message: "again", continuationToken: "http:explicit" },
+    ]);
+  });
+
+  it("fails when the session is missing from /v1/sessions", async () => {
+    stub = await startStub({ sessions: [], events: [] });
+    await expect(
+      runChat({
+        baseUrl: stub.url,
+        sessionId: "ses_missing",
+        oneShot: true,
+        noColor: true,
+      })
+    ).rejects.toThrow(/not found in \/v1\/sessions/);
+  });
+
+  it("fails when the session has no continuation token", async () => {
+    stub = await startStub({
+      sessions: [
+        { sessionId: "ses_attach", continuationToken: null, mode: "task" },
+      ],
+      events: [],
+    });
+    await expect(
+      runChat({
+        baseUrl: stub.url,
+        sessionId: "ses_attach",
+        oneShot: true,
+        noColor: true,
+      })
+    ).rejects.toThrow(/no continuation token.*task/);
+  });
+});