@cursor/july 0.1.24 → 0.1.25

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