@cursor/july 0.1.27 → 0.1.29

package/src/bin/agent-serve.ts

@@ -85,7 +85,7 @@ Usage:
   ${CLI} sessions    [--url <baseUrl> | --prod] [--json]
                           [--slug <slug>] [--team <id>] [--dir <path>]
   ${CLI} session     <sessionId> [--url <baseUrl> | --prod]
-                          [--json | --text | --events]
+                          [--json | --text | --events] [--out <file.ndjson>]
                           [--slug <slug>] [--team <id>] [--dir <path>]
   ${CLI} cost        [sessionId] [--url <baseUrl> | --prod] [--json]
                           [--slug <slug>] [--team <id>] [--dir <path>]
@@ -110,11 +110,12 @@ Usage:
                           [--tag <tag>]... [--verbose] [--timeout-ms <n>]
                           [--strict] [--max-concurrency <n>]
                           [--junit <path>] [--artifacts <dir>|--no-artifacts]
+                          [--out <file.json>]
                           [--skip-report] [--no-stream] [--no-wait]
                           [--prod | --url <baseUrl>] [--slug <slug>]
                           [--team <id>]
   ${CLI} eval status [runId] --prod|--url <baseUrl> [--dir <path>] [--json]
-                          [--slug <slug>] [--team <id>]
+                          [--out <file.json>] [--slug <slug>] [--team <id>]
   ${CLI} eval cancel <runId> --prod|--url <baseUrl> [--dir <path>] [--json]
                           [--slug <slug>] [--team <id>]
   ${CLI} info        [--dir <path>] [--json]
@@ -299,6 +300,9 @@ Options:
                      connections (defineConnection({ agent })) on cloud-runtime
                      turns; local turns always use loopback.
   --no-schedules     Disable the cron runner outside dev mode.
+  --no-control-plane serve: do not start the bundled control plane (schedule
+                     and reminder clocks). Cursor hosting passes this so the
+                     kit uses the Cursor backend instead.
   --team             deploy/deployments/deployment/stop/rotate-token and
                      chat/resume/run/call/eval/logs/sessions/session/playground
                      --prod: Cursor team id. Defaults to the account's team when
@@ -392,9 +396,25 @@ Options:
   --comment          github replay: comment body for comment events.
   --context          github replay: commit-status context.
   --dry-run          github replay: print synthesized payloads, don't POST.
-  --out              github replay: write synthesized payloads as fixtures.
+  --out              eval / eval status <runId>: also write the full results
+                     JSON to this path. session: write the raw NDJSON trace
+                     there instead of printing (same format as run --events;
+                     playground-openable). github replay: write synthesized
+                     payloads as fixtures.
 `;
 
+function writeStdout(text: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
 async function main(argv: string[]): Promise<number> {
   const [command, ...restIn] = argv;
   if (
@@ -403,11 +423,13 @@ async function main(argv: string[]): Promise<number> {
     command === "--help" ||
     command === "-h"
   ) {
-    process.stdout.write(HELP);
+    // Await the write: HELP is larger than a pipe buffer, and process.exit
+    // after main() would otherwise truncate --help under execFile / CI.
+    await writeStdout(HELP);
     return command === undefined ? 1 : 0;
   }
   if (command === "version" || command === "--version" || command === "-V") {
-    process.stdout.write(`${CLI} ${packageVersion()}\n`);
+    await writeStdout(`${CLI} ${packageVersion()}\n`);
     return 0;
   }
 
@@ -436,6 +458,7 @@ async function main(argv: string[]): Promise<number> {
       "allow-anonymous-cursor-account-mcp": { type: "boolean", default: false },
       "cursor-github-proxy": { type: "boolean", default: false },
       "no-schedules": { type: "boolean", default: false },
+      "no-control-plane": { type: "boolean", default: false },
       "no-playground": { type: "boolean", default: false },
       "no-docs": { type: "boolean", default: false },
       url: { type: "string" },
@@ -775,6 +798,7 @@ async function main(argv: string[]): Promise<number> {
             apiKey: values["api-key"],
             slug: values.slug,
             bearerToken: values["bearer-token"],
+            out: values.out,
           })
         );
       }
@@ -819,6 +843,7 @@ async function main(argv: string[]): Promise<number> {
           artifacts: values["no-artifacts"] ? false : values.artifacts,
           skipReport: values["skip-report"],
           maxConcurrency: parseMaxConcurrency(values["max-concurrency"]),
+          out: values.out,
         })
       );
     }
@@ -912,6 +937,7 @@ async function main(argv: string[]): Promise<number> {
           json: values.json,
           text: values.text,
           rawEvents: values["raw-events"],
+          out: values.out,
         })
       );
     }
@@ -1140,6 +1166,7 @@ async function main(argv: string[]): Promise<number> {
         cursorGithubProxy:
           values["cursor-github-proxy"] === true ? true : undefined,
         schedules: values["no-schedules"] === true ? false : undefined,
+        noControlPlane: values["no-control-plane"] === true ? true : undefined,
         playground: values["no-playground"] === true ? false : undefined,
         docs: values["no-docs"] === true ? false : undefined,
         publicUrl: values["public-url"],
@@ -1291,6 +1318,7 @@ function axFromOptions(
     artifacts: partial.artifacts,
     skipReport: partial.skipReport,
     maxConcurrency: partial.maxConcurrency,
+    out: partial.out,
   };
 }
 

package/src/channels/slack/auth.ts

@@ -4,29 +4,39 @@
 
 import { samePrincipal } from "../../internal/auth.js";
 import type { AuthContext } from "../../types.js";
-import type { SlackBinding, SlackBlockAction, SlackMessage } from "./types.js";
+import type {
+  SlackBinding,
+  SlackBlockAction,
+  SlackMessage,
+  SlackRespondTo,
+} from "./types.js";
 
-/**
- * Build a thread-scoped principal so any participant in the same Slack
- * thread can continue the session. The triggering user is preserved in
- * attributes for message context.
- */
-export function buildSlackAuthContext(args: {
+export type BuildSlackAuthArgs = {
   channelId: string;
   threadTs: string;
   teamId?: string;
   userId?: string;
   userName?: string;
   isBot?: boolean;
-  /**
-   * Engagement surface that started the session (e.g. `"channel_post"` for
-   * the opt-in channel watch). Recorded as an attribute; the principal stays
-   * thread-scoped so an @mention in the same thread continues the session.
-   */
   engagement?: string;
-}): AuthContext {
+  /** Defaults to `"thread"`. `"author"` appends `:{userId}` to the principal. */
+  respondTo?: SlackRespondTo;
+};
+
+/**
+ * Build a Slack session principal.
+ *
+ * - `"thread"` (default): any participant can continue.
+ * - `"author"`: only the starter (`…:{userId}`), same shape approvals already honor.
+ */
+export function buildSlackAuthContext(args: BuildSlackAuthArgs): AuthContext {
   const team = args.teamId ?? "unknown";
-  const principalId = `slack:${team}:${args.channelId}:${args.threadTs}`;
+  const respondTo = args.respondTo ?? "thread";
+  const base = `slack:${team}:${args.channelId}:${args.threadTs}`;
+  const authorScoped =
+    respondTo === "author" && args.userId !== undefined && args.userId !== "";
+  const principalId = authorScoped ? `${base}:${args.userId}` : base;
+
   const attributes: Record<string, string> = {
     channel_id: args.channelId,
     thread_ts: args.threadTs,
@@ -106,7 +116,7 @@ export function blockActionAuth(action: SlackBlockAction): AuthContext {
 export function defaultSlackAuth(
   message: SlackMessage,
   ctx: SlackBinding,
-  options?: { engagement?: string }
+  options?: { engagement?: string; respondTo?: SlackRespondTo }
 ): AuthContext | null {
   if (message.author === undefined) {
     return null;
@@ -114,14 +124,11 @@ export function defaultSlackAuth(
   return buildSlackAuthContext({
     channelId: ctx.slack.channelId,
     threadTs: ctx.slack.threadTs,
-    ...(message.teamId === undefined ? {} : { teamId: message.teamId }),
+    teamId: message.teamId,
     userId: message.author.userId,
-    ...(message.author.userName === undefined
-      ? {}
-      : { userName: message.author.userName }),
+    userName: message.author.userName,
     isBot: message.author.isBot,
-    ...(options?.engagement === undefined
-      ? {}
-      : { engagement: options.engagement }),
+    engagement: options?.engagement,
+    respondTo: options?.respondTo,
   });
 }

package/src/channels/slack/cursor-account.ts

@@ -172,6 +172,8 @@ export async function dispatchCursorSlackEnvelope(args: {
     log,
     evalCommandsEnabled: runtime.options.evalCommands !== false,
     cursorAgentName: envelope.agentName,
+    // Backend router already refused externals for this envelope.
+    blockExternals: false,
     ...(args.hasContinuationSession === undefined
       ? {}
       : { hasContinuationSession: args.hasContinuationSession }),

package/src/channels/slack/defaults.ts

@@ -20,9 +20,11 @@ import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
 import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.js";
 import type {
+  SlackAccessPolicy,
   SlackChannelState,
   SlackCredentials,
   SlackMessageHandler,
+  SlackRespondTo,
   SlackSuggestedPrompt,
 } from "./types.js";
 
@@ -30,6 +32,19 @@ const SLACK_TURN_FAILURE_FALLBACK =
   "I hit an error while handling your request. Please try again or rephrase.";
 const SLACK_TURN_FAILURE_MAX_CHARS = 400;
 
+export function resolveSlackRespondTo(
+  policy: SlackAccessPolicy | undefined
+): SlackRespondTo {
+  return policy?.respondTo === "author" ? "author" : "thread";
+}
+
+/** Defaults to true when omitted. */
+export function resolveSlackBlockExternals(
+  policy: SlackAccessPolicy | undefined
+): boolean {
+  return policy?.blockExternals !== false;
+}
+
 /** Scrubbed turn.failed body for Slack (secrets / paths / URLs stripped). */
 export function formatSlackTurnFailureMessage(raw: string | undefined): string {
   const scrubbed = scrubSlackErrorDetail(raw?.trim() ?? "");
@@ -68,29 +83,34 @@ function resolveLoadingMessages(
 
 /** Default mention/DM inbound handler (optional custom loading rotation). */
 export function createDefaultOnInbound(
-  loadingMessages?: readonly string[]
+  loadingMessages?: readonly string[],
+  policy?: SlackAccessPolicy
 ): SlackMessageHandler {
   const rotating = resolveLoadingMessages(loadingMessages);
+  const respondTo = resolveSlackRespondTo(policy);
   return async (ctx, message) => {
     await ctx.thread.startTyping("Thinking…", rotating);
-    const auth = defaultSlackAuth(message, ctx);
+    const auth = defaultSlackAuth(message, ctx, { respondTo });
     return auth === null ? null : { auth };
   };
 }
 
 /**
  * Default watched-channel-post handler (optional custom loading rotation).
- * Same thread-scoped principal as mentions, tagged with
+ * Same principal policy as mentions, tagged with
  * `engagement: "channel_post"` for auth policies.
  */
 export function createDefaultOnChannelPost(
-  loadingMessages?: readonly string[]
+  loadingMessages?: readonly string[],
+  policy?: SlackAccessPolicy
 ): SlackMessageHandler {
   const rotating = resolveLoadingMessages(loadingMessages);
+  const respondTo = resolveSlackRespondTo(policy);
   return async (ctx, message) => {
     await ctx.thread.startTyping("Thinking…", rotating);
     const auth = defaultSlackAuth(message, ctx, {
       engagement: "channel_post",
+      respondTo,
     });
     return auth === null ? null : { auth };
   };

package/src/channels/slack/dispatch.ts

@@ -17,6 +17,7 @@ import {
   parseSlackEvalDirective,
 } from "./eval-directive.js";
 import type { EventIdDedupe } from "./event-id-dedupe.js";
+import { isExternalSlackSender } from "./external-policy.js";
 import {
   formatSlackContextBlock,
   parseAppMentionEvent,
@@ -91,6 +92,11 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
   evalCommandsEnabled?: boolean;
   /** cursorAccount agent name stripped before `eval` directive parsing. */
   cursorAgentName?: string;
+  /**
+   * Drop external senders before the handler. Defaults to `true`; pass
+   * `false` to admit them (or when an upstream gate already refused them).
+   */
+  blockExternals?: boolean;
 }
 
 function triggeringMergeMessage(
@@ -132,6 +138,7 @@ export async function dispatchInboundMessage(args: {
    * (`OncallBuddy eval list`).
    */
   cursorAgentName?: string;
+  blockExternals?: boolean;
 }): Promise<void> {
   const { message, kind } = args;
   const log = args.log ?? defaultSlackLog;
@@ -142,7 +149,7 @@ export async function dispatchInboundMessage(args: {
     host: args.host,
     artifacts: args.artifacts,
     log,
-    ...(message.teamId === undefined ? {} : { teamId: message.teamId }),
+    teamId: message.teamId,
   });
 
   log.info("inbound", {
@@ -155,6 +162,38 @@ export async function dispatchInboundMessage(args: {
     team: message.teamId,
   });
 
+  if (args.blockExternals !== false && message.author?.isBot !== true) {
+    const userId = message.author?.userId ?? "";
+    const teamId = message.teamId;
+    if (teamId === undefined || teamId === "") {
+      log.info("inbound dropped (missing team)", {
+        kind,
+        channel: message.channelId,
+        thread_ts: message.threadTs,
+        user: userId,
+        event_id: args.eventId,
+      });
+      return;
+    }
+    if (
+      await isExternalSlackSender({
+        botToken: args.credentials?.botToken,
+        slackTeamId: teamId,
+        userId,
+      })
+    ) {
+      log.info("inbound dropped (external sender)", {
+        kind,
+        channel: message.channelId,
+        thread_ts: message.threadTs,
+        user: userId,
+        team: teamId,
+        event_id: args.eventId,
+      });
+      return;
+    }
+  }
+
   const continuation = slackContinuationKey(
     message.channelId,
     message.threadTs
@@ -463,6 +502,7 @@ export function dispatchInboundFromEventBody(
         log,
         evalCommandsEnabled: deps.evalCommandsEnabled,
         cursorAgentName: deps.cursorAgentName,
+        blockExternals: deps.blockExternals,
         ...(deps.hasContinuationSession === undefined
           ? {}
           : { hasContinuationSession: deps.hasContinuationSession }),
@@ -504,6 +544,7 @@ export function dispatchInboundFromEventBody(
         log,
         evalCommandsEnabled: deps.evalCommandsEnabled,
         cursorAgentName: deps.cursorAgentName,
+        blockExternals: deps.blockExternals,
         ...(deps.hasContinuationSession === undefined
           ? {}
           : { hasContinuationSession: deps.hasContinuationSession }),

package/src/channels/slack/external-policy.ts

@@ -0,0 +1,62 @@
+/**
+ * Workspace-membership checks for AgentKit Slack agents.
+ * Mirrors backend `isExternalSlackUser` (cloud-agent/slack/externalChannelPolicy).
+ */
+
+import { callSlackApi } from "./api.js";
+import type { SlackBotToken } from "./types.js";
+
+type SlackUserInfo = {
+  team_id?: string;
+  is_stranger?: boolean;
+  is_restricted?: boolean;
+  is_ultra_restricted?: boolean;
+  enterprise_user?: { teams?: string[] };
+};
+
+/** Pure classifier over a `users.info` user object. Fails open to external. */
+export function classifySlackUserExternality(args: {
+  slackTeamId: string;
+  user: SlackUserInfo;
+}): boolean {
+  const { slackTeamId, user } = args;
+  if (
+    user.is_stranger === true ||
+    user.is_restricted === true ||
+    user.is_ultra_restricted === true
+  ) {
+    return true;
+  }
+  return (
+    user.team_id !== undefined &&
+    user.team_id !== slackTeamId &&
+    !(user.enterprise_user?.teams ?? []).includes(slackTeamId)
+  );
+}
+
+/** Lookup + classify. Empty userId / API failure → external. */
+export async function isExternalSlackSender(args: {
+  botToken: SlackBotToken | undefined;
+  slackTeamId: string;
+  userId: string;
+}): Promise<boolean> {
+  if (args.userId === "") {
+    return true;
+  }
+  try {
+    const result = await callSlackApi({
+      botToken: args.botToken,
+      operation: "users.info",
+      body: { user: args.userId },
+    });
+    if (result.ok !== true || result.user === undefined) {
+      return true;
+    }
+    return classifySlackUserExternality({
+      slackTeamId: args.slackTeamId,
+      user: result.user as SlackUserInfo,
+    });
+  } catch {
+    return true;
+  }
+}

package/src/channels/slack/index.ts

@@ -33,6 +33,7 @@ export * from "./dispatch.js";
 export * from "./doctor.js";
 export * from "./eval-directive.js";
 export * from "./event-id-dedupe.js";
+export * from "./external-policy.js";
 export * from "./inbound.js";
 export * from "./init.js";
 export * from "./interactive.js";

package/src/channels/slack/interactive.ts

@@ -20,6 +20,7 @@ import { updateMessage } from "./api.js";
 import { decisionFromActionId, parseApprovalActionValue } from "./approvals.js";
 import { buildSlackInteractiveApprovalAuth } from "./auth.js";
 import { dispatchInboundMessage } from "./dispatch.js";
+import { isExternalSlackSender } from "./external-policy.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
 import type {
   SlackBlockAction,
@@ -41,6 +42,8 @@ export interface SlackInteractiveDispatchDeps {
   ) => Promise<PendingApproval>;
   waitUntil: (promise: Promise<unknown>) => void;
   log?: SlackLog;
+  /** Defaults to true. */
+  blockExternals?: boolean;
 }
 
 /**
@@ -116,11 +119,35 @@ export async function dispatchInteractiveFromPayload(
   }
 
   const teamId = attrs.team_id;
+  if (deps.blockExternals !== false && parsed.userId !== "") {
+    if (teamId === undefined || teamId === "") {
+      log.info("interactive approval dropped (missing team)", {
+        session: value.sessionId,
+        user: parsed.userId,
+      });
+      return true;
+    }
+    if (
+      await isExternalSlackSender({
+        botToken: deps.credentials?.botToken,
+        slackTeamId: teamId,
+        userId: parsed.userId,
+      })
+    ) {
+      log.info("interactive approval dropped (external sender)", {
+        session: value.sessionId,
+        user: parsed.userId,
+        team: teamId,
+      });
+      return true;
+    }
+  }
+
   const clickingAuth = buildSlackInteractiveApprovalAuth({
     sessionAuth,
     channelId: parsed.channelId || sessionChannel,
     threadTs: parsed.threadTs || sessionThread,
-    ...(teamId === undefined || teamId === "" ? {} : { teamId }),
+    teamId: teamId === undefined || teamId === "" ? undefined : teamId,
     clickingUserId: parsed.userId,
   });
 
@@ -204,12 +231,9 @@ export function parseSlackBlockAction(
       : typeof user.name === "string"
         ? user.name
         : undefined;
-  const teamId =
-    typeof team.id === "string"
-      ? team.id
-      : typeof user.team_id === "string"
-        ? user.team_id
-        : undefined;
+  // Payload `team.id` only — never `user.team_id` (Connect home team).
+  // Membership gates must baseline the install workspace separately.
+  const teamId = typeof team.id === "string" ? team.id : undefined;
   const label =
     typeof action.text === "object" &&
     action.text !== null &&
@@ -278,6 +302,10 @@ export interface SlackBlockActionDispatchDeps extends SlackContinuationProbes {
   host: HostContext;
   artifacts: ArtifactsApi;
   log?: SlackLog;
+  /** Defaults to true. */
+  blockExternals?: boolean;
+  /** Install workspace from `auth.test`; baseline for the external gate. */
+  installTeamId?: string;
 }
 
 /**
@@ -285,7 +313,10 @@ export interface SlackBlockActionDispatchDeps extends SlackContinuationProbes {
  * `action_ts` (unique per click, never a real thread message), so ask-dedupe
  * claims and `<slack_thread>` exclusions stay per-click.
  */
-function blockActionAsMessage(action: SlackBlockAction): SlackMessage {
+function blockActionAsMessage(
+  action: SlackBlockAction,
+  installTeamId: string | undefined
+): SlackMessage {
   const text = `[clicked: ${action.label ?? action.actionId}]`;
   return {
     text,
@@ -294,7 +325,7 @@ function blockActionAsMessage(action: SlackBlockAction): SlackMessage {
     ts: action.actionTs,
     threadTs: action.threadTs,
     channelId: action.channelId,
-    teamId: action.teamId,
+    teamId: installTeamId,
     author: {
       userId: action.userId,
       userName: action.userName,
@@ -344,7 +375,7 @@ export async function dispatchBlockAction(
 
   await dispatchInboundMessage({
     kind: "block_action",
-    message: blockActionAsMessage(action),
+    message: blockActionAsMessage(action, deps.installTeamId),
     handler: (ctx) => deps.handler(ctx, action),
     send: deps.send,
     credentials: deps.credentials,
@@ -353,6 +384,7 @@ export async function dispatchBlockAction(
     log,
     // Click text is synthetic — never treat it as a stop/eval directive.
     evalCommandsEnabled: false,
+    blockExternals: deps.blockExternals,
     hasContinuationSession: deps.hasContinuationSession,
     isContinuationBusy: deps.isContinuationBusy,
     getContinuationLastBotMessageTs: deps.getContinuationLastBotMessageTs,