@cursor/july 0.1.26 → 0.1.28

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

@@ -1,294 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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/);
-  });
-});