@cursor/july 0.1.20 → 0.1.21

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

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