@cursor/july 0.1.74 → 0.1.76

package/dist/internal/review-comments.js

@@ -32,9 +32,55 @@ export function createReviewCommentReader(args) {
                 : createHostGithubReviewCommentReader(args.github);
     }
 }
+/**
+ * Resolver for a resolved target. Returns undefined when the host cannot
+ * serve that provider, so callers degrade instead of throwing.
+ */
+export function createReviewThreadResolver(args) {
+    switch (args.target.provider) {
+        case "github":
+            return args.github === undefined
+                ? undefined
+                : createHostGithubReviewThreadResolver(args.github);
+    }
+}
+/**
+ * Resolve the review threads that own `commentIds` on `prUrl`.
+ *
+ * No-ops (never throws) when the PR is on an SCM this host cannot write,
+ * no client is bound, or `commentIds` is empty. Same degrade-don't-fail
+ * posture as {@link createReviewCommentReader}.
+ */
+export function resolveReviewThreadsForComments(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (args.commentIds.length === 0) {
+            return skippedResolve("no comments to resolve");
+        }
+        const target = resolveScmReviewTarget(args.prUrl);
+        if (target === undefined) {
+            return skippedResolve("no SCM resolver for this PR URL");
+        }
+        const resolver = (_a = args.resolver) !== null && _a !== void 0 ? _a : createReviewThreadResolver({
+            target,
+            github: args.github,
+        });
+        if (resolver === undefined) {
+            return skippedResolve("no GitHub client bound to resolve threads");
+        }
+        return resolver.resolveReviewThreadsForComments({
+            target,
+            commentIds: args.commentIds,
+            signal: args.signal,
+        });
+    });
+}
 /** Cap on pages pulled per PR; GitHub serves 100 comments per page. */
 const REVIEW_COMMENTS_MAX_PAGES = 5;
 const REVIEW_COMMENTS_PAGE_SIZE = 100;
+/** Cap on review-thread pages when mapping comment ids to GraphQL thread ids. */
+const REVIEW_THREADS_MAX_PAGES = 20;
+const REVIEW_THREADS_PAGE_SIZE = 100;
 /**
  * Reads inline review comments through the host GitHub client (Cursor
  * account lease, App installation token, or PAT).
@@ -72,6 +118,149 @@ export function createHostGithubReviewCommentReader(github) {
         },
     };
 }
+/**
+ * Resolves inline review threads through the host GitHub client (Cursor
+ * account lease, App installation token, or PAT). GitHub GraphQL has no
+ * comment→thread field, so this pages the PR's review threads and matches
+ * each REST comment id by `databaseId` — the same approach as Bugbot's
+ * `resolveReviewThreadForComment`.
+ */
+export function createHostGithubReviewThreadResolver(github) {
+    return {
+        resolveReviewThreadsForComments(_a) {
+            return __awaiter(this, arguments, void 0, function* ({ target, commentIds, signal }) {
+                var _b, _c, _d, _e, _f;
+                var _g, _h;
+                const uniqueIds = [...new Set(commentIds.filter((id) => id > 0))];
+                if (uniqueIds.length === 0) {
+                    return skippedResolve("no comments to resolve");
+                }
+                const [owner, repo] = target.repo.split("/", 2);
+                if (owner === undefined || repo === undefined || repo === "") {
+                    return skippedResolve("unparseable owner/repo from PR URL");
+                }
+                try {
+                    const octokit = yield github.getOctokit();
+                    const wanted = new Set(uniqueIds);
+                    const matched = new Map();
+                    let cursor = null;
+                    for (let page = 0; page < REVIEW_THREADS_MAX_PAGES; page++) {
+                        signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
+                        const response = (yield octokit.graphql(REVIEW_THREADS_FOR_PR_QUERY, {
+                            owner,
+                            repo,
+                            number: target.prNumber,
+                            cursor,
+                        }));
+                        const reviewThreads = (_c = (_b = response.repository) === null || _b === void 0 ? void 0 : _b.pullRequest) === null || _c === void 0 ? void 0 : _c.reviewThreads;
+                        for (const thread of (_g = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.nodes) !== null && _g !== void 0 ? _g : []) {
+                            if ((thread === null || thread === void 0 ? void 0 : thread.id) === undefined || thread.id === "") {
+                                continue;
+                            }
+                            for (const comment of (_h = (_d = thread.comments) === null || _d === void 0 ? void 0 : _d.nodes) !== null && _h !== void 0 ? _h : []) {
+                                const databaseId = comment === null || comment === void 0 ? void 0 : comment.databaseId;
+                                if (databaseId !== undefined &&
+                                    databaseId !== null &&
+                                    wanted.has(databaseId) &&
+                                    !matched.has(databaseId)) {
+                                    matched.set(databaseId, {
+                                        threadId: thread.id,
+                                        isResolved: thread.isResolved === true,
+                                    });
+                                }
+                            }
+                        }
+                        if (matched.size === wanted.size) {
+                            break;
+                        }
+                        const pageInfo = reviewThreads === null || reviewThreads === void 0 ? void 0 : reviewThreads.pageInfo;
+                        if ((pageInfo === null || pageInfo === void 0 ? void 0 : pageInfo.hasNextPage) !== true || !pageInfo.endCursor) {
+                            break;
+                        }
+                        cursor = pageInfo.endCursor;
+                    }
+                    const toResolve = [
+                        ...new Map([...matched.values()]
+                            .filter((thread) => !thread.isResolved)
+                            .map((thread) => [thread.threadId, thread.threadId])).values(),
+                    ];
+                    let resolved = 0;
+                    let failed = 0;
+                    for (const threadId of toResolve) {
+                        signal === null || signal === void 0 ? void 0 : signal.throwIfAborted();
+                        try {
+                            const mutation = (yield octokit.graphql(RESOLVE_REVIEW_THREAD_MUTATION, { threadId }));
+                            if (((_f = (_e = mutation.resolveReviewThread) === null || _e === void 0 ? void 0 : _e.thread) === null || _f === void 0 ? void 0 : _f.isResolved) === true) {
+                                resolved += 1;
+                            }
+                            else {
+                                failed += 1;
+                            }
+                        }
+                        catch (_j) {
+                            failed += 1;
+                        }
+                    }
+                    const alreadyResolved = new Set([...matched.values()]
+                        .filter((thread) => thread.isResolved)
+                        .map((thread) => thread.threadId)).size;
+                    const notFound = wanted.size - matched.size;
+                    return {
+                        requested: uniqueIds.length,
+                        resolved,
+                        alreadyResolved,
+                        notFound,
+                        failed,
+                        detail: `resolved ${resolved} of ${toResolve.length} open thread(s) for ${uniqueIds.length} comment(s) via host GitHub (${alreadyResolved} already resolved, ${notFound} not found, ${failed} failed)`,
+                    };
+                }
+                catch (error) {
+                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                        throw error;
+                    }
+                    return {
+                        requested: uniqueIds.length,
+                        resolved: 0,
+                        alreadyResolved: 0,
+                        notFound: 0,
+                        failed: uniqueIds.length,
+                        detail: `host GitHub thread resolve failed: ${error instanceof Error ? error.message : String(error)}`,
+                    };
+                }
+            });
+        },
+    };
+}
+const REVIEW_THREADS_FOR_PR_QUERY = `
+query ReviewThreadsForPr(
+  $owner: String!
+  $repo: String!
+  $number: Int!
+  $cursor: String
+) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: ${REVIEW_THREADS_PAGE_SIZE}, after: $cursor) {
+        nodes {
+          id
+          isResolved
+          comments(first: ${REVIEW_THREADS_PAGE_SIZE}) {
+            nodes { databaseId }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+      }
+    }
+  }
+}
+`;
+const RESOLVE_REVIEW_THREAD_MUTATION = `
+mutation ResolveReviewThread($threadId: ID!) {
+  resolveReviewThread(input: { threadId: $threadId }) {
+    thread { isResolved }
+  }
+}
+`;
 /**
  * GitHub review comment → {@link ExistingReviewComment}.
  *
@@ -334,6 +523,16 @@ function skippedHost(detail) {
         detail,
     };
 }
+function skippedResolve(detail) {
+    return {
+        requested: 0,
+        resolved: 0,
+        alreadyResolved: 0,
+        notFound: 0,
+        failed: 0,
+        detail,
+    };
+}
 function parseGithubPrUrl(prUrl) {
     let url;
     try {

package/dist/internal/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/internal/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkCH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAOhB,YAAY,EACb,MAAM,aAAa,CAAC;AAkHrB,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAwBpE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;CACvB;AAaD,6EAA6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,oEAAoE;IACpE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,GAAE,YAAY,GAAG,0BAA+B,GACtD,OAAO,CAAC,gBAAgB,CAAC,CAywB3B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/internal/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuCH,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAOhB,YAAY,EACb,MAAM,aAAa,CAAC;AAwHrB,OAAO,EAAE,KAAK,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAwBpE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,YAAY,CAAC;CACvB;AAaD,6EAA6E;AAC7E,MAAM,WAAW,0BAA0B;IACzC,oEAAoE;IACpE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,UAAU,EAAE,EACpB,OAAO,GAAE,YAAY,GAAG,0BAA+B,GACtD,OAAO,CAAC,gBAAgB,CAAC,CAoxB3B"}

package/dist/internal/server.js

@@ -35,6 +35,7 @@ import { Buffer } from "node:buffer";
 import { once } from "node:events";
 import { createServer, } from "node:http";
 import { join } from "node:path";
+import { dispatchDeploymentEvent, getDeploymentsChannelOptions, } from "../channels/deployments/deployments-channel.js";
 import { createCursorAccountGithubTokenResolver, getGithubCursorAccountRuntime, parseCursorGithubRepoScope, resolveCursorGithubPermissions, resolveCursorGithubProxyUrl, } from "../channels/github/cursor-account.js";
 import { findGitHubChannelTargets } from "../channels/github/forward.js";
 import { getOriginCursorAccountRuntime, parseCursorOriginRepoScope, } from "../channels/origin/cursor-account.js";
@@ -46,6 +47,7 @@ import { CursorAccountMcpBridge, collectCursorAccountConnections, cursorAccountM
 import { CursorBackendClient } from "./cursor/backend-client.js";
 import { cursorExternalApiUrl, resolveApiKey, SIGN_IN_HINT, } from "./cursor/credentials.js";
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
+import { DeploymentEventRelay, fanOutDeploymentEvent, resolveDeploymentSubscriptions, } from "./cursor-deployment-relay.js";
 import { CursorEventRelay, formatCursorScmDispatchOutcome, formatCursorScmEventLog, scmEventToGitHubPayload, scmMetadataToOriginPayload, } from "./cursor-event-relay.js";
 import { AGENT_SERVE_GENERATION_ENV_VAR } from "./cursor-relay-core.js";
 import { CursorSlackRelay, createCursorSlackApiCaller, formatCursorSlackEventLog, } from "./cursor-slack-relay.js";
@@ -536,6 +538,14 @@ export function startServer(mounts_1) {
             cursorAccountOnly: options.cursorEvents === undefined &&
                 (cursorGithubTargets.length > 0 || cursorOriginTargets.length > 0),
         });
+        // Cursor deployment-events relay: automatic when a mounted agent authored
+        // `deploymentsChannel({ ... })`.
+        const cursorDeploymentRelay = startCursorDeploymentRelay({
+            options,
+            runtimes,
+            accountKey,
+            logger,
+        });
         const server = createServer((req, res) => {
             void instrumentHttp(otelRuntime, req, res, () => handleRequest(router, req, res, logger));
         });
@@ -553,6 +563,7 @@ export function startServer(mounts_1) {
             });
         }
         catch (error) {
+            yield cursorDeploymentRelay === null || cursorDeploymentRelay === void 0 ? void 0 : cursorDeploymentRelay.stop();
             yield cursorEventRelay === null || cursorEventRelay === void 0 ? void 0 : cursorEventRelay.stop();
             yield cursorSlackRelay === null || cursorSlackRelay === void 0 ? void 0 : cursorSlackRelay.stop();
             cursorGithubCredentials === null || cursorGithubCredentials === void 0 ? void 0 : cursorGithubCredentials.stop();
@@ -703,6 +714,7 @@ export function startServer(mounts_1) {
                 var _a;
                 var _b;
                 playgroundDev === null || playgroundDev === void 0 ? void 0 : playgroundDev.stop();
+                yield cursorDeploymentRelay === null || cursorDeploymentRelay === void 0 ? void 0 : cursorDeploymentRelay.stop();
                 yield cursorEventRelay === null || cursorEventRelay === void 0 ? void 0 : cursorEventRelay.stop();
                 yield cursorSlackRelay === null || cursorSlackRelay === void 0 ? void 0 : cursorSlackRelay.stop();
                 for (const runtime of runtimes) {
@@ -1660,13 +1672,110 @@ function collectCursorSlackTargets(runtimes) {
     }
     return targets;
 }
+/** Every mounted `deploymentsChannel`, with its resolved subscriptions. */
+function collectCursorDeploymentTargets(runtimes, skipped) {
+    const targets = [];
+    for (const runtime of runtimes) {
+        for (const channel of runtime.project.channels) {
+            const options = getDeploymentsChannelOptions(channel.definition);
+            if (options === undefined) {
+                continue;
+            }
+            const subscriptions = resolveDeploymentSubscriptions(options);
+            if (subscriptions.length === 0) {
+                // Declared the channel but named no repositories — usually an unset
+                // env var. Say so rather than starting a relay that receives nothing.
+                skipped.push(`${runtime.slug || runtime.project.name}/${channel.id}`);
+                continue;
+            }
+            targets.push({ runtime, channelId: channel.id, options, subscriptions });
+        }
+    }
+    return targets;
+}
 /**
- * Automatic Cursor Slack relay for cursor-account Slack channels: registers
- * the mounted agents with `/v0/slack-events`, binds each channel's outbound
- * API transport to the backend proxy, and dispatches relayed envelopes into
- * the pack's normal inbound path. Requires a signed-in host — fail serve
- * fast rather than mounting channels that can never hear or speak.
+ * Cursor deployment-events relay: automatic when a mounted agent authored
+ * `deploymentsChannel({ ... })`. One relay per process reads
+ * `/v0/deployment-events` for the union of every channel's repositories, and
+ * each event is routed to the channels that asked for it — the same ownership
+ * `startCursorSlackRelay` and `startCursorEventRelay` have.
  */
+function startCursorDeploymentRelay(input) {
+    var _a;
+    const { options, runtimes, accountKey, logger } = input;
+    const skipped = [];
+    const targets = collectCursorDeploymentTargets(runtimes, skipped);
+    if (skipped.length > 0) {
+        logger(`[agent-sdk] deployment-events: no repositories declared on ${skipped.join(", ")}; those channels receive nothing`);
+    }
+    if (targets.length === 0) {
+        return undefined;
+    }
+    if (accountKey === undefined) {
+        throw new Error(`This project has channels subscribed to deployment events (deploymentsChannel({ repos })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`);
+    }
+    // Union across channels: one registration per repo for the whole process,
+    // however many channels named it. Per-channel environment and event-type
+    // filtering happens at dispatch.
+    const byRepo = new Map();
+    for (const target of targets) {
+        for (const subscription of target.subscriptions) {
+            const existing = byRepo.get(subscription.repo);
+            if (existing === undefined) {
+                byRepo.set(subscription.repo, {
+                    repo: subscription.repo,
+                    environments: [...subscription.environments],
+                    events: new Set(subscription.events),
+                });
+                continue;
+            }
+            for (const event of subscription.events)
+                existing.events.add(event);
+            // An empty environment list means "every environment", so it absorbs.
+            existing.environments =
+                existing.environments.length === 0 ||
+                    subscription.environments.length === 0
+                    ? []
+                    : [
+                        ...new Set([
+                            ...existing.environments,
+                            ...subscription.environments,
+                        ]),
+                    ];
+        }
+    }
+    // Same host split as scm-events and slack-events: `/v0/deployment-events/*`
+    // is on api.cursor.com, not api2.
+    const baseStateRoot = (_a = options.stateRoot) !== null && _a !== void 0 ? _a : join(targets[0].runtime.project.rootDir, ".agent-serve");
+    const relay = new DeploymentEventRelay({
+        baseUrl: cursorExternalApiUrl(),
+        apiKey: accountKey.apiKey,
+        stateDir: join(baseStateRoot, "deployment-events"),
+        subscriptions: [...byRepo.values()],
+        logger,
+        dispatch: (event) => __awaiter(this, void 0, void 0, function* () {
+            return fanOutDeploymentEvent({
+                event,
+                logger,
+                targets: targets.map((target) => ({
+                    name: `${target.runtime.slug || target.runtime.project.name}/${target.channelId}`,
+                    subscriptions: target.subscriptions,
+                    deliver: (delivered) => dispatchDeploymentEvent({
+                        options: target.options,
+                        event: delivered,
+                        args: buildChannelHandlerArgs({
+                            runtime: target.runtime,
+                            channelId: target.channelId,
+                        }),
+                    }),
+                })),
+            });
+        }),
+    });
+    relay.start();
+    logger(`[agent-sdk] deployment-events: relaying ${byRepo.size} repository subscription(s) to ${targets.length} channel(s)`);
+    return relay;
+}
 function startCursorSlackRelay(input) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;