@cursor/bdk 0.2.2 → 0.2.4

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

@@ -1,334 +0,0 @@
-/**
- * Durable Slack follow-up nudge store (Benny-style).
- *
- * Mid-turn inject and boundary resume share one exactly-once contract:
- * pending nudges rename into delivered/ keyed by source message ts.
- */
-
-import { createHash, randomBytes } from "node:crypto";
-import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-export interface SlackNudgeRecord {
-  id: string;
-  continuationKey: string;
-  sourceTs: string;
-  text: string;
-  author?: string;
-  createdAt: string;
-  /** Content hash for pending dedupe. */
-  contentHash: string;
-}
-
-export interface SlackNudgeAppendInput {
-  continuationKey: string;
-  sourceTs: string;
-  text: string;
-  author?: string;
-}
-
-/**
- * Map an arbitrary key onto a single path segment under the store root.
- * Rejects empty / `.` / `..` and strips remaining dots so path traversal
- * cannot escape `<stateRoot>/slack-nudges` (or `slack-asks`).
- */
-function safeKey(continuationKey: string): string {
-  const trimmed = continuationKey.trim();
-  if (trimmed === "" || trimmed === "." || trimmed === "..") {
-    return "_empty";
-  }
-  const sanitized = trimmed
-    .replace(/[^a-zA-Z0-9._-]+/g, "_")
-    .replace(/^\.+/, "")
-    .replace(/\.+/g, "_")
-    .slice(0, 180);
-  if (sanitized === "" || sanitized === "." || sanitized === "..") {
-    return "_empty";
-  }
-  return sanitized;
-}
-
-function contentHash(text: string): string {
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-
-function newNudgeId(): string {
-  return `nudge_${randomBytes(8).toString("hex")}`;
-}
-
-export function formatSlackFollowupNudgeBlock(
-  nudges: readonly SlackNudgeRecord[],
-): string | undefined {
-  if (nudges.length === 0) {
-    return undefined;
-  }
-  const lines = [
-    "<slack_followup>",
-    "New Slack follow-up(s) arrived while you were working. Incorporate them before your final reply. If an ask was already answered in-thread, ack briefly instead of re-answering.",
-    "",
-  ];
-  for (const nudge of nudges) {
-    const who = nudge.author === undefined || nudge.author === "" ? "someone" : nudge.author;
-    lines.push(`- ${who} @ ${nudge.sourceTs}:`);
-    lines.push(nudge.text.trim() === "" ? "(empty)" : nudge.text.trim());
-    lines.push("");
-  }
-  lines.push("</slack_followup>");
-  return lines.join("\n").trimEnd();
-}
-
-/**
- * Filesystem nudge store under `<root>/<continuation>/pending|delivered`.
- */
-export class SlackNudgeStore {
-  private readonly rootDir: string;
-
-  constructor(rootDir: string) {
-    this.rootDir = rootDir;
-  }
-
-  private continuationDir(continuationKey: string): string {
-    return join(this.rootDir, safeKey(continuationKey));
-  }
-
-  private pendingDir(continuationKey: string): string {
-    return join(this.continuationDir(continuationKey), "pending");
-  }
-
-  private deliveredDir(continuationKey: string): string {
-    return join(this.continuationDir(continuationKey), "delivered");
-  }
-
-  private deliveredPath(continuationKey: string, sourceTs: string): string {
-    return join(this.deliveredDir(continuationKey), safeKey(sourceTs));
-  }
-
-  async append(input: SlackNudgeAppendInput): Promise<boolean> {
-    const continuationKey = input.continuationKey.trim();
-    const sourceTs = input.sourceTs.trim();
-    const text = input.text.trim();
-    if (continuationKey === "" || sourceTs === "" || text === "") {
-      return false;
-    }
-    if (await this.isDelivered(continuationKey, sourceTs)) {
-      return false;
-    }
-    const pending = await this.listPending(continuationKey);
-    const hash = contentHash(text);
-    if (pending.some(item => item.sourceTs === sourceTs || item.contentHash === hash)) {
-      return false;
-    }
-    const record: SlackNudgeRecord = {
-      id: newNudgeId(),
-      continuationKey,
-      sourceTs,
-      text,
-      ...(input.author === undefined || input.author === "" ? {} : { author: input.author }),
-      createdAt: new Date().toISOString(),
-      contentHash: hash,
-    };
-    const dir = this.pendingDir(continuationKey);
-    await mkdir(dir, { recursive: true });
-    const target = join(dir, `${record.id}.json`);
-    const tmp = `${target}.${process.pid}.tmp`;
-    await writeFile(tmp, `${JSON.stringify(record)}\n`, "utf8");
-    await rename(tmp, target);
-    return true;
-  }
-
-  async listPending(continuationKey: string): Promise<SlackNudgeRecord[]> {
-    const dir = this.pendingDir(continuationKey);
-    let names: string[];
-    try {
-      names = await readdir(dir);
-    } catch {
-      return [];
-    }
-    const records: SlackNudgeRecord[] = [];
-    for (const name of names) {
-      if (!name.endsWith(".json")) {
-        continue;
-      }
-      try {
-        const raw = await readFile(join(dir, name), "utf8");
-        const parsed = JSON.parse(raw) as SlackNudgeRecord;
-        if (
-          typeof parsed.id === "string" &&
-          typeof parsed.sourceTs === "string" &&
-          typeof parsed.text === "string"
-        ) {
-          records.push(parsed);
-        }
-      } catch {
-        // Skip corrupt pending files.
-      }
-    }
-    records.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    return records;
-  }
-
-  async isDelivered(continuationKey: string, sourceTs: string): Promise<boolean> {
-    if (continuationKey.trim() === "" || sourceTs.trim() === "") {
-      return false;
-    }
-    try {
-      await readFile(this.deliveredPath(continuationKey, sourceTs), "utf8");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async hasUndelivered(continuationKey: string): Promise<boolean> {
-    return (await this.listPending(continuationKey)).length > 0;
-  }
-
-  /**
-   * How many follow-ups have reached the agent on this thread. Monotonic
-   * within a continuation, so a caller can spot a delivery by comparing two
-   * readings — unlike {@link hasUndelivered}, which races the carrier: both
-   * run at the same tool boundary, and a queued nudge drained before the
-   * first reading never looks pending at all.
-   */
-  async deliveredCount(continuationKey: string): Promise<number> {
-    if (continuationKey.trim() === "") {
-      return 0;
-    }
-    try {
-      return (await readdir(this.deliveredDir(continuationKey))).length;
-    } catch {
-      return 0;
-    }
-  }
-
-  /**
-   * Atomically move all pending nudges to delivered and return them.
-   * Already-delivered source ts values are dropped (exactly-once).
-   */
-  async drainForInject(continuationKey: string): Promise<SlackNudgeRecord[]> {
-    const pending = await this.listPending(continuationKey);
-    if (pending.length === 0) {
-      return [];
-    }
-    await mkdir(this.deliveredDir(continuationKey), { recursive: true });
-    const delivered: SlackNudgeRecord[] = [];
-    for (const record of pending) {
-      const pendingPath = join(this.pendingDir(continuationKey), `${record.id}.json`);
-      if (await this.isDelivered(continuationKey, record.sourceTs)) {
-        await rm(pendingPath, { force: true });
-        continue;
-      }
-      const dest = this.deliveredPath(continuationKey, record.sourceTs);
-      const tmp = `${dest}.${process.pid}.tmp`;
-      try {
-        await writeFile(tmp, `${JSON.stringify(record)}\n`, "utf8");
-        await rename(tmp, dest);
-        await rm(pendingPath, { force: true });
-        delivered.push(record);
-      } catch {
-        await rm(tmp, { force: true }).catch(() => {});
-        // Race: another drain won — treat as delivered.
-        await rm(pendingPath, { force: true }).catch(() => {});
-      }
-    }
-    return delivered;
-  }
-
-  /**
-   * Settle a follow-up the caller is handling itself, so the carrier cannot
-   * inject it again. Used by the boundary drain: a follow-up the carrier did
-   * not reach becomes the next turn's prompt, and without this its pending
-   * record survives into that turn and gets injected on top of the ask it
-   * already is.
-   */
-  async markDelivered(continuationKey: string, sourceTs: string): Promise<void> {
-    const key = continuationKey.trim();
-    const ts = sourceTs.trim();
-    if (key === "" || ts === "") {
-      return;
-    }
-    const pending = await this.listPending(key);
-    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`;
-    try {
-      await writeFile(
-        tmp,
-        `${JSON.stringify(record ?? { continuationKey: key, sourceTs: ts })}\n`,
-        "utf8",
-      );
-      await rename(tmp, dest);
-    } catch {
-      await rm(tmp, { force: true }).catch(() => {});
-    }
-    if (record !== undefined) {
-      await rm(join(this.pendingDir(key), `${record.id}.json`), {
-        force: true,
-      }).catch(() => {});
-    }
-  }
-
-  async clear(continuationKey: string): Promise<void> {
-    await rm(this.continuationDir(continuationKey), {
-      recursive: true,
-      force: true,
-    });
-  }
-
-  /** Drain + format for tool/hook inject. */
-  async drainFormatted(continuationKey: string): Promise<string | undefined> {
-    return formatSlackFollowupNudgeBlock(await this.drainForInject(continuationKey));
-  }
-}
-
-/**
- * Durable ask claim store: one marker per `channelId:message.ts` so delayed
- * Slack redelivery cannot start a second full answer.
- */
-export class SlackAskDedupeStore {
-  private readonly rootDir: string;
-
-  constructor(rootDir: string) {
-    this.rootDir = rootDir;
-  }
-
-  private markerPath(channelId: string, messageTs: string): string {
-    return join(this.rootDir, `${safeKey(channelId)}__${safeKey(messageTs)}.claimed`);
-  }
-
-  /** Returns true the first time this ask is claimed. */
-  async tryClaim(channelId: string, messageTs: string): Promise<boolean> {
-    if (channelId.trim() === "" || messageTs.trim() === "") {
-      return false;
-    }
-    const path = this.markerPath(channelId, messageTs);
-    await mkdir(this.rootDir, { recursive: true });
-    try {
-      await writeFile(path, `${new Date().toISOString()}\n`, {
-        encoding: "utf8",
-        flag: "wx",
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /** Drop a claim so a failed delivery can be retried. */
-  async release(channelId: string, messageTs: string): Promise<void> {
-    if (channelId.trim() === "" || messageTs.trim() === "") {
-      return;
-    }
-    await rm(this.markerPath(channelId, messageTs), { force: true });
-  }
-
-  async wasClaimed(channelId: string, messageTs: string): Promise<boolean> {
-    try {
-      await readFile(this.markerPath(channelId, messageTs), "utf8");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}

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

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