@cursor/july 0.1.93 → 0.1.95

package/src/internal/scm/pr-url.ts

@@ -0,0 +1,95 @@
+/**
+ * Provider-neutral PR URL parse. GitHub.com plus the Origin page shapes
+ * humans paste: cursor.com/codebase, review.cursor.com/pr, origin.cursor.com.
+ */
+
+export type PrProvider = "github" | "origin";
+
+export type ParsedPrUrl = {
+  provider: PrProvider;
+  owner: string;
+  repo: string;
+  number: number;
+  url: string;
+};
+
+const ORIGIN_PAGE = /^origin(-[a-z0-9]+)?\.cursor\.com$/i;
+
+function positiveInt(raw: string | undefined): number | undefined {
+  if (raw === undefined) {
+    return undefined;
+  }
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) {
+    return undefined;
+  }
+  return n;
+}
+
+function parsed(
+  provider: PrProvider,
+  owner: string | undefined,
+  repo: string | undefined,
+  number: number | undefined
+): ParsedPrUrl | undefined {
+  if (owner === undefined || repo === undefined || number === undefined) {
+    return undefined;
+  }
+  const url =
+    provider === "origin"
+      ? `https://cursor.com/codebase/${owner}/${repo}/pull/${number}`
+      : `https://github.com/${owner}/${repo}/pull/${number}`;
+  return { provider, owner, repo, number, url };
+}
+
+/** Strip Slack mrkdwn wrappers and trailing punctuation before `URL`. */
+function normalizeRaw(raw: string): string {
+  return raw
+    .trim()
+    .replace(/^[<[]+/, "")
+    .replace(/[>\].,;]+$/, "");
+}
+
+export function parsePrUrl(raw: string): ParsedPrUrl | undefined {
+  let url: URL;
+  try {
+    url = new URL(normalizeRaw(raw));
+  } catch {
+    return undefined;
+  }
+
+  const parts = url.pathname.split("/").filter(Boolean);
+  const host = url.hostname.toLowerCase();
+
+  if (
+    (host === "github.com" || host === "www.github.com") &&
+    parts.length >= 4 &&
+    parts[2] === "pull"
+  ) {
+    return parsed("github", parts[0], parts[1], positiveInt(parts[3]));
+  }
+
+  if (ORIGIN_PAGE.test(host) && parts.length >= 4 && parts[2] === "github") {
+    return parsed("origin", parts[0], parts[1], positiveInt(parts[3]));
+  }
+
+  if (
+    (host === "cursor.com" || host === "www.cursor.com") &&
+    parts[0] === "codebase" &&
+    parts.length >= 5 &&
+    parts[3] === "pull"
+  ) {
+    return parsed("origin", parts[1], parts[2], positiveInt(parts[4]));
+  }
+
+  if (host === "review.cursor.com" && parts[0] === "pr") {
+    if (parts.length >= 5 && parts[3] === "github") {
+      return parsed("origin", parts[1], parts[2], positiveInt(parts[4]));
+    }
+    if (parts.length >= 4) {
+      return parsed("origin", parts[1], parts[2], positiveInt(parts[3]));
+    }
+  }
+
+  return undefined;
+}

package/src/internal/sdk-runner.ts

@@ -29,6 +29,7 @@ import {
   type TurnUsage,
 } from "../types.js";
 import { mapSdkTokenUsage, usageTokenSum } from "./cloud-turn-cost.js";
+import type { ConversationMirror } from "./conversation-mirror.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
 
 /** Internal seam between the session engine and the Cursor SDK harness. */
@@ -117,6 +118,13 @@ export interface CursorSdkRunnerOptions {
    * `LocalAgentStore` for heavy multi-session concurrency.
    */
   store?: LocalAgentStore;
+  /**
+   * Durable mirror for local conversations (v2 hosted engines). Hydrated
+   * before `Agent.resume` so a follow-up landing on a fresh pod finds the
+   * conversation, and persisted — awaited — after each local turn settles,
+   * because a hosted pod can be parked right after the execution reply.
+   */
+  conversationMirror?: ConversationMirror;
   /** Diagnostics for degraded paths (resume-miss fallback). */
   logger?: (line: string) => void;
   /**
@@ -316,6 +324,13 @@ export class CursorSdkRunner implements AgentRunner {
       }
       try {
         const result = await run.wait();
+        // Mirror the conversation before replying: on hosted v2 the pod can
+        // be parked as soon as the execution reply lands, so a
+        // fire-and-forget write would race VM teardown. Failed turns still
+        // checkpoint the user message, so they persist too.
+        if (request.runtime === "local") {
+          await this.persistConversation(request, agent.agentId);
+        }
         let outcome = toTurnOutcome(result);
         if (outcome.status === "error") {
           // An error result usually means the handle's transport is poisoned
@@ -469,8 +484,7 @@ export class CursorSdkRunner implements AgentRunner {
   private async buildLocalOptions(
     request: RunnerPrewarmRequest
   ): Promise<AgentOptions> {
-    const store =
-      this.options.store ?? (await this.getStore(request.runnerStateDir));
+    const store = await this.resolveStore(request);
     return {
       ...this.buildSharedOptions(request),
       // The built-in tool allowlist rides AgentOptions, not `local`, and is
@@ -507,6 +521,15 @@ export class CursorSdkRunner implements AgentRunner {
     }
 
     const agentId = request.sdkAgentId ?? request.sessionId;
+    const mirror = this.options.conversationMirror;
+    if (mirror !== undefined) {
+      // Host replacement: restore the conversation from the durable mirror
+      // before resuming, so the thread continues instead of starting fresh.
+      // A sink failure propagates and fails the turn (retryable) — reading
+      // an outage as "nothing mirrored" would silently fork the thread.
+      const store = await this.resolveStore(request);
+      await mirror.hydrate(store, agentId);
+    }
     try {
       return await Agent.resume(agentId, options);
     } catch (error) {
@@ -570,6 +593,38 @@ export class CursorSdkRunner implements AgentRunner {
     return Agent.create(options);
   }
 
+  private resolveStore(
+    request: Pick<RunnerPrewarmRequest, "runnerStateDir">
+  ): Promise<LocalAgentStore> {
+    return this.options.store !== undefined
+      ? Promise.resolve(this.options.store)
+      : this.getStore(request.runnerStateDir);
+  }
+
+  /**
+   * Mirror the settled turn's conversation. Persist failures are logged and
+   * dropped — a durable-mirror outage must not fail a turn that already ran.
+   */
+  private async persistConversation(
+    request: RunnerTurnRequest,
+    sdkAgentId: string
+  ): Promise<void> {
+    const mirror = this.options.conversationMirror;
+    if (mirror === undefined) {
+      return;
+    }
+    try {
+      const store = await this.resolveStore(request);
+      await mirror.persist(store, sdkAgentId);
+    } catch (error) {
+      this.log(
+        `[agent-sdk] conversation mirror: persist for ${sdkAgentId} failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+
   private getStore(stateDir: string): Promise<LocalAgentStore> {
     let storePromise = this.stores.get(stateDir);
     if (storePromise === undefined) {