@cursor/july 0.1.74 → 0.1.76

package/src/internal/server.ts

@@ -14,6 +14,11 @@ import {
 } from "node:http";
 import type { AddressInfo } from "node:net";
 import { join } from "node:path";
+import {
+  dispatchDeploymentEvent,
+  getDeploymentsChannelOptions,
+} from "../channels/deployments/deployments-channel.js";
+import type { DeploymentsChannelOptions } from "../channels/deployments/types.js";
 import {
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
@@ -62,6 +67,12 @@ import {
   SIGN_IN_HINT,
 } from "./cursor/credentials.js";
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
+import {
+  DeploymentEventRelay,
+  fanOutDeploymentEvent,
+  type ResolvedSubscription,
+  resolveDeploymentSubscriptions,
+} from "./cursor-deployment-relay.js";
 import {
   CursorEventRelay,
   type CursorScmSubscription,
@@ -774,6 +785,15 @@ export async function startServer(
       (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)
@@ -793,6 +813,7 @@ export async function startServer(
       logger,
     });
   } catch (error) {
+    await cursorDeploymentRelay?.stop();
     await cursorEventRelay?.stop();
     await cursorSlackRelay?.stop();
     cursorGithubCredentials?.stop();
@@ -953,6 +974,7 @@ export async function startServer(
     },
     close: async () => {
       playgroundDev?.stop();
+      await cursorDeploymentRelay?.stop();
       await cursorEventRelay?.stop();
       await cursorSlackRelay?.stop();
       for (const runtime of runtimes) {
@@ -2170,6 +2192,133 @@ function collectCursorSlackTargets(
  * the pack's normal inbound path. Requires a signed-in host — fail serve
  * fast rather than mounting channels that can never hear or speak.
  */
+interface CursorDeploymentTarget {
+  runtime: MountedRuntime;
+  channelId: string;
+  options: DeploymentsChannelOptions;
+  subscriptions: ResolvedSubscription[];
+}
+
+/** Every mounted `deploymentsChannel`, with its resolved subscriptions. */
+function collectCursorDeploymentTargets(
+  runtimes: MountedRuntime[],
+  skipped: string[]
+): CursorDeploymentTarget[] {
+  const targets: CursorDeploymentTarget[] = [];
+  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;
+}
+
+/**
+ * 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: {
+  options: ServeOptions;
+  runtimes: MountedRuntime[];
+  accountKey: ResolvedApiKey | undefined;
+  logger: (line: string) => void;
+}): DeploymentEventRelay | undefined {
+  const { options, runtimes, accountKey, logger } = input;
+  const skipped: string[] = [];
+  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<string, ResolvedSubscription>();
+  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 =
+    options.stateRoot ??
+    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: async (event) =>
+      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;
+}
+
 async function startCursorSlackRelay(input: {
   options: ServeOptions;
   runtimes: MountedRuntime[];