@cursor/bdk 0.2.2 → 0.2.4

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

@@ -1,314 +0,0 @@
-/**
- * Opt-in channel watch: dispatch on posts in allowlisted channels.
- *
- * Filtering rules (the anti-slop guarantees):
- * - The allowlist is a finite id list, or a lone `"*"` for every channel
- *   the bot is in. Mixing `"*"` with ids is a definition error.
- * - Top-level posts only by default. `"replies"` is thread replies only
- *   (`ts !== threadTs`). `"all"` is both. A lone `"*"` is replies only.
- * - Posts that @mention the bot are skipped here (the `app_mention` path
- *   owns them).
- * - Bot-authored posts are dropped unless `includeBotPosts` is configured
- *   (alert feeds / webhook integrations); the watching bot's own posts are
- *   always dropped either way (loop safety).
- * - An optional debounce window lets rapid edits settle: edits update the
- *   pending text, deleting the post cancels the dispatch.
- */
-
-import type { WebClient } from "@slack/web-api";
-import type { SlackChannelMessageEvent } from "./inbound.js";
-import { defaultSlackLog, type SlackLog } from "./log.js";
-import type { SlackChannelPostsOptions, SlackMessage } from "./types.js";
-
-const CHANNEL_ID_PATTERN = /^[CG][A-Z0-9]+$/;
-
-/**
- * Channel-watch allowlist contract, mirrored by the control plane's
- * deploy-time validation (proto posture: both sides validate
- * independently). Ids are required because on Cursor-managed hosting they
- * become channel-scoped subscription edges — the control plane drops
- * channel posts outside the id set before any compute wakes, and it cannot
- * resolve `#names`.
- */
-export const CHANNEL_POSTS_MAX_CHANNEL_IDS = 10;
-
-/**
- * True when the allowlist is only `"*"`: every channel the bot is in.
- * Guest-side only. It is not a deploy-manifest subscription — the control
- * plane rejects `"*"` and already delivers a reply in a thread a mention
- * started. Top-level posts do not match it (`posts: "replies"`).
- */
-export function channelPostsWatchEverywhere(entries: readonly string[]): boolean {
-  const trimmed = entries.map(entry => entry.trim()).filter(entry => entry !== "");
-  return trimmed.length > 0 && trimmed.every(entry => entry === "*");
-}
-
-/** The channel-id (`C…`/`G…`) entries of an allowlist, deduped. */
-export function channelPostIdEntries(entries: readonly string[]): string[] {
-  const ids = new Set<string>();
-  for (const raw of entries) {
-    const entry = raw.trim();
-    if (CHANNEL_ID_PATTERN.test(entry)) {
-      ids.add(entry);
-    }
-  }
-  return [...ids];
-}
-
-/**
- * Validate `channelPosts.allow` at definition time. Returns an actionable
- * error string (to be prefixed with the option path), or undefined.
- */
-export function validateChannelPostsAllow(entries: readonly string[]): string | undefined {
-  if (channelPostsWatchEverywhere(entries)) {
-    return undefined;
-  }
-  if (entries.some(entry => entry.trim() === "*")) {
-    return (
-      'must not mix "*": a lone "*" watches every channel the bot is in, ' +
-      "thread replies only. Otherwise list channel ids (C…/G…), up to " +
-      `${CHANNEL_POSTS_MAX_CHANNEL_IDS} channels.`
-    );
-  }
-  const ids = channelPostIdEntries(entries);
-  if (ids.length === 0) {
-    return (
-      "must include at least one channel id (C…/G…). Ids define the " +
-      "watched set on Cursor-managed hosting; `#name` entries alone are " +
-      "not enough."
-    );
-  }
-  if (ids.length > CHANNEL_POSTS_MAX_CHANNEL_IDS) {
-    return `lists ${ids.length} channel ids; the maximum is ${CHANNEL_POSTS_MAX_CHANNEL_IDS}.`;
-  }
-  return undefined;
-}
-
-/** Allowlist over channel ids and `#names` (names resolve lazily). */
-export class SlackChannelAllowlist {
-  private readonly ids = new Set<string>();
-  private readonly names = new Set<string>();
-  private readonly everywhere: boolean;
-
-  constructor(entries: readonly string[]) {
-    this.everywhere = channelPostsWatchEverywhere(entries);
-    if (this.everywhere) {
-      return;
-    }
-    for (const raw of entries) {
-      const entry = raw.trim();
-      // A mixed "*" is a definition error. Ignore it here so a stale
-      // config degrades to its explicit entries instead of matching all.
-      if (entry === "" || entry === "*") {
-        continue;
-      }
-      if (entry.startsWith("#")) {
-        this.names.add(entry.slice(1).toLowerCase());
-      } else if (CHANNEL_ID_PATTERN.test(entry)) {
-        this.ids.add(entry);
-      } else {
-        // Bare name without "#" — treat as a name for forgiving authoring.
-        this.names.add(entry.toLowerCase());
-      }
-    }
-  }
-
-  matches(channelId: string): boolean {
-    return this.everywhere || this.ids.has(channelId);
-  }
-
-  unresolvedNames(): string[] {
-    return [...this.names];
-  }
-
-  /** Fold resolved `name → id` pairs into the id set. */
-  applyResolvedNames(resolved: ReadonlyMap<string, string>): void {
-    for (const name of this.names) {
-      const id = resolved.get(name);
-      if (id !== undefined) {
-        this.ids.add(id);
-      }
-    }
-  }
-}
-
-/**
- * Resolve channel `#names` to ids via `conversations.list`. Best-effort:
- * returns whatever resolved; the caller logs names that stayed unresolved.
- */
-export async function resolveChannelNames(
-  client: WebClient,
-  names: readonly string[],
-  log: SlackLog = defaultSlackLog,
-): Promise<Map<string, string>> {
-  const wanted = new Set(names.map(name => name.toLowerCase()));
-  const resolved = new Map<string, string>();
-  if (wanted.size === 0) {
-    return resolved;
-  }
-  let cursor: string | undefined;
-  for (let page = 0; page < 20 && resolved.size < wanted.size; page += 1) {
-    const response = await client.conversations.list({
-      types: "public_channel,private_channel",
-      exclude_archived: true,
-      limit: 200,
-      ...(cursor === undefined ? {} : { cursor }),
-    });
-    for (const channel of response.channels ?? []) {
-      const name = channel.name?.toLowerCase();
-      if (name !== undefined && wanted.has(name) && channel.id !== undefined) {
-        resolved.set(name, channel.id);
-      }
-    }
-    cursor = response.response_metadata?.next_cursor || undefined;
-    if (cursor === undefined) {
-      break;
-    }
-  }
-  for (const name of wanted) {
-    if (!resolved.has(name)) {
-      log.error("channel watch: could not resolve channel name", {
-        name: `#${name}`,
-      });
-    }
-  }
-  return resolved;
-}
-
-export interface ChannelPostWatcher {
-  /** Handle a parsed channel message event. Returns true when consumed. */
-  handle(event: SlackChannelMessageEvent, eventId?: string): boolean;
-  /** Cancel pending debounced dispatches. */
-  stop(): void;
-}
-
-export function createChannelPostWatcher(args: {
-  options: SlackChannelPostsOptions;
-  allowlist: SlackChannelAllowlist;
-  /** Bot user id (from `auth.test`) so bot mentions route via app_mention. */
-  getBotUserId: () => string | undefined;
-  /** This app's own `bot_id` (from `auth.test`) for self-post loop safety. */
-  getBotId?: () => string | undefined;
-  dispatch: (message: SlackMessage, eventId?: string) => void;
-  log?: SlackLog;
-}): ChannelPostWatcher {
-  const log = args.log ?? defaultSlackLog;
-  const posts = args.options.posts ?? "top-level";
-  const includeBotPosts = args.options.includeBotPosts === true;
-  const debounceMs = args.options.debounceMs ?? 0;
-  const pending = new Map<
-    string,
-    {
-      timer: ReturnType<typeof setTimeout>;
-      message: SlackMessage;
-      eventId?: string;
-    }
-  >();
-
-  const pendingKey = (channelId: string, ts: string): string => `${channelId}:${ts}`;
-
-  function skip(reason: string, message: SlackMessage): true {
-    log.debug(`channel watch skip (${reason})`, {
-      channel: message.channelId,
-      message_ts: message.ts,
-      thread_ts: message.threadTs,
-    });
-    return true;
-  }
-
-  function fire(message: SlackMessage, eventId: string | undefined): void {
-    log.info("channel watch dispatch", {
-      channel: message.channelId,
-      message_ts: message.ts,
-      thread_ts: message.threadTs,
-      event_id: eventId,
-    });
-    args.dispatch(message, eventId);
-  }
-
-  return {
-    handle(event, eventId) {
-      if (event.kind === "deleted") {
-        const key = pendingKey(event.channelId, event.ts);
-        const entry = pending.get(key);
-        if (entry !== undefined) {
-          clearTimeout(entry.timer);
-          pending.delete(key);
-          log.info("channel watch cancel (post deleted)", {
-            channel: event.channelId,
-            message_ts: event.ts,
-          });
-        }
-        return true;
-      }
-
-      const message = event.message;
-      if (!args.allowlist.matches(message.channelId)) {
-        return skip("channel not allowlisted", message);
-      }
-
-      if (event.kind === "edited") {
-        const entry = pending.get(pendingKey(message.channelId, message.ts));
-        if (entry !== undefined) {
-          entry.message = { ...entry.message, ...message };
-        }
-        // Edits never (re-)dispatch on their own.
-        return true;
-      }
-
-      const reply = message.ts !== message.threadTs;
-      if (posts === "replies" && !reply) {
-        return skip("top-level post (posts: replies)", message);
-      }
-      if (posts === "top-level" && reply) {
-        return skip("thread reply (posts: top-level)", message);
-      }
-      const botUserId = args.getBotUserId();
-      const author = message.author;
-      if (author?.isBot === true) {
-        if (!includeBotPosts) {
-          return skip("bot-authored post (includeBotPosts off)", message);
-        }
-        const selfBotId = args.getBotId?.();
-        if (selfBotId === undefined && botUserId === undefined) {
-          return skip("bot-authored post (bot identity unknown; loop safety)", message);
-        }
-        if (
-          (selfBotId !== undefined && author.botId === selfBotId) ||
-          (botUserId !== undefined && author.userId !== "" && author.userId === botUserId)
-        ) {
-          return skip("own post (loop safety)", message);
-        }
-      }
-      if (botUserId !== undefined && message.text.includes(`<@${botUserId}>`)) {
-        return skip("bot mention (app_mention path owns it)", message);
-      }
-
-      if (debounceMs <= 0) {
-        fire(message, eventId);
-        return true;
-      }
-      const key = pendingKey(message.channelId, message.ts);
-      const existing = pending.get(key);
-      if (existing !== undefined) {
-        clearTimeout(existing.timer);
-      }
-      const entry = {
-        timer: setTimeout(() => {
-          pending.delete(key);
-          fire(entry.message, entry.eventId);
-        }, debounceMs),
-        message,
-        ...(eventId === undefined ? {} : { eventId }),
-      };
-      pending.set(key, entry);
-      return true;
-    },
-    stop() {
-      for (const entry of pending.values()) {
-        clearTimeout(entry.timer);
-      }
-      pending.clear();
-    },
-  };
-}

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

@@ -1,249 +0,0 @@
-/**
- * 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;
-  }
-}