@cursor/july 0.1.96 → 0.1.97

package/src/channels/slack/approvals.ts

@@ -6,6 +6,8 @@ import type { ApprovalDecision } from "../../types.js";
 
 export const SLACK_APPROVE_ACTION_ID = "agent_serve_approve";
 export const SLACK_DENY_ACTION_ID = "agent_serve_deny";
+export const SLACK_AUTH_CONNECTED_ACTION_ID = "agent_serve_auth_connected";
+export const SLACK_AUTH_CANCEL_ACTION_ID = "agent_serve_auth_cancel";
 
 export interface SlackApprovalActionValue {
   sessionId: string;
@@ -54,6 +56,29 @@ export function decisionFromActionId(
   return null;
 }
 
+export function decisionFromAuthActionId(
+  actionId: string
+): ApprovalDecision | null {
+  if (actionId === SLACK_AUTH_CONNECTED_ACTION_ID) {
+    return "approve";
+  }
+  if (actionId === SLACK_AUTH_CANCEL_ACTION_ID) {
+    return "deny";
+  }
+  return null;
+}
+
+export function authThreadStatus(connection: string): string {
+  const prefix = "Waiting for ";
+  const suffix = " auth…";
+  const budget = 50 - prefix.length - suffix.length;
+  const name =
+    connection.length <= budget
+      ? connection
+      : `${connection.slice(0, Math.max(0, budget - 1))}…`;
+  return `${prefix}${name}${suffix}`;
+}
+
 const REDACTED = "[REDACTED]";
 const SENSITIVE_KEY =
   /(?:pass(?:word|wd)?|secret|token|api[_-]?key|authorization|credential|private[_-]?key|access[_-]?key)/i;
@@ -176,6 +201,86 @@ export function buildApprovalBlocks(args: {
   ];
 }
 
+export function buildAuthBlocks(args: {
+  sessionId: string;
+  callId: string;
+  toolName: string;
+  connection: string;
+  authUrl: string;
+}): unknown[] {
+  const value = encodeApprovalActionValue({
+    sessionId: args.sessionId,
+    callId: args.callId,
+  });
+  const label =
+    args.connection.length > 20
+      ? `Authorize ${args.connection.slice(0, 17)}…`
+      : `Authorize ${args.connection}`;
+  return [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: "MCP authorization needed",
+        emoji: true,
+      },
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `Connect \`${args.connection}\` so \`${args.toolName}\` can continue.`,
+      },
+    },
+    {
+      type: "actions",
+      block_id: `auth_${args.callId}`.slice(0, 255),
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: label, emoji: true },
+          url: args.authUrl,
+        },
+        {
+          type: "button",
+          action_id: SLACK_AUTH_CONNECTED_ACTION_ID,
+          text: { type: "plain_text", text: "Connected", emoji: true },
+          style: "primary",
+          value,
+        },
+        {
+          type: "button",
+          action_id: SLACK_AUTH_CANCEL_ACTION_ID,
+          text: { type: "plain_text", text: "Cancel", emoji: true },
+          style: "danger",
+          value,
+        },
+      ],
+    },
+  ];
+}
+
+export function buildResolvedAuthBlocks(args: {
+  connection: string;
+  decision: ApprovalDecision;
+  byUserId?: string;
+}): unknown[] {
+  const verb = args.decision === "approve" ? "Connected" : "Cancelled";
+  const by =
+    args.byUserId === undefined || args.byUserId === ""
+      ? ""
+      : ` by <@${args.byUserId}>`;
+  return [
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*${verb}*${by} — \`${args.connection}\``,
+      },
+    },
+  ];
+}
+
 export function buildResolvedApprovalBlocks(args: {
   toolName: string;
   decision: ApprovalDecision;

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

@@ -0,0 +1,267 @@
+/**
+ * Official Slack CLI project files for `slack init --manual`.
+ *
+ * `.slack/` is the committed Slack CLI project: hook, manifests, hooks.json.
+ * Agent SDK serve owns the socket; do not `slack deploy` / `slack run`.
+ */
+
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const SLACK_CLI_HOME_BIN = ".slack/bin/slack";
+
+export const SLACK_CLI_GET_MANIFEST = "node .slack/get-manifest.mjs";
+
+export type SlackCliEnvironment = "local" | "deployed";
+
+const TEAM_ID_RE = /\(Team ID: ([TE][A-Z0-9]+)\)/g;
+
+const GET_MANIFEST_JS = `import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+function target() {
+  const env = process.env.SLACK_ENV ?? process.env.SLACK_APP_ENVIRONMENT;
+  if (env === "deployed" || env === "prod") return "manifest.prod.json";
+  if (env === "local" || env === "dev") return "manifest.dev.json";
+  try {
+    const raw = readFileSync(join(here, "cli-environment"), "utf8").trim();
+    if (raw === "deployed" || raw === "prod") return "manifest.prod.json";
+  } catch {
+    // default local
+  }
+  return "manifest.dev.json";
+}
+
+process.stdout.write(readFileSync(join(here, target()), "utf8"));
+`;
+
+function isEnoent(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+/** Official Slack CLI, if present. `SLACK_CLI` overrides. */
+export function detectSlackCli(
+  env: NodeJS.ProcessEnv = process.env
+): string | undefined {
+  const override = env.SLACK_CLI;
+  if (override !== undefined && override !== "") {
+    return override;
+  }
+  const home = env.HOME ?? env.USERPROFILE ?? homedir();
+  const homeBin = join(home, SLACK_CLI_HOME_BIN);
+  return existsSync(homeBin) ? homeBin : undefined;
+}
+
+/** Hook + manifests under `.slack/`. Merge hooks.json; keep existing config. */
+export async function writeSlackCliProject(
+  rootDir: string,
+  manifests: ReadonlyArray<{ name: string; contents: string }>
+): Promise<string[]> {
+  const slackDir = join(rootDir, ".slack");
+  await mkdir(slackDir, { recursive: true });
+  const created: string[] = [];
+
+  await writeFile(join(slackDir, "get-manifest.mjs"), GET_MANIFEST_JS);
+  created.push(".slack/get-manifest.mjs");
+
+  for (const file of manifests) {
+    await writeFile(join(slackDir, file.name), file.contents);
+    created.push(`.slack/${file.name}`);
+  }
+
+  if (await upsertGetManifestHook(slackDir)) {
+    created.push(".slack/hooks.json");
+  }
+  if (
+    await writeIfMissing(
+      join(slackDir, "config.json"),
+      `${JSON.stringify(
+        {
+          manifest: { source: "local" },
+          project_id: randomUUID(),
+        },
+        null,
+        2
+      )}\n`
+    )
+  ) {
+    created.push(".slack/config.json");
+  }
+  if (await mergeGitignore(join(slackDir, ".gitignore"))) {
+    created.push(".slack/.gitignore");
+  }
+  return created;
+}
+
+async function upsertGetManifestHook(slackDir: string): Promise<boolean> {
+  const path = join(slackDir, "hooks.json");
+  let existing: { hooks?: Record<string, string> };
+  try {
+    const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      throw new Error(".slack/hooks.json is not a JSON object");
+    }
+    existing = parsed as { hooks?: Record<string, string> };
+  } catch (error) {
+    if (!isEnoent(error)) {
+      throw error;
+    }
+    await writeFile(
+      path,
+      `${JSON.stringify({ hooks: { "get-manifest": SLACK_CLI_GET_MANIFEST } }, null, 2)}\n`
+    );
+    return true;
+  }
+  const hooks = existing.hooks ?? {};
+  if (hooks["get-manifest"] === SLACK_CLI_GET_MANIFEST) {
+    return false;
+  }
+  hooks["get-manifest"] = SLACK_CLI_GET_MANIFEST;
+  existing.hooks = hooks;
+  await writeFile(path, `${JSON.stringify(existing, null, 2)}\n`);
+  return true;
+}
+
+async function writeIfMissing(
+  path: string,
+  contents: string
+): Promise<boolean> {
+  try {
+    await writeFile(path, contents, { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "EEXIST"
+    ) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function mergeGitignore(path: string): Promise<boolean> {
+  const lines = ["apps.dev.json", "cache/", "cli-environment"];
+  let existing = "";
+  try {
+    existing = await readFile(path, "utf8");
+  } catch (error) {
+    if (!isEnoent(error)) {
+      throw error;
+    }
+    await writeFile(path, `${lines.join("\n")}\n`);
+    return true;
+  }
+  const have = new Set(
+    existing
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line !== "")
+  );
+  const missing = lines.filter((line) => !have.has(line));
+  if (missing.length === 0) {
+    return false;
+  }
+  const prefix =
+    existing === "" || existing.endsWith("\n") ? existing : `${existing}\n`;
+  await writeFile(path, `${prefix}${missing.join("\n")}\n`);
+  return true;
+}
+
+export function parseSlackAuthTeams(text: string): string[] {
+  const ids: string[] = [];
+  for (const match of text.matchAll(TEAM_ID_RE)) {
+    const id = match[1];
+    if (id !== undefined && !ids.includes(id)) {
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+
+export async function readSlackCliAppId(
+  dir: string,
+  environment: SlackCliEnvironment,
+  team?: string
+): Promise<string | undefined> {
+  const apps = await loadAppMap(dir, environment);
+  if (apps === undefined) {
+    return undefined;
+  }
+  if (team !== undefined) {
+    return appIdOf(apps[team]);
+  }
+  return firstAppId(apps);
+}
+
+async function loadAppMap(
+  dir: string,
+  environment: SlackCliEnvironment
+): Promise<Record<string, unknown> | undefined> {
+  if (environment === "local") {
+    return readJson(join(dir, ".slack/apps.dev.json"));
+  }
+  const deployed = await readJson(join(dir, ".slack/apps.json"));
+  if (deployed === undefined) {
+    return undefined;
+  }
+  const apps = deployed.apps;
+  if (apps !== undefined && typeof apps === "object" && apps !== null) {
+    return apps as Record<string, unknown>;
+  }
+  return deployed;
+}
+
+function firstAppId(value: Record<string, unknown>): string | undefined {
+  for (const entry of Object.values(value)) {
+    const id = appIdOf(entry);
+    if (id !== undefined) {
+      return id;
+    }
+  }
+  return undefined;
+}
+
+function appIdOf(entry: unknown): string | undefined {
+  if (entry === undefined || entry === null || typeof entry !== "object") {
+    return undefined;
+  }
+  const appId = (entry as { app_id?: unknown }).app_id;
+  if (typeof appId === "string" && appId.startsWith("A")) {
+    return appId;
+  }
+  return undefined;
+}
+
+async function readJson(
+  path: string
+): Promise<Record<string, unknown> | undefined> {
+  try {
+    const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
+    if (
+      parsed === null ||
+      typeof parsed !== "object" ||
+      Array.isArray(parsed)
+    ) {
+      return undefined;
+    }
+    return parsed as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+}

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,
@@ -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();
@@ -351,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;
@@ -372,50 +456,11 @@ export function buildDefaultEvents(
         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,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

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,