@cursor/july 0.1.96 → 0.1.97

package/src/internal/mcp-oauth.ts

@@ -411,13 +411,25 @@ export class HostMcpOAuthProvider implements OAuthClientProvider {
   }
 }
 
+function clientForRedirect(
+  info: OAuthClientInformationFull | undefined,
+  redirectUrl: string
+): OAuthClientInformationFull | undefined {
+  if (info === undefined || !info.redirect_uris.includes(redirectUrl)) {
+    return undefined;
+  }
+  return info;
+}
+
 export async function createHostMcpOAuthProvider(args: {
   identifier: string;
   resourceUrl: string;
   store?: FileMcpOAuthStore;
   onRedirect?: (url: URL) => void;
+  redirectUrl?: string;
 }): Promise<HostMcpOAuthProvider> {
   const store = args.store ?? new FileMcpOAuthStore();
+  const redirectUrl = args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL;
   const [fileTokens, fileClient, omitResourceIndicator] = await Promise.all([
     store.loadTokens(args.identifier, args.resourceUrl),
     store.loadClientInformation(args.identifier, args.resourceUrl),
@@ -427,8 +439,12 @@ export async function createHostMcpOAuthProvider(args: {
     identifier: args.identifier,
     resourceUrl: args.resourceUrl,
     store,
+    redirectUrl,
     tokens: fileTokens ?? tokensFromEnv(args.identifier),
-    clientInformation: fileClient ?? clientIdFromEnv(args.identifier),
+    clientInformation: clientForRedirect(
+      fileClient ?? clientIdFromEnv(args.identifier),
+      redirectUrl
+    ),
     onRedirect: args.onRedirect,
     omitResourceIndicator,
   });

package/src/internal/otel/collector.ts

@@ -284,6 +284,36 @@ export function createOtelCollector(
           );
         return;
       }
+      case "action.auth_requested": {
+        ensureTurn(event, session, startTime)
+          ?.tools.get(event.data.callId)
+          ?.addEvent("auth_requested", undefined, startTime);
+        emitLog(
+          "action.auth_requested",
+          SeverityNumber.INFO,
+          attrs({
+            ...baseLog(event, session),
+            "cursor.tool.name": event.data.toolName,
+            "agent_sdk.call_id": event.data.callId,
+            "agent_sdk.mcp_connection": event.data.connection,
+          })
+        );
+        return;
+      }
+      case "action.auth_resolved": {
+        ensureTurn(event, session, startTime)
+          ?.tools.get(event.data.callId)
+          ?.addEvent(
+            "auth_resolved",
+            attrs({
+              "agent_sdk.decision": event.data.decision,
+              "agent_sdk.decision_by": event.data.by,
+              "agent_sdk.mcp_connection": event.data.connection,
+            }),
+            startTime
+          );
+        return;
+      }
       case "action.result": {
         const turn = ensureTurn(event, session, startTime);
         const span = turn?.tools.get(event.data.callId);

package/src/internal/server.ts

@@ -130,6 +130,11 @@ import {
   MCP_ENDPOINT_PATH,
   TOOL_MCP_ENDPOINT_PATH,
 } from "./mcp-endpoint.js";
+import {
+  mcpOauthServeCallbackPath,
+  mcpOauthServeCallbackUrl,
+} from "./mcp-oauth-on-demand.js";
+import type { McpOauthSecretsTarget } from "./mcp-oauth-persist.js";
 import { isLoopbackAddress } from "./net.js";
 import { createOtelCollector, type OtelCollector } from "./otel/collector.js";
 import { pickAuthoredOtel, resolveOtelConfig } from "./otel/config.js";
@@ -240,6 +245,8 @@ function isV2Project(project: { agent: { architecture?: string } }): boolean {
 export interface StartServerInternalOptions {
   /** Test seam: replace the Cursor SDK runner (integration tests). */
   runner?: AgentRunner;
+  /** Test seam: bind the `--store` secrets client for on-demand MCP OAuth. */
+  mcpOauthSecrets?: McpOauthSecretsTarget;
 }
 
 /**
@@ -647,6 +654,12 @@ export async function startServer(
       otel: otelCollector,
       otelMeter: otelRuntime?.meter,
     });
+    engine.oauthCallbackHub.secrets = options.mcpOauthSecrets;
+    engine.oauthCallbackHub.secretsBind = {
+      slug: slug === "" ? undefined : slug,
+      cloudToolsUrl: options.cloudToolsUrl,
+    };
+    engine.oauthCallbackHub.logger = logger;
     // Rehydrate sessions from the authored storage sink before any
     // channel or route can address them (continuation tokens must resolve).
     await engine.restoreStoredSessions();
@@ -732,6 +745,7 @@ export async function startServer(
       multi,
       logger,
       logRing,
+      diagStateRoot: baseStateRoot,
       ...(options.authToken === undefined
         ? {}
         : { authToken: options.authToken }),
@@ -762,6 +776,8 @@ export async function startServer(
           },
           resolveApproval: (sessionId, callId, decision, auth) =>
             engine.resolveApproval(sessionId, callId, decision, auth),
+          resolveAuth: (sessionId, callId, decision, auth) =>
+            engine.resolveAuth(sessionId, callId, decision, auth),
           hasContinuationSession: (continuationToken) =>
             engine.hasContinuationSession(channel.id, continuationToken),
           isContinuationBusy: (continuationToken) =>
@@ -1013,6 +1029,7 @@ export async function startServer(
   const address = server.address() as AddressInfo;
   const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
   const url = `http://${displayHost}:${boundPort}`;
+  const oauthOrigin = (options.publicUrl ?? url).replace(/\/$/, "");
 
   // Resolve peer + Cursor account MCP connections now that the listen port is
   // known (see resolved-connections.ts for the URL/runtime rules).
@@ -1039,6 +1056,20 @@ export async function startServer(
     if (resolved.length > 0) {
       runtime.engine.setResolvedConnections(resolved);
     }
+    const oauthBase = runtime.slug === "" ? "" : `/${runtime.slug}`;
+    runtime.engine.setMcpOauthCallbackUrl(
+      mcpOauthServeCallbackUrl(oauthOrigin, oauthBase)
+    );
+    if (accountBridge !== undefined && accountRefs !== undefined) {
+      const bridge = accountBridge;
+      runtime.engine.setCursorAccountAuthProbe(async (connection) => {
+        const ref = accountRefs.find((entry) => entry.name === connection);
+        if (ref === undefined) {
+          return undefined;
+        }
+        return await bridge.probeAuthUrl(ref);
+      });
+    }
     const hasServerTools = runtime.project.agent.tools.some(
       (tool) => tool.execution === "server"
     );
@@ -1227,6 +1258,11 @@ function mountAgentRoutes(
     /** Cursor account bridge + this mount's account MCP connections, when authored. */
     accountBridge?: CursorAccountMcpBridge;
     accountRefs?: CursorAccountConnectionRef[];
+    /**
+     * Serve `--state-root`. Hosted-execution writes `hosted-execution.json`
+     * here so the Temporal host can read a stable path after the POST.
+     */
+    diagStateRoot?: string;
   }
 ): void {
   const { slug, project, engine, scheduleRunner, reminderRunner } = runtime;
@@ -1288,6 +1324,9 @@ function mountAgentRoutes(
         }),
       drainSessionDurability: (sessionId) =>
         engine.drainSessionDurability(sessionId),
+      ...(args.diagStateRoot === undefined
+        ? {}
+        : { stateRoot: args.diagStateRoot }),
     });
   }
   // Playground lists/opens Slack (and other channel) sessions across
@@ -1303,6 +1342,13 @@ function mountAgentRoutes(
   // tools (Slack principals never match local/anonymous HTTP auth).
   const relaxSessionApprovalAuth = relaxSessionReadAuth;
 
+  router.add({
+    method: "GET",
+    pattern: `${base}${mcpOauthServeCallbackPath()}`,
+    auth: "none",
+    handler: (request) => engine.oauthCallbackHub.handleCallback(request),
+  });
+
   router.add({
     method: "GET",
     pattern: `${base}/v1/health`,
@@ -1391,7 +1437,7 @@ function mountAgentRoutes(
     method: "GET",
     pattern: `${base}/v1/sessions`,
     auth: httpAuth,
-    handler: async (_request, ctx) => {
+    handler: async (request, ctx) => {
       // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
       // bearer or custom channel auth (strict per-principal isolation).
       // `--allow-anonymous` alone is a shared-principal trust boundary (corp
@@ -1401,9 +1447,14 @@ function mountAgentRoutes(
         (relaxSessionReadAuthBeyondLoopback ||
           (typeof ctx.requestIp === "string" &&
             isLoopbackAddress(ctx.requestIp)));
-      const listed = await engine.listSessionsWithSource(ctx.auth, {
-        includeAll,
-      });
+      // `?latest=1` — only the newest visible session. Clients binding a
+      // default session (agsh) do not need the whole list, and on hosted
+      // storage the whole list is a database scan.
+      const latest = new URL(request.url).searchParams.get("latest");
+      const listed =
+        latest === "1" || latest === "true"
+          ? await engine.latestSessionWithSource(ctx.auth, { includeAll })
+          : await engine.listSessionsWithSource(ctx.auth, { includeAll });
       return jsonResponse({
         sessions: listed.sessions,
         source: listed.source,
@@ -1613,23 +1664,22 @@ function mountAgentRoutes(
         return binding.errorResponse;
       }
       try {
-        const catalog = await engine.listCatalogTools({
+        const described = await engine.describeCatalogTool(toolName, {
           auth: ctx.auth,
           ...binding,
         });
-        const tool = catalog.tools.find((t) => t.name === toolName);
-        if (tool === undefined) {
+        if (described.tool === undefined) {
           return jsonResponse(
             {
               ok: false,
               error: "unknown_tool",
               message: `Unknown tool "${toolName}".`,
-              availableTools: catalog.tools.map((t) => t.name),
+              availableTools: described.availableTools,
             },
             { status: 404 }
           );
         }
-        return jsonResponse(catalogDetailEntry(tool));
+        return jsonResponse(catalogDetailEntry(described.tool));
       } catch (error) {
         if (error instanceof InvalidContinuationTokenError) {
           return errorResponse(