@cursor/july 0.1.108 → 0.1.111

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

@@ -34,7 +34,13 @@ export function classifySlackUserExternality(args: {
   );
 }
 
-/** Lookup + classify. Empty userId / API failure → external. */
+const classified = new Map<string, boolean>();
+
+export function resetExternalSenderCache(): void {
+  classified.clear();
+}
+
+/** Lookup + classify. Empty userId / API failure → external. Hits cache. */
 export async function isExternalSlackSender(args: {
   botToken: SlackBotToken | undefined;
   slackTeamId: string;
@@ -43,6 +49,11 @@ export async function isExternalSlackSender(args: {
   if (args.userId === "") {
     return true;
   }
+  const key = `${args.slackTeamId}:${args.userId}`;
+  const cached = classified.get(key);
+  if (cached !== undefined) {
+    return cached;
+  }
   try {
     const result = await callSlackApi({
       botToken: args.botToken,
@@ -52,10 +63,12 @@ export async function isExternalSlackSender(args: {
     if (result.ok !== true || result.user === undefined) {
       return true;
     }
-    return classifySlackUserExternality({
+    const external = classifySlackUserExternality({
       slackTeamId: args.slackTeamId,
       user: result.user as SlackUserInfo,
     });
+    classified.set(key, external);
+    return external;
   } catch {
     return true;
   }

package/src/channels/slack/footer.ts

@@ -0,0 +1,108 @@
+import { dashboardSessionUrl } from "../../dashboard-session-url.js";
+import { markdownToSlackMrkdwn, updateMessage } from "./api.js";
+import type { SlackBotToken, SoftSlackResult } from "./types.js";
+
+export type SlackReplyFooterContext = {
+  sessionId: string;
+  channelId: string;
+  threadTs: string;
+  text: string;
+  status: "completed" | "failed";
+  durationMs: number;
+};
+
+export type SlackReplyFooter =
+  | string
+  | ((
+      ctx: SlackReplyFooterContext
+    ) => string | undefined | Promise<string | undefined>);
+
+export function turnDurationMs(startedAtMs: number | null | undefined): number {
+  if (startedAtMs === null || startedAtMs === undefined) {
+    return 0;
+  }
+  return Math.max(0, Date.now() - startedAtMs);
+}
+
+export function formatElapsed(ms: number): string {
+  if (ms < 10_000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+  const total = Math.round(ms / 1000);
+  const h = Math.floor(total / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  const s = total % 60;
+  if (h > 0) {
+    return `${h}h ${m}m ${s}s`;
+  }
+  if (m > 0) {
+    return `${m}m ${s}s`;
+  }
+  return `${s}s`;
+}
+
+export async function resolveSlackFooterBlocks(
+  footer: SlackReplyFooter | undefined,
+  ctx: SlackReplyFooterContext
+): Promise<unknown[] | undefined> {
+  if (footer === undefined) {
+    return undefined;
+  }
+  const text = typeof footer === "function" ? await footer(ctx) : footer;
+  if (text === undefined || text.trim() === "") {
+    return undefined;
+  }
+  return [
+    {
+      type: "context",
+      elements: [{ type: "mrkdwn", text }],
+    },
+  ];
+}
+
+export function slackPostedReply(args: { text: string; footer?: unknown[] }): {
+  text: string;
+  blocks: unknown[] | undefined;
+} {
+  const text = markdownToSlackMrkdwn(args.text);
+  if (args.footer === undefined || args.footer.length === 0) {
+    return { text, blocks: undefined };
+  }
+  return {
+    text,
+    blocks: [
+      { type: "section", text: { type: "mrkdwn", text } },
+      ...args.footer,
+    ],
+  };
+}
+
+export async function paintSlackFooter(args: {
+  footer: SlackReplyFooter | undefined;
+  ctx: SlackReplyFooterContext;
+  ts: string;
+  botToken: SlackBotToken | undefined;
+}): Promise<SoftSlackResult | undefined> {
+  const blocks = await resolveSlackFooterBlocks(args.footer, args.ctx);
+  if (blocks === undefined) {
+    return undefined;
+  }
+  const body = slackPostedReply({ text: args.ctx.text, footer: blocks });
+  return updateMessage({
+    botToken: args.botToken,
+    channel: args.ctx.channelId,
+    ts: args.ts,
+    text: body.text,
+    blocks: body.blocks,
+  });
+}
+
+export function slackSessionFooter(opts?: { slug?: string }): SlackReplyFooter {
+  return ctx => {
+    const url = dashboardSessionUrl(ctx.sessionId, { slug: opts?.slug });
+    if (url === undefined) {
+      return undefined;
+    }
+    return `<${url}|View session> · ${formatElapsed(ctx.durationMs)}`;
+  };
+}

package/src/channels/slack/index.ts

@@ -13,6 +13,7 @@
  * ```
  */
 
+export { dashboardSessionUrl } from "../../dashboard-session-url.js";
 export * from "./api.js";
 export * from "./approvals.js";
 export * from "./assistant.js";
@@ -30,6 +31,7 @@ export * from "./doctor.js";
 export * from "./eval-directive.js";
 export * from "./event-id-dedupe.js";
 export * from "./external-policy.js";
+export * from "./footer.js";
 export * from "./inbound.js";
 export * from "./init.js";
 export * from "./interactive.js";

package/src/channels/slack/interactive.ts

@@ -8,6 +8,7 @@
  */
 
 import type { ContinuationIdentity } from "../../internal/continuation-identity.js";
+import { isSlackImChannel } from "../../internal/slack-thread-key.js";
 import type {
   ApprovalDecision,
   ArtifactsApi,
@@ -116,6 +117,7 @@ export async function dispatchInteractiveFromPayload(
     return true;
   }
   if (
+    !isSlackImChannel(parsed.channelId) &&
     sessionThread !== "" &&
     parsed.threadTs !== "" &&
     sessionThread !== parsed.threadTs
@@ -315,7 +317,7 @@ export async function resolveBlockActionCard(args: {
     ts: action.messageTs,
     text: note,
     blocks: [
-      ...action.messageBlocks.filter((block) => !clicked(block)),
+      ...action.messageBlocks.filter(block => !clicked(block)),
       { type: "context", elements: [{ type: "mrkdwn", text: note }] },
     ],
   });
@@ -404,7 +406,7 @@ export async function dispatchBlockAction(
   await dispatchInboundMessage({
     kind: "block_action",
     message: blockActionAsMessage(action, deps.installTeamId),
-    handler: (ctx) => deps.handler(ctx, action),
+    handler: ctx => deps.handler(ctx, action),
     send: deps.send,
     credentials: deps.credentials,
     host: deps.host,

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

@@ -15,6 +15,7 @@
  * chunks and tool steps can land in the same message.
  */
 
+import { markHostedFirstVisibleReply } from "../../internal/hosted-execution-latency.js";
 import type { ChannelEventContext } from "../../types.js";
 import {
   appendChatStream,
@@ -43,7 +44,7 @@ export interface LiveDeliveryDeps {
 type OpenArgs = {
   channel: SlackChannel;
   channelId: string;
-  threadTs: string;
+  threadTs?: string;
   sessionId: string;
   markdown_text?: string;
   chunks?: StreamTaskChunk[];
@@ -155,6 +156,10 @@ export function createStreamDeliveryStrategy(
       stream_ts: started.ts,
       session: sessionId,
     });
+    markHostedFirstVisibleReply({
+      outcome: "progress_update",
+      deliverySurface: "slack",
+    });
     return true;
   };
 
@@ -168,14 +173,19 @@ export function createStreamDeliveryStrategy(
     if (existing !== null) {
       return existing;
     }
-    const threadTs = args.channel.state.threadTs;
-    if (threadTs === null || threadTs === "") {
+    if (args.channelId === "") {
+      return null;
+    }
+    if (
+      args.channel.state.threadTs === null ||
+      args.channel.state.threadTs === ""
+    ) {
       return null;
     }
     const opened = await open({
       channel: args.channel,
       channelId: args.channelId,
-      threadTs,
+      threadTs: args.channel.state.threadTs,
       sessionId: args.sessionId,
       markdown_text: args.markdown_text,
       chunks: args.chunks,
@@ -278,8 +288,10 @@ export function createStreamDeliveryStrategy(
     const log = getLog();
     await stopChatStream({ botToken, channel: channelId, ts });
     channel.state.streamTs = null;
-    const threadTs = channel.state.threadTs;
-    if (remainder === "" || threadTs === null || threadTs === "") {
+    if (remainder === "") {
+      return true;
+    }
+    if (channel.state.threadTs === null || channel.state.threadTs === "") {
       return true;
     }
     try {
@@ -287,7 +299,7 @@ export function createStreamDeliveryStrategy(
         botToken,
         channel: channelId,
         text: remainder,
-        threadTs,
+        threadTs: channel.state.threadTs,
         plainText: remainder.length >= SLACK_MARKDOWN_TEXT_MAX_LEN,
       });
       channel.state.lastBotMessageTs = posted.ts;
@@ -298,6 +310,10 @@ export function createStreamDeliveryStrategy(
         session: sessionId,
         continued_chars: remainder.length,
       });
+      markHostedFirstVisibleReply({
+        outcome: "final_post",
+        deliverySurface: "slack",
+      });
       return true;
     } catch (error) {
       log.warn("stream continuation failed", {

package/src/channels/slack/log.ts

@@ -55,7 +55,7 @@ export function formatSlackLogLine(
 }
 
 export function createSlackLogger(
-  write: SlackLogWrite = (line) => console.log(line)
+  write: SlackLogWrite = line => console.log(line)
 ): SlackLog {
   const emit = (
     level: SlackLogLevel,

package/src/channels/slack/manifest.ts

@@ -144,7 +144,7 @@ export function buildSlackManifest(
 
   const botScopes = includeAgentView
     ? [...BOT_SCOPES]
-    : BOT_SCOPES.filter((scope) => scope !== "assistant:write");
+    : BOT_SCOPES.filter(scope => scope !== "assistant:write");
 
   const botEvents =
     options.channelPosts === true

package/src/channels/slack/nudge-carrier.ts

@@ -216,7 +216,7 @@ export async function materializeSlackNudgeCarrier(args: {
   const command = `node ${SLACK_NUDGE_CARRIER_REL}`;
   for (const step of ["preToolUse", "postToolUse"] as const) {
     const list = [...(hooks[step] ?? [])].filter(
-      (entry) => !entry.command.includes("slack-nudge-carrier")
+      entry => !entry.command.includes("slack-nudge-carrier")
     );
     list.push({ command, failClosed: false });
     hooks[step] = list;

package/src/channels/slack/nudge-store.ts

@@ -127,7 +127,7 @@ export class SlackNudgeStore {
     const hash = contentHash(text);
     if (
       pending.some(
-        (item) => item.sourceTs === sourceTs || item.contentHash === hash
+        item => item.sourceTs === sourceTs || item.contentHash === hash
       )
     ) {
       return false;
@@ -273,7 +273,7 @@ export class SlackNudgeStore {
       return;
     }
     const pending = await this.listPending(key);
-    const record = pending.find((item) => item.sourceTs === ts);
+    const record = pending.find(item => item.sourceTs === ts);
     await mkdir(this.deliveredDir(key), { recursive: true });
     const dest = this.deliveredPath(key, ts);
     const tmp = `${dest}.${process.pid}.tmp`;

package/src/channels/slack/paint-start.ts

@@ -0,0 +1,93 @@
+/**
+ * First Slack paint: ack the parent and raise the thinking chip.
+ * Inbound fires this before send(); turn.started is the backstop.
+ */
+
+import { addReaction, removeReaction, setThreadStatus } from "./api.js";
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { defaultSlackLog, type SlackLog } from "./log.js";
+import type { SlackBotToken } from "./types.js";
+
+export const START_CHIP: string = SLACK_DEFAULT_LOADING_MESSAGES[0];
+
+export async function paintTurnStart(args: {
+  botToken: SlackBotToken | undefined;
+  channelId: string;
+  threadTs: string;
+  ack: string;
+  log?: SlackLog;
+}): Promise<void> {
+  if (args.channelId === "" || args.threadTs === "" || args.ack === "") {
+    return;
+  }
+  const log = args.log ?? defaultSlackLog;
+  const [react, status] = await Promise.all([
+    addReaction({
+      botToken: args.botToken,
+      channel: args.channelId,
+      ts: args.threadTs,
+      name: args.ack,
+    }),
+    setThreadStatus({
+      botToken: args.botToken,
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      status: START_CHIP,
+    }),
+  ]);
+  if (!react.ok && react.error !== "already_reacted") {
+    log.warn("agentic ack failed", {
+      error: react.error,
+      channel: args.channelId,
+      ts: args.threadTs,
+    });
+  }
+  if (!status.ok) {
+    log.warn("agentic status failed", {
+      error: status.error,
+      channel: args.channelId,
+      thread_ts: args.threadTs,
+    });
+  }
+}
+
+export async function retractTurnStart(args: {
+  botToken: SlackBotToken | undefined;
+  channelId: string;
+  threadTs: string;
+  ack: string;
+  log?: SlackLog;
+}): Promise<void> {
+  if (args.channelId === "" || args.threadTs === "" || args.ack === "") {
+    return;
+  }
+  const log = args.log ?? defaultSlackLog;
+  const [react, status] = await Promise.all([
+    removeReaction({
+      botToken: args.botToken,
+      channel: args.channelId,
+      ts: args.threadTs,
+      name: args.ack,
+    }),
+    setThreadStatus({
+      botToken: args.botToken,
+      channelId: args.channelId,
+      threadTs: args.threadTs,
+      status: "",
+    }),
+  ]);
+  if (!react.ok && react.error !== "no_reaction") {
+    log.warn("agentic ack retract failed", {
+      error: react.error,
+      channel: args.channelId,
+      ts: args.threadTs,
+    });
+  }
+  if (!status.ok) {
+    log.warn("agentic status retract failed", {
+      error: status.error,
+      channel: args.channelId,
+      thread_ts: args.threadTs,
+    });
+  }
+}