@cursor/july 0.1.109 → 0.1.111

package/src/internal/cursor-account-mcp-auth.ts

@@ -87,7 +87,7 @@ export async function authorizeCursorAccountConnectors(
   // servers, so personal connectors can never apply to a deployment.
   const available = (
     await backendClient.getAvailableMcpServers({ teamId })
-  ).filter((server) => server.isTeamServer);
+  ).filter(server => server.isTeamServer);
 
   const selected = selectConnectors(available, args.servers);
   for (const missing of selected.unmatched) {
@@ -103,10 +103,10 @@ export async function authorizeCursorAccountConnectors(
   }
 
   const nameById = new Map(
-    selected.servers.map((server) => [server.id, server.name])
+    selected.servers.map(server => [server.id, server.name])
   );
   const statuses = await backendClient.checkHttpMcpStatus({
-    serverIds: selected.servers.map((server) => server.id),
+    serverIds: selected.servers.map(server => server.id),
     oauthRedirectUri: redirectUri,
     serviceAccountId,
   });
@@ -183,7 +183,7 @@ function selectConnectors(
   for (const name of filter) {
     const wanted = name.trim().toLowerCase();
     const matches = available.filter(
-      (server) =>
+      server =>
         server.name.toLowerCase() === wanted ||
         server.serverIdentifier?.toLowerCase() === wanted
     );
@@ -210,7 +210,7 @@ function uniqueConnectorMatch(
     return undefined;
   }
   const byIdentifier = available.filter(
-    (server) => server.serverIdentifier?.toLowerCase() === wanted
+    server => server.serverIdentifier?.toLowerCase() === wanted
   );
   if (byIdentifier.length === 1) {
     return byIdentifier[0];
@@ -219,7 +219,7 @@ function uniqueConnectorMatch(
     return undefined;
   }
   const byName = available.filter(
-    (server) => server.name.toLowerCase() === wanted
+    server => server.name.toLowerCase() === wanted
   );
   if (byName.length === 1) {
     return byName[0];
@@ -261,12 +261,12 @@ export async function probeConnectorAuthUrls(args: {
       return urls;
     }
     const statuses = await args.client.checkHttpMcpStatus({
-      serverIds: matched.map((server) => server.id),
+      serverIds: matched.map(server => server.id),
       oauthRedirectUri: mcpOauthRedirectUri(),
       serviceAccountId: args.serviceAccountId,
     });
     const statusById = new Map(
-      statuses.map((status) => [status.id, status] as const)
+      statuses.map(status => [status.id, status] as const)
     );
     for (const identifier of args.identifiers) {
       const match = uniqueConnectorMatch(available, identifier);
@@ -312,7 +312,7 @@ async function pollUntilAuthorized(args: {
       // Transient probe errors; keep polling until the deadline.
       continue;
     }
-    const status = statuses.find((entry) => entry.id === args.serverId);
+    const status = statuses.find(entry => entry.id === args.serverId);
     if (status !== undefined && !status.requiresAuth) {
       return true;
     }

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

@@ -85,7 +85,7 @@ export function resolveDeploymentSubscriptions(options: {
     const environments = [
       ...new Set(
         (subscription.environments ?? options.environments ?? [])
-          .map((value) => value.trim())
+          .map(value => value.trim())
           .filter(Boolean)
       ),
     ];
@@ -190,9 +190,9 @@ export async function fanOutDeploymentEvent(input: {
   logger: (line: string) => void;
 }): Promise<void> {
   const { event, logger } = input;
-  const matched = input.targets.filter((target) =>
+  const matched = input.targets.filter(target =>
     target.subscriptions.some(
-      (subscription) =>
+      subscription =>
         subscription.deploySourceUri === event.deploySourceUri &&
         deploymentEventMatches(subscription, event)
     )
@@ -230,11 +230,11 @@ export class DeploymentEventRelay {
       logPrefix: "deployment-events",
       subscribePath: "/v0/deployment-events/subscriptions",
       pollPath: "/v0/deployment-events",
-      buildRegistrationBody: (consumerId) => ({
+      buildRegistrationBody: consumerId => ({
         consumerId,
         subscriptions: currentDeploymentSubscriptions(
           options.subscriptions
-        ).map((subscription) => ({
+        ).map(subscription => ({
           deploySourceUri: subscription.deploySourceUri,
           environments: subscription.environments,
           events: [...subscription.events],
@@ -242,11 +242,11 @@ export class DeploymentEventRelay {
       }),
       // Empty subscriptions drop this consumer's registration on clean stop
       // instead of leaving it to lapse by TTL.
-      buildDeregistrationBody: (consumerId) => ({
+      buildDeregistrationBody: consumerId => ({
         consumerId,
         subscriptions: [],
       }),
-      applyRegistrationResponse: (json) => {
+      applyRegistrationResponse: json => {
         const result = json as { deploySourceUris?: SubscriptionStatus[] };
         const wantedSubscriptions = currentDeploymentSubscriptions(
           options.subscriptions
@@ -257,7 +257,7 @@ export class DeploymentEventRelay {
         const confirmed: string[] = [];
         for (const status of result.deploySourceUris ?? []) {
           const wanted = wantedSubscriptions.find(
-            (subscription) =>
+            subscription =>
               subscription.deploySourceUri === status.deploySourceUri
           );
           if (!status.isSubscribed || wanted === undefined) {
@@ -271,7 +271,7 @@ export class DeploymentEventRelay {
         }
         if (confirmed.length > 0) {
           const kinds = [
-            ...new Set(wantedSubscriptions.flatMap((s) => [...s.events])),
+            ...new Set(wantedSubscriptions.flatMap(s => [...s.events])),
           ];
           lines.push(
             `subscribed to ${confirmed.join(", ")} for events: ${kinds.join(", ")}`
@@ -279,7 +279,7 @@ export class DeploymentEventRelay {
         }
         return lines;
       },
-      shouldDispatch: (event) => this.shouldDispatch(event),
+      shouldDispatch: event => this.shouldDispatch(event),
       dispatch: ({ offset: _offset, ...envelope }) =>
         options.dispatch(envelope),
     };

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

@@ -400,7 +400,7 @@ function stubGitHubCiPullRequests(input: {
   prUrl: string | undefined;
 }): Array<{ number: number; html_url?: string }> {
   if (input.snapshot !== undefined && input.snapshot.length > 0) {
-    return input.snapshot.map((pr) => ({
+    return input.snapshot.map(pr => ({
       number: pr.number,
       ...(pr.url === undefined ? {} : { html_url: pr.url }),
     }));
@@ -567,14 +567,14 @@ export function resolveCursorScmSubscriptions(
   options: Pick<CursorEventRelayOptions, "repos" | "events" | "subscriptions">
 ): CursorScmSubscription[] {
   if (options.subscriptions !== undefined) {
-    return options.subscriptions.map((subscription) => ({
+    return options.subscriptions.map(subscription => ({
       provider: subscription.provider,
       repo: subscription.repo.trim().toLowerCase(),
       events: [...subscription.events],
     }));
   }
   const events = [...(options.events ?? [])];
-  return (options.repos ?? []).map((repo) => ({
+  return (options.repos ?? []).map(repo => ({
     provider: "github" as const,
     repo: repo.trim().toLowerCase(),
     events,
@@ -599,7 +599,7 @@ export class CursorEventRelay {
   constructor(private readonly options: CursorEventRelayOptions) {
     this.subscriptions = resolveCursorScmSubscriptions(options);
     const requestedEvents = new Map(
-      this.subscriptions.map((subscription) => [
+      this.subscriptions.map(subscription => [
         subscriptionKey(subscription.provider, subscription.repo),
         new Set(subscription.events),
       ])
@@ -608,9 +608,9 @@ export class CursorEventRelay {
       logPrefix: "cursor-events",
       subscribePath: "/v0/scm-events/subscriptions",
       pollPath: "/v0/scm-events",
-      buildRegistrationBody: (consumerId) => ({
+      buildRegistrationBody: consumerId => ({
         consumerId,
-        subscriptions: this.subscriptions.map((subscription) => ({
+        subscriptions: this.subscriptions.map(subscription => ({
           provider: subscription.provider,
           repo: subscription.repo,
           events: [...subscription.events],
@@ -621,7 +621,7 @@ export class CursorEventRelay {
       // registration leaves a hole in the log until the next process
       // registers, and the durable offset cannot replay what was never
       // written. A consumer that does not come back lapses by TTL.
-      applyRegistrationResponse: (json) => {
+      applyRegistrationResponse: json => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];
         this.subscribedEvents = new Map();
@@ -641,7 +641,7 @@ export class CursorEventRelay {
         }
         if (confirmed.length > 0) {
           const eventKinds = [
-            ...new Set(this.subscriptions.flatMap((s) => [...s.events])),
+            ...new Set(this.subscriptions.flatMap(s => [...s.events])),
           ];
           lines.push(
             `subscribed to ${confirmed.join(", ")} for events: ${eventKinds.join(", ")}`
@@ -649,8 +649,8 @@ export class CursorEventRelay {
         }
         return lines;
       },
-      shouldDispatch: (event) => this.shouldDispatch(event),
-      dispatch: (event) => this.options.dispatch(event),
+      shouldDispatch: event => this.shouldDispatch(event),
+      dispatch: event => this.options.dispatch(event),
     };
     this.core = new CursorRelayCore<CursorScmEvent>({
       baseUrl: options.baseUrl,

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

@@ -288,7 +288,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
     // loose loses nothing).
     await Promise.race([
       this.consumePromise?.catch(() => {}),
-      new Promise<void>((resolve) => {
+      new Promise<void>(resolve => {
         const timer = setTimeout(resolve, 2_000);
         timer.unref?.();
       }),
@@ -586,7 +586,7 @@ export class CursorRelayCore<TEvent extends { offset: string }> {
   }
 
   private sleep(ms: number): Promise<void> {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       const signal = this.abort?.signal;
       if (signal?.aborted === true) {
         resolve();

package/src/internal/deploy-client.ts

@@ -232,6 +232,7 @@ export interface AgentkitDeployAccepted {
 export interface AgentkitDeployComponent {
   componentKey: string;
   agentPath?: string;
+  persistent?: boolean;
 }
 
 /** Customer-visible v2 deploy status (`GET /internal/agentsdk/deployments/:slug`). */
@@ -271,6 +272,17 @@ export interface AgentkitDeployStatus {
   secretNames?: string[];
 }
 
+/** One v2 application from `GET /internal/agentsdk/deployments`. */
+export interface AgentkitDeploymentListItem {
+  architecture: "v2";
+  applicationId: string;
+  releaseId: string;
+  slug: string;
+  teamId: number;
+  status: AgentkitCustomerStatus;
+  deployments: Array<{ desiredUpdatedAt: string }>;
+}
+
 export const TERMINAL_AGENTKIT_DEPLOY_STATUSES: ReadonlySet<AgentkitCustomerStatus> =
   new Set(["running", "failed", "stopped"]);
 
@@ -283,8 +295,36 @@ export interface AgentkitStopAccepted {
   applicationId: string;
   releaseId: string;
   status: string;
+  cancellation?: AgentkitCancelRunsResult;
+}
+
+export interface AgentkitGlobalSuspensionAccepted {
+  applicationId: string;
+  status: "running" | "stopped";
+  cancellation?: AgentkitCancelRunsResult;
+}
+
+export interface AgentkitCancelRunsResult {
+  batchesStarted: number;
+  failed: number;
+  sessionsMarkedFailed?: number;
 }
 
+const agentkitCancelRunsResultSchema: z.ZodType<AgentkitCancelRunsResult> =
+  z.object({
+    batchesStarted: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    sessionsMarkedFailed: z.number().int().nonnegative().optional(),
+  });
+
+const agentkitEventRepositoriesSchema = z.object({
+  repositories: z.array(z.string()),
+});
+
+const agentkitInstallReleaseSchema = z.object({
+  releaseId: z.string(),
+});
+
 /**
  * `POST /internal/agentsdk/deployments/:slug/sessions` 202 body. A hosted v2
  * session start is a Temporal delivery: a fresh start allocates `ses_…`
@@ -300,6 +340,33 @@ export interface AgentkitStartSessionAccepted {
   asOf?: string;
 }
 
+/**
+ * One hosted execution of a v2 session: a pod wake that ran (or tried to
+ * run) a turn. `turnStatus` is the engine's outcome (`finished`, `error`,
+ * `running`, …); `processDeath` marks an entry flushed from a crash handler.
+ */
+export interface AgentkitSessionRun {
+  executionId: string;
+  writtenAt: string;
+  turnStatus: string;
+  durationMs: number;
+  message?: string;
+  error?: { name: string; message: string; stack?: string };
+  processDeath?: boolean;
+  logs: Array<{ index: number; at: string; line: string }>;
+}
+
+/**
+ * `GET /internal/agentsdk/deployments/:slug/sessions/:sessionId/runs` body.
+ * A v2 deployment has no resident engine to query, so these durable
+ * control-plane snapshots are the session's history.
+ */
+export interface AgentkitSessionRuns {
+  executions: AgentkitSessionRun[];
+  /** Engine start.log tee; null when the framework store has no snapshot. */
+  startLog: string | null;
+}
+
 /** One secret's metadata from the list endpoint — names only, never values. */
 export interface SecretInfo {
   name: string;
@@ -380,11 +447,39 @@ const agentkitDeployStatusSchema = z
   })
   .passthrough();
 
+const agentkitDeploymentListItemSchema = z
+  .object({
+    architecture: z.literal("v2"),
+    applicationId: z.string().min(1),
+    releaseId: z.string().min(1),
+    slug: z.string().min(1),
+    teamId: z.number(),
+    status: agentkitDeployStatusSchema.shape.status,
+    deployments: z.array(
+      z.object({ desiredUpdatedAt: z.string() }).passthrough()
+    ),
+  })
+  .passthrough();
+
+const agentkitDeploymentListResponseSchema = z.object({
+  deployments: z.array(agentkitDeploymentListItemSchema),
+  nextPageToken: z.string().nullable(),
+});
+
 const agentkitStopAcceptedSchema = z
   .object({
     applicationId: z.string().min(1),
     releaseId: z.string().min(1),
     status: z.string(),
+    cancellation: agentkitCancelRunsResultSchema.optional(),
+  })
+  .passthrough();
+
+const agentkitGlobalSuspensionAcceptedSchema = z
+  .object({
+    applicationId: z.string().min(1),
+    status: z.enum(["running", "stopped"]),
+    cancellation: agentkitCancelRunsResultSchema.optional(),
   })
   .passthrough();
 
@@ -399,6 +494,41 @@ const agentkitStartSessionAcceptedSchema = z
   })
   .passthrough();
 
+const agentkitSessionRunsSchema = z
+  .object({
+    executions: z.array(
+      z
+        .object({
+          executionId: z.string().min(1),
+          writtenAt: z.string(),
+          turnStatus: z.string(),
+          durationMs: z.number().nonnegative(),
+          message: z.string().optional(),
+          error: z
+            .object({
+              name: z.string(),
+              message: z.string(),
+              stack: z.string().optional(),
+            })
+            .passthrough()
+            .optional(),
+          processDeath: z.boolean().optional(),
+          logs: z.array(
+            z
+              .object({
+                index: z.number(),
+                at: z.string(),
+                line: z.string(),
+              })
+              .passthrough()
+          ),
+        })
+        .passthrough()
+    ),
+    startLog: z.string().nullable(),
+  })
+  .passthrough();
+
 const deploymentSchema = z.object({
   id: z.number(),
   slug: z.string(),
@@ -488,12 +618,6 @@ const rotateResponseSchema = z
   })
   .passthrough();
 
-const rotatePodCredentialResponseSchema = z
-  .object({
-    podCredentialMaskedKey: z.string().min(1),
-  })
-  .passthrough();
-
 const setSecretsResponseSchema = z
   .object({
     secretNames: z.array(z.string()),
@@ -638,6 +762,7 @@ export class AgentServeDeployClient {
     repositories?: string[];
     /** Redeploy an existing Cursor-managed (multi-tenant) product. */
     multiTenant?: boolean;
+    persistent?: boolean;
   }): Promise<AgentkitDeployAccepted> {
     const slugError = validateDeploymentSlug(args.slug);
     if (slugError !== undefined) {
@@ -667,6 +792,7 @@ export class AgentServeDeployClient {
             ? args.repositories
             : undefined,
         ...(args.multiTenant === true ? { multiTenant: true } : {}),
+        persistent: args.persistent,
       },
       context: { verb: "deploy", slug: args.slug },
     });
@@ -692,15 +818,95 @@ export class AgentServeDeployClient {
   async stopAgentkit(args: {
     teamId: number;
     slug: string;
+    cancelRuns?: boolean;
   }): Promise<AgentkitStopAccepted> {
     const raw = await this.request({
       method: "POST",
-      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/stop?teamId=${args.teamId}`,
+      path:
+        `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/stop?teamId=${args.teamId}` +
+        (args.cancelRuns === true ? "&cancelRuns=true" : ""),
       context: { verb: "stop", slug: args.slug },
     });
     return agentkitStopAcceptedSchema.parse(raw);
   }
 
+  async setAgentkitGlobalSuspension(args: {
+    teamId: number;
+    slug: string;
+    suspended: boolean;
+    cancelRuns?: boolean;
+  }): Promise<AgentkitGlobalSuspensionAccepted> {
+    const action = args.suspended ? "global-stop" : "global-resume";
+    const cancelQuery =
+      args.suspended === true && args.cancelRuns === true
+        ? "&cancelRuns=true"
+        : "";
+    const raw = await this.request({
+      method: "POST",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/${action}?teamId=${args.teamId}${cancelQuery}`,
+      context: {
+        verb: args.suspended ? "globally stop" : "globally resume",
+        slug: args.slug,
+      },
+    });
+    return agentkitGlobalSuspensionAcceptedSchema.parse(raw);
+  }
+
+  async cancelAgentkitRuns(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<AgentkitCancelRunsResult> {
+    const raw = await this.request({
+      method: "POST",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/cancel-runs?teamId=${args.teamId}`,
+      context: { verb: "cancel runs", slug: args.slug },
+    });
+    return agentkitCancelRunsResultSchema.parse(raw);
+  }
+
+  /**
+   * Repoint a v2 install's event repositories
+   * (`PUT /internal/agentsdk/deployments/:slug/event-repositories`). Deploy
+   * cannot carry these for a multi-tenant product.
+   */
+  async setAgentkitEventRepositories(args: {
+    teamId: number;
+    slug: string;
+    repositories: string[];
+  }): Promise<string[]> {
+    const raw = await this.request({
+      method: "PUT",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/event-repositories?teamId=${args.teamId}`,
+      body: { repositories: args.repositories },
+      context: { verb: "set event repositories", slug: args.slug },
+    });
+    return agentkitEventRepositoriesSchema.parse(raw).repositories;
+  }
+
+  /**
+   * Pin a v2 install onto a release
+   * (`PUT /internal/agentsdk/deployments/:slug/release`), newest ready one
+   * when neither selector is given. A multi-tenant deploy leaves tenants
+   * on the release they were installed on.
+   */
+  async upgradeAgentkitInstall(args: {
+    teamId: number;
+    slug: string;
+    releaseId?: string;
+    version?: string;
+  }): Promise<string> {
+    const raw = await this.request({
+      method: "PUT",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/release?teamId=${args.teamId}`,
+      body: {
+        ...(args.releaseId === undefined ? {} : { releaseId: args.releaseId }),
+        ...(args.version === undefined ? {} : { version: args.version }),
+      },
+      context: { verb: "upgrade", slug: args.slug },
+    });
+    return agentkitInstallReleaseSchema.parse(raw).releaseId;
+  }
+
   /**
    * Delete a v2 deployment (`DELETE /internal/agentsdk/deployments/:slug`).
    * 202 means accepted; poll {@link getAgentkitDeploy} until 404.
@@ -729,6 +935,7 @@ export class AgentServeDeployClient {
     sessionId?: string;
     dryRun?: boolean;
     asOf?: string;
+    componentKey?: string;
   }): Promise<AgentkitStartSessionAccepted> {
     const raw = await this.request({
       method: "POST",
@@ -739,12 +946,27 @@ export class AgentServeDeployClient {
         sessionId: args.sessionId,
         dryRun: args.dryRun === true ? true : undefined,
         asOf: args.asOf,
+        componentKey: args.componentKey,
       },
       context: { verb: "start session", slug: args.slug },
     });
     return agentkitStartSessionAcceptedSchema.parse(raw);
   }
 
+  /** Hosted executions and the start-log tee for one v2 session. */
+  async getAgentkitSessionRuns(args: {
+    teamId: number;
+    slug: string;
+    sessionId: string;
+  }): Promise<AgentkitSessionRuns> {
+    const raw = await this.request({
+      method: "GET",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/sessions/${encodeURIComponent(args.sessionId)}/runs?teamId=${args.teamId}`,
+      context: { verb: "get session runs", slug: args.slug },
+    });
+    return agentkitSessionRunsSchema.parse(raw);
+  }
+
   async listDeployments(args: { teamId: number }): Promise<Deployment[]> {
     const raw = await this.request({
       method: "GET",
@@ -754,6 +976,30 @@ export class AgentServeDeployClient {
     return listResponseSchema.parse(raw).deployments;
   }
 
+  async listAgentkitDeployments(args: {
+    teamId: number;
+  }): Promise<AgentkitDeploymentListItem[]> {
+    const deployments: AgentkitDeploymentListItem[] = [];
+    let pageToken: string | null = null;
+    do {
+      const qs =
+        `teamId=${args.teamId}&pageSize=100` +
+        (pageToken === null
+          ? ""
+          : `&pageToken=${encodeURIComponent(pageToken)}`);
+      const page = agentkitDeploymentListResponseSchema.parse(
+        await this.request({
+          method: "GET",
+          path: `/internal/agentsdk/deployments?${qs}`,
+          context: { verb: "list architecture v2 deployments" },
+        })
+      );
+      deployments.push(...page.deployments);
+      pageToken = page.nextPageToken;
+    } while (pageToken !== null);
+    return deployments;
+  }
+
   async getDeployment(args: {
     teamId: number;
     slug: string;
@@ -803,6 +1049,19 @@ export class AgentServeDeployClient {
     return rotateResponseSchema.parse(raw).aliasToken;
   }
 
+  /** Rotate the alias token on an AgentSDK v2 deployment. */
+  async rotateAgentsdkAliasToken(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<string> {
+    const raw = await this.request({
+      method: "POST",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/rotate-alias-token?teamId=${args.teamId}`,
+      context: { verb: "rotate alias token", slug: args.slug },
+    });
+    return rotateResponseSchema.parse(raw).aliasToken;
+  }
+
   /**
    * Upsert secrets by name (unlisted names stay untouched). Returns the
    * post-write union of secret names, sorted. Validates names and value
@@ -922,23 +1181,6 @@ export class AgentServeDeployClient {
     }
   }
 
-  /**
-   * Rotate the deployment's pod credential. Returns the masked new key —
-   * the raw key is injected into the pod on the next deploy, never
-   * returned to clients.
-   */
-  async rotatePodCredential(args: {
-    teamId: number;
-    slug: string;
-  }): Promise<string> {
-    const raw = await this.request({
-      method: "POST",
-      path: `/internal/agent-serve/deployments/${encodeURIComponent(args.slug)}/rotate-pod-credential?teamId=${args.teamId}`,
-      context: { verb: "rotate pod credential", slug: args.slug },
-    });
-    return rotatePodCredentialResponseSchema.parse(raw).podCredentialMaskedKey;
-  }
-
   /**
    * Read an Automation's exported workflow definition for
    * `convert-automation`. Missing, no-access, and gate-off all surface as