@cursor/bdk 0.2.3 → 0.2.4

package/src/channels/slack/placeholder.ts

@@ -1,358 +0,0 @@
-/**
- * Replaceable first Slack line while the agent is still starting.
- * The authored static line is posted exactly as declared.
- * `chat.startStream` then `stopStream` so the line exists and the chip
- * can paint. An open stream hides `assistant.threads.setStatus`.
- * The first post-update edits that ts. An unclaimed line is deleted
- * when the turn ends.
- */
-
-import { isSlackImChannel } from "../../internal/slack-thread-key.js";
-import {
-  deleteMessage,
-  postMessage,
-  startChatStream,
-  stopChatStream,
-  updateMessage,
-} from "./api.js";
-import { defaultSlackLog, type SlackLog } from "./log.js";
-import type { SlackBotToken } from "./types.js";
-
-type Slot = {
-  claimed: boolean;
-  ts: string | null;
-  streamed: boolean;
-};
-
-type Taken = {
-  ts: string;
-  streamed: boolean;
-};
-
-type PlaceholderLineArgs = {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  recipientUserId?: string | null;
-  recipientTeamId?: string | null;
-};
-
-const slots = new Map<string, Slot>();
-
-function slotKey(channelId: string, threadTs: string): string {
-  return `${channelId}:${threadTs}`;
-}
-
-function channelKeys(channelId: string): string[] {
-  if (!isSlackImChannel(channelId)) {
-    return [];
-  }
-  const prefix = `${channelId}:`;
-  const keys: string[] = [];
-  for (const key of slots.keys()) {
-    if (key.startsWith(prefix)) {
-      keys.push(key);
-    }
-  }
-  return keys;
-}
-
-export function resetPlaceholderSlots(): void {
-  slots.clear();
-}
-
-function openPlaceholder(key: string): boolean {
-  if (slots.has(key)) {
-    return false;
-  }
-  slots.set(key, { claimed: false, ts: null, streamed: false });
-  return true;
-}
-
-function takePlaceholder(key: string): Taken | undefined {
-  const slot = slots.get(key);
-  if (slot === undefined || slot.claimed) {
-    return undefined;
-  }
-  slot.claimed = true;
-  if (slot.ts === null) {
-    return undefined;
-  }
-  slots.delete(key);
-  return { ts: slot.ts, streamed: slot.streamed };
-}
-
-function rememberPlaceholder(key: string, ts: string, streamed: boolean): boolean {
-  const slot = slots.get(key);
-  if (slot === undefined || slot.claimed) {
-    return false;
-  }
-  slot.ts = ts;
-  slot.streamed = streamed;
-  return true;
-}
-
-function closePlaceholder(key: string): Slot | undefined {
-  const slot = slots.get(key);
-  slots.delete(key);
-  return slot;
-}
-
-type FinishArgs = {
-  channelId: string;
-  botToken: SlackBotToken | undefined;
-  log?: SlackLog;
-};
-
-async function retractKey(key: string, args: FinishArgs): Promise<void> {
-  const closed = closePlaceholder(key);
-  if (closed === undefined || closed.claimed || closed.ts === null) {
-    return;
-  }
-  await retractPosted({
-    botToken: args.botToken,
-    channelId: args.channelId,
-    ts: closed.ts,
-    streamed: closed.streamed,
-    log: args.log,
-  });
-}
-
-/** Retract only one thread's slot; admission cleanup must not sweep DM peers. */
-export async function retractPlaceholderSlot(args: {
-  channelId: string;
-  threadTs: string;
-  botToken: SlackBotToken | undefined;
-  log?: SlackLog;
-}): Promise<void> {
-  await retractKey(slotKey(args.channelId, args.threadTs), args);
-}
-
-export async function finishPlaceholder(args: {
-  channelId: string;
-  threadTs: string;
-  botToken: SlackBotToken | undefined;
-  log?: SlackLog;
-}): Promise<void> {
-  const first = slotKey(args.channelId, args.threadTs);
-  await retractKey(first, args);
-  for (const key of channelKeys(args.channelId)) {
-    await retractKey(key, args);
-  }
-}
-
-export function startPlaceholder(args: {
-  line: string;
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  log?: SlackLog;
-  recipientUserId?: string | null;
-  recipientTeamId?: string | null;
-}): { done: Promise<void>; retract: () => Promise<void> } | undefined {
-  const key = slotKey(args.channelId, args.threadTs);
-  if (!openPlaceholder(key)) {
-    return undefined;
-  }
-  const log = args.log ?? defaultSlackLog;
-  return {
-    done: postPlaceholder({ ...args, key, log }),
-    retract: () => retractKey(key, { ...args, log }),
-  };
-}
-
-/**
- * Seed the in-process placeholder slot with a control-plane-posted message
- * ts so the first agentic update overlays that exact Slack message.
- */
-export type PlaceholderAdoption = "adopted" | "already_adopted" | "occupied";
-
-export function adoptPlaceholder(args: {
-  channelId: string;
-  threadTs: string;
-  ts: string;
-  streamed?: boolean;
-}): PlaceholderAdoption {
-  const key = slotKey(args.channelId, args.threadTs);
-  const existing = slots.get(key);
-  if (
-    existing !== undefined &&
-    !existing.claimed &&
-    existing.ts === args.ts &&
-    existing.streamed === (args.streamed === true)
-  ) {
-    return "already_adopted";
-  }
-  if (!openPlaceholder(key)) {
-    return "occupied";
-  }
-  return rememberPlaceholder(key, args.ts, args.streamed === true) ? "adopted" : "occupied";
-}
-
-/** Delete a control-plane placeholder that this process could not adopt. */
-export async function retractPlaceholderMessage(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  ts: string;
-  streamed: boolean;
-  log?: SlackLog;
-}): Promise<void> {
-  await retractPosted(args);
-}
-
-async function postPlaceholder(args: {
-  line: string;
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  threadTs: string;
-  key: string;
-  log: SlackLog;
-  recipientUserId?: string | null;
-  recipientTeamId?: string | null;
-}): Promise<void> {
-  try {
-    const posted = await postPlaceholderLine(args, args.line);
-    if (rememberPlaceholder(args.key, posted.ts, posted.streamed)) {
-      args.log.info("placeholder posted", {
-        channel: args.channelId,
-        thread_ts: args.threadTs,
-        message_ts: posted.ts,
-        chars: args.line.length,
-      });
-      return;
-    }
-    await retractPosted({
-      botToken: args.botToken,
-      channelId: args.channelId,
-      ts: posted.ts,
-      streamed: posted.streamed,
-      log: args.log,
-    });
-  } catch (error) {
-    args.log.warn(
-      `placeholder post failed: ${error instanceof Error ? error.message : String(error)}`,
-      { channel: args.channelId, thread_ts: args.threadTs },
-    );
-    const closed = closePlaceholder(args.key);
-    if (closed === undefined || closed.claimed || closed.ts === null) {
-      return;
-    }
-    await retractPosted({
-      botToken: args.botToken,
-      channelId: args.channelId,
-      ts: closed.ts,
-      streamed: closed.streamed,
-      log: args.log,
-    });
-  }
-}
-
-async function postPlaceholderLine(
-  args: PlaceholderLineArgs,
-  line: string,
-): Promise<{ ts: string; streamed: boolean }> {
-  const user = args.recipientUserId;
-  const team = args.recipientTeamId;
-  const started = await startChatStream({
-    botToken: args.botToken,
-    channel: args.channelId,
-    thread_ts: args.threadTs,
-    markdown_text: line,
-    recipient_user_id: user === null || user === "" ? undefined : user,
-    recipient_team_id: team === null || team === "" ? undefined : team,
-  });
-  if (started.ok) {
-    const stopped = await stopChatStream({
-      botToken: args.botToken,
-      channel: args.channelId,
-      ts: started.ts,
-    });
-    return { ts: started.ts, streamed: !stopped.ok };
-  }
-  const posted = await postMessage({
-    botToken: args.botToken,
-    channel: args.channelId,
-    text: line,
-    threadTs: args.threadTs,
-  });
-  return { ts: posted.ts, streamed: false };
-}
-
-export async function overlayPlaceholder(args: {
-  channelId: string;
-  threadTs: string;
-  botToken: SlackBotToken | undefined;
-  text: string;
-}): Promise<string | undefined> {
-  const primary = slotKey(args.channelId, args.threadTs);
-  const painted = await paintSlot(primary, args);
-  for (const key of channelKeys(args.channelId)) {
-    await paintSlot(key, args);
-  }
-  return painted;
-}
-
-async function paintSlot(
-  key: string,
-  args: {
-    botToken: SlackBotToken | undefined;
-    channelId: string;
-    text: string;
-  },
-): Promise<string | undefined> {
-  const taken = takePlaceholder(key);
-  if (taken === undefined) {
-    return undefined;
-  }
-  if (taken.streamed) {
-    await stopChatStream({
-      botToken: args.botToken,
-      channel: args.channelId,
-      ts: taken.ts,
-    });
-  }
-  const result = await updateMessage({
-    botToken: args.botToken,
-    channel: args.channelId,
-    ts: taken.ts,
-    text: args.text,
-  });
-  if (result.ok) {
-    return taken.ts;
-  }
-  await retractPosted({
-    botToken: args.botToken,
-    channelId: args.channelId,
-    ts: taken.ts,
-    streamed: false,
-  });
-  return undefined;
-}
-
-async function retractPosted(args: {
-  botToken: SlackBotToken | undefined;
-  channelId: string;
-  ts: string;
-  streamed: boolean;
-  log?: SlackLog;
-}): Promise<void> {
-  if (args.streamed) {
-    await stopChatStream({
-      botToken: args.botToken,
-      channel: args.channelId,
-      ts: args.ts,
-    });
-  }
-  const result = await deleteMessage({
-    botToken: args.botToken,
-    channel: args.channelId,
-    ts: args.ts,
-  });
-  if (!result.ok) {
-    (args.log ?? defaultSlackLog).warn("placeholder retract failed", {
-      error: result.error,
-      channel: args.channelId,
-      ts: args.ts,
-    });
-  }
-}

package/src/channels/slack/pr-ref.ts

@@ -1,74 +0,0 @@
-/**
- * Best-effort PR references from free-form chat (Slack, etc.).
- */
-
-import { type PrProvider, parsePrUrl } from "../../internal/scm/pr-url.js";
-
-export interface GithubPrRef {
-  /** Normalized URL `https://github.com/owner/repo/pull/N`. */
-  url: string;
-  /** Compact `owner/repo#N`. */
-  label: string;
-  owner: string;
-  repo: string;
-  number: number;
-}
-
-export type OriginPrRef = GithubPrRef;
-
-const URL_IN_TEXT = /https?:\/\/[^\s>|]+/gi;
-
-function githubRef(owner: string, repo: string, number: number): GithubPrRef {
-  return {
-    owner,
-    repo,
-    number,
-    url: `https://github.com/${owner}/${repo}/pull/${number}`,
-    label: `${owner}/${repo}#${number}`,
-  };
-}
-
-function firstUrlRef(text: string, provider: PrProvider): GithubPrRef | undefined {
-  const matches = text.match(URL_IN_TEXT);
-  if (matches === null) {
-    return undefined;
-  }
-  for (const raw of matches) {
-    const parsed = parsePrUrl(raw);
-    if (parsed?.provider === provider) {
-      return {
-        owner: parsed.owner,
-        repo: parsed.repo,
-        number: parsed.number,
-        url: parsed.url,
-        label: `${parsed.owner}/${parsed.repo}#${parsed.number}`,
-      };
-    }
-  }
-  return undefined;
-}
-
-/**
- * Find the first Origin PR URL in `text`.
- * Does not treat bare `owner/repo#N` as Origin.
- */
-export function extractOriginPrRef(text: string): OriginPrRef | undefined {
-  return firstUrlRef(text, "origin");
-}
-
-/**
- * Find the first GitHub PR URL or `owner/repo#N` in `text`.
- * Returns `undefined` when none is present.
- */
-export function extractGithubPrRef(text: string): GithubPrRef | undefined {
-  const fromUrl = firstUrlRef(text, "github");
-  if (fromUrl !== undefined) {
-    return fromUrl;
-  }
-
-  const hashMatch = text.match(/\b([\w.-]+)\/([\w.-]+)#(\d+)\b/);
-  if (hashMatch === null) {
-    return undefined;
-  }
-  return githubRef(hashMatch[1] as string, hashMatch[2] as string, Number(hashMatch[3]));
-}

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

@@ -1,138 +0,0 @@
-import { markHostedFirstVisibleReply } from "../../internal/hosted-execution-latency.js";
-/**
- * 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) {
-          markHostedFirstVisibleReply({
-            outcome: "progress_update",
-            deliverySurface: "slack",
-          });
-          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;
-        markHostedFirstVisibleReply({
-          outcome: "progress_update",
-          deliverySurface: "slack",
-        });
-      } 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;
-      markHostedFirstVisibleReply({
-        outcome: "progress_update",
-        deliverySurface: "slack",
-      });
-      return true;
-    },
-
-    clear,
-  };
-}

package/src/channels/slack/reasoning-card.ts

@@ -1,125 +0,0 @@
-/**
- * The "Thinking" task card that receives the model's reasoning as it streams.
- * Slack appends a card's `details` across updates, so the card is fed
- * deltas: the part of the current reasoning block already on Slack, plus a
- * buffer of what has not gone out yet.
- */
-
-import type { ChannelEventContext } from "../../types.js";
-import type { ResolvedSlackReasoningCard } from "./reply-options.js";
-import { type StreamTaskChunk, truncateCardText } from "./stream.js";
-import type { ReasoningCardState, SlackChannelState } from "./types.js";
-
-const FLUSH_MS = 1_000;
-const FLUSH_CHARS = 160;
-const CARD_ID = "reasoning";
-const BLOCK_SEPARATOR = "\n\n";
-
-type Channel = ChannelEventContext<SlackChannelState>;
-type CardStatus = "in_progress" | "complete";
-
-export interface ReasoningCard {
-  /** Buffer the current reasoning block's cumulative text; flushes when due. */
-  append(args: { channel: Channel; sessionId: string; text: string }): Promise<void>;
-  /** Send buffered text and set the card status. */
-  flush(args: { channel: Channel; sessionId: string; status: CardStatus }): Promise<void>;
-  /** The next reasoning block appends after a blank line. */
-  endBlock(channel: Channel): void;
-  inProgress(channel: Channel): boolean;
-}
-
-/** Delivers one chunk into the reply stream; `false` when nothing went out. */
-export type SendCardChunk = (args: {
-  channel: Channel;
-  sessionId: string;
-  chunk: StreamTaskChunk;
-}) => Promise<boolean>;
-
-function cardState(state: SlackChannelState): ReasoningCardState {
-  if (state.reasoningCard === undefined) {
-    state.reasoningCard = {
-      status: null,
-      blockSent: null,
-      pending: "",
-      lastFlushMs: null,
-      chars: 0,
-    };
-  }
-  return state.reasoningCard;
-}
-
-export function createReasoningCard(
-  card: ResolvedSlackReasoningCard,
-  send: SendCardChunk,
-): ReasoningCard {
-  const flush: ReasoningCard["flush"] = async ({ channel, sessionId, status }) => {
-    const state = cardState(channel.state);
-    if (state.pending === "" && (state.status === status || state.status === null)) {
-      return;
-    }
-    const chunk: StreamTaskChunk = {
-      type: "task_update",
-      id: CARD_ID,
-      title: card.title,
-      status,
-    };
-    if (state.pending !== "") {
-      chunk.details = state.pending;
-    }
-    // Stamped on the attempt, so a failing stream is retried at most once
-    // per flush window instead of once per token.
-    state.lastFlushMs = Date.now();
-    if (!(await send({ channel, sessionId, chunk }))) {
-      return;
-    }
-    state.chars += state.pending.length;
-    state.pending = "";
-    state.status = status;
-  };
-
-  return {
-    flush,
-
-    async append({ channel, sessionId, text }) {
-      const state = cardState(channel.state);
-      if (state.chars >= card.maxChars) {
-        return;
-      }
-      const sent = state.blockSent ?? 0;
-      let delta: string;
-      if (sent > 0 && text.length >= sent) {
-        delta = text.slice(sent);
-      } else {
-        const hasText = state.chars + state.pending.length > 0;
-        delta = `${hasText ? BLOCK_SEPARATOR : ""}${text}`;
-      }
-      state.blockSent = text.length;
-      if (delta === "") {
-        return;
-      }
-      let pending = `${state.pending}${delta}`;
-      const room = card.maxChars - state.chars;
-      if (pending.length > room) {
-        pending = truncateCardText(pending, room);
-        state.chars = card.maxChars - pending.length;
-      }
-      state.pending = pending;
-
-      const due =
-        state.lastFlushMs === null ||
-        Date.now() - state.lastFlushMs >= FLUSH_MS ||
-        pending.length >= FLUSH_CHARS;
-      if (due) {
-        await flush({ channel, sessionId, status: "in_progress" });
-      }
-    },
-
-    endBlock(channel) {
-      cardState(channel.state).blockSent = null;
-    },
-
-    inProgress(channel) {
-      return channel.state.reasoningCard?.status === "in_progress";
-    },
-  };
-}