@cursor/july 0.1.100 → 0.1.101

package/src/internal/distribution.ts

@@ -131,6 +131,11 @@ export const AUTHORING_ENTRY_FILES: ReadonlyArray<
   ["channels/origin", "channels/origin/index.js"],
   ["channels/deployments", "channels/deployments/index.js"],
   ["skills", "skills.js"],
+  ["extensions", "extensions.js"],
+  [
+    "extensions/cursor-cloud-agents",
+    "extensions/cursor-cloud-agents/extension.js",
+  ],
   ["schedules", "schedules.js"],
   ["reminders", "reminders.js"],
   ["connections", "connections.js"],

package/src/internal/framework-file-storage.ts

@@ -15,9 +15,9 @@
  * {@link storageKeys} scheme was designed for exactly this: keys are a
  * stable versioned contract that sinks may route on, so
  * {@link composeFrameworkStorage} splits one {@link StorageConfig} by key
- * kind — `session` / `session-events` / `session-runs` / `continuation`
- * go to the framework file store (file-shaped; the store accepts values
- * up to 64 MiB per
+ * kind — `session` / `session-events` / `session-runs` / `logs` /
+ * `continuation` go to the framework file store (file-shaped; the store
+ * accepts values up to 64 MiB per
  * object without chunking, versus the KV proxy's 1 MiB row cap), while
  * author `kv`, eval runs, A/B samples, and conditional writes stay on the
  * control-plane KV proxy (the dashboard reads them there, and CAS needs a
@@ -42,6 +42,7 @@ const FRAMEWORK_FILE_KINDS: ReadonlySet<string> = new Set([
   "session",
   "session-events",
   "session-runs",
+  "logs",
   "continuation",
 ]);
 
@@ -105,7 +106,7 @@ export function fileSinkStorageCore(sink: FileSink): FileSinkStorageCore {
           `framework file storage: key "${key}" has a path segment the store cannot represent`
         );
       }
-      await sink.put(key, new TextEncoder().encode(JSON.stringify(value)));
+      await sink.put(key, encodeDocument(key, value));
     },
     async get(key): Promise<JsonValue | undefined> {
       if (isUnrepresentableFileKey(key)) {
@@ -151,9 +152,42 @@ export function fileSinkStorageCore(sink: FileSink): FileSinkStorageCore {
   };
 }
 
+function frameworkFileKind(key: string): string | undefined {
+  if (!key.startsWith(`${STORAGE_KEY_ROOT}/`)) {
+    return undefined;
+  }
+  const rest = key.slice(STORAGE_KEY_ROOT.length + 1);
+  const agentEnd = rest.indexOf("/");
+  if (agentEnd === -1) {
+    return undefined;
+  }
+  const afterAgent = rest.slice(agentEnd + 1);
+  const kindEnd = afterAgent.indexOf("/");
+  return kindEnd === -1 ? afterAgent : afterAgent.slice(0, kindEnd);
+}
+
+function isLogKey(key: string): boolean {
+  return frameworkFileKind(key) === "logs";
+}
+
+function encodeDocument(key: string, value: JsonValue): Uint8Array {
+  // start.log is raw UTF-8, not a JSON document. Stringify would quote
+  // every line and store a JSON string literal instead of the tee.
+  if (isLogKey(key)) {
+    return new TextEncoder().encode(
+      typeof value === "string" ? value : JSON.stringify(value)
+    );
+  }
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+
 function decodeDocument(key: string, bytes: Uint8Array): JsonValue {
+  const text = new TextDecoder().decode(bytes);
+  if (isLogKey(key)) {
+    return text;
+  }
   try {
-    return JSON.parse(new TextDecoder().decode(bytes)) as JsonValue;
+    return JSON.parse(text) as JsonValue;
   } catch (error) {
     throw new Error(
       `framework file storage: stored document at "${key}" is not JSON (${

package/src/internal/hosted-delivery.ts

@@ -4,6 +4,7 @@ import type {
   ChannelHandlerArgs,
   SendMessageOptions,
 } from "../types.js";
+import { refreshBoundDeploymentSecrets } from "./cursor/hosted-deployment-secrets.js";
 import {
   createDeferredChannelSession,
   DeferredChannelSessionError,
@@ -28,19 +29,17 @@ import {
 import {
   abortReasonFromTurnStatus,
   HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
-  hostedErrorStackSnippet,
   hostedExecutionDiagId,
-  writeHostedExecutionDiag,
 } from "./hosted-execution-diag.js";
+import {
+  flushHostedExecutionRecord,
+  type HostedExecutionFlushSinks,
+} from "./hosted-execution-flush.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
 import { errorResponse, readJsonObject } from "./http-channel.js";
 import type { LogRingEntry } from "./log-ring.js";
 import type { Router } from "./router.js";
-import {
-  type SessionRunExecutionWrite,
-  serializeSessionRunError,
-  snapshotSessionRunLogs,
-} from "./session-run-log.js";
+import type { SessionRunExecutionWrite } from "./session-run-log.js";
 
 type DispatchInput = {
   delivery: HostedAdmission;
@@ -279,6 +278,8 @@ export function registerHostedDeliveryRoute(input: {
    * store; this path still awaits so a parked pod cannot shed the write.
    */
   persistSessionRun?(write: SessionRunExecutionWrite): Promise<void>;
+  /** Snapshot the local `start.log` tee onto `logs/{ses_…}`. */
+  flushStartLog?(startLogId: string): Promise<void>;
   /** Snapshot of the process log ring at persist time. */
   snapshotLogs?(): LogRingEntry[];
 }): void {
@@ -318,6 +319,7 @@ export function registerHostedDeliveryRoute(input: {
     pattern: `${input.base}${HOSTED_ADMISSION_PATH}`,
     auth: [auth],
     handler: async (request) => {
+      refreshBoundDeploymentSecrets();
       const startedAt = performance.now();
       const finish = (response: Response) =>
         withServerTiming(response, performance.now() - startedAt);
@@ -373,6 +375,7 @@ export function registerHostedDeliveryRoute(input: {
     pattern: `${input.base}${HOSTED_EXECUTION_PATH}`,
     auth: [auth],
     handler: async (request) => {
+      refreshBoundDeploymentSecrets();
       const startedAt = performance.now();
       const finish = (response: Response) =>
         withServerTiming(response, performance.now() - startedAt);
@@ -414,6 +417,20 @@ export function registerHostedDeliveryRoute(input: {
       admitted.execution ??= (async (): Promise<ExecutionReply> => {
         const startedAt = performance.now();
         const executionId = hostedExecutionDiagId(execution.admissionToken);
+        const sinks: HostedExecutionFlushSinks = {
+          ...(input.stateRoot === undefined
+            ? {}
+            : { stateRoot: input.stateRoot }),
+          ...(input.persistSessionRun === undefined
+            ? {}
+            : { persistSessionRun: input.persistSessionRun }),
+          ...(input.flushStartLog === undefined
+            ? {}
+            : { flushStartLog: input.flushStartLog }),
+          ...(input.snapshotLogs === undefined
+            ? {}
+            : { snapshotLogs: input.snapshotLogs }),
+        };
         const writeDiag = async (fields: {
           sessionId: string;
           turnStatus: string;
@@ -423,62 +440,20 @@ export function registerHostedDeliveryRoute(input: {
             | "execute_throw";
           error?: unknown;
         }): Promise<void> => {
-          const durationMs = Math.max(
-            0,
-            Math.round(performance.now() - startedAt)
-          );
-          const message =
-            fields.message === undefined
-              ? undefined
-              : boundedMessage(fields.message);
-          const stack =
-            fields.error === undefined
-              ? undefined
-              : hostedErrorStackSnippet(fields.error);
-          if (input.stateRoot !== undefined) {
-            await writeHostedExecutionDiag(input.stateRoot, {
-              v: 1,
-              executionId,
-              writtenAt: new Date().toISOString(),
-              sessionPublicId: execution.sessionPublicId,
-              sessionId: fields.sessionId,
-              turnStatus: fields.turnStatus,
-              durationMs,
-              ...(message === undefined ? {} : { message }),
-              ...(stack === undefined || stack.length === 0 ? {} : { stack }),
-              ...(message !== undefined && /abort/i.test(message)
-                ? { signalAborted: true }
-                : {}),
-              ...(fields.abortReason === undefined
-                ? {}
-                : { abortReason: fields.abortReason }),
-            });
-          }
-          if (input.persistSessionRun === undefined) {
-            return;
-          }
-          const error =
-            fields.error === undefined
-              ? undefined
-              : serializeSessionRunError(fields.error);
-          try {
-            await input.persistSessionRun({
-              executionId,
-              writtenAt: new Date().toISOString(),
-              sessionPublicId: execution.sessionPublicId,
-              sessionId: fields.sessionId,
-              turnStatus: fields.turnStatus,
-              durationMs,
-              ...(fields.abortReason === undefined
-                ? {}
-                : { abortReason: fields.abortReason }),
-              ...(message === undefined ? {} : { message }),
-              ...(error === undefined ? {} : { error }),
-              logs: snapshotSessionRunLogs(input.snapshotLogs?.() ?? []),
-            });
-          } catch {
-            // Soft-fail: a store outage must not change the HTTP reply.
-          }
+          await flushHostedExecutionRecord(sinks, {
+            executionId,
+            sessionPublicId: execution.sessionPublicId,
+            sessionId: fields.sessionId,
+            turnStatus: fields.turnStatus,
+            durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+            ...(fields.message === undefined
+              ? {}
+              : { message: fields.message }),
+            ...(fields.abortReason === undefined
+              ? {}
+              : { abortReason: fields.abortReason }),
+            ...(fields.error === undefined ? {} : { error: fields.error }),
+          });
         };
         // Claim the file before the turn runs. The host reads it after its
         // own POST returns, which for a 9-minute timeout is while this turn

package/src/internal/hosted-execution-diag.ts

@@ -1,3 +1,9 @@
+/**
+ * Guest-local TAS diag (`hosted-execution.json`). Flushed with the durable
+ * session-run document and the `start.log` tee by
+ * `hosted-execution-flush.ts`.
+ */
+
 import { createHash, randomBytes } from "node:crypto";
 import { mkdir, rename, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";

package/src/internal/hosted-execution-flush.ts

@@ -0,0 +1,142 @@
+/**
+ * One hosted-execution flush. Two artifacts, same moments:
+ *
+ * - Guest-local `hosted-execution.json` — TAS failed-execute diag.
+ * - Durable `session-runs/{ses_…}` plus the `start.log` tee — dashboard.
+ *
+ * Claim (`running`) → terminal → process-death. Process-death upgrades the
+ * durable document and re-snapshots the tee; the local json stays `running`
+ * so TAS does not treat a previous delivery's terminal record as this one.
+ */
+
+import {
+  type HostedExecutionDiagAbortReason,
+  hostedErrorStackSnippet,
+  writeHostedExecutionDiag,
+} from "./hosted-execution-diag.js";
+import type { LogRingEntry } from "./log-ring.js";
+import {
+  type SessionRunAbortReason,
+  type SessionRunExecutionWrite,
+  serializeSessionRunError,
+  snapshotSessionRunLogs,
+} from "./session-run-log.js";
+
+const MAX_ERROR_MESSAGE_LENGTH = 1024;
+
+function boundedMessage(text: string): string {
+  return text.length > MAX_ERROR_MESSAGE_LENGTH
+    ? `${text.slice(0, MAX_ERROR_MESSAGE_LENGTH)}…`
+    : text;
+}
+
+export type HostedExecutionFlushSinks = {
+  /** Serve `--state-root`. Omit to skip the guest-local TAS diag. */
+  stateRoot?: string;
+  persistSessionRun?(write: SessionRunExecutionWrite): Promise<void>;
+  flushStartLog?(startLogId: string): Promise<void>;
+  snapshotLogs?(): LogRingEntry[];
+};
+
+export type HostedExecutionFlushFields = {
+  executionId: string;
+  sessionPublicId: string;
+  sessionId: string;
+  turnStatus: string;
+  durationMs: number;
+  message?: string;
+  abortReason?: HostedExecutionDiagAbortReason;
+  error?: unknown;
+};
+
+/**
+ * Write the local TAS diag and the durable session-run + tee together.
+ * Soft-fail per sink so a store outage does not change hosted HTTP.
+ */
+export async function flushHostedExecutionRecord(
+  sinks: HostedExecutionFlushSinks,
+  fields: HostedExecutionFlushFields
+): Promise<void> {
+  const writtenAt = new Date().toISOString();
+  const message =
+    fields.message === undefined ? undefined : boundedMessage(fields.message);
+  const stack =
+    fields.error === undefined
+      ? undefined
+      : hostedErrorStackSnippet(fields.error);
+  if (sinks.stateRoot !== undefined) {
+    await writeHostedExecutionDiag(sinks.stateRoot, {
+      v: 1,
+      executionId: fields.executionId,
+      writtenAt,
+      sessionPublicId: fields.sessionPublicId,
+      sessionId: fields.sessionId,
+      turnStatus: fields.turnStatus,
+      durationMs: fields.durationMs,
+      ...(message === undefined ? {} : { message }),
+      ...(stack === undefined || stack.length === 0 ? {} : { stack }),
+      ...(message !== undefined && /abort/i.test(message)
+        ? { signalAborted: true }
+        : {}),
+      ...(fields.abortReason === undefined
+        ? {}
+        : { abortReason: fields.abortReason }),
+    });
+  }
+  if (sinks.persistSessionRun !== undefined) {
+    const error =
+      fields.error === undefined
+        ? undefined
+        : serializeSessionRunError(fields.error);
+    try {
+      await sinks.persistSessionRun({
+        executionId: fields.executionId,
+        writtenAt,
+        sessionPublicId: fields.sessionPublicId,
+        sessionId: fields.sessionId,
+        turnStatus: fields.turnStatus,
+        durationMs: fields.durationMs,
+        ...(fields.abortReason === undefined
+          ? {}
+          : { abortReason: fields.abortReason }),
+        ...(message === undefined ? {} : { message }),
+        ...(error === undefined ? {} : { error }),
+        logs: snapshotSessionRunLogs(sinks.snapshotLogs?.() ?? []),
+      });
+    } catch {
+      // Soft-fail: a store outage must not change the HTTP reply.
+    }
+  }
+  if (sinks.flushStartLog !== undefined) {
+    try {
+      await sinks.flushStartLog(fields.sessionPublicId);
+    } catch {
+      // Soft-fail: same posture as the session-run persist.
+    }
+  }
+}
+
+/**
+ * Durable-only crash flush. Leaves `hosted-execution.json` at `running`.
+ */
+export async function flushHostedExecutionProcessDeath(args: {
+  flushProcessDeath: (
+    reason: Extract<
+      SessionRunAbortReason,
+      "process_exit" | "uncaught_exception" | "unhandled_rejection"
+    >,
+    error?: unknown
+  ) => Promise<void>;
+  flushStartLog?: (startLogId: string) => Promise<void>;
+  startLogId?: string;
+  reason: Extract<
+    SessionRunAbortReason,
+    "process_exit" | "uncaught_exception" | "unhandled_rejection"
+  >;
+  error?: unknown;
+}): Promise<void> {
+  await args.flushProcessDeath(args.reason, args.error);
+  if (args.startLogId !== undefined && args.flushStartLog !== undefined) {
+    await args.flushStartLog(args.startLogId);
+  }
+}

package/src/internal/mcp-endpoint.ts

@@ -326,6 +326,7 @@ function buildConnectionBridgeMcpServer(
       sessionId: sessionId ?? "",
       connectionName,
       toolName: request.params.name,
+      input: request.params.arguments,
     });
     if (answer.answered) {
       return sdkResultToMcpResult(answer.result);

package/src/internal/mcp-host.ts

@@ -15,13 +15,14 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type {
-  DiscoveredConnection,
-  HostMcpCallResult,
-  HostMcpRegistry,
-  HostMcpToolInfo,
-  JsonObject,
-  McpToolAnnotations,
+import {
+  connectionAllowsTool,
+  type DiscoveredConnection,
+  type HostMcpCallResult,
+  type HostMcpRegistry,
+  type HostMcpToolInfo,
+  type JsonObject,
+  type McpToolAnnotations,
 } from "../types.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
 import { createHostMcpOAuthProvider } from "./mcp-oauth.js";
@@ -113,9 +114,12 @@ export class McpHost implements HostMcpRegistry {
   }
 
   async listTools(connectionName: string): Promise<HostMcpToolInfo[]> {
+    const connection = this.requireConnection(connectionName);
     return this.withClient(connectionName, async (client) => {
       const listed = await client.listTools();
-      return listed.tools.map(toToolInfo);
+      return listed.tools
+        .map(toToolInfo)
+        .filter((tool) => connectionAllowsTool(connection, tool.name));
     });
   }
 
@@ -144,10 +148,13 @@ export class McpHost implements HostMcpRegistry {
       listTools: () =>
         withFreshClient(async (client) => {
           const listed = await client.listTools();
-          return listed.tools.map(toToolInfo);
+          return listed.tools
+            .map(toToolInfo)
+            .filter((tool) => connectionAllowsTool(connection, tool.name));
         }),
-      callTool: (toolName, args = {}) =>
-        withFreshClient(async (client) => {
+      callTool: (toolName, args = {}) => {
+        assertConnectionAllowsTool(connection, toolName);
+        return withFreshClient(async (client) => {
           const result = await client.callTool({
             name: toolName,
             arguments: args,
@@ -156,7 +163,8 @@ export class McpHost implements HostMcpRegistry {
             connection.name,
             normalizeCallResult(result)
           );
-        }),
+        });
+      },
     };
   }
 
@@ -165,6 +173,8 @@ export class McpHost implements HostMcpRegistry {
     toolName: string,
     args: Record<string, unknown> = {}
   ): Promise<HostMcpCallResult> {
+    const connection = this.requireConnection(connectionName);
+    assertConnectionAllowsTool(connection, toolName);
     return this.withClient(connectionName, async (client) => {
       const result = await client.callTool({
         name: toolName,
@@ -254,7 +264,7 @@ export class McpHost implements HostMcpRegistry {
     await opened.close();
   }
 
-  private async connect(name: string): Promise<OpenedConnection> {
+  private requireConnection(name: string): DiscoveredConnection {
     const connection = this.byName.get(name);
     if (connection === undefined) {
       const known = this.names().join(", ") || "(none)";
@@ -262,8 +272,24 @@ export class McpHost implements HostMcpRegistry {
         `Unknown MCP connection "${name}". Authored MCP connections: ${known}.`
       );
     }
-    return openConnection(connection, this.oauthRedirectUrl);
+    return connection;
+  }
+
+  private async connect(name: string): Promise<OpenedConnection> {
+    return openConnection(this.requireConnection(name), this.oauthRedirectUrl);
+  }
+}
+
+function assertConnectionAllowsTool(
+  connection: DiscoveredConnection,
+  toolName: string
+): void {
+  if (connectionAllowsTool(connection, toolName)) {
+    return;
   }
+  throw new Error(
+    `MCP connection "${connection.name}" does not allow tool "${toolName}".`
+  );
 }
 
 /** Exported for unit tests. */

package/src/internal/review-comments.ts

@@ -639,7 +639,9 @@ type OriginThreadJson = {
  */
 type OriginActorJson = {
   user?: { id?: string; email?: string };
-  app?: { id?: string; slug?: string };
+  // Apps have no slug (they are id + display name); `slug` is being retired
+  // from the public actor and is never read here.
+  app?: { id?: string; displayName?: string };
   serviceAccount?: { id?: string };
 };
 
@@ -685,7 +687,8 @@ export function listedCommentFromOriginComment(
       : startLine;
   const commitSha = thread.version?.headSha;
   const author = comment.author;
-  const authorLogin = author?.app?.slug ?? author?.user?.email;
+  const authorLogin =
+    author?.app?.displayName ?? author?.app?.id ?? author?.user?.email;
   // App and service-account actors are machine identities; only a `user`
   // actor is a human PR participant.
   const authorIsBot =