@cursor/july 0.1.7 → 0.1.9

package/dist/channels/slack/nudge-store.js

@@ -0,0 +1,266 @@
+/**
+ * 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createHash, randomBytes } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { join } from "node:path";
+/**
+ * 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) {
+    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) {
+    return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+function newNudgeId() {
+    return `nudge_${randomBytes(8).toString("hex")}`;
+}
+export function formatSlackFollowupNudgeBlock(nudges) {
+    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 {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    continuationDir(continuationKey) {
+        return join(this.rootDir, safeKey(continuationKey));
+    }
+    pendingDir(continuationKey) {
+        return join(this.continuationDir(continuationKey), "pending");
+    }
+    deliveredDir(continuationKey) {
+        return join(this.continuationDir(continuationKey), "delivered");
+    }
+    deliveredPath(continuationKey, sourceTs) {
+        return join(this.deliveredDir(continuationKey), safeKey(sourceTs));
+    }
+    append(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const continuationKey = input.continuationKey.trim();
+            const sourceTs = input.sourceTs.trim();
+            const text = input.text.trim();
+            if (continuationKey === "" || sourceTs === "" || text === "") {
+                return false;
+            }
+            if (yield this.isDelivered(continuationKey, sourceTs)) {
+                return false;
+            }
+            const pending = yield this.listPending(continuationKey);
+            const hash = contentHash(text);
+            if (pending.some((item) => item.sourceTs === sourceTs || item.contentHash === hash)) {
+                return false;
+            }
+            const record = Object.assign(Object.assign({ id: newNudgeId(), continuationKey,
+                sourceTs,
+                text }, (input.author === undefined || input.author === ""
+                ? {}
+                : { author: input.author })), { createdAt: new Date().toISOString(), contentHash: hash });
+            const dir = this.pendingDir(continuationKey);
+            yield mkdir(dir, { recursive: true });
+            const target = join(dir, `${record.id}.json`);
+            const tmp = `${target}.${process.pid}.tmp`;
+            yield writeFile(tmp, `${JSON.stringify(record)}\n`, "utf8");
+            yield rename(tmp, target);
+            return true;
+        });
+    }
+    listPending(continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dir = this.pendingDir(continuationKey);
+            let names;
+            try {
+                names = yield readdir(dir);
+            }
+            catch (_a) {
+                return [];
+            }
+            const records = [];
+            for (const name of names) {
+                if (!name.endsWith(".json")) {
+                    continue;
+                }
+                try {
+                    const raw = yield readFile(join(dir, name), "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (typeof parsed.id === "string" &&
+                        typeof parsed.sourceTs === "string" &&
+                        typeof parsed.text === "string") {
+                        records.push(parsed);
+                    }
+                }
+                catch (_b) {
+                    // Skip corrupt pending files.
+                }
+            }
+            records.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+            return records;
+        });
+    }
+    isDelivered(continuationKey, sourceTs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (continuationKey.trim() === "" || sourceTs.trim() === "") {
+                return false;
+            }
+            try {
+                yield readFile(this.deliveredPath(continuationKey, sourceTs), "utf8");
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    hasUndelivered(continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.listPending(continuationKey)).length > 0;
+        });
+    }
+    /**
+     * Atomically move all pending nudges to delivered and return them.
+     * Already-delivered source ts values are dropped (exactly-once).
+     */
+    drainForInject(continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pending = yield this.listPending(continuationKey);
+            if (pending.length === 0) {
+                return [];
+            }
+            yield mkdir(this.deliveredDir(continuationKey), { recursive: true });
+            const delivered = [];
+            for (const record of pending) {
+                const pendingPath = join(this.pendingDir(continuationKey), `${record.id}.json`);
+                if (yield this.isDelivered(continuationKey, record.sourceTs)) {
+                    yield rm(pendingPath, { force: true });
+                    continue;
+                }
+                const dest = this.deliveredPath(continuationKey, record.sourceTs);
+                const tmp = `${dest}.${process.pid}.tmp`;
+                try {
+                    yield writeFile(tmp, `${JSON.stringify(record)}\n`, "utf8");
+                    yield rename(tmp, dest);
+                    yield rm(pendingPath, { force: true });
+                    delivered.push(record);
+                }
+                catch (_a) {
+                    yield rm(tmp, { force: true }).catch(() => { });
+                    // Race: another drain won — treat as delivered.
+                    yield rm(pendingPath, { force: true }).catch(() => { });
+                }
+            }
+            return delivered;
+        });
+    }
+    clear(continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield rm(this.continuationDir(continuationKey), {
+                recursive: true,
+                force: true,
+            });
+        });
+    }
+    /** Drain + format for tool/hook inject. */
+    drainFormatted(continuationKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return formatSlackFollowupNudgeBlock(yield 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 {
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    markerPath(channelId, messageTs) {
+        return join(this.rootDir, `${safeKey(channelId)}__${safeKey(messageTs)}.claimed`);
+    }
+    /** Returns true the first time this ask is claimed. */
+    tryClaim(channelId, messageTs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (channelId.trim() === "" || messageTs.trim() === "") {
+                return false;
+            }
+            const path = this.markerPath(channelId, messageTs);
+            yield mkdir(this.rootDir, { recursive: true });
+            try {
+                yield writeFile(path, `${new Date().toISOString()}\n`, {
+                    encoding: "utf8",
+                    flag: "wx",
+                });
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+    /** Drop a claim so a failed delivery can be retried. */
+    release(channelId, messageTs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (channelId.trim() === "" || messageTs.trim() === "") {
+                return;
+            }
+            yield rm(this.markerPath(channelId, messageTs), { force: true });
+        });
+    }
+    wasClaimed(channelId, messageTs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield readFile(this.markerPath(channelId, messageTs), "utf8");
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+}

package/dist/channels/slack/post-update-delivery.js

@@ -0,0 +1,318 @@
+/**
+ * Live-reply delivery strategies for the Slack default handlers.
+ *
+ * A single strategy owns how an in-progress reply is opened, updated,
+ * finalized, and cleaned up so the handlers in `defaults.ts` don't fork on the
+ * delivery mode at every event:
+ *
+ * - `stream`: Slack chat.startStream / appendStream / stopStream.
+ * - `post-update`: a chat.postMessage skeleton edited with chat.update. This is
+ *   the only path that preserves Cursor-account identity pinning (which only
+ *   covers postMessage).
+ *
+ * `buildDefaultEvents` selects one via {@link selectLiveDeliveryStrategy} up
+ * front and calls into it. All calls keep the same soft-fail / log behavior as
+ * the inlined logic they replaced.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { appendChatStream, deleteMessage, postMessage, setThreadStatus, startChatStream, stopChatStream, updateMessage, } from "./api.js";
+import { SLACK_POST_UPDATE_MIN_INTERVAL_MS } from "./constants.js";
+import { computeStreamAppend } from "./stream.js";
+function createPostUpdateStrategy(deps) {
+    const { botToken, getLog } = deps;
+    return {
+        inlineToolSteps: false,
+        start(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
+                const log = getLog();
+                try {
+                    const posted = yield postMessage({
+                        botToken,
+                        channel: channelId,
+                        text: "…",
+                        threadTs,
+                    });
+                    if (posted.ts !== "") {
+                        channel.state.streamTs = posted.ts;
+                        channel.state.streamChannelId = channelId;
+                        channel.state.lastPostedText = "";
+                        log.info("postMessage skeleton ok", {
+                            channel: channelId,
+                            message_ts: posted.ts,
+                            session: sessionId,
+                        });
+                    }
+                }
+                catch (error) {
+                    log.warn("postMessage skeleton failed", {
+                        error: error instanceof Error ? error.message : String(error),
+                        channel: channelId,
+                        session: sessionId,
+                    });
+                    // Transient proxy/network failures must not permanently disable
+                    // live delivery — only the stream path sets streamingUnavailable
+                    // when Slack reports the feature unsupported.
+                }
+            });
+        },
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                var _b;
+                const now = Date.now();
+                const isFirstUpdate = channel.state.lastPostedText === null ||
+                    channel.state.lastPostedText === "";
+                const lastAt = (_b = channel.state.lastPostUpdateAtMs) !== null && _b !== void 0 ? _b : 0;
+                const due = isFirstUpdate || now - lastAt >= SLACK_POST_UPDATE_MIN_INTERVAL_MS;
+                if (!due) {
+                    // Skip intermediate update; message.completed flushes full text.
+                    return;
+                }
+                const result = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text,
+                });
+                if (!result.ok) {
+                    getLog().warn("chat.update failed", {
+                        error: result.error,
+                        channel: channelId,
+                        message_ts: streamTs,
+                        session: sessionId,
+                    });
+                    return;
+                }
+                channel.state.lastPostUpdateAtMs = now;
+                channel.state.lastPostedText = text;
+            });
+        },
+        finalize(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const log = getLog();
+                const result = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text,
+                });
+                channel.state.streamTs = null;
+                if (result.ok) {
+                    channel.state.lastPostedText = text;
+                    log.info("reply delivered via chat.update", {
+                        channel: channelId,
+                        message_ts: streamTs,
+                        session: sessionId,
+                        chars: text.length,
+                    });
+                    return { delivered: true };
+                }
+                log.warn("chat.update finalize failed; falling back to postMessage", {
+                    error: result.error,
+                    channel: channelId,
+                    message_ts: streamTs,
+                    session: sessionId,
+                });
+                // Only suppress the fallback when the skeleton already holds the exact
+                // final text. Partial updates must not permanently truncate.
+                if (channel.state.lastPostedText === text) {
+                    return { delivered: true };
+                }
+                // The skeleton still shows the placeholder or a stale partial and we're
+                // about to post the full reply as a fresh message. Best-effort delete the
+                // orphan so the thread doesn't show a duplicate.
+                yield deleteMessage({ botToken, channel: channelId, ts: streamTs });
+                return { delivered: false };
+            });
+        },
+        finalizeEmpty(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
+                yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text: " ",
+                });
+            });
+        },
+        cleanupOrphan(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel }) {
+                var _b;
+                // A skeleton that was never finalized (e.g. an empty turn that produced
+                // no message.completed) would otherwise linger as a "…" placeholder
+                // forever. Best-effort delete it and clear typing.
+                const orphanTs = channel.state.streamTs;
+                if (orphanTs === null || orphanTs === "") {
+                    return;
+                }
+                const orphanChannelId = (_b = channel.state.streamChannelId) !== null && _b !== void 0 ? _b : channel.state.channelId;
+                if (orphanChannelId !== null && orphanChannelId !== "") {
+                    yield deleteMessage({
+                        botToken,
+                        channel: orphanChannelId,
+                        ts: orphanTs,
+                    });
+                }
+                channel.state.streamTs = null;
+                if (channel.state.channelId !== null && channel.state.threadTs !== null) {
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: channel.state.channelId,
+                        threadTs: channel.state.threadTs,
+                        status: "",
+                    });
+                }
+            });
+        },
+        fail(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
+                const updated = yield updateMessage({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    text: errorText,
+                });
+                channel.state.streamTs = null;
+                return { delivered: updated.ok };
+            });
+        },
+    };
+}
+function createStreamStrategy(deps) {
+    const { botToken, getLog } = deps;
+    return {
+        inlineToolSteps: true,
+        start(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, threadTs, sessionId }) {
+                const log = getLog();
+                const started = yield startChatStream({
+                    botToken,
+                    channel: channelId,
+                    thread_ts: threadTs,
+                    markdown_text: "",
+                });
+                if (!started.ok) {
+                    log.warn("chat.startStream unavailable", {
+                        error: started.error,
+                        channel: channelId,
+                        thread_ts: threadTs,
+                        session: sessionId,
+                    });
+                    if (started.unsupported === true) {
+                        channel.state.streamingUnavailable = true;
+                    }
+                    return;
+                }
+                channel.state.streamTs = started.ts;
+                channel.state.streamChannelId = started.channel;
+                channel.state.lastPostedText = "";
+                log.info("chat.startStream ok", {
+                    channel: started.channel,
+                    stream_ts: started.ts,
+                    session: sessionId,
+                });
+            });
+        },
+        append(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
+                if (appendText === "") {
+                    return;
+                }
+                const result = yield appendChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: appendText,
+                });
+                if (!result.ok) {
+                    getLog().warn("appendStream failed", {
+                        error: result.error,
+                        channel: channelId,
+                        stream_ts: streamTs,
+                        session: sessionId,
+                    });
+                    if (result.unsupported === true) {
+                        channel.state.streamingUnavailable = true;
+                    }
+                    return;
+                }
+                channel.state.lastPostedText = text;
+            });
+        },
+        finalize(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, text, sessionId }) {
+                const log = getLog();
+                // Only send the unsent suffix — full text was already appended.
+                const appendText = computeStreamAppend(channel.state.lastPostedText, text);
+                const stopped = yield stopChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: appendText === "" ? undefined : appendText,
+                });
+                if (stopped.ok) {
+                    channel.state.streamTs = null;
+                    channel.state.lastPostedText = text;
+                    log.info("reply delivered via stream", {
+                        channel: channelId,
+                        stream_ts: streamTs,
+                        session: sessionId,
+                        chars: text.length,
+                    });
+                    return { delivered: true };
+                }
+                log.warn("chat.stopStream failed; falling back to postMessage", {
+                    error: stopped.error,
+                    channel: channelId,
+                    stream_ts: streamTs,
+                    session: sessionId,
+                });
+                if (stopped.unsupported === true) {
+                    channel.state.streamingUnavailable = true;
+                }
+                channel.state.streamTs = null;
+                // If we already streamed content, do not post the full reply again.
+                const alreadyStreamed = typeof channel.state.lastPostedText === "string" &&
+                    channel.state.lastPostedText.length > 0;
+                return { delivered: alreadyStreamed };
+            });
+        },
+        finalizeEmpty(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channelId, streamTs }) {
+                yield stopChatStream({ botToken, channel: channelId, ts: streamTs });
+            });
+        },
+        cleanupOrphan() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // The stream path closes its message in message.completed / turn.failed;
+                // there is nothing to clean up after turn.completed.
+            });
+        },
+        fail(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ channel, channelId, streamTs, errorText }) {
+                const stopped = yield stopChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: streamTs,
+                    markdown_text: errorText,
+                });
+                channel.state.streamTs = null;
+                return { delivered: stopped.ok };
+            });
+        },
+    };
+}
+/** Pick the live-reply delivery strategy for a `buildDefaultEvents` instance. */
+export function selectLiveDeliveryStrategy(deps, usePostUpdate) {
+    return usePostUpdate
+        ? createPostUpdateStrategy(deps)
+        : createStreamStrategy(deps);
+}

package/dist/channels/slack/slack-channel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AAuCxB,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC7D,OAAO,GAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,GAAG;IAChD,SAAS,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;CACnC,GACL,iBAAiB,CAAC,iBAAiB,CAAC,CAyTtC"}
+{"version":3,"file":"slack-channel.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/slack-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EACV,iBAAiB,EAMlB,MAAM,gBAAgB,CAAC;AAsCxB,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAC7D,OAAO,GAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,GAAG;IAChD,SAAS,CAAC,EAAE,oBAAoB,CAAC,IAAI,CAAC,CAAC;CACnC,GACL,iBAAiB,CAAC,iBAAiB,CAAC,CAqYtC"}