@cursor/july 0.1.95 → 0.1.97

package/src/channels/slack/defaults.ts

@@ -2,7 +2,7 @@
  * Default inbound handlers and stream-event sinks for the Slack channel.
  */
 
-import type { ChannelEventHandlers } from "../../types.js";
+import type { ChannelEventContext, ChannelEventHandlers } from "../../types.js";
 import {
   appendChatStream,
   postMessage,
@@ -166,7 +166,7 @@ export function buildDefaultEvents(
       status: "",
     });
     if (!result.ok) {
-      getLog().warn("assistant.threads.setStatus not-ok", {
+      getLog().warn("slack setStatus not-ok", {
         error: result.error,
         channel: channelId,
         thread_ts: threadTs,
@@ -174,6 +174,91 @@ export function buildDefaultEvents(
     }
   };
 
+  /**
+   * Deliver assistant text to the bound Slack thread. Used by a stop-reason
+   * `message.completed` and by `turn.completed` when the last assistant
+   * block was `finishReason: "tool_call"` (answer then `tag_artifact`,
+   * etc.) so the playground result still reaches Slack.
+   */
+  const deliverReplyText = async (args: {
+    channel: ChannelEventContext<SlackChannelState>;
+    text: string;
+    sessionId: string;
+  }): Promise<boolean> => {
+    const log = getLog();
+    const state = args.channel.state;
+    if (
+      state.channelId === null ||
+      state.threadTs === null ||
+      args.text === ""
+    ) {
+      return false;
+    }
+    if (state.lastPostedText === args.text) {
+      // Stream append sets this watermark while chat.stopStream is still
+      // pending. Treat a match as "already on Slack", not "already finalized".
+      const streamTs = state.streamTs;
+      if (streamTs !== null && streamTs !== "") {
+        const canStream = streaming && state.streamingUnavailable !== true;
+        if (canStream) {
+          await strategy.finalize({
+            channel: args.channel,
+            channelId: state.streamChannelId ?? state.channelId,
+            text: args.text,
+            sessionId: args.sessionId,
+          });
+        } else {
+          await strategy.cleanupOrphan({ channel: args.channel });
+        }
+      }
+      return true;
+    }
+
+    const canStream = streaming && state.streamingUnavailable !== true;
+    if (canStream) {
+      const { delivered } = await strategy.finalize({
+        channel: args.channel,
+        channelId: state.streamChannelId ?? state.channelId,
+        text: args.text,
+        sessionId: args.sessionId,
+      });
+      if (delivered) {
+        return true;
+      }
+    }
+
+    try {
+      const posted = await postMessage({
+        botToken,
+        channel: state.channelId,
+        text: args.text,
+        threadTs: state.threadTs,
+      });
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = posted.ts;
+      log.info("reply delivered via postMessage", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        message_ts: posted.ts,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    } catch (error) {
+      log.error(
+        `postMessage failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        {
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          session: args.sessionId,
+        }
+      );
+      return false;
+    }
+  };
+
   return {
     async "turn.started"(event, channel) {
       const log = getLog();
@@ -205,42 +290,22 @@ export function buildDefaultEvents(
         status: "Working…",
         loadingMessages,
       });
-
-      // Retry streaming each turn unless a prior call proved the feature
-      // unsupported for this workspace/app. Thinking stays on setStatus
-      // (Cursor-account proxy pins agent username/icon on that method).
-      if (!streaming || state.streamingUnavailable === true) {
-        return;
-      }
-
-      await strategy.start({
-        channel,
-        channelId: state.channelId,
-        threadTs: state.threadTs,
-        sessionId: event.sessionId,
-      });
     },
 
     async "message.appended"(event, channel) {
       if (!streaming || channel.state.streamingUnavailable === true) {
         return;
       }
-      const streamTs = channel.state.streamTs;
       const channelId =
         channel.state.streamChannelId ?? channel.state.channelId;
-      if (
-        streamTs === null ||
-        streamTs === "" ||
-        channelId === null ||
-        channelId === ""
-      ) {
+      const threadTs = channel.state.threadTs;
+      if (channelId === null || channelId === "" || threadTs === null) {
         return;
       }
 
       await strategy.append({
         channel,
         channelId,
-        streamTs,
         text: event.data.text,
         sessionId: event.sessionId,
       });
@@ -298,24 +363,23 @@ export function buildDefaultEvents(
         strategy.inlineToolSteps &&
         thinkingSteps &&
         streaming &&
-        channel.state.streamingUnavailable !== true &&
-        channel.state.streamTs !== null &&
-        channel.state.streamTs !== ""
+        channel.state.streamingUnavailable !== true
       ) {
         const channelId =
           channel.state.streamChannelId ?? channel.state.channelId;
-        if (channelId !== null && channelId !== "") {
+        const threadTs = channel.state.threadTs;
+        if (channelId !== null && channelId !== "" && threadTs !== null) {
           const chunks = buildTaskChunksForCalls(
             event.data.calls,
             "in_progress"
           );
-          const result = await appendChatStream({
-            botToken,
-            channel: channelId,
-            ts: channel.state.streamTs,
+          const streamed = await strategy.appendChunks({
+            channel,
+            channelId,
             chunks,
+            sessionId: event.sessionId,
           });
-          if (result.ok) {
+          if (streamed) {
             if (
               channel.state.channelId !== null &&
               channel.state.threadTs !== null
@@ -372,7 +436,6 @@ export function buildDefaultEvents(
     },
 
     async "message.completed"(event, channel) {
-      const log = getLog();
       if (event.data.finishReason === "tool_call") {
         channel.state.pendingToolCallMessage =
           firstNonEmptyLine(event.data.text) ?? null;
@@ -388,67 +451,16 @@ export function buildDefaultEvents(
       // Empty final text: still close any open stream / clear the skeleton
       // and clear typing.
       if (event.data.text === "") {
-        if (state.streamTs !== null && state.streamTs !== "") {
-          await strategy.finalizeEmpty({
-            channel,
-            channelId: state.streamChannelId ?? state.channelId,
-            streamTs: state.streamTs,
-          });
-          channel.state.streamTs = null;
-        }
+        await strategy.finalizeEmpty({ channel });
         await clearWorkingStatus(state.channelId, state.threadTs);
         return;
       }
 
-      const canStream =
-        streaming &&
-        state.streamingUnavailable !== true &&
-        state.streamTs !== null &&
-        state.streamTs !== "";
-
-      if (canStream && state.streamTs !== null) {
-        const { delivered } = await strategy.finalize({
-          channel,
-          channelId: state.streamChannelId ?? state.channelId,
-          streamTs: state.streamTs,
-          text: event.data.text,
-          sessionId: event.sessionId,
-        });
-        if (delivered) {
-          await clearWorkingStatus(state.channelId, state.threadTs);
-          return;
-        }
-      }
-
-      try {
-        const posted = await postMessage({
-          botToken,
-          channel: state.channelId,
-          text: event.data.text,
-          threadTs: state.threadTs,
-        });
-        channel.state.lastPostedText = event.data.text;
-        channel.state.lastBotMessageTs = posted.ts;
-        log.info("reply delivered via postMessage", {
-          channel: state.channelId,
-          thread_ts: state.threadTs,
-          message_ts: posted.ts,
-          session: event.sessionId,
-          chars: event.data.text.length,
-        });
-      } catch (error) {
-        log.error(
-          `postMessage failed: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-          {
-            channel: state.channelId,
-            thread_ts: state.threadTs,
-            session: event.sessionId,
-          }
-        );
-      }
-
+      await deliverReplyText({
+        channel,
+        text: event.data.text,
+        sessionId: event.sessionId,
+      });
       await clearWorkingStatus(state.channelId, state.threadTs);
     },
 
@@ -461,6 +473,24 @@ export function buildDefaultEvents(
         thread_ts: channel.state.threadTs,
       });
 
+      // Mid-turn `tool_call` text is held as status, not posted. If the
+      // turn ends without a later `finishReason: "stop"` block, the
+      // playground still has `result` (last assistant text) and Slack
+      // would otherwise stay silent.
+      const result = event.data.result;
+      const unpublished =
+        typeof result === "string" &&
+        result !== "" &&
+        result !== channel.state.lastPostedText;
+      if (unpublished) {
+        await deliverReplyText({
+          channel,
+          text: result,
+          sessionId: event.sessionId,
+        });
+      }
+      // Always close leftovers. deliverReplyText may fall through to
+      // postMessage when streaming is unavailable and leave streamTs open.
       await strategy.cleanupOrphan({ channel });
 
       // Always drop the assistant chip. message.completed already clears
@@ -509,11 +539,10 @@ export function buildDefaultEvents(
       const errorText = formatSlackTurnFailureMessage(event.data.message);
 
       let delivered = false;
-      if (state.streamTs !== null && state.streamTs !== "") {
+      if (streaming && state.streamingUnavailable !== true) {
         ({ delivered } = await strategy.fail({
           channel,
           channelId: state.streamChannelId ?? state.channelId,
-          streamTs: state.streamTs,
           errorText,
           sessionId: event.sessionId,
         }));

package/src/channels/slack/dispatch.ts

@@ -9,6 +9,7 @@ import {
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
+import { steeringEnabled } from "../../internal/steering.js";
 import type {
   ArtifactsApi,
   HostContext,
@@ -16,7 +17,11 @@ import type {
   SendMessageFn,
 } from "../../types.js";
 import { buildSlackBinding, slackContinuationKey } from "./api.js";
-import { firstLineTitle, maybeSetThreadTitle } from "./assistant.js";
+import {
+  firstLineTitle,
+  maybeSetSuggestedPrompts,
+  maybeSetThreadTitle,
+} from "./assistant.js";
 import {
   appendSlackAttachmentAnnotations,
   prepareSlackAttachments,
@@ -33,6 +38,7 @@ import { isExternalSlackSender } from "./external-policy.js";
 import {
   formatSlackContextBlock,
   parseAppMentionEvent,
+  parseAssistantThreadStarted,
   parseChannelMessageEvent,
   parseDirectMessageEvent,
   parseReactionAddedEvent,
@@ -51,6 +57,7 @@ import type {
   SlackDispatchDecision,
   SlackMessage,
   SlackMessageHandler,
+  SlackSuggestedPrompt,
 } from "./types.js";
 
 const FOLLOWUP_TYPING = "Saw your follow-up…";
@@ -167,6 +174,12 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
    * `false` to admit them (or when an upstream gate already refused them).
    */
   blockExternals?: boolean;
+  /**
+   * Suggested prompts written on `assistant_thread_started` so the
+   * assistant pane is not blank before the first user message.
+   */
+  suggestedPrompts?: SlackSuggestedPrompt[];
+  suggestedPromptsTitle?: string;
 }
 
 function triggeringMergeMessage(
@@ -529,27 +542,24 @@ export async function dispatchInboundMessage(args: {
         continuation,
         event_id: args.eventId,
       });
-      // Queue it for mid-turn injection too. The carrier drains this at the
-      // running turn's next tool boundary; whatever it does not reach in time
-      // still drains into the boundary turn, deduped by sourceTs.
-      try {
-        await args.host.slackNudges?.append({
-          continuationKey: continuation,
-          sourceTs: message.ts,
-          text: media.userText,
-          ...(message.author?.userName === undefined
-            ? {}
-            : { author: message.author.userName }),
-        });
-      } catch (nudgeError) {
-        log.warn("nudge append failed", {
-          error:
-            nudgeError instanceof Error
-              ? nudgeError.message
-              : String(nudgeError),
-          continuation,
-          event_id: args.eventId,
-        });
+      if (!steeringEnabled()) {
+        try {
+          await args.host.slackNudges?.append({
+            continuationKey: continuation,
+            sourceTs: message.ts,
+            text: media.userText,
+            author: message.author?.userName,
+          });
+        } catch (nudgeError) {
+          log.warn("nudge append failed", {
+            error:
+              nudgeError instanceof Error
+                ? nudgeError.message
+                : String(nudgeError),
+            continuation,
+            event_id: args.eventId,
+          });
+        }
       }
       try {
         if (args.followUpStatus !== false) {
@@ -750,6 +760,30 @@ export function dispatchInboundFromEventBody(
     return true;
   }
 
+  const assistantThread = parseAssistantThreadStarted(body);
+  if (assistantThread !== null) {
+    const prompts = deps.suggestedPrompts ?? [];
+    log.info("assistant thread started", {
+      channel: assistantThread.channelId,
+      thread_ts: assistantThread.threadTs,
+      user: assistantThread.userId,
+      event_id: eventId,
+    });
+    if (prompts.length > 0) {
+      deps.waitUntil(
+        maybeSetSuggestedPrompts({
+          botToken: deps.credentials?.botToken,
+          channelId: assistantThread.channelId,
+          threadTs: assistantThread.threadTs,
+          prompts,
+          title: deps.suggestedPromptsTitle,
+          log,
+        })
+      );
+    }
+    return true;
+  }
+
   if (deps.channelWatch !== undefined) {
     // Parse keeps bot-authored posts; the watcher enforces the per-channel
     // policy (includeBotPosts, own-post loop safety) with skip logging.

package/src/channels/slack/inbound.ts

@@ -121,6 +121,49 @@ export function parseAppMentionEvent(
   return delegation === undefined ? message : { ...message, delegation };
 }
 
+export interface SlackAssistantThreadStarted {
+  channelId: string;
+  threadTs: string;
+  userId?: string;
+  teamId?: string;
+}
+
+/** Slack fires this when a user opens the assistant pane. No model turn. */
+export function parseAssistantThreadStarted(
+  body: unknown
+): SlackAssistantThreadStarted | null {
+  const root = asRecord(body);
+  if (root === null || root.type !== "event_callback") {
+    return null;
+  }
+  const event = asRecord(root.event);
+  if (event === null || event.type !== "assistant_thread_started") {
+    return null;
+  }
+  const thread = asRecord(event.assistant_thread);
+  if (thread === null) {
+    return null;
+  }
+  const channelId = asString(thread.channel_id);
+  const threadTs = asString(thread.thread_ts);
+  if (
+    channelId === undefined ||
+    channelId === "" ||
+    threadTs === undefined ||
+    threadTs === ""
+  ) {
+    return null;
+  }
+  const userId = asString(thread.user_id);
+  const teamId = asString(root.team_id) ?? asString(event.team_id);
+  return {
+    channelId,
+    threadTs,
+    userId: userId === undefined || userId === "" ? undefined : userId,
+    teamId: teamId === undefined || teamId === "" ? undefined : teamId,
+  };
+}
+
 /**
  * Parse DM / IM messages. More generous than a strict channel_type check:
  * accepts `channel_type === "im"` or channel ids starting with `D`, and

package/src/channels/slack/init.ts

@@ -2,13 +2,14 @@
  * Scaffold a Slack channel into an agent-serve project.
  *
  * `initSlackChannel` is the create-safe writer: `agent/channels/slack.ts`
- * only. DIY manifests for paste at api.slack.com live in
+ * only. DIY manifests + Slack CLI `.slack/` live in
  * {@link initSlackManual} so `slack create` cannot reach them.
  */
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { PACKAGE_NAME } from "../../internal/distribution.js";
+import { writeSlackCliProject } from "./cli-project.js";
 import { envPrefixFromName, slackEnvKeys } from "./credentials.js";
 import {
   buildSlackManifestPair,
@@ -131,7 +132,8 @@ export async function initSlackChannel(
 
 /**
  * `slack init --manual`: channel file plus DIY manifests
- * (`managedByCursor: false`), env.example, and setup-status.json.
+ * (`managedByCursor: false`), Slack CLI `.slack/` project, env.example,
+ * and setup-status.json.
  */
 export async function initSlackManual(
   options: InitSlackManualOptions
@@ -151,9 +153,6 @@ export async function initSlackManual(
     description: options.description,
     channelPosts: options.channelPosts,
   });
-  for (const file of slackManifestFileEntries(pair)) {
-    await write(`.agent-serve/slack/${file.name}`, file.contents);
-  }
   await write(
     ".agent-serve/slack/env.example",
     `# Copy to .env.local (or export in your shell). Use the *dev* Slack app
@@ -176,6 +175,12 @@ ${target.envKeys.app}=xapp-...
       2
     )}\n`
   );
+  files.push(
+    ...(await writeSlackCliProject(
+      target.rootDir,
+      slackManifestFileEntries(pair)
+    ))
+  );
 
   return {
     rootDir: target.rootDir,

package/src/channels/slack/interactive.ts

@@ -15,10 +15,15 @@ import type {
   ChannelSession,
   HostContext,
   PendingApproval,
+  PendingAuth,
   SendMessageFn,
 } from "../../types.js";
 import { updateMessage } from "./api.js";
-import { decisionFromActionId, parseApprovalActionValue } from "./approvals.js";
+import {
+  decisionFromActionId,
+  decisionFromAuthActionId,
+  parseApprovalActionValue,
+} from "./approvals.js";
 import { buildSlackInteractiveApprovalAuth } from "./auth.js";
 import { dispatchInboundMessage } from "./dispatch.js";
 import { isExternalSlackSender } from "./external-policy.js";
@@ -41,6 +46,12 @@ export interface SlackInteractiveDispatchDeps {
     decision: ApprovalDecision,
     auth: AuthContext | null
   ) => Promise<PendingApproval>;
+  resolveAuth: (
+    sessionId: string,
+    callId: string,
+    decision: ApprovalDecision,
+    auth: AuthContext | null
+  ) => Promise<PendingAuth>;
   waitUntil: (promise: Promise<unknown>) => void;
   log?: SlackLog;
   /** Defaults to true. */
@@ -61,11 +72,17 @@ export async function dispatchInteractiveFromPayload(
     return false;
   }
 
-  const decision = decisionFromActionId(parsed.actionId);
+  const approvalDecision = decisionFromActionId(parsed.actionId);
+  const authDecision = decisionFromAuthActionId(parsed.actionId);
   const value = parseApprovalActionValue(parsed.value);
-  if (decision === null || value === null) {
+  if (value === null || (approvalDecision === null && authDecision === null)) {
     return false;
   }
+  const decision = approvalDecision ?? authDecision;
+  if (decision === null) {
+    return false;
+  }
+  const kind = approvalDecision !== null ? "approval" : "auth";
 
   log.info("interactive approval", {
     decision,
@@ -153,12 +170,21 @@ export async function dispatchInteractiveFromPayload(
   });
 
   try {
-    await deps.resolveApproval(
-      value.sessionId,
-      value.callId,
-      decision,
-      clickingAuth
-    );
+    if (kind === "auth") {
+      await deps.resolveAuth(
+        value.sessionId,
+        value.callId,
+        decision,
+        clickingAuth
+      );
+    } else {
+      await deps.resolveApproval(
+        value.sessionId,
+        value.callId,
+        decision,
+        clickingAuth
+      );
+    }
   } catch (error) {
     log.warn("interactive approval resolve failed", {
       session: value.sessionId,