@cursor/july 0.1.96 → 0.1.97

package/src/channels/slack/manifest.ts

@@ -222,7 +222,7 @@ export function buildSlackManifestPair(
   };
 }
 
-/** Relative names under `.agent-serve/slack/`. */
+/** Manifest filenames written under `.slack/`. */
 export function slackManifestFileEntries(
   pair: { dev: SlackAppManifest; prod: SlackAppManifest },
   env: "dev" | "prod" | "both" = "both"

package/src/channels/slack/setup.ts

@@ -2,7 +2,7 @@
  * Slack setup guide printed by `agent-serve slack setup`.
  *
  * Dedicated Socket Mode app via `slack create` (dashboard wizard).
- * `slack init --manual` is the unmanaged paste-at-api.slack.com path.
+ * `slack init --manual` is the unmanaged Slack CLI / paste path.
  * {@link SLACK_SETUP_PHASES} is that checklist; its ids key
  * `.agent-serve/slack/setup-status.json`.
  */
@@ -21,6 +21,7 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     title: "Generate channel + manifests",
     steps: [
       "agent-serve slack init --manual --dir . --name My Agent",
+      "Installs the Slack app when Slack CLI is logged in. Otherwise next asks the user to install it.",
       "Manifests default to Socket Mode (no public Request URL).",
     ],
   },
@@ -29,9 +30,11 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Create two Slack apps from manifests",
     steps: [
-      "Open https://api.slack.com/apps -> Create New App from a manifest",
-      "Paste .agent-serve/slack/manifest.dev.json -> create the *dev* app",
-      "Repeat with manifest.prod.json for the *prod* app",
+      "Preferred: Slack CLI at ~/.slack/bin/slack. slack login --no-prompt, then slack app install --environment local --team <T> --force",
+      "Prod: SLACK_ENV=deployed slack app install --environment deployed --team <T> --force",
+      "Do not slack deploy; Agent SDK serve owns Socket Mode",
+      "Fallback: https://api.slack.com/apps -> Create New App from a manifest",
+      "Paste .slack/manifest.dev.json, then manifest.prod.json",
     ],
   },
   {
@@ -39,8 +42,9 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Install + mint App-Level Token",
     steps: [
-      "Install to Workspace; copy Bot User OAuth Token (xoxb-...)",
+      "Slack CLI install leaves tokens in that process only. Copy xoxb from OAuth & Permissions at https://api.slack.com/apps/<appId>",
       "App-Level Tokens: create token with connections:write; copy xapp-...",
+      "If Slack CLI wrote SLACK_* to .env, copy them into .env.local using env.example names",
     ],
   },
   {
@@ -106,7 +110,7 @@ export function formatSlackSetupGuide(): string {
     "  Finish Slack consent and the bot name there. The CLI writes",
     "  tokens into .env.local.",
     "",
-    "Manual Slack app: `slack init --manual`. Phases below.",
+    "Manual Slack app: `slack init --manual` (Slack CLI, or paste at api.slack.com).",
     "Goal: importable dev + prod Slack apps over Socket Mode (no public URL).",
     "App-Level Token (xapp-...) + Bot Token (xoxb-...) required.",
     "",

package/src/channels/slack/slack-channel.ts

@@ -487,6 +487,7 @@ export function slackChannel(
               credentials,
               getSession: args.getSession,
               resolveApproval: args.resolveApproval,
+              resolveAuth: args.resolveAuth,
               waitUntil: args.waitUntil,
               log: getLog(),
               blockExternals,

package/src/channels/slack/tool-approval-events.ts

@@ -21,8 +21,11 @@
 import type { ChannelEventHandlers } from "../../types.js";
 import { postMessage, setThreadStatus, updateMessage } from "./api.js";
 import {
+  authThreadStatus,
   buildApprovalBlocks,
+  buildAuthBlocks,
   buildResolvedApprovalBlocks,
+  buildResolvedAuthBlocks,
 } from "./approvals.js";
 import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
@@ -132,5 +135,95 @@ export function buildToolApprovalEvents(
         decision: event.data.decision,
       });
     },
+
+    async "action.auth_requested"(event, channel, ctx) {
+      const log = getLog();
+      const state = channel.state;
+      if (state.channelId === null || state.threadTs === null) {
+        return;
+      }
+      const blocks = buildAuthBlocks({
+        sessionId: ctx.session.id,
+        callId: event.data.callId,
+        toolName: event.data.toolName,
+        connection: event.data.connection,
+        authUrl: event.data.authUrl,
+      });
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: `Authorization required for \`${event.data.connection}\``,
+          blocks,
+        });
+        channel.state.approvalMessageByCallId = {
+          ...(state.approvalMessageByCallId ?? {}),
+          [event.data.callId]: posted.ts,
+        };
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: authThreadStatus(event.data.connection),
+          loadingMessages: [
+            authThreadStatus(event.data.connection),
+            ...SLACK_DEFAULT_LOADING_MESSAGES,
+          ],
+        });
+        log.info("auth card posted", {
+          call_id: event.data.callId,
+          connection: event.data.connection,
+          message_ts: posted.ts,
+        });
+      } catch (error) {
+        log.warn("auth card post failed", {
+          call_id: event.data.callId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+
+    async "action.auth_resolved"(event, channel) {
+      const log = getLog();
+      const state = channel.state;
+      const messageTs = state.approvalMessageByCallId?.[event.data.callId];
+      if (
+        state.channelId !== null &&
+        messageTs !== undefined &&
+        messageTs !== ""
+      ) {
+        const blocks = buildResolvedAuthBlocks({
+          connection: event.data.connection,
+          decision: event.data.decision,
+          byUserId: event.data.by,
+        });
+        const verb =
+          event.data.decision === "approve" ? "Connected" : "Cancelled";
+        await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: messageTs,
+          text: `${verb} — ${event.data.connection}`,
+          blocks,
+        });
+        const next = { ...(state.approvalMessageByCallId ?? {}) };
+        delete next[event.data.callId];
+        channel.state.approvalMessageByCallId = next;
+      }
+      if (state.channelId !== null && state.threadTs !== null) {
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: "Working…",
+          loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+        });
+      }
+      log.info("auth resolved in slack", {
+        call_id: event.data.callId,
+        decision: event.data.decision,
+      });
+    },
   };
 }

package/src/evals/run-facts.ts

@@ -182,6 +182,38 @@ export function deriveRunFacts(events: readonly SessionEvent[]): EvalRunFacts {
         }
         break;
       }
+      case "action.auth_requested": {
+        const request: EvalInputRequestFact = {
+          callId: event.data.callId,
+          toolName: event.data.toolName,
+          args: {
+            connection: event.data.connection,
+            authUrl: event.data.authUrl,
+          },
+          resolved: false,
+        };
+        inputRequests.push(request);
+        inputRequestsByCallId.set(event.data.callId, request);
+        break;
+      }
+      case "action.auth_resolved": {
+        const request = inputRequestsByCallId.get(event.data.callId);
+        if (request !== undefined) {
+          request.resolved = true;
+          request.decision = event.data.decision;
+        }
+        const fact = ensureCall(
+          event.data.callId,
+          event.data.toolName,
+          event.turnId,
+          event.data.parentCallId
+        );
+        fact.approvalDecision = event.data.decision;
+        if (event.data.decision === "deny") {
+          fact.status = "rejected";
+        }
+        break;
+      }
       case "subagent.called": {
         const existing = subagentsByCallId.get(event.data.callId);
         if (existing === undefined) {

package/src/internal/advertise-tools.ts

@@ -118,24 +118,45 @@ export async function resolveAdvertisedTools(args: {
     return [];
   }
   const sourceFor = args.sourceFor ?? sourceForConnection;
+  // Each connection's listing is a network round trip against a distinct
+  // server (auth callback, MCP initialize, tools/list), so they run
+  // concurrently; the fan-out is bounded by the agent's declared
+  // connections. Name assignment below stays in declaration order so
+  // collision suffixes do not depend on which server answered first.
+  type Listing =
+    | {
+        connection: DiscoveredConnection;
+        ok: true;
+        source: AdvertisedToolSource;
+        listed: HostMcpToolInfo[];
+      }
+    | { connection: DiscoveredConnection; ok: false; error: unknown };
+  const listings = await Promise.all(
+    advertising.map(async (connection): Promise<Listing> => {
+      try {
+        const source = await sourceFor(connection, args.session, args.hostMcp);
+        const listed = await source.listTools();
+        return { connection, ok: true, source, listed };
+      } catch (error) {
+        return { connection, ok: false, error };
+      }
+    })
+  );
   const claimed = new Set(args.agent.tools.map((tool) => tool.name));
   const resolved: DiscoveredTool[] = [];
-  for (const connection of advertising) {
-    let listed: HostMcpToolInfo[];
-    let source: AdvertisedToolSource;
-    try {
-      source = await sourceFor(connection, args.session, args.hostMcp);
-      listed = await source.listTools();
-    } catch (error) {
+  for (const listing of listings) {
+    const { connection } = listing;
+    if (!listing.ok) {
       if (args.onConnectionError !== undefined) {
-        args.onConnectionError(connection.name, error);
+        args.onConnectionError(connection.name, listing.error);
         continue;
       }
       throw new Error(
-        `Failed to list tools on advertised connection "${connection.name}": ${describeError(error)}`,
-        { cause: error }
+        `Failed to list tools on advertised connection "${connection.name}": ${describeError(listing.error)}`,
+        { cause: listing.error }
       );
     }
+    const { source, listed } = listing;
     const intended = listed.filter(
       (info) =>
         !isDoNotCallTool(info.annotations) &&

package/src/internal/approval-gate.ts

@@ -1,13 +1,12 @@
 /**
- * In-memory gate for human-in-the-loop tool approvals. The session
- * engine parks inside a server-tool `execute` by awaiting
- * {@link ApprovalGate.wait}; HTTP (or the playground) unblocks via
- * {@link ApprovalGate.resolve}.
+ * In-memory gate for human-in-the-loop parks. The session engine parks
+ * inside a server-tool `execute` by awaiting {@link ApprovalGate.wait};
+ * HTTP (or the playground) unblocks via {@link ApprovalGate.resolve}.
  *
- * Pending approvals are also mirrored onto {@link SessionRecord} for
- * durability of the *list* across reloads. After a process restart the
- * in-flight SDK tool callback is gone, so resolve returns false and
- * the host treats the approval as interrupted.
+ * Used for `needsApproval` and MCP on-demand auth. Pending rows are also
+ * mirrored onto {@link SessionRecord} for durability of the *list* across
+ * reloads. After a process restart the in-flight SDK tool callback is gone,
+ * so resolve returns false and the host treats the park as interrupted.
  */
 
 import type { ApprovalDecision, PendingApproval } from "../types.js";
@@ -21,33 +20,25 @@ export interface ApprovalResolution {
   by?: string;
 }
 
-interface Waiter {
-  meta: PendingApproval;
+interface Waiter<T> {
+  meta: T;
   resolve: (resolution: ApprovalResolution) => void;
 }
 
-export class ApprovalGate {
-  private readonly waiters = new Map<string, Waiter>();
+export class ApprovalGate<T extends { callId: string } = PendingApproval> {
+  private readonly waiters = new Map<string, Waiter<T>>();
 
-  wait(
-    meta: PendingApproval & { sessionId: string }
-  ): Promise<ApprovalResolution> {
-    const key = approvalKey(meta.sessionId, meta.callId);
+  wait(sessionId: string, meta: T): Promise<ApprovalResolution> {
+    const key = approvalKey(sessionId, meta.callId);
     const existing = this.waiters.get(key);
     if (existing !== undefined) {
       throw new Error(
-        `Approval already pending for session ${meta.sessionId} call ${meta.callId}`
+        `Approval already pending for session ${sessionId} call ${meta.callId}`
       );
     }
     return new Promise<ApprovalResolution>((resolveDecision) => {
       this.waiters.set(key, {
-        meta: {
-          callId: meta.callId,
-          turnId: meta.turnId,
-          toolName: meta.toolName,
-          args: meta.args,
-          requestedAt: meta.requestedAt,
-        },
+        meta,
         resolve: resolveDecision,
       });
     });
@@ -69,11 +60,11 @@ export class ApprovalGate {
       return false;
     }
     this.waiters.delete(key);
+    const by =
+      resolvedBy === undefined || resolvedBy === "" ? undefined : resolvedBy;
     waiter.resolve({
       decision,
-      ...(resolvedBy === undefined || resolvedBy === ""
-        ? {}
-        : { by: resolvedBy }),
+      by,
     });
     return true;
   }
@@ -82,9 +73,9 @@ export class ApprovalGate {
     return this.waiters.has(approvalKey(sessionId, callId));
   }
 
-  list(sessionId: string): PendingApproval[] {
+  list(sessionId: string): T[] {
     const prefix = `${sessionId}\0`;
-    const out: PendingApproval[] = [];
+    const out: T[] = [];
     for (const [key, waiter] of this.waiters) {
       if (key.startsWith(prefix)) {
         out.push(waiter.meta);

package/src/internal/chat-client.ts

@@ -483,6 +483,25 @@ async function streamTurn(args: StreamTurnArgs): Promise<number> {
         );
         continue;
       }
+      if (event.type === "action.auth_requested") {
+        closeAssistant();
+        write(
+          `    ${c.yellow("⏸")} ${c.bold(event.data.connection)} ${c.dim(
+            "awaiting MCP authorization"
+          )}\n`
+        );
+        continue;
+      }
+      if (event.type === "action.auth_resolved") {
+        const mark =
+          event.data.decision === "approve" ? c.green("✓") : c.red("✗");
+        write(
+          `    ${mark} ${c.bold(event.data.connection)} ${c.dim(
+            event.data.decision === "approve" ? "connected" : "denied"
+          )}\n`
+        );
+        continue;
+      }
       if (event.type === "action.result") {
         if (
           event.data.toolName === "task" &&

package/src/internal/cli-deploy.ts

@@ -112,6 +112,11 @@ export interface DeployCliOptions {
   cursorEventsRepos?: string[];
   /** deploy `--allow-domain <domain>` (repeatable; unioned with the manifest). */
   allowDomains?: string[];
+  /**
+   * deploy `--multi-tenant`: add a release to an existing Cursor-managed
+   * (multi-tenant) product. Cannot create a new multi-tenant application.
+   */
+  multiTenant?: boolean;
   /** Test seams. */
   fetchImpl?: typeof fetch;
   /** Inject the connector-auth browser opener (tests; also forces interactive). */
@@ -311,7 +316,9 @@ export async function cmdDeploy(options: DeployCliOptions): Promise<number> {
     manifests.push(await readDeployManifest(target.dir));
   }
   if (manifests.every((manifest) => manifest.architecture === "v2")) {
-    return deployAgentsdkApplication(ctx, options, targets);
+    return deployAgentsdkApplication(ctx, options, targets, {
+      hasScmChannels: manifests.some((manifest) => manifest.hasScmChannels),
+    });
   }
   if (
     !ctx.json &&
@@ -722,9 +729,18 @@ async function deployOne(
       gitRef,
       agentPath,
       repositories: options.cursorEventsRepos,
+      hasScmChannels: manifest.hasScmChannels,
+      multiTenant: options.multiTenant === true,
     });
   }
 
+  if (options.multiTenant === true) {
+    ctx.err(
+      "--multi-tenant is only valid for architecture: v2 deploys (Cursor-managed products).\n"
+    );
+    return 1;
+  }
+
   // Today's only source shape: the control plane builds from a git ref.
   // See DeploySource for the artifact seam.
   const source: DeploySource = {
@@ -804,11 +820,9 @@ async function deployOne(
   }
 
   if (detail.status !== "running") {
-    const errorDetail =
-      detail.lastError === null || detail.lastError === undefined
-        ? ""
-        : `: ${sanitizeCustomerError(detail.lastError)}`;
-    ctx.err(`Deployment ${slug} ended ${detail.status}${errorDetail}\n`);
+    ctx.err(
+      `Deployment ${slug} ended ${detail.status}${deployFailureDetail(detail.lastError)}\n`
+    );
     return 1;
   }
   const deployedPublicRoutes = detail.publicRoutePaths ?? [];
@@ -845,7 +859,8 @@ async function deployOne(
 async function deployAgentsdkApplication(
   ctx: DeployCliContext,
   options: DeployCliOptions,
-  targets: readonly DeployTarget[]
+  targets: readonly DeployTarget[],
+  declarations: { hasScmChannels: boolean }
 ): Promise<number> {
   const parentDir = resolve(options.dir ?? ".");
   const slug = slugFromDirectoryName(basename(parentDir));
@@ -926,6 +941,8 @@ async function deployAgentsdkApplication(
     agentPath: undefined,
     components,
     repositories: options.cursorEventsRepos,
+    hasScmChannels: declarations.hasScmChannels,
+    multiTenant: options.multiTenant === true,
   });
 }
 
@@ -944,6 +961,10 @@ async function deployOneAgentsdk(
     agentPath: string | undefined;
     components?: AgentkitDeployComponent[];
     repositories: string[] | undefined;
+    /** Any component declares a GitHub/Origin channel. */
+    hasScmChannels: boolean;
+    /** Redeploy an existing Cursor-managed product. */
+    multiTenant: boolean;
   }
 ): Promise<number> {
   const { slug } = args;
@@ -953,6 +974,9 @@ async function deployOneAgentsdk(
       : `  components:  ${args.components
           .map((component) => component.componentKey)
           .join(", ")}\n`;
+  if (args.multiTenant && !ctx.json) {
+    ctx.err("  multi-tenant: existing product\n");
+  }
   let accepted: AgentkitDeployAccepted;
   try {
     accepted = await ctx.client.deployAgentkit({
@@ -963,6 +987,7 @@ async function deployOneAgentsdk(
       agentPath: args.agentPath,
       components: args.components,
       repositories: args.repositories,
+      ...(args.multiTenant ? { multiTenant: true } : {}),
     });
   } catch (error) {
     return renderApiError(error, ctx.err);
@@ -1004,7 +1029,9 @@ async function deployOneAgentsdk(
   }
 
   if (detail.status !== "running") {
-    ctx.err(`Deployment ${slug} ended ${detail.status}\n`);
+    ctx.err(
+      `Deployment ${slug} ended ${detail.status}${deployFailureDetail(detail.lastError)}\n`
+    );
     return 1;
   }
   ctx.out(
@@ -1017,8 +1044,19 @@ async function deployOneAgentsdk(
         ? ""
         : `  components:   ${args.components
             .map((component) => component.componentKey)
-            .join(", ")}\n`)
+            .join(", ")}\n`) +
+      (detail.repositories === undefined || !args.hasScmChannels
+        ? ""
+        : `  watching:     ${detail.repositories.length === 0 ? "(nothing)" : detail.repositories.join(", ")}\n`)
   );
+  // An agent with GitHub/Origin channels bound to no repository scope gets
+  // no deliveries at all, which is otherwise invisible in this output.
+  if (args.hasScmChannels && detail.repositories?.length === 0) {
+    ctx.err(
+      `warning: ${slug} watches no repositories, so its GitHub/Origin channels receive no events.\n` +
+        `  Redeploy with --cursor-events-repo <owner>/<name> to set the scope.\n`
+    );
+  }
   return 0;
 }
 
@@ -1128,6 +1166,11 @@ interface DeployManifest {
    * (only `/v1/channels/…` subtrees can be public); surfaced as a warning.
    */
   httpChannelPublicEndpoint: boolean;
+  /**
+   * The agent has GitHub/Origin channels, so it only receives deliveries
+   * while the deployment is bound to at least one `owner/name` scope.
+   */
+  hasScmChannels: boolean;
 }
 
 /**
@@ -1163,6 +1206,10 @@ async function readDeployManifest(dir: string): Promise<DeployManifest> {
     httpChannelPublicEndpoint: (project.httpChannel.auth ?? []).some(
       isPublicEndpointPolicy
     ),
+    hasScmChannels: project.channels.some((channel) => {
+      const kind = channel.definition.meta?.kind;
+      return kind === "github" || kind === "origin";
+    }),
   };
 }
 
@@ -1938,9 +1985,32 @@ function aliasTokenBlock(aliasToken: string): string {
   );
 }
 
+/**
+ * `: <reason>` suffix for a deploy that ended in a non-running state, or
+ * empty when the control plane recorded no reason.
+ */
+function deployFailureDetail(lastError: string | null | undefined): string {
+  if (
+    lastError === null ||
+    lastError === undefined ||
+    lastError.trim() === ""
+  ) {
+    return "";
+  }
+  return `: ${sanitizeCustomerError(lastError.trim())}`;
+}
+
 function renderApiError(error: unknown, err: (text: string) => void): number {
   if (error instanceof DeployApiError) {
     err(`${error.message}\n`);
+    if (
+      error.status === 409 &&
+      error.message.includes("application multiTenant does not match")
+    ) {
+      err(
+        "This slug is a Cursor-managed (multi-tenant) product. Redeploy it with --multi-tenant.\n"
+      );
+    }
     return 1;
   }
   throw error;

package/src/internal/cli-mcp-oauth.ts

@@ -23,10 +23,10 @@ import { CLI_COMMAND_NAME as CLI, LOG_PREFIX } from "./distribution.js";
 import {
   createHostMcpOAuthProvider,
   MCP_OAUTH_CALLBACK_URL,
-  mcpOauthSecretNames,
   openBrowser,
   waitForMcpOAuthCallback,
 } from "./mcp-oauth.js";
+import { upsertHostMcpOauthSecrets } from "./mcp-oauth-persist.js";
 import { resolveProdSlug } from "./resolve-prod-target.js";
 
 export type McpOauthCliOptions = {
@@ -381,29 +381,15 @@ async function storeOauthSecrets(args: {
     return auth;
   }
 
-  const names = mcpOauthSecretNames(args.connection);
-  const secrets: Array<{ name: string; value: string }> = [
-    { name: names.accessToken, value: tokens.access_token },
-  ];
-  if (
-    tokens.refresh_token !== undefined &&
-    tokens.refresh_token.trim() !== ""
-  ) {
-    secrets.push({ name: names.refreshToken, value: tokens.refresh_token });
-  }
-  if (args.clientId !== undefined && args.clientId.trim() !== "") {
-    secrets.push({ name: names.clientId, value: args.clientId });
-  }
-
   try {
-    const secretNames = await auth.client.setSecrets({
-      teamId: auth.teamId,
-      slug,
-      secrets,
+    const secretNames = await upsertHostMcpOauthSecrets({
+      connection: args.connection,
+      tokens,
+      clientId: args.clientId,
+      target: { client: auth.client, teamId: auth.teamId, slug },
     });
     args.out(
-      `${LOG_PREFIX} Stored on ${slug}: ${secrets.map((s) => s.name).join(", ")}.\n` +
-        `${LOG_PREFIX} Secrets now: ${secretNames.join(", ")}. Next deploy picks them up.\n`
+      `${LOG_PREFIX} Stored on ${slug}. Secrets now: ${secretNames.join(", ")}. Next deploy picks them up.\n`
     );
     return 0;
   } catch (error) {