@cursor/july 0.1.31 → 0.1.33

package/src/internal/cursor-relay-core.ts

@@ -151,6 +151,42 @@ export interface CursorRelayCoreOptions<TEvent extends { offset: string }> {
   fetchImpl?: typeof fetch;
   /** Test seam: override long-poll wait (default 25s). */
   pollWaitMs?: number;
+  /**
+   * Desired-revision generation for hosted engines. Sent as
+   * `x-agent-serve-generation` so the control plane can fence zombies after
+   * a redeploy. Defaults to `process.env.AGENT_SERVE_GENERATION` when set.
+   */
+  deploymentGeneration?: number;
+}
+
+/** Must match server-shared `AGENT_SERVE_GENERATION_HEADER`. */
+export const AGENT_SERVE_GENERATION_HEADER = "x-agent-serve-generation";
+
+/** Must match server-shared `AGENT_SERVE_GENERATION_ENV_VAR`. */
+export const AGENT_SERVE_GENERATION_ENV_VAR = "AGENT_SERVE_GENERATION";
+
+export function resolveAgentServeDeploymentGeneration(
+  explicit?: number
+): number | undefined {
+  if (
+    explicit !== undefined &&
+    Number.isSafeInteger(explicit) &&
+    explicit > 0
+  ) {
+    return explicit;
+  }
+  const raw = process.env[AGENT_SERVE_GENERATION_ENV_VAR]?.trim();
+  if (raw === undefined || raw.length === 0) {
+    return undefined;
+  }
+  if (!/^\d+$/.test(raw)) {
+    return undefined;
+  }
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    return undefined;
+  }
+  return parsed;
 }
 
 export class CursorRelayCore<TEvent extends { offset: string }> {
@@ -160,6 +196,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
   private consumePromise: Promise<void> | undefined;
   private readonly offsetStore: RelayOffsetStore;
   private readonly fetchImpl: typeof fetch;
+  private readonly deploymentGeneration: number | undefined;
   private consumerId = "";
   /** undefined until the first registration, so a clean first success logs. */
   private lastRegistrationLog: string | undefined;
@@ -175,6 +212,9 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
   constructor(private readonly options: CursorRelayCoreOptions<TEvent>) {
     this.offsetStore = new RelayOffsetStore(options.stateDir);
     this.fetchImpl = options.fetchImpl ?? fetch;
+    this.deploymentGeneration = resolveAgentServeDeploymentGeneration(
+      options.deploymentGeneration
+    );
   }
 
   start(): void {
@@ -285,6 +325,13 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
         headers: {
           authorization: `Bearer ${this.options.apiKey}`,
           "content-type": "application/json",
+          ...(this.deploymentGeneration === undefined
+            ? {}
+            : {
+                [AGENT_SERVE_GENERATION_HEADER]: String(
+                  this.deploymentGeneration
+                ),
+              }),
         },
         body: JSON.stringify(adapter.buildDeregistrationBody(this.consumerId)),
         signal: controller.signal,
@@ -322,6 +369,13 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
       headers: {
         authorization: `Bearer ${this.options.apiKey}`,
         ...(body === undefined ? {} : { "content-type": "application/json" }),
+        ...(this.deploymentGeneration === undefined
+          ? {}
+          : {
+              [AGENT_SERVE_GENERATION_HEADER]: String(
+                this.deploymentGeneration
+              ),
+            }),
       },
       ...(body === undefined ? {} : { body: JSON.stringify(body) }),
       ...(this.abort === undefined ? {} : { signal: this.abort.signal }),
@@ -514,14 +568,19 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
     response: Response,
     backoffMs: number
   ): Promise<number> {
-    const isAuthFailure = response.status === 401 || response.status === 403;
-    const sleepMs = isAuthFailure ? AUTH_FAILURE_BACKOFF_MS : backoffMs;
+    // 409 = generation fence (stale resident after redeploy). Same long
+    // backoff as auth: retrying every second cannot heal a wrong generation.
+    const isAuthOrFenceFailure =
+      response.status === 401 ||
+      response.status === 403 ||
+      response.status === 409;
+    const sleepMs = isAuthOrFenceFailure ? AUTH_FAILURE_BACKOFF_MS : backoffMs;
     const text = await response.text().catch(() => "");
     this.log(
       `poll failed: ${response.status} ${text.slice(0, 300)} (retrying in ${Math.round(sleepMs / 1000)}s)`
     );
     await this.sleep(sleepMs);
-    return isAuthFailure
+    return isAuthOrFenceFailure
       ? AUTH_FAILURE_BACKOFF_MS
       : Math.min(backoffMs * 2, MAX_BACKOFF_MS);
   }

package/src/internal/review-comments.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
+import type { HostGitHubClient } from "../types.js";
 
-export type ReviewCommentPublisher = "local_gh";
+export type ReviewCommentPublisher = "local_gh" | "host_github";
 
 export type ReviewCommentPostResult = {
   posted: boolean;
@@ -84,6 +85,80 @@ export function createLocalGhReviewPublisher(): ReviewCommentPublisherImplementa
   };
 }
 
+/**
+ * Posts a PR review through the host GitHub client (Cursor account lease,
+ * App installation token, or PAT). Prefer this on Cursor-deployed agents —
+ * no separate GitHub write secret is required when `githubChannel({
+ * cursorAccount })` is bound.
+ */
+export function createHostGithubReviewPublisher(
+  github: HostGitHubClient
+): ReviewCommentPublisherImplementation {
+  return {
+    async postReview(args) {
+      return postReviewViaHostGithub(github, args);
+    },
+  };
+}
+
+async function postReviewViaHostGithub(
+  github: HostGitHubClient,
+  args: ReviewCommentPostArgs
+): Promise<ReviewCommentPostResult> {
+  const prepared = prepareReviewCommentsRequest(args);
+  if (prepared.kind === "skipped") {
+    return {
+      ...prepared.result,
+      publisher: "host_github",
+    };
+  }
+
+  const { request } = prepared;
+  const [owner, repo] = request.repo.split("/", 2);
+  if (owner === undefined || repo === undefined || repo === "") {
+    return skippedHost("unparseable owner/repo from PR URL");
+  }
+
+  try {
+    args.signal?.throwIfAborted();
+    const octokit = await github.getOctokit();
+    args.signal?.throwIfAborted();
+    const response = await octokit.rest.pulls.createReview({
+      owner,
+      repo,
+      pull_number: request.prNumber,
+      commit_id: request.headSha,
+      body: request.message,
+      event: "COMMENT",
+      comments: request.comments.map(toGithubPullRequestReviewComment),
+    });
+    const htmlUrl =
+      typeof response.data.html_url === "string"
+        ? response.data.html_url
+        : undefined;
+    const inlineCommentCount = request.comments.length;
+    return {
+      posted: true,
+      publisher: "host_github",
+      mode:
+        inlineCommentCount > 0
+          ? "review_with_inline_comments"
+          : "review_body_only",
+      inlineCommentCount,
+      detail: htmlUrl
+        ? `posted via host GitHub: ${htmlUrl}`
+        : `posted via host GitHub with ${inlineCommentCount} inline comment(s)`,
+    };
+  } catch (error) {
+    if (args.signal?.aborted) {
+      throw error;
+    }
+    return skippedHost(
+      `host GitHub review post failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
 async function postReviewViaLocalGh(
   args: ReviewCommentPostArgs
 ): Promise<ReviewCommentPostResult> {
@@ -129,10 +204,25 @@ async function postReviewViaLocalGh(
   }
 }
 
+type GithubPullRequestReviewComment = {
+  path: string;
+  body: string;
+  line: number;
+  side: "RIGHT";
+  start_line?: number;
+  start_side?: "RIGHT";
+};
+
 function toGithubReviewComment(
   comment: ReviewInlineComment
 ): Record<string, string | number> {
-  const body: Record<string, string | number> = {
+  return toGithubPullRequestReviewComment(comment);
+}
+
+function toGithubPullRequestReviewComment(
+  comment: ReviewInlineComment
+): GithubPullRequestReviewComment {
+  const body: GithubPullRequestReviewComment = {
     path: comment.file,
     body: comment.body,
     line: comment.line,
@@ -159,6 +249,16 @@ function skipped(detail: string): ReviewCommentPostResult {
   };
 }
 
+function skippedHost(detail: string): ReviewCommentPostResult {
+  return {
+    posted: false,
+    publisher: "host_github",
+    mode: "skipped",
+    inlineCommentCount: 0,
+    detail,
+  };
+}
+
 function parseGithubPrUrl(
   prUrl: string
 ):

package/src/internal/server.ts

@@ -959,7 +959,15 @@ function mountAgentRoutes(
     method: "GET",
     pattern: `${base}/v1/health`,
     auth: "none",
-    handler: () => jsonResponse({ ok: true, name: project.name }),
+    // Temporal consumes this response before promoting a newly deployed pod.
+    // Include the framework build there so deploy observability gets the
+    // version from the process that will serve turns, with no second request.
+    handler: () =>
+      jsonResponse({
+        ok: true,
+        name: project.name,
+        version: packageVersion(),
+      }),
   });
 
   // Bootstrap the SPA can't derive from its own URL (agent name, dev mode, and