@cursor/july 0.1.109 → 0.1.112

package/src/channels/slack/agentic-posted.ts

@@ -0,0 +1,148 @@
+/**
+ * This-turn Slack posts. `reserve` is the ts `post-update` returns.
+ * `bind` attaches the Slack ts after `chat.postMessage`. `has` is either.
+ * `lastPostAt` is the quiet clock: turn start, then each `post-update`.
+ */
+
+export const SLACK_QUIET_MS = 90_000;
+
+export const SLACK_QUIET_HINT =
+  "<slack_quiet>Thread has been quiet. post-update if the picture changed (dead-end, widen, or breakthrough).</slack_quiet>";
+
+type Turn = {
+  n: number;
+  reserved: Set<string>;
+  slack: Map<string, string>;
+  text: Map<string, string>;
+  lastPostAt: number;
+};
+
+type Hintable = {
+  content: ReadonlyArray<{ type: string; text?: string }>;
+  isError?: boolean;
+};
+
+const posted = new Map<string, Turn>();
+
+function empty(now: number = Date.now()): Turn {
+  return {
+    n: 0,
+    reserved: new Set(),
+    slack: new Map(),
+    text: new Map(),
+    lastPostAt: now,
+  };
+}
+
+function turn(sessionId: string): Turn {
+  let current = posted.get(sessionId);
+  if (current === undefined) {
+    current = empty();
+    posted.set(sessionId, current);
+  }
+  return current;
+}
+
+export function begin(sessionId: string, now: number = Date.now()): void {
+  posted.set(sessionId, empty(now));
+}
+
+export function end(sessionId: string): void {
+  posted.delete(sessionId);
+}
+
+export function reserve(sessionId: string, now: number = Date.now()): string {
+  const current = turn(sessionId);
+  current.n += 1;
+  current.lastPostAt = now;
+  const ts = String(current.n);
+  current.reserved.add(ts);
+  return ts;
+}
+
+export function appendSlackQuietHint<T extends Hintable>(
+  sessionId: string,
+  result: T,
+  now: number = Date.now()
+): T {
+  if (result.isError === true) {
+    return result;
+  }
+  const current = posted.get(sessionId);
+  if (current === undefined || now - current.lastPostAt < SLACK_QUIET_MS) {
+    return result;
+  }
+  return {
+    ...result,
+    content: [...result.content, { type: "text", text: SLACK_QUIET_HINT }],
+  };
+}
+
+export function bind(
+  sessionId: string,
+  ts: string,
+  slackTs: string,
+  text: string
+): void {
+  const current = turn(sessionId);
+  current.reserved.delete(ts);
+  current.slack.set(ts, slackTs);
+  current.slack.set(slackTs, slackTs);
+  current.text.set(slackTs, text);
+}
+
+export function setPostedText(
+  sessionId: string,
+  slackTs: string,
+  text: string
+): void {
+  posted.get(sessionId)?.text.set(slackTs, text);
+}
+
+export function has(sessionId: string, ts: string): boolean {
+  const current = posted.get(sessionId);
+  return (
+    current !== undefined && (current.reserved.has(ts) || current.slack.has(ts))
+  );
+}
+
+export function resolve(sessionId: string, ts: string): string | undefined {
+  return posted.get(sessionId)?.slack.get(ts);
+}
+
+export function remove(sessionId: string, ts: string): void {
+  const current = posted.get(sessionId);
+  if (current === undefined) {
+    return;
+  }
+  current.reserved.delete(ts);
+  const slackTs = current.slack.get(ts) ?? ts;
+  current.text.delete(slackTs);
+  for (const [key, value] of current.slack) {
+    if (key === ts || key === slackTs || value === slackTs) {
+      current.slack.delete(key);
+    }
+  }
+}
+
+export function latest(sessionId: string): string | undefined {
+  const current = posted.get(sessionId);
+  if (current === undefined || current.slack.size === 0) {
+    return undefined;
+  }
+  return [...current.slack.values()].at(-1);
+}
+
+export function latestPosted(
+  sessionId: string
+): { ts: string; text: string } | undefined {
+  const ts = latest(sessionId);
+  if (ts === undefined) {
+    return undefined;
+  }
+  const text = posted.get(sessionId)?.text.get(ts);
+  if (text === undefined || text === "") {
+    return undefined;
+  }
+  return { ts, text };
+}

package/src/channels/slack/agentic-signals.ts

@@ -0,0 +1,248 @@
+/**
+ * Tool names the agentic Slack watcher honors.
+ * Mounted tools are `<namespace>__<name>`; bare names work too.
+ */
+
+import { isAbsolute } from "node:path";
+import { SLACK_STATUS_MAX_LEN } from "./constants.js";
+import type { StreamTaskStatus } from "./stream.js";
+
+export const POST_UPDATE = "post-update";
+export const POST_FILE = "post-file";
+export const POST_CARD = "post-card";
+export const REACT = "react";
+export const SET_STATUS = "set-status";
+export const EDIT_MESSAGE = "edit-message";
+export const DELETE_MESSAGE = "delete-message";
+export const MAX_UPDATE_CHARS = 900;
+export const MAX_REASON_CHARS = 200;
+const OWNED_SIGNALS = [
+  POST_UPDATE,
+  POST_FILE,
+  POST_CARD,
+  REACT,
+  SET_STATUS,
+  EDIT_MESSAGE,
+  DELETE_MESSAGE,
+] as const;
+const EMOJI_NAME: RegExp = /^[a-z0-9_+-]{1,50}$/;
+
+export function emojiName(raw: string): string | undefined {
+  const name = raw.replace(/^:+|:+$/g, "").toLowerCase();
+  if (!EMOJI_NAME.test(name)) {
+    return undefined;
+  }
+  return name;
+}
+
+export function isSignal(toolName: string, signal: string): boolean {
+  return toolName === signal || toolName.endsWith(`__${signal}`);
+}
+
+export function isOwnedSignal(toolName: string): boolean {
+  return OWNED_SIGNALS.some(signal => isSignal(toolName, signal));
+}
+
+function asObject(output: unknown): Record<string, unknown> | undefined {
+  if (typeof output === "string") {
+    const trimmed = output.trim();
+    if (!trimmed.startsWith("{")) {
+      return undefined;
+    }
+    try {
+      const parsed: unknown = JSON.parse(trimmed);
+      if (
+        typeof parsed === "object" &&
+        parsed !== null &&
+        !Array.isArray(parsed)
+      ) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      return undefined;
+    }
+    return undefined;
+  }
+  if (typeof output !== "object" || output === null || Array.isArray(output)) {
+    return undefined;
+  }
+  return output as Record<string, unknown>;
+}
+
+export function publishedText(output: unknown): string | undefined {
+  const value = asObject(output);
+  if (value === undefined) {
+    return undefined;
+  }
+  const message = value.message;
+  if (typeof message !== "string") {
+    return undefined;
+  }
+  const text = message.trim();
+  if (text === "" || text.length > MAX_UPDATE_CHARS) {
+    return undefined;
+  }
+  return text;
+}
+
+export function parseUpdate(
+  output: unknown
+): { message: string; ts?: string } | undefined {
+  const message = publishedText(output);
+  if (message === undefined) {
+    return undefined;
+  }
+  const ts = asObject(output)?.ts;
+  if (typeof ts !== "string") {
+    return { message };
+  }
+  const trimmed = ts.trim();
+  return trimmed === "" ? { message } : { message, ts: trimmed };
+}
+
+function cardStatus(value: unknown): StreamTaskStatus | undefined {
+  if (
+    value === "pending" ||
+    value === "in_progress" ||
+    value === "complete" ||
+    value === "error"
+  ) {
+    return value;
+  }
+  return undefined;
+}
+
+export function parseCard(output: unknown):
+  | {
+      id: string;
+      title: string;
+      status: StreamTaskStatus;
+      details?: string;
+    }
+  | undefined {
+  const value = asObject(output);
+  if (value === undefined) {
+    return undefined;
+  }
+  const id = value.id;
+  const title = value.title;
+  const status = cardStatus(value.status);
+  const details = value.details;
+  if (typeof id !== "string" || id.trim() === "") {
+    return undefined;
+  }
+  if (typeof title !== "string" || title.trim() === "") {
+    return undefined;
+  }
+  if (status === undefined) {
+    return undefined;
+  }
+  const card: {
+    id: string;
+    title: string;
+    status: StreamTaskStatus;
+    details?: string;
+  } = {
+    id: id.trim(),
+    title: title.trim(),
+    status,
+  };
+  if (typeof details === "string" && details.trim() !== "") {
+    card.details = details.trim();
+  }
+  return card;
+}
+
+export function parseReaction(
+  output: unknown
+): { emoji: string; ts?: string } | undefined {
+  const value = asObject(output);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value.emoji !== "string") {
+    return undefined;
+  }
+  const emoji = emojiName(value.emoji);
+  if (emoji === undefined) {
+    return undefined;
+  }
+  const reaction: { emoji: string; ts?: string } = { emoji };
+  if (typeof value.ts === "string" && value.ts.trim() !== "") {
+    reaction.ts = value.ts.trim();
+  }
+  return reaction;
+}
+
+export function parseEdit(
+  output: unknown
+): { ts: string; message: string } | undefined {
+  const value = asObject(output);
+  if (value === undefined || typeof value.ts !== "string") {
+    return undefined;
+  }
+  const ts = value.ts.trim();
+  if (ts === "") {
+    return undefined;
+  }
+  const message = publishedText(output);
+  if (message === undefined) {
+    return undefined;
+  }
+  return { ts, message };
+}
+
+export function parseDelete(
+  output: unknown
+): { ts: string; reason: string } | undefined {
+  const value = asObject(output);
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value.ts !== "string" || typeof value.reason !== "string") {
+    return undefined;
+  }
+  const ts = value.ts.trim();
+  const reason = value.reason.trim();
+  if (ts === "" || reason === "" || reason.length > MAX_REASON_CHARS) {
+    return undefined;
+  }
+  return { ts, reason };
+}
+
+export function parseStatus(output: unknown): string | undefined {
+  const value = asObject(output);
+  if (value === undefined || typeof value.status !== "string") {
+    return undefined;
+  }
+  if (value.status.length > SLACK_STATUS_MAX_LEN) {
+    return undefined;
+  }
+  return value.status;
+}
+
+export interface StagedFile {
+  path: string;
+  name: string;
+  workspace: string;
+}
+
+export function parseStagedFile(output: unknown): StagedFile | undefined {
+  const value = asObject(output);
+  if (value === undefined) {
+    return undefined;
+  }
+  const path = value.path;
+  const name = value.name;
+  const workspace = value.workspace;
+  if (typeof path !== "string" || path === "" || !isAbsolute(path)) {
+    return undefined;
+  }
+  if (typeof name !== "string" || name === "") {
+    return undefined;
+  }
+  if (typeof workspace !== "string" || workspace === "") {
+    return undefined;
+  }
+  return { path, name, workspace };
+}

package/src/channels/slack/api.ts

@@ -4,6 +4,7 @@
 
 import { ErrorCode, type WebAPIPlatformError, WebClient } from "@slack/web-api";
 import { slackifyMarkdown } from "slackify-markdown";
+import { slackThreadKey } from "../../internal/slack-thread-key.js";
 import type { ArtifactsApi, HostContext } from "../../types.js";
 import { highlightCodeFences } from "./code-fences.js";
 import {
@@ -63,12 +64,12 @@ export async function resolveAppToken(
   return token;
 }
 
-/** Channel-local continuation key: `<slackChannelId>:<threadTs>`. */
+/** Channel-local continuation key. IMs are the channel; threads keep ts. */
 export function slackContinuationKey(
   channelId: string,
   threadTs: string
 ): string {
-  return `${channelId}:${threadTs}`;
+  return slackThreadKey(channelId, threadTs);
 }
 
 function isPlatformError(error: unknown): error is WebAPIPlatformError {
@@ -161,10 +162,10 @@ export function truncateLoadingMessages(
   nowMs: number = Date.now()
 ): string[] {
   const cleaned = messages
-    .map((message) =>
+    .map(message =>
       truncateTypingStatus(message, SLACK_LOADING_MESSAGE_MAX_LEN)
     )
-    .filter((message) => message.length > 0);
+    .filter(message => message.length > 0);
   if (cleaned.length <= SLACK_LOADING_MESSAGES_MAX) {
     return cleaned;
   }
@@ -229,10 +230,7 @@ export async function setThreadStatus(args: {
     const loadingRaw =
       args.loadingMessages !== undefined && args.loadingMessages.length > 0
         ? args.loadingMessages
-        : [
-            status,
-            ...SLACK_DEFAULT_LOADING_MESSAGES.filter((m) => m !== status),
-          ];
+        : [status, ...SLACK_DEFAULT_LOADING_MESSAGES.filter(m => m !== status)];
     const loading_messages = truncateLoadingMessages(loadingRaw);
     if (loading_messages.length > 0) {
       body.loading_messages = loading_messages;
@@ -294,7 +292,7 @@ export async function setSuggestedPrompts(args: {
 }): Promise<SoftSlackResult> {
   const body: Record<string, unknown> = {
     channel_id: args.channelId,
-    prompts: args.prompts.map((p) => ({
+    prompts: args.prompts.map(p => ({
       title: p.title,
       message: p.message,
     })),
@@ -418,13 +416,13 @@ const SLACK_MRKDWN_LINK_PATTERN = /<https?:\/\/[^|>]+\|/;
  * Convert CommonMark accepted by `markdown_text` to Slack's legacy mrkdwn
  * without letting the CommonMark parser reinterpret Slack-native syntax.
  */
-function markdownToSlackMrkdwn(markdown: string): string {
+export function markdownToSlackMrkdwn(markdown: string): string {
   const literals: string[] = [];
   const placeholder = (index: number): string =>
     `\ue000SLACK_LITERAL_${index}\ue001`;
   const protectedMarkdown = markdown.replace(
     SLACK_MRKDWN_LITERAL_PATTERN,
-    (literal) => {
+    literal => {
       const index = literals.push(literal) - 1;
       return placeholder(index);
     }
@@ -648,6 +646,48 @@ export async function deleteMessage(args: {
   });
 }
 
+/** Add an emoji reaction (`reactions.add`). Soft-fails. */
+export async function addReaction(args: {
+  botToken: SlackBotToken | undefined;
+  channel: string;
+  ts: string;
+  name: string;
+}): Promise<SoftSlackResult> {
+  if (args.channel === "" || args.ts === "" || args.name === "") {
+    return { ok: false, error: "missing_channel_ts_or_name" };
+  }
+  return callSlackApiSoft({
+    botToken: args.botToken,
+    operation: "reactions.add",
+    body: {
+      channel: args.channel,
+      timestamp: args.ts,
+      name: args.name,
+    },
+  });
+}
+
+/** Remove an emoji reaction (`reactions.remove`). Soft-fails. */
+export async function removeReaction(args: {
+  botToken: SlackBotToken | undefined;
+  channel: string;
+  ts: string;
+  name: string;
+}): Promise<SoftSlackResult> {
+  if (args.channel === "" || args.ts === "" || args.name === "") {
+    return { ok: false, error: "missing_channel_ts_or_name" };
+  }
+  return callSlackApiSoft({
+    botToken: args.botToken,
+    operation: "reactions.remove",
+    body: {
+      channel: args.channel,
+      timestamp: args.ts,
+      name: args.name,
+    },
+  });
+}
+
 export function buildSlackBinding(args: {
   botToken: SlackBotToken | undefined;
   channelId: string;

package/src/channels/slack/approvals.ts

@@ -89,7 +89,7 @@ export function redactSensitiveValues(value: unknown): unknown {
     return value;
   }
   if (Array.isArray(value)) {
-    return value.map((item) => redactSensitiveValues(item));
+    return value.map(item => redactSensitiveValues(item));
   }
   if (typeof value === "object") {
     const out: Record<string, unknown> = {};

package/src/channels/slack/attachments.ts

@@ -488,7 +488,7 @@ export async function prepareSlackAttachments(
     options.downloadTimeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
 
   const loaded = await Promise.all(
-    options.files.slice(0, maxFiles).map(async (file) => {
+    options.files.slice(0, maxFiles).map(async file => {
       const classification = classifySlackFile(file);
       if (classification === undefined) {
         return undefined;

package/src/channels/slack/auth.ts

@@ -3,6 +3,7 @@
  */
 
 import { samePrincipal } from "../../internal/auth.js";
+import { slackThreadKey } from "../../internal/slack-thread-key.js";
 import type { AuthContext } from "../../types.js";
 import type {
   SlackBinding,
@@ -32,7 +33,8 @@ export type BuildSlackAuthArgs = {
 export function buildSlackAuthContext(args: BuildSlackAuthArgs): AuthContext {
   const team = args.teamId ?? "unknown";
   const respondTo = args.respondTo ?? "thread";
-  const base = `slack:${team}:${args.channelId}:${args.threadTs}`;
+  const conversation = slackThreadKey(args.channelId, args.threadTs);
+  const base = `slack:${team}:${conversation}`;
   const authorScoped =
     respondTo === "author" && args.userId !== undefined && args.userId !== "";
   const principalId = authorScoped ? `${base}:${args.userId}` : base;

package/src/channels/slack/blocks.ts

@@ -41,7 +41,7 @@ export function mrkdwnSections(lines: readonly string[]): unknown[] {
   if (current !== "") {
     texts.push(current);
   }
-  return texts.map((text) => ({
+  return texts.map(text => ({
     type: "section",
     text: { type: "mrkdwn", text },
   }));
@@ -127,10 +127,10 @@ export function slackTableBlock(args: {
       );
     }
   }
-  const headerRow = args.headers.map((header) => slackRawTextCell(header));
+  const headerRow = args.headers.map(header => slackRawTextCell(header));
   const block: SlackTableBlock = {
     type: "table",
-    rows: [headerRow, ...args.rows.map((row) => [...row])],
+    rows: [headerRow, ...args.rows.map(row => [...row])],
   };
   if (args.columnSettings !== undefined && args.columnSettings.length > 0) {
     block.column_settings = [...args.columnSettings];

package/src/channels/slack/bot-mentions.ts

@@ -109,8 +109,8 @@ export function normalizeBotMentionAllowlist(
   allowFrom: readonly string[]
 ): string[] {
   const entries = allowFrom
-    .map((entry) => entry.trim())
-    .filter((entry) => entry !== "");
+    .map(entry => entry.trim())
+    .filter(entry => entry !== "");
   if (entries.length === 0) {
     throw new Error(
       "slackChannel engagement.botMentions.allowFrom must list at least one bot id (B…) or bot user id (U…); there is no wildcard."
@@ -134,8 +134,8 @@ export function botMentionsFromEnv(
 ): SlackBotMentionsOptions | undefined {
   const allowFrom = (process.env[envVar] ?? "")
     .split(",")
-    .map((entry) => entry.trim())
-    .filter((entry) => entry !== "");
+    .map(entry => entry.trim())
+    .filter(entry => entry !== "");
   return allowFrom.length === 0 ? undefined : { allowFrom };
 }
 
@@ -258,9 +258,7 @@ export class SlackBotMentionGate {
       recent: [],
       lastAtMs: nowMs,
     };
-    budget.recent = budget.recent.filter(
-      (atMs) => atMs > nowMs - this.windowMs
-    );
+    budget.recent = budget.recent.filter(atMs => atMs > nowMs - this.windowMs);
     if (budget.total >= this.maxPerThreadTotal) {
       return {
         allow: false,

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

@@ -74,7 +74,7 @@ export async function resolveChannelNames(
   names: readonly string[],
   log: SlackLog = defaultSlackLog
 ): Promise<Map<string, string>> {
-  const wanted = new Set(names.map((name) => name.toLowerCase()));
+  const wanted = new Set(names.map(name => name.toLowerCase()));
   const resolved = new Map<string, string>();
   if (wanted.size === 0) {
     return resolved;

package/src/channels/slack/cli-project.ts

@@ -170,10 +170,10 @@ async function mergeGitignore(path: string): Promise<boolean> {
   const have = new Set(
     existing
       .split(/\r?\n/)
-      .map((line) => line.trim())
-      .filter((line) => line !== "")
+      .map(line => line.trim())
+      .filter(line => line !== "")
   );
-  const missing = lines.filter((line) => !have.has(line));
+  const missing = lines.filter(line => !have.has(line));
   if (missing.length === 0) {
     return false;
   }