@cursor/july 0.1.96 → 0.1.99

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,
@@ -18,6 +18,7 @@ import {
 } from "./constants.js";
 import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
+import { createProgressDelivery } from "./progress-delivery.js";
 import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.js";
 import type {
   SlackAccessPolicy,
@@ -154,6 +155,10 @@ export function buildDefaultEvents(
   const botToken = credentials?.botToken;
   const getLog = options.getLog ?? (() => defaultSlackLog);
   const strategy = createStreamDeliveryStrategy({ botToken, getLog });
+  const progress = createProgressDelivery({ botToken, getLog });
+
+  const streamLive = (state: SlackChannelState): boolean =>
+    streaming && !state.streamingUnavailable;
 
   const clearWorkingStatus = async (
     channelId: string,
@@ -174,15 +179,126 @@ export function buildDefaultEvents(
     }
   };
 
+  const finishProgress = 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 (await progress.replace({ channel: args.channel, text: args.text })) {
+      log.info("reply delivered via progress update", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    }
+    await progress.clear({ channel: args.channel });
+    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;
+    }
+  };
+
+  /**
+   * 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 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 !== "") {
+        if (streamLive(state)) {
+          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;
+    }
+
+    if (streamLive(state)) {
+      const { delivered } = await strategy.finalize({
+        channel: args.channel,
+        channelId: state.streamChannelId ?? state.channelId,
+        text: args.text,
+        sessionId: args.sessionId,
+      });
+      if (delivered) {
+        return true;
+      }
+    }
+
+    return finishProgress(args);
+  };
+
   return {
     async "turn.started"(event, channel) {
       const log = getLog();
+      await progress.clear({ channel });
       channel.state.pendingToolCallMessage = null;
       channel.state.lastReasoningTypingAtMs = null;
       channel.state.lastReasoningTypingStatus = null;
       channel.state.streamTs = null;
       channel.state.streamChannelId = null;
       channel.state.lastPostedText = null;
+      channel.state.streamBlockText = null;
       // Keep lastBotMessageTs across turns — warm delta watermark.
       channel.state.approvalMessageByCallId = {};
 
@@ -208,7 +324,7 @@ export function buildDefaultEvents(
     },
 
     async "message.appended"(event, channel) {
-      if (!streaming || channel.state.streamingUnavailable === true) {
+      if (!streamLive(channel.state)) {
         return;
       }
       const channelId =
@@ -277,8 +393,7 @@ export function buildDefaultEvents(
       if (
         strategy.inlineToolSteps &&
         thinkingSteps &&
-        streaming &&
-        channel.state.streamingUnavailable !== true
+        streamLive(channel.state)
       ) {
         const channelId =
           channel.state.streamChannelId ?? channel.state.channelId;
@@ -318,17 +433,24 @@ export function buildDefaultEvents(
           threadTs: channel.state.threadTs,
           status: statusText,
         });
+        if (
+          thinkingSteps &&
+          channel.state.streamingUnavailable === true &&
+          (channel.state.streamTs === null || channel.state.streamTs === "")
+        ) {
+          await progress.upsert({ channel, text: statusText });
+        }
       }
     },
 
     async "action.result"(event, channel) {
+      const streamTs = channel.state.streamTs;
       if (
         !strategy.inlineToolSteps ||
         !thinkingSteps ||
-        !streaming ||
-        channel.state.streamingUnavailable === true ||
-        channel.state.streamTs === null ||
-        channel.state.streamTs === ""
+        !streamLive(channel.state) ||
+        streamTs === null ||
+        streamTs === ""
       ) {
         return;
       }
@@ -345,16 +467,18 @@ export function buildDefaultEvents(
       await appendChatStream({
         botToken,
         channel: channelId,
-        ts: channel.state.streamTs,
+        ts: streamTs,
         chunks: [chunk],
       });
     },
 
     async "message.completed"(event, channel) {
-      const log = getLog();
       if (event.data.finishReason === "tool_call") {
         channel.state.pendingToolCallMessage =
           firstNonEmptyLine(event.data.text) ?? null;
+        // The harness restarts its cumulative text after a tool call, so the
+        // next block appends in full instead of diffing against this one.
+        channel.state.streamBlockText = null;
         return;
       }
       channel.state.pendingToolCallMessage = null;
@@ -368,54 +492,16 @@ export function buildDefaultEvents(
       // and clear typing.
       if (event.data.text === "") {
         await strategy.finalizeEmpty({ channel });
+        await progress.clear({ channel });
         await clearWorkingStatus(state.channelId, state.threadTs);
         return;
       }
 
-      const canStream = streaming && state.streamingUnavailable !== true;
-
-      if (canStream) {
-        const { delivered } = await strategy.finalize({
-          channel,
-          channelId: state.streamChannelId ?? state.channelId,
-          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);
     },
 
@@ -428,7 +514,26 @@ 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 });
+      await progress.clear({ channel });
 
       // Always drop the assistant chip. message.completed already clears
       // after a normal reply, but a tool-call-only finish (or a missed
@@ -476,7 +581,7 @@ export function buildDefaultEvents(
       const errorText = formatSlackTurnFailureMessage(event.data.message);
 
       let delivered = false;
-      if (streaming && state.streamingUnavailable !== true) {
+      if (streamLive(state)) {
         ({ delivered } = await strategy.fail({
           channel,
           channelId: state.streamChannelId ?? state.channelId,
@@ -485,25 +590,11 @@ export function buildDefaultEvents(
         }));
       }
       if (!delivered) {
-        try {
-          await postMessage({
-            botToken,
-            channel: state.channelId,
-            text: errorText,
-            threadTs: state.threadTs,
-          });
-        } catch (error) {
-          log.error(
-            `turn.failed postMessage failed: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-            {
-              channel: state.channelId,
-              thread_ts: state.threadTs,
-              session: event.sessionId,
-            }
-          );
-        }
+        await finishProgress({
+          channel,
+          text: errorText,
+          sessionId: event.sessionId,
+        });
       }
       await clearWorkingStatus(state.channelId, state.threadTs);
     },

package/src/channels/slack/dispatch.ts

@@ -126,8 +126,10 @@ export function emptySlackChannelState(
     streamTs: null,
     streamChannelId: null,
     lastPostedText: null,
+    streamBlockText: null,
     lastBotMessageTs: null,
     streamingUnavailable: false,
+    progressTs: null,
     approvalMessageByCallId: {},
     ...patch,
   };

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,

package/src/channels/slack/live-delivery.ts

@@ -41,7 +41,7 @@ type StreamArgs = {
 /**
  * How the default handlers deliver an in-progress reply. Methods write live
  * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
- * `streamingUnavailable`) on `channel.state` directly.
+ * `streamBlockText`, `streamingUnavailable`) on `channel.state` directly.
  */
 export interface LiveDeliveryStrategy {
   readonly inlineToolSteps: boolean;
@@ -127,6 +127,7 @@ export function createStreamDeliveryStrategy(
     channel.state.streamTs = started.ts;
     channel.state.streamChannelId = started.channel;
     channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
+    channel.state.streamBlockText = channel.state.lastPostedText;
     log.info("chat.startStream ok", {
       channel: started.channel,
       stream_ts: started.ts,
@@ -167,7 +168,7 @@ export function createStreamDeliveryStrategy(
     text: string;
   }): Promise<{ ok: boolean; error?: string }> => {
     const appendText = computeStreamAppend(
-      args.channel.state.lastPostedText,
+      args.channel.state.streamBlockText,
       args.text
     );
     const stopped = await stopChatStream({
@@ -213,7 +214,7 @@ export function createStreamDeliveryStrategy(
         return;
       }
       const appendText = computeStreamAppend(
-        channel.state.lastPostedText,
+        channel.state.streamBlockText,
         text
       );
       if (appendText === "") {
@@ -238,6 +239,7 @@ export function createStreamDeliveryStrategy(
         return;
       }
       channel.state.lastPostedText = text;
+      channel.state.streamBlockText = text;
     },
 
     async appendChunks({ channel, channelId, chunks, sessionId }) {

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/progress-delivery.ts

@@ -0,0 +1,133 @@
+/**
+ * Mid-turn thread progress when `chat.startStream` is unavailable.
+ * One editable message; `setThreadStatus` stays on the caller.
+ */
+
+import type { ChannelEventContext } from "../../types.js";
+import { deleteMessage, postMessage, updateMessage } from "./api.js";
+import type { SlackLog } from "./log.js";
+import type { SlackBotToken, SlackChannelState } from "./types.js";
+
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+
+export interface ProgressDeliveryDeps {
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+}
+
+function activeProgressTs(state: SlackChannelState): string | null {
+  const ts = state.progressTs;
+  return ts == null || ts === "" ? null : ts;
+}
+
+export interface ProgressDelivery {
+  upsert(args: { channel: SlackChannel; text: string }): Promise<void>;
+  replace(args: { channel: SlackChannel; text: string }): Promise<boolean>;
+  clear(args: { channel: SlackChannel }): Promise<void>;
+}
+
+export function createProgressDelivery(
+  deps: ProgressDeliveryDeps
+): ProgressDelivery {
+  const { botToken, getLog } = deps;
+
+  const clear: ProgressDelivery["clear"] = async (args) => {
+    const state = args.channel.state;
+    const ts = activeProgressTs(state);
+    state.progressTs = null;
+    if (ts === null || state.channelId === null) {
+      return;
+    }
+    const deleted = await deleteMessage({
+      botToken,
+      channel: state.channelId,
+      ts,
+    });
+    if (!deleted.ok) {
+      getLog().warn("progress delete failed", {
+        error: deleted.error,
+        channel: state.channelId,
+        progress_ts: ts,
+      });
+    }
+  };
+
+  return {
+    async upsert(args) {
+      const state = args.channel.state;
+      if (
+        state.channelId === null ||
+        state.threadTs === null ||
+        args.text === ""
+      ) {
+        return;
+      }
+      const existing = activeProgressTs(state);
+      if (existing !== null) {
+        const updated = await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: existing,
+          text: args.text,
+        });
+        if (updated.ok) {
+          return;
+        }
+        getLog().warn("progress update failed; posting a new message", {
+          error: updated.error,
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          progress_ts: existing,
+        });
+        await clear({ channel: args.channel });
+      }
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: args.text,
+        });
+        state.progressTs = posted.ts;
+      } catch (error) {
+        getLog().warn(
+          `progress post failed: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
+          {
+            channel: state.channelId,
+            thread_ts: state.threadTs,
+          }
+        );
+      }
+    },
+
+    async replace(args) {
+      const state = args.channel.state;
+      const ts = activeProgressTs(state);
+      if (ts === null || state.channelId === null || args.text === "") {
+        return false;
+      }
+      const updated = await updateMessage({
+        botToken,
+        channel: state.channelId,
+        ts,
+        text: args.text,
+      });
+      if (!updated.ok) {
+        getLog().warn("progress replace failed", {
+          error: updated.error,
+          channel: state.channelId,
+          progress_ts: ts,
+        });
+        return false;
+      }
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = ts;
+      state.progressTs = null;
+      return true;
+    },
+
+    clear,
+  };
+}