@cursor/july 0.1.19 → 0.1.21

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

@@ -0,0 +1,350 @@
+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 { DeploymentDetail } from "./deploy-client.js";
+import {
+  fetchLogs,
+  progressMessage,
+  runLogsTail,
+  sanitizeCustomerError,
+} from "./logs-client.js";
+import { PROD_ENGINE_WAKE_HEADERS } from "./resolve-prod-target.js";
+
+interface StubLogsServer {
+  url: string;
+  close: () => Promise<void>;
+  requests: Array<{ after: string | null; headers: Record<string, string> }>;
+  setEntries: (
+    entries: Array<{ index: number; at: string; line: string }>
+  ) => void;
+}
+
+async function startStubLogsServer(): Promise<StubLogsServer> {
+  let entries: Array<{ index: number; at: string; line: string }> = [];
+  const requests: StubLogsServer["requests"] = [];
+  const server: Server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    if (req.method === "GET" && url.pathname === "/v1/logs") {
+      const headers: Record<string, string> = {};
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (typeof value === "string") {
+          headers[key] = value;
+        }
+      }
+      requests.push({ after: url.searchParams.get("after"), headers });
+      const afterRaw = url.searchParams.get("after");
+      const after =
+        afterRaw === null || afterRaw === ""
+          ? -1
+          : Number.parseInt(afterRaw, 10);
+      const cursor = Number.isFinite(after) ? after : -1;
+      const batch = entries.filter((e) => e.index > cursor);
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          entries: batch,
+          nextAfter:
+            batch.length === 0
+              ? cursor
+              : (batch[batch.length - 1]?.index ?? cursor),
+        })
+      );
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+  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,
+    setEntries: (next) => {
+      entries = next;
+    },
+    close: () =>
+      new Promise<void>((resolvePromise, reject) =>
+        server.close((error) => (error ? reject(error) : resolvePromise()))
+      ),
+  };
+}
+
+describe("sanitizeCustomerError / progressMessage", () => {
+  it("scrubs hosting URLs and jargon", () => {
+    expect(
+      sanitizeCustomerError(
+        "setup: https://foo.cursorvm.com/x pod-abc anyrun PROVISIONING"
+      )
+    ).not.toMatch(/cursorvm|anyrun|pod-abc|PROVISIONING/i);
+  });
+
+  it("rewrites git clone process names for customers", () => {
+    expect(
+      sanitizeCustomerError(
+        "setup: Process gitCloneCheckout failed with exit code 128"
+      )
+    ).toContain("git clone");
+    expect(
+      sanitizeCustomerError(
+        "setup: Process gitCloneCheckout failed with exit code 128"
+      )
+    ).not.toContain("gitCloneCheckout");
+  });
+
+  it("formats failed progress with sanitized lastError", () => {
+    expect(
+      progressMessage("failed", "setup: https://secret.example/fail")
+    ).toBe("Deploy failed: setup: [url]");
+  });
+
+  it("prefers statusMessage over the coarse progress vocabulary", () => {
+    expect(progressMessage("building", null, "Checking out source…")).toBe(
+      "Checking out source…"
+    );
+    expect(progressMessage("building", null, "Installing dependencies…")).toBe(
+      "Installing dependencies…"
+    );
+  });
+});
+
+describe("fetchLogs / runLogsTail", () => {
+  let stub: StubLogsServer;
+
+  afterEach(async () => {
+    await stub.close();
+  });
+
+  it("dumps current buffer with --once", async () => {
+    stub = await startStubLogsServer();
+    stub.setEntries([
+      { index: 0, at: "2026-07-17T00:00:00.000Z", line: "hello" },
+      { index: 1, at: "2026-07-17T00:00:01.000Z", line: "world" },
+    ]);
+    const out: string[] = [];
+    await runLogsTail({
+      dir: ".",
+      url: stub.url,
+      once: true,
+      write: (t) => out.push(t),
+      err: () => {},
+    });
+    expect(out.join("")).toBe("hello\nworld\n");
+  });
+
+  it("follows and advances the after cursor until aborted", async () => {
+    stub = await startStubLogsServer();
+    stub.setEntries([
+      { index: 0, at: "2026-07-17T00:00:00.000Z", line: "one" },
+    ]);
+    const out: string[] = [];
+    const controller = new AbortController();
+    let polls = 0;
+    await runLogsTail({
+      dir: ".",
+      url: stub.url,
+      write: (t) => out.push(t),
+      err: () => {},
+      signal: controller.signal,
+      intervalMs: 10,
+      sleep: async () => {
+        polls += 1;
+        if (polls === 1) {
+          stub.setEntries([
+            { index: 0, at: "2026-07-17T00:00:00.000Z", line: "one" },
+            { index: 1, at: "2026-07-17T00:00:01.000Z", line: "two" },
+          ]);
+        }
+        if (polls >= 2) {
+          controller.abort();
+        }
+      },
+    });
+    expect(out.join("")).toContain("one\n");
+    expect(out.join("")).toContain("two\n");
+    expect(stub.requests.some((r) => r.after === "0")).toBe(true);
+  });
+
+  it("prints --prod progress once without handing off when not running", async () => {
+    stub = await startStubLogsServer();
+    const out: string[] = [];
+    const err: string[] = [];
+    await runLogsTail({
+      prod: true,
+      dir: ".",
+      slug: "buddy",
+      once: true,
+      write: (t) => out.push(t),
+      err: (t) => err.push(t),
+      getDeployment: async () =>
+        ({
+          id: 1,
+          slug: "buddy",
+          teamId: 1,
+          deploymentKind: "repo",
+          status: "pending",
+          progress: "queued",
+          generation: 1,
+          engineAlias: "/alias",
+          lastError: null,
+        }) satisfies DeploymentDetail,
+      resolveRuntime: async () => ({ agentUrl: stub.url }),
+    });
+    expect(out.join("")).toBe("Waiting to start…\n");
+    expect(`${out.join("")}${err.join("")}`).not.toMatch(
+      /engine access|anyrun|cursorvm|PROVISIONING/i
+    );
+  });
+
+  it("follows --prod from building to runtime logs without leaking infra", async () => {
+    stub = await startStubLogsServer();
+    stub.setEntries([
+      { index: 0, at: "2026-07-17T00:00:00.000Z", line: "agent booted" },
+    ]);
+
+    const queue: DeploymentDetail[] = [
+      {
+        id: 1,
+        slug: "buddy",
+        teamId: 1,
+        deploymentKind: "repo",
+        status: "deploying",
+        progress: "building",
+        generation: 1,
+        engineAlias: "/alias",
+        lastError: null,
+      },
+      {
+        id: 1,
+        slug: "buddy",
+        teamId: 1,
+        deploymentKind: "repo",
+        status: "running",
+        progress: "running",
+        generation: 1,
+        engineAlias: "/alias",
+        lastError: null,
+      },
+    ];
+
+    const out: string[] = [];
+    const err: string[] = [];
+    const controller = new AbortController();
+    await runLogsTail({
+      prod: true,
+      dir: ".",
+      slug: "buddy",
+      write: (t) => out.push(t),
+      err: (t) => err.push(t),
+      signal: controller.signal,
+      getDeployment: async () => {
+        const next = queue.shift();
+        if (next === undefined) {
+          return {
+            id: 1,
+            slug: "buddy",
+            teamId: 1,
+            deploymentKind: "repo",
+            status: "running",
+            progress: "running",
+            generation: 1,
+            engineAlias: "/alias",
+            lastError: null,
+          };
+        }
+        return next;
+      },
+      resolveRuntime: async () => ({
+        agentUrl: stub.url,
+        headers: {
+          "x-anyrun-port-token": "port-tok",
+          ...PROD_ENGINE_WAKE_HEADERS,
+        },
+      }),
+      intervalMs: 1,
+      sleep: async () => {
+        if (out.some((line) => line.includes("agent booted"))) {
+          controller.abort();
+        }
+      },
+    });
+
+    const text = `${out.join("")}\n${err.join("")}`;
+    expect(out.join("")).toContain("Checking out source…");
+    expect(out.join("")).toContain("agent booted\n");
+    expect(out.join("")).not.toContain("Deployment running");
+    expect(text).not.toMatch(/engine access|anyrun|cursorvm|PROVISIONING/i);
+    expect(stub.requests[0]?.headers["x-anyrun-port-token"]).toBe("port-tok");
+    expect(
+      stub.requests[0]?.headers["x-anyrun-hibernation-lower-bound-s"]
+    ).toBe(PROD_ENGINE_WAKE_HEADERS["x-anyrun-hibernation-lower-bound-s"]);
+  });
+
+  it("fetchLogs returns entries", async () => {
+    stub = await startStubLogsServer();
+    stub.setEntries([{ index: 3, at: "2026-07-17T00:00:00.000Z", line: "x" }]);
+    const result = await fetchLogs({ baseUrl: stub.url, after: 2 });
+    expect(result.entries).toHaveLength(1);
+    expect(result.nextAfter).toBe(3);
+  });
+
+  it("emits NDJSON progress and log events with --json", async () => {
+    stub = await startStubLogsServer();
+    stub.setEntries([
+      { index: 0, at: "2026-07-17T00:00:00.000Z", line: "booted" },
+    ]);
+    const queue: DeploymentDetail[] = [
+      {
+        id: 1,
+        slug: "buddy",
+        teamId: 1,
+        deploymentKind: "repo",
+        status: "deploying",
+        progress: "building",
+        generation: 1,
+        engineAlias: "/alias",
+        lastError: null,
+      },
+      {
+        id: 1,
+        slug: "buddy",
+        teamId: 1,
+        deploymentKind: "repo",
+        status: "running",
+        progress: "running",
+        generation: 1,
+        engineAlias: "/alias",
+        lastError: null,
+      },
+    ];
+    const out: string[] = [];
+    const controller = new AbortController();
+    await runLogsTail({
+      prod: true,
+      dir: ".",
+      slug: "buddy",
+      json: true,
+      write: (t) => out.push(t),
+      err: () => {},
+      signal: controller.signal,
+      getDeployment: async () => queue.shift()!,
+      resolveRuntime: async () => ({ agentUrl: stub.url }),
+      intervalMs: 1,
+      sleep: async () => {
+        if (out.some((line) => line.includes('"type":"log"'))) {
+          controller.abort();
+        }
+      },
+    });
+    const events = out
+      .join("")
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { type: string });
+    expect(events.some((e) => e.type === "progress")).toBe(true);
+    expect(events.some((e) => e.type === "log")).toBe(true);
+    expect(out.join("")).toContain('"progress":"building"');
+    expect(out.join("")).toContain('"line":"booted"');
+  });
+});