@cursor/july 0.1.74 → 0.1.75

package/dist/internal/cursor-deployment-relay.js

@@ -0,0 +1,201 @@
+/**
+ * Pull relay for `/v0/deployment-events`.
+ *
+ * A {@link RelayAdapter} over {@link CursorRelayCore} — the same engine the
+ * GitHub SCM and Slack relays use, so registration heartbeats, durable
+ * offsets, backoff, and bounded dispatch retry are inherited rather than
+ * reimplemented. Only the subscribe/poll paths, the registration body, and
+ * the per-event filter differ.
+ */
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { CursorRelayCore } from "./cursor-relay-core.js";
+const DEFAULT_EVENTS = ["deployment.succeeded"];
+/** Normalize the channel's `repos` option into concrete subscriptions. */
+export function resolveDeploymentSubscriptions(options) {
+    var _a, _b, _c, _d;
+    const byRepo = new Map();
+    for (const entry of options.repos) {
+        const subscription = typeof entry === "string" ? { repo: entry } : entry;
+        // Case-folded only: `Deployment.repository` has no documented format, and
+        // the server keys subscriptions the same way.
+        const repo = subscription.repo.trim().toLowerCase();
+        if (repo === "") {
+            throw new Error(`deploymentsChannel: invalid repo "${subscription.repo}".`);
+        }
+        const environments = [
+            ...new Set(((_b = (_a = subscription.environments) !== null && _a !== void 0 ? _a : options.environments) !== null && _b !== void 0 ? _b : [])
+                .map((value) => value.trim())
+                .filter(Boolean)),
+        ];
+        const events = new Set((_d = (_c = subscription.events) !== null && _c !== void 0 ? _c : options.events) !== null && _d !== void 0 ? _d : DEFAULT_EVENTS);
+        if (events.size === 0) {
+            throw new Error(`deploymentsChannel: repo "${repo}" subscribes to no events.`);
+        }
+        // Later entries for the same repo widen the earlier one rather than
+        // silently replacing it.
+        const existing = byRepo.get(repo);
+        if (existing === undefined) {
+            byRepo.set(repo, { repo, environments, events });
+            continue;
+        }
+        for (const event of events)
+            existing.events.add(event);
+        existing.environments =
+            existing.environments.length === 0 || environments.length === 0
+                ? []
+                : [...new Set([...existing.environments, ...environments])];
+    }
+    // Empty is legal here and means "this channel wants nothing", which is how
+    // an env-configured channel stays inert without a repo list. The wire-level
+    // empty list means deregister, so the host simply never registers it.
+    return [...byRepo.values()];
+}
+/** Whether one confirmed subscription wants this event. */
+export function deploymentEventMatches(subscription, envelope) {
+    if (!subscription.events.has(envelope.eventType)) {
+        return false;
+    }
+    return (subscription.environments.length === 0 ||
+        subscription.environments.includes(envelope.environment));
+}
+/**
+ * Deliver one event to every channel subscribed to it.
+ *
+ * Each channel is delivered independently: one channel's handler throwing
+ * must not skip the channels after it, because the relay core retries the
+ * whole dispatch and the channels that already ran would see the event twice.
+ * Throws only when every subscribed channel failed, so a retry cannot
+ * re-deliver to a channel that succeeded.
+ */
+export function fanOutDeploymentEvent(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { event, logger } = input;
+        const matched = input.targets.filter((target) => target.subscriptions.some((subscription) => subscription.repo === event.repo &&
+            deploymentEventMatches(subscription, event)));
+        const failures = [];
+        for (const target of matched) {
+            try {
+                yield target.deliver(event);
+            }
+            catch (error) {
+                failures.push(target.name);
+                logger(`[agent-sdk] deployment-events: ${target.name} failed on ${event.eventId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        logger(`[agent-sdk] deployment-events: ${event.eventType} ${event.repo}@${event.sha} (${event.environment}) → ${matched.length - failures.length}/${matched.length} channel(s)`);
+        if (failures.length > 0 && failures.length === matched.length) {
+            throw new Error(`deployment-events: every subscribed channel failed on ${event.eventId} (${failures.join(", ")})`);
+        }
+    });
+}
+export class DeploymentEventRelay {
+    constructor(options) {
+        this.options = options;
+        this.subscribed = new Map();
+        this.loggedSkippedRepos = new Set();
+        const adapter = {
+            logPrefix: "deployment-events",
+            subscribePath: "/v0/deployment-events/subscriptions",
+            pollPath: "/v0/deployment-events",
+            buildRegistrationBody: (consumerId) => ({
+                consumerId,
+                subscriptions: options.subscriptions.map((subscription) => ({
+                    repo: subscription.repo,
+                    environments: subscription.environments,
+                    events: [...subscription.events],
+                })),
+            }),
+            // Empty subscriptions drop this consumer's registration on clean stop
+            // instead of leaving it to lapse by TTL.
+            buildDeregistrationBody: (consumerId) => ({
+                consumerId,
+                subscriptions: [],
+            }),
+            applyRegistrationResponse: (json) => {
+                var _a, _b;
+                const result = json;
+                this.subscribed = new Map();
+                this.loggedSkippedRepos.clear();
+                const lines = [];
+                const confirmed = [];
+                for (const status of (_a = result.repos) !== null && _a !== void 0 ? _a : []) {
+                    const wanted = options.subscriptions.find((subscription) => subscription.repo === status.repo);
+                    if (!status.isSubscribed || wanted === undefined) {
+                        lines.push(`not subscribed to ${status.repo}: ${(_b = status.detail) !== null && _b !== void 0 ? _b : "unknown reason"}`);
+                        continue;
+                    }
+                    this.subscribed.set(status.repo, wanted);
+                    confirmed.push(status.repo);
+                }
+                if (confirmed.length > 0) {
+                    const kinds = [
+                        ...new Set(options.subscriptions.flatMap((s) => [...s.events])),
+                    ];
+                    lines.push(`subscribed to ${confirmed.join(", ")} for events: ${kinds.join(", ")}`);
+                }
+                return lines;
+            },
+            shouldDispatch: (event) => this.shouldDispatch(event),
+            dispatch: (_a) => {
+                var { offset: _offset } = _a, envelope = __rest(_a, ["offset"]);
+                return options.dispatch(envelope);
+            },
+        };
+        this.core = new CursorRelayCore(Object.assign(Object.assign({ baseUrl: options.baseUrl, apiKey: options.apiKey, stateDir: options.stateDir, adapter, logger: options.logger }, (options.fetchImpl === undefined
+            ? {}
+            : { fetchImpl: options.fetchImpl })), (options.pollWaitMs === undefined
+            ? {}
+            : { pollWaitMs: options.pollWaitMs })));
+    }
+    /**
+     * Whether an event from this principal's stream belongs to THIS relay.
+     * The stream is per-principal, and one API key can back several relays
+     * (other hosts, or an agent running its own alongside the host's), so each
+     * one re-checks the events against the subscriptions the server confirmed
+     * for it.
+     */
+    shouldDispatch(event) {
+        const envelope = event;
+        if (envelope === null ||
+            typeof envelope !== "object" ||
+            typeof envelope.repo !== "string") {
+            return false;
+        }
+        const subscription = this.subscribed.get(envelope.repo);
+        if (subscription === undefined) {
+            if (!this.loggedSkippedRepos.has(envelope.repo)) {
+                this.loggedSkippedRepos.add(envelope.repo);
+                this.options.logger(`[agent-sdk] deployment-events: skipping events for ${envelope.repo}: not in this host's subscription (another consumer of this API key likely subscribed it)`);
+            }
+            return false;
+        }
+        return deploymentEventMatches(subscription, envelope);
+    }
+    start() {
+        this.core.start();
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.core.stop();
+        });
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"distribution.d.ts","sourceRoot":"","sources":["../../src/internal/distribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,sEAAsE;AACtE,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,WAAW,cAAc,CAAC;AACvC,eAAO,MAAM,UAAU,EAAE,MAA2B,CAAC;AACrD,eAAO,MAAM,gBAAgB,EAAE,MAAiC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAA+B,CAAC;AAc/D;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,kEAAkE;AAClE,wBAAgB,cAAc,IAAI,MAAM,CAOvC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAC/C,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CA2BzC,CAAC"}
+{"version":3,"file":"distribution.d.ts","sourceRoot":"","sources":["../../src/internal/distribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,sEAAsE;AACtE,eAAO,MAAM,YAAY,iBAAiB,CAAC;AAE3C,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,WAAW,cAAc,CAAC;AACvC,eAAO,MAAM,UAAU,EAAE,MAA2B,CAAC;AACrD,eAAO,MAAM,gBAAgB,EAAE,MAAiC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAA+B,CAAC;AAc/D;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,kEAAkE;AAClE,wBAAgB,cAAc,IAAI,MAAM,CAOvC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAC/C,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CA4BzC,CAAC"}

package/dist/internal/distribution.js

@@ -81,6 +81,7 @@ export const AUTHORING_ENTRY_FILES = [
     ["channels/slack", "channels/slack/index.js"],
     ["channels/github", "channels/github/index.js"],
     ["channels/origin", "channels/origin/index.js"],
+    ["channels/deployments", "channels/deployments/index.js"],
     ["skills", "skills.js"],
     ["schedules", "schedules.js"],
     ["reminders", "reminders.js"],

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;