@cursor/july 0.1.26 → 0.1.28

package/src/internal/sessions-client.test.ts

@@ -1,518 +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 } from "vitest";
-import type { SessionSummary } from "../types.js";
-import { cmdChat, cmdResume, cmdSession, cmdSessions } from "./cli-ax.js";
-import { PROD_ENGINE_WAKE_HEADERS } from "./resolve-prod-target.js";
-import {
-  fetchSessionEvents,
-  formatSessionsTable,
-  listSessions,
-  listSessionsWithSource,
-  pickPreviousSession,
-  resolvePreviousSessionId,
-} from "./sessions-client.js";
-
-interface StubServer {
-  url: string;
-  close: () => Promise<void>;
-  requests: Array<{ path: string; headers: Record<string, string> }>;
-}
-
-async function startStub(opts: {
-  sessions?: unknown[];
-  source?: "cursor-hosted" | "local";
-  events?: unknown[];
-  eventsStatus?: number;
-  /** When set, follow-up POSTs + stream succeed for `chat --json --resume`. */
-  acceptFollowUp?: boolean;
-}): Promise<StubServer> {
-  const requests: StubServer["requests"] = [];
-  const server: Server = createServer((req, res) => {
-    const url = new URL(req.url ?? "/", "http://localhost");
-    const headers: Record<string, string> = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (typeof value === "string") {
-        headers[key] = value;
-      }
-    }
-    requests.push({
-      path: `${req.method} ${url.pathname}${url.search}`,
-      headers,
-    });
-
-    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/sessions") {
-      send(200, {
-        sessions: opts.sessions ?? [],
-        ...(opts.source === undefined ? {} : { source: opts.source }),
-      });
-      return;
-    }
-    if (
-      req.method === "GET" &&
-      url.pathname.startsWith("/v1/session/") &&
-      url.pathname.endsWith("/events")
-    ) {
-      const status = opts.eventsStatus ?? 200;
-      if (status !== 200) {
-        send(status, { error: "nope" });
-        return;
-      }
-      if (url.searchParams.get("format") === "json") {
-        send(200, { sessionId: "ses_1", events: opts.events ?? [] });
-        return;
-      }
-      sendNdjson(opts.events ?? []);
-      return;
-    }
-    if (
-      opts.acceptFollowUp === true &&
-      req.method === "POST" &&
-      /^\/v1\/session\/[^/]+$/.test(url.pathname)
-    ) {
-      const sessionId = url.pathname.split("/").pop() ?? "ses_unknown";
-      req.resume();
-      req.on("end", () => {
-        send(200, {
-          ok: true,
-          sessionId,
-          continuationToken: "http:tok",
-        });
-      });
-      return;
-    }
-    if (
-      opts.acceptFollowUp === true &&
-      req.method === "GET" &&
-      /^\/v1\/session\/[^/]+\/stream$/.test(url.pathname)
-    ) {
-      const sessionId = url.pathname.split("/")[3] ?? "ses_a";
-      const start = Number(url.searchParams.get("startIndex") ?? "0");
-      sendNdjson([
-        {
-          type: "turn.started",
-          index: start,
-          sessionId,
-          turnId: "turn_resume",
-          at: "2026-07-17T12:00:00.000Z",
-          data: {},
-        },
-        {
-          type: "message.completed",
-          index: start + 1,
-          sessionId,
-          turnId: "turn_resume",
-          at: "2026-07-17T12:00:01.000Z",
-          data: { text: "resumed reply", finishReason: "stop" },
-        },
-        {
-          type: "session.completed",
-          index: start + 2,
-          sessionId,
-          at: "2026-07-17T12:00:02.000Z",
-          data: {},
-        },
-      ]);
-      return;
-    }
-    send(404, { 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}`,
-    requests,
-    close: () =>
-      new Promise<void>((resolvePromise, reject) =>
-        server.close((error) => (error ? reject(error) : resolvePromise()))
-      ),
-  };
-}
-
-const sampleSessions = [
-  {
-    sessionId: "ses_a",
-    channelId: "http",
-    mode: "chat",
-    turnCount: 2,
-    running: false,
-    createdAt: "2026-07-17T10:00:00.000Z",
-    updatedAt: "2026-07-17T10:05:00.000Z",
-    continuationToken: "http:tok",
-  },
-  {
-    sessionId: "ses_b",
-    channelId: "slack",
-    mode: "task",
-    turnCount: 1,
-    running: true,
-    createdAt: "2026-07-17T11:00:00.000Z",
-    updatedAt: "2026-07-17T11:01:00.000Z",
-    continuationToken: null,
-  },
-];
-
-const sampleEvents = [
-  {
-    type: "session.started",
-    index: 0,
-    sessionId: "ses_a",
-    at: "2026-07-17T10:00:00.000Z",
-    data: {},
-  },
-  {
-    type: "message.received",
-    index: 1,
-    sessionId: "ses_a",
-    at: "2026-07-17T10:00:01.000Z",
-    turnId: "t1",
-    data: { text: "hello", channelId: "http" },
-  },
-  {
-    type: "message.completed",
-    index: 2,
-    sessionId: "ses_a",
-    at: "2026-07-17T10:00:02.000Z",
-    turnId: "t1",
-    data: { text: "hi there", finishReason: "stop" },
-  },
-  {
-    type: "turn.completed",
-    index: 3,
-    sessionId: "ses_a",
-    at: "2026-07-17T10:00:03.000Z",
-    turnId: "t1",
-    data: {
-      usage: { inputTokens: 1, outputTokens: 2 },
-    },
-  },
-];
-
-describe("sessions-client", () => {
-  let stub: StubServer | undefined;
-
-  afterEach(async () => {
-    await stub?.close();
-    stub = undefined;
-  });
-
-  it("lists sessions", async () => {
-    stub = await startStub({ sessions: sampleSessions });
-    const sessions = await listSessions({ baseUrl: stub.url });
-    expect(sessions).toHaveLength(2);
-    expect(sessions[0]?.sessionId).toBe("ses_a");
-  });
-
-  it("formats a table", () => {
-    const table = formatSessionsTable(sampleSessions as never);
-    expect(table).toContain("ses_a");
-    expect(table).toContain("slack");
-    expect(table).toContain("SESSION");
-  });
-
-  it("fetches session events as JSON", async () => {
-    stub = await startStub({ events: sampleEvents });
-    const events = await fetchSessionEvents({
-      baseUrl: stub.url,
-      sessionId: "ses_a",
-    });
-    expect(events).toHaveLength(4);
-    expect(stub.requests[0]?.path).toContain("format=json");
-  });
-});
-
-describe("pickPreviousSession", () => {
-  let stub: StubServer | undefined;
-
-  afterEach(async () => {
-    await stub?.close();
-    stub = undefined;
-  });
-
-  it("picks the most recently updated followable session", () => {
-    const sessions: SessionSummary[] = [
-      {
-        sessionId: "ses_old",
-        channelId: "http",
-        mode: "chat",
-        turnCount: 1,
-        running: false,
-        createdAt: "2026-07-17T09:00:00.000Z",
-        updatedAt: "2026-07-17T09:05:00.000Z",
-        continuationToken: "http:old",
-      },
-      {
-        sessionId: "ses_new",
-        channelId: "http",
-        mode: "chat",
-        turnCount: 2,
-        running: false,
-        createdAt: "2026-07-17T10:00:00.000Z",
-        updatedAt: "2026-07-17T12:00:00.000Z",
-        continuationToken: "http:new",
-      },
-      {
-        sessionId: "ses_task",
-        channelId: "slack",
-        mode: "task",
-        turnCount: 1,
-        running: false,
-        createdAt: "2026-07-17T13:00:00.000Z",
-        updatedAt: "2026-07-17T13:01:00.000Z",
-        continuationToken: null,
-      },
-    ];
-    expect(pickPreviousSession(sessions)?.sessionId).toBe("ses_new");
-  });
-
-  it("returns undefined when nothing is followable", () => {
-    expect(pickPreviousSession([])).toBeUndefined();
-    expect(
-      pickPreviousSession([
-        {
-          sessionId: "ses_task",
-          channelId: "slack",
-          mode: "task",
-          turnCount: 1,
-          running: false,
-          createdAt: "2026-07-17T13:00:00.000Z",
-          updatedAt: "2026-07-17T13:01:00.000Z",
-          continuationToken: null,
-        },
-      ])
-    ).toBeUndefined();
-  });
-
-  it("resolvePreviousSessionId hits /v1/sessions", async () => {
-    stub = await startStub({ sessions: sampleSessions });
-    await expect(resolvePreviousSessionId({ baseUrl: stub.url })).resolves.toBe(
-      "ses_a"
-    );
-  });
-});
-
-describe("cmdSessions / cmdSession", () => {
-  let stub: StubServer;
-  let stdoutWrite: typeof process.stdout.write;
-  let stderrWrite: typeof process.stderr.write;
-  let out: string;
-  let err: string;
-
-  const captureIo = (): void => {
-    out = "";
-    err = "";
-    stdoutWrite = process.stdout.write.bind(process.stdout);
-    stderrWrite = process.stderr.write.bind(process.stderr);
-    process.stdout.write = ((chunk: string | Uint8Array) => {
-      out += typeof chunk === "string" ? chunk : chunk.toString();
-      return true;
-    }) as typeof process.stdout.write;
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      err += typeof chunk === "string" ? chunk : chunk.toString();
-      return true;
-    }) as typeof process.stderr.write;
-  };
-
-  afterEach(async () => {
-    process.stdout.write = stdoutWrite;
-    process.stderr.write = stderrWrite;
-    await stub.close();
-  });
-
-  it("prints a sessions table and JSON", async () => {
-    stub = await startStub({
-      sessions: sampleSessions,
-      source: "cursor-hosted",
-    });
-    captureIo();
-    const code = await cmdSessions({
-      dir: ".",
-      url: stub.url,
-    });
-    expect(code).toBe(0);
-    expect(out).toContain("ses_a");
-    expect(out).toContain("SESSION");
-    expect(out).toContain("Listing from cursor-hosted storage (durable DB).");
-
-    out = "";
-    const jsonCode = await cmdSessions({
-      dir: ".",
-      url: stub.url,
-      json: true,
-    });
-    expect(jsonCode).toBe(0);
-    const parsed = JSON.parse(out) as {
-      sessions: unknown[];
-      source?: string;
-    };
-    expect(parsed.sessions).toHaveLength(2);
-    expect(parsed.source).toBe("cursor-hosted");
-  });
-
-  it("surfaces local source when the server reports it", async () => {
-    stub = await startStub({ sessions: [], source: "local" });
-    captureIo();
-    const code = await cmdSessions({ dir: ".", url: stub.url });
-    expect(code).toBe(0);
-    expect(out).toContain("Listing from local session store.");
-    expect(out).toContain("No sessions.");
-    await expect(
-      listSessionsWithSource({ baseUrl: stub.url })
-    ).resolves.toEqual({ sessions: [], source: "local" });
-  });
-
-  it("prints a session trajectory", async () => {
-    stub = await startStub({ events: sampleEvents });
-    captureIo();
-    const code = await cmdSession("ses_a", { dir: ".", url: stub.url });
-    expect(code).toBe(0);
-    expect(out).toContain("hello");
-    expect(out).toContain("hi there");
-  });
-
-  it("sends --prod headers and keeps customer output infra-free", async () => {
-    stub = await startStub({ sessions: sampleSessions });
-    captureIo();
-    const sessions = await listSessions({
-      baseUrl: stub.url,
-      auth: {
-        headers: {
-          "x-anyrun-port-token": "port-tok",
-          ...PROD_ENGINE_WAKE_HEADERS,
-        },
-      },
-    });
-    expect(sessions).toHaveLength(2);
-    expect(stub.requests[0]?.headers["x-anyrun-port-token"]).toBe("port-tok");
-
-    const code = await cmdSessions({ dir: ".", url: stub.url });
-    expect(code).toBe(0);
-    expect(`${out}${err}`).not.toMatch(/engine access|anyrun|cursorvm/i);
-  });
-
-  it("rejects missing session id", async () => {
-    stub = await startStub({});
-    captureIo();
-    const code = await cmdSession(undefined, { dir: ".", url: stub.url });
-    expect(code).toBe(2);
-    expect(err).toContain("Usage:");
-  });
-});
-
-describe("cmdResume / chat --resume", () => {
-  let stub: StubServer | undefined;
-  let stdoutWrite: typeof process.stdout.write;
-  let stderrWrite: typeof process.stderr.write;
-  let out: string;
-  let err: string;
-
-  const captureIo = (): void => {
-    out = "";
-    err = "";
-    stdoutWrite = process.stdout.write.bind(process.stdout);
-    stderrWrite = process.stderr.write.bind(process.stderr);
-    process.stdout.write = ((chunk: string | Uint8Array) => {
-      out += typeof chunk === "string" ? chunk : chunk.toString();
-      return true;
-    }) as typeof process.stdout.write;
-    process.stderr.write = ((chunk: string | Uint8Array) => {
-      err += typeof chunk === "string" ? chunk : chunk.toString();
-      return true;
-    }) as typeof process.stderr.write;
-  };
-
-  afterEach(async () => {
-    process.stdout.write = stdoutWrite;
-    process.stderr.write = stderrWrite;
-    await stub?.close();
-    stub = undefined;
-  });
-
-  it("errors when there is no previous followable session", async () => {
-    stub = await startStub({ sessions: [] });
-    captureIo();
-    const code = await cmdResume(undefined, { dir: ".", url: stub.url });
-    expect(code).toBe(1);
-    expect(err).toContain("No previous followable session");
-  });
-
-  it("resumes the previous session without an id (json one-shot)", async () => {
-    stub = await startStub({
-      sessions: sampleSessions,
-      acceptFollowUp: true,
-    });
-    captureIo();
-    const code = await cmdResume(undefined, {
-      dir: ".",
-      url: stub.url,
-      json: true,
-      messages: ["continue"],
-    });
-    expect(code).toBe(0);
-    // Only ses_a is followable in sampleSessions (ses_b has no token).
-    expect(
-      stub.requests.some((r) => r.path.startsWith("POST /v1/session/ses_a"))
-    ).toBe(true);
-  });
-
-  it("chat --resume picks the previous session", async () => {
-    stub = await startStub({
-      sessions: [
-        ...sampleSessions,
-        {
-          sessionId: "ses_newer",
-          channelId: "http",
-          mode: "chat",
-          turnCount: 3,
-          running: false,
-          createdAt: "2026-07-17T12:00:00.000Z",
-          updatedAt: "2026-07-17T14:00:00.000Z",
-          continuationToken: "http:newer",
-        },
-      ],
-      acceptFollowUp: true,
-    });
-    captureIo();
-    const code = await cmdChat({
-      dir: ".",
-      url: stub.url,
-      resume: true,
-      json: true,
-      messages: ["ping"],
-    });
-    expect(code).toBe(0);
-    const followUp = stub.requests.find((r) =>
-      r.path.startsWith("POST /v1/session/ses_newer")
-    );
-    expect(followUp).toBeDefined();
-  });
-
-  it("still accepts an explicit session id", async () => {
-    stub = await startStub({
-      sessions: sampleSessions,
-      acceptFollowUp: true,
-    });
-    captureIo();
-    const code = await cmdResume("ses_a", {
-      dir: ".",
-      url: stub.url,
-      json: true,
-      messages: ["hi again"],
-    });
-    expect(code).toBe(0);
-    expect(
-      stub.requests.some((r) => r.path.startsWith("POST /v1/session/ses_a"))
-    ).toBe(true);
-  });
-});