@cursor/july 0.1.55 → 0.1.61

package/src/internal/server.ts

@@ -17,7 +17,6 @@ import { join } from "node:path";
 import {
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
-  cursorGithubPermissionsForChannel,
   type GithubCursorAccountRuntime,
   getGithubCursorAccountRuntime,
   parseCursorGithubRepoScope,
@@ -25,6 +24,12 @@ import {
   resolveCursorGithubProxyUrl,
 } from "../channels/github/cursor-account.js";
 import { findGitHubChannelTargets } from "../channels/github/forward.js";
+import {
+  getOriginCursorAccountRuntime,
+  type OriginCursorAccountRuntime,
+  parseCursorOriginRepoScope,
+} from "../channels/origin/cursor-account.js";
+import { findOriginChannelTargets } from "../channels/origin/origin-channel.js";
 import {
   dispatchCursorSlackEnvelope,
   getSlackCursorAccountRuntime,
@@ -59,9 +64,11 @@ import {
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
 import {
   CursorEventRelay,
+  type CursorScmSubscription,
   formatCursorScmDispatchOutcome,
   formatCursorScmEventLog,
   scmMetadataToGitHubPayload,
+  scmMetadataToOriginPayload,
 } from "./cursor-event-relay.js";
 import {
   type CursorSlackAgentRegistration,
@@ -89,6 +96,7 @@ import {
 } from "./eval-run-store.js";
 import {
   collectGitHubTriggerTargets,
+  collectOriginTriggerTargets,
   handleAgentServeTrigger,
 } from "./handleAgentServeTrigger.js";
 import { createHostPlatforms, warmupHostGitHubAuth } from "./host-platforms.js";
@@ -151,11 +159,7 @@ import {
 } from "./resolved-connections.js";
 import { Router } from "./router.js";
 import { ScheduleRunner, UnknownScheduleError } from "./schedule-runner.js";
-import {
-  type AgentRunner,
-  CursorSdkRunner,
-  resolveServeWorkspaceScanCacheTtlMs,
-} from "./sdk-runner.js";
+import { type AgentRunner, CursorSdkRunner } from "./sdk-runner.js";
 import {
   SessionAuthError,
   SessionBusyError,
@@ -267,11 +271,20 @@ export async function startServer(
   }
 
   const cursorGithubTargets = collectCursorGithubTargets(mounts);
+  const cursorOriginTargets = collectCursorOriginTargets(mounts);
   const cursorGithubConfig = resolveCursorGithubEventConfig({
     configured: options.cursorEvents,
     targets: cursorGithubTargets,
   });
-  const effectiveCursorEvents = cursorGithubConfig.cursorEvents;
+  const cursorOriginScope = resolveCursorOriginRepoScope({
+    explicitRepos: options.cursorEvents?.repos ?? [],
+    targets: cursorOriginTargets,
+  });
+  const effectiveCursorEvents =
+    cursorGithubConfig.cursorEvents ??
+    (cursorOriginScope === undefined
+      ? undefined
+      : { repos: [...cursorOriginScope.repos] });
 
   // One resolution for every Cursor credential consumer (SDK runner, account
   // MCP bridge, SCM event relay, GitHub credentials): explicit option →
@@ -379,17 +392,11 @@ export async function startServer(
       "[agent-sdk] warning: --allow-anonymous admits every HTTP caller as the same principal; use only on a trusted network (e.g. Tailscale) and prefer --bearer-token for shared hosts"
     );
   }
-  const workspaceScanCacheTtlMs = resolveServeWorkspaceScanCacheTtlMs({
-    dev,
-  });
   const runner =
     options.runner ??
     new CursorSdkRunner({
       ...(accountKey === undefined ? {} : { apiKey: accountKey.apiKey }),
       logger,
-      ...(workspaceScanCacheTtlMs === undefined
-        ? {}
-        : { workspaceScanCacheTtlMs }),
     });
 
   const router = new Router();
@@ -684,7 +691,7 @@ export async function startServer(
   // job (backend `/github_webhook` already verified); we only admit loopback
   // so this route is not a public unsigned endpoint. Agents decide whether
   // to run via their onPullRequest / onComment / … hooks.
-  const collectTriggerTargets = () =>
+  const collectGitHubTargets = () =>
     collectGitHubTriggerTargets({
       mounts: runtimes.map((runtime) => ({
         slug: runtime.slug,
@@ -693,6 +700,15 @@ export async function startServer(
           buildChannelHandlerArgs({ runtime, channelId }),
       })),
     });
+  const collectOriginTargets = () =>
+    collectOriginTriggerTargets({
+      mounts: runtimes.map((runtime) => ({
+        slug: runtime.slug,
+        channels: runtime.project.channels,
+        buildHandlerArgs: (channelId) =>
+          buildChannelHandlerArgs({ runtime, channelId }),
+      })),
+    });
   router.add({
     method: "POST",
     pattern: "/v1/webhooks/github",
@@ -704,7 +720,7 @@ export async function startServer(
         bodyText,
         eventName: request.headers.get("x-github-event"),
         deliveryId: request.headers.get("x-github-delivery") ?? undefined,
-        targets: collectTriggerTargets(),
+        targets: collectGitHubTargets(),
       });
       const status = result.ok ? 202 : (result.targets[0]?.status ?? 500);
       return jsonResponse(result, { status });
@@ -743,13 +759,17 @@ export async function startServer(
   // Cursor SCM events relay (opt-in: serve({ cursorEvents }) / --cursor-events).
   const cursorEventRelay = startCursorEventRelay({
     config: effectiveCursorEvents,
+    githubRepos: cursorGithubConfig.cursorEvents?.repos ?? [],
+    originRepos: cursorOriginScope?.repos ?? [],
     stateRoot: options.stateRoot,
     mounts,
     auth: cursorEventsAuth,
     logger,
-    collectTriggerTargets,
+    collectGitHubTargets,
+    collectOriginTargets,
     cursorAccountOnly:
-      options.cursorEvents === undefined && cursorGithubTargets.length > 0,
+      options.cursorEvents === undefined &&
+      (cursorGithubTargets.length > 0 || cursorOriginTargets.length > 0),
   });
 
   const server = createServer((req, res) => {
@@ -1759,37 +1779,73 @@ function requireCursorEventsAuth(
 /**
  * Opt-in Cursor SCM events relay. Credentials are already required by
  * {@link requireCursorEventsAuth}; the remaining unusable configs (no repos,
- * no github channel) warn and leave the relay off — serve still starts.
+ * no github/origin channel) warn and leave the relay off — serve still starts.
+ *
+ * GitHub and Origin subscriptions are registered independently so mirrored
+ * `owner/name` slugs do not mix. `--cursor-events --repo` feeds GitHub
+ * channels; Origin is subscribed only when an `originChannel({ cursorAccount })`
+ * opted in.
  */
 function startCursorEventRelay(input: {
   config: ServeOptions["cursorEvents"];
+  githubRepos: readonly string[];
+  originRepos: readonly string[];
   stateRoot: string | undefined;
   mounts: AgentMount[];
   auth: CursorEventsAuth | undefined;
   logger: (line: string) => void;
-  collectTriggerTargets: () => ReturnType<typeof collectGitHubTriggerTargets>;
+  collectGitHubTargets: () => ReturnType<typeof collectGitHubTriggerTargets>;
+  collectOriginTargets: () => ReturnType<typeof collectOriginTriggerTargets>;
   cursorAccountOnly: boolean;
 }): CursorEventRelay | undefined {
-  const { config, stateRoot, mounts, auth, logger, collectTriggerTargets } =
-    input;
+  const { config, stateRoot, mounts, auth, logger } = input;
   if (config === undefined || auth === undefined) {
     return undefined;
   }
-  const repos = [...new Set(config.repos.map((repo) => repo.trim()))].filter(
-    (repo) => repo.length > 0
-  );
-  if (repos.length === 0) {
-    logger(
-      "[agent-sdk] cursor-events: no repos configured (pass --repo owner/name); relay disabled"
-    );
-    return undefined;
-  }
   const githubTargets = findGitHubChannelTargets(mounts);
-  const events = [...new Set(githubTargets.flatMap((target) => target.events))];
-  if (events.length === 0) {
-    logger(
-      "[agent-sdk] cursor-events: no mounted agent declares a github channel; relay disabled"
-    );
+  const originTargets = findOriginChannelTargets(mounts);
+  const githubEvents = [
+    ...new Set(githubTargets.flatMap((target) => target.events)),
+  ];
+  const originEvents = [
+    ...new Set(originTargets.flatMap((target) => target.events)),
+  ];
+  const githubRepos = [
+    ...new Set(input.githubRepos.map((repo) => repo.trim().toLowerCase())),
+  ].filter((repo) => repo.length > 0);
+  const originRepos = [
+    ...new Set(input.originRepos.map((repo) => repo.trim().toLowerCase())),
+  ].filter((repo) => repo.length > 0);
+
+  const subscriptions: CursorScmSubscription[] = [];
+  if (githubEvents.length > 0 && githubRepos.length > 0) {
+    for (const repo of githubRepos) {
+      subscriptions.push({
+        provider: "github",
+        repo,
+        events: githubEvents,
+      });
+    }
+  }
+  if (originEvents.length > 0 && originRepos.length > 0) {
+    for (const repo of originRepos) {
+      subscriptions.push({
+        provider: "origin",
+        repo,
+        events: originEvents,
+      });
+    }
+  }
+  if (subscriptions.length === 0) {
+    if (githubRepos.length === 0 && originRepos.length === 0) {
+      logger(
+        "[agent-sdk] cursor-events: no repos configured (pass --repo owner/name); relay disabled"
+      );
+    } else {
+      logger(
+        "[agent-sdk] cursor-events: no mounted agent declares a github or origin channel; relay disabled"
+      );
+    }
     return undefined;
   }
   const baseStateRoot =
@@ -1798,15 +1854,36 @@ function startCursorEventRelay(input: {
   const relay = new CursorEventRelay({
     baseUrl: auth.baseUrl,
     apiKey: auth.apiKey,
-    repos,
-    events,
+    subscriptions,
     stateDir: join(baseStateRoot, "cursor-events"),
     logger,
-    // Stream is compact metadata (Sand-style); stub a GitHub body from the
-    // envelope — rich pullRequest meta when present for onPullRequest Zod.
     dispatch: async (event) => {
+      if (event.provider === "origin") {
+        const targets = input.collectOriginTargets().filter((target) => {
+          const cursorAccount = target.options.cursorAccount;
+          if (
+            input.cursorAccountOnly &&
+            cursorAccount !== true &&
+            typeof cursorAccount !== "object"
+          ) {
+            return false;
+          }
+          return typeof cursorAccount !== "object"
+            ? true
+            : cursorAccount.repos.some(
+                (repo) => repo.toLowerCase() === event.repo.toLowerCase()
+              );
+        });
+        const result = await handleAgentServeTrigger({
+          type: "origin",
+          bodyText: JSON.stringify(scmMetadataToOriginPayload(event)),
+          targets,
+        });
+        logCursorScmDispatch(logger, event, result);
+        return;
+      }
       if (event.provider !== "github") return;
-      const targets = collectTriggerTargets().filter((target) => {
+      const targets = input.collectGitHubTargets().filter((target) => {
         const cursorAccount = target.options.cursorAccount;
         if (
           input.cursorAccountOnly &&
@@ -1828,27 +1905,35 @@ function startCursorEventRelay(input: {
         deliveryId: event.deliveryId,
         targets,
       });
-      const outcomes = result.targets
-        .map((target) => formatCursorScmDispatchOutcome(target))
-        .join(", ");
-      const rejected = result.targets.filter((target) => target.status >= 400);
-      if (rejected.length > 0) {
-        logger(
-          `[agent-sdk] cursor-events: dropped ${formatCursorScmEventLog(event)} before hook: ${rejected.map(formatCursorScmDispatchOutcome).join(", ")}`
-        );
-      }
-      logger(
-        `[agent-sdk] cursor-events: dispatched ${formatCursorScmEventLog(event)}${outcomes === "" ? "" : ` → ${outcomes}`}`
-      );
+      logCursorScmDispatch(logger, event, result);
     },
   });
   relay.start();
   logger(
-    `[agent-sdk] cursor-events: relaying ${events.length} event kind(s) for ${repos.join(", ")} from ${auth.baseUrl}`
+    `[agent-sdk] cursor-events: relaying ${subscriptions.length} subscription(s) from ${auth.baseUrl}`
   );
   return relay;
 }
 
+function logCursorScmDispatch(
+  logger: (line: string) => void,
+  event: Parameters<typeof formatCursorScmEventLog>[0],
+  result: Awaited<ReturnType<typeof handleAgentServeTrigger>>
+): void {
+  const outcomes = result.targets
+    .map((target) => formatCursorScmDispatchOutcome(target))
+    .join(", ");
+  const rejected = result.targets.filter((target) => target.status >= 400);
+  if (rejected.length > 0) {
+    logger(
+      `[agent-sdk] cursor-events: dropped ${formatCursorScmEventLog(event)} before hook: ${rejected.map(formatCursorScmDispatchOutcome).join(", ")}`
+    );
+  }
+  logger(
+    `[agent-sdk] cursor-events: dispatched ${formatCursorScmEventLog(event)}${outcomes === "" ? "" : ` → ${outcomes}`}`
+  );
+}
+
 interface CursorGithubTarget {
   slug: string;
   channelId: string;
@@ -1893,11 +1978,8 @@ function resolveCursorGithubEventConfig(input: {
     ]),
   ];
   const permissions = resolveCursorGithubPermissions(
-    input.targets.map((target) =>
-      cursorGithubPermissionsForChannel(
-        target.accountRuntime.options,
-        target.accountRuntime.scope?.permissions
-      )
+    input.targets.map(
+      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
     )
   );
   const scope = parseCursorGithubRepoScope(repos, permissions);
@@ -1910,6 +1992,54 @@ function resolveCursorGithubEventConfig(input: {
   };
 }
 
+interface CursorOriginTarget {
+  slug: string;
+  channelId: string;
+  accountRuntime: OriginCursorAccountRuntime;
+}
+
+function collectCursorOriginTargets(
+  mounts: AgentMount[]
+): CursorOriginTarget[] {
+  const targets: CursorOriginTarget[] = [];
+  for (const mount of mounts) {
+    for (const channel of mount.project.channels) {
+      const accountRuntime = getOriginCursorAccountRuntime(channel.definition);
+      if (accountRuntime !== undefined) {
+        targets.push({
+          slug: mount.slug,
+          channelId: channel.id,
+          accountRuntime,
+        });
+      }
+    }
+  }
+  return targets;
+}
+
+/**
+ * Origin cursorAccount repos. `true` takes the host's explicit `--repo`
+ * list (not GitHub channel-declared repos). `{ repos }` is self-contained.
+ */
+function resolveCursorOriginRepoScope(input: {
+  explicitRepos: readonly string[];
+  targets: CursorOriginTarget[];
+}): ReturnType<typeof parseCursorOriginRepoScope> | undefined {
+  if (input.targets.length === 0) {
+    return undefined;
+  }
+  const wantsHostRepos = input.targets.some(
+    (target) => target.accountRuntime.options.cursorAccount === true
+  );
+  const repos = [
+    ...(wantsHostRepos ? input.explicitRepos : []),
+    ...input.targets.flatMap(
+      (target) => target.accountRuntime.scope?.repos ?? []
+    ),
+  ];
+  return parseCursorOriginRepoScope(repos);
+}
+
 interface CursorSlackTarget {
   runtime: MountedRuntime;
   channelId: string;

package/src/internal/session-engine.ts

@@ -17,7 +17,6 @@ import {
   resolveABMaxPlaygroundSessions,
   resolveABSplit,
 } from "../ab.js";
-import { slackThreadPermalink } from "../channels/slack/links.js";
 import {
   SlackAskDedupeStore,
   SlackNudgeStore,
@@ -122,6 +121,7 @@ import {
 } from "./prompt-context.js";
 import { assertCloudCanHonorAccountServersFilters } from "./resolved-connections.js";
 import type { AgentRunner } from "./sdk-runner.js";
+import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
 import { StorageCoordinator } from "./storage-coordinator.js";
 import type { FrameworkSessionStore } from "./storage-roles.js";
@@ -2759,12 +2759,12 @@ export class SessionEngine {
     return records
       .filter((record) => includeAll || samePrincipal(record.auth, caller))
       .map((record) => {
-        const externalUrl = externalUrlForSession(record);
+        const links = sessionExternalLinks(record);
         return {
           sessionId: record.sessionId,
           channelId: record.channelId,
           mode: record.mode,
-          ...(record.title === undefined ? {} : { title: record.title }),
+          title: record.title,
           turnCount: record.turnCount,
           running:
             this.activeTurns.has(record.sessionId) ||
@@ -2781,7 +2781,8 @@ export class SessionEngine {
                   record.channelId,
                   record.continuationKey
                 ),
-          ...(externalUrl === undefined ? {} : { externalUrl }),
+          externalUrl: links.slack ?? links.github,
+          prUrl: links.github,
         };
       });
   }
@@ -3643,23 +3644,6 @@ function approvalResolverLabel(auth: AuthContext | null): string | undefined {
   return auth.principalId;
 }
 
-/** Deep link to the external conversation (Slack thread today). */
-function externalUrlForSession(record: SessionRecord): string | undefined {
-  const auth = record.auth;
-  if (auth === null || auth.authenticator !== "slack") {
-    return undefined;
-  }
-  const channelId = auth.attributes?.channel_id ?? "";
-  const threadTs = auth.attributes?.thread_ts ?? "";
-  const teamId = auth.attributes?.team_id;
-  const url = slackThreadPermalink({
-    channelId,
-    threadTs,
-    ...(teamId === undefined ? {} : { teamId }),
-  });
-  return url ?? undefined;
-}
-
 /** Let the HTTP NDJSON writer flush before the next SDK update. */
 function yieldEventLoop(): Promise<void> {
   return new Promise((resolve) => {

package/src/internal/session-links.ts

@@ -0,0 +1,88 @@
+import { parseGitHubPrRef } from "../channels/github/replay.js";
+import { slackThreadPermalink } from "../channels/slack/links.js";
+import { extractGithubPrRef } from "../channels/slack/pr-ref.js";
+import type { AgentCloudOptions, AuthContext } from "../types.js";
+
+export type SessionExternalLinks = {
+  slack: string | undefined;
+  github: string | undefined;
+};
+
+type SessionLinkSource = {
+  auth: AuthContext | null;
+  title?: string;
+  continuationKey: string | null;
+  cloudOverride?: AgentCloudOptions;
+};
+
+const SLACK_TITLE = /^slack:([CGD][A-Z0-9]+):(\d+\.\d+)$/i;
+const SLACK_CONTINUATION = /^([CGD][A-Z0-9]+):(\d+\.\d+)$/i;
+
+export function sessionExternalLinks(
+  record: SessionLinkSource
+): SessionExternalLinks {
+  return {
+    slack: slackUrl(record),
+    github: githubUrl(record),
+  };
+}
+
+function slackUrl(record: SessionLinkSource): string | undefined {
+  const auth = record.auth;
+  if (auth !== null && auth.authenticator === "slack") {
+    const fromAuth = slackThreadPermalink({
+      channelId: auth.attributes?.channel_id ?? "",
+      threadTs: auth.attributes?.thread_ts ?? "",
+      teamId: auth.attributes?.team_id,
+    });
+    if (fromAuth !== null) {
+      return fromAuth;
+    }
+  }
+  const fromTitle = (record.title ?? "").trim().match(SLACK_TITLE);
+  if (fromTitle !== null) {
+    return (
+      slackThreadPermalink({
+        channelId: fromTitle[1] as string,
+        threadTs: fromTitle[2] as string,
+      }) ?? undefined
+    );
+  }
+  const fromKey = (record.continuationKey ?? "")
+    .trim()
+    .match(SLACK_CONTINUATION);
+  if (fromKey === null) {
+    return undefined;
+  }
+  return (
+    slackThreadPermalink({
+      channelId: fromKey[1] as string,
+      threadTs: fromKey[2] as string,
+    }) ?? undefined
+  );
+}
+
+function githubUrl(record: SessionLinkSource): string | undefined {
+  const fromTitle = extractGithubPrRef(record.title ?? "");
+  if (fromTitle !== undefined) {
+    return fromTitle.url;
+  }
+  const key = record.continuationKey ?? "";
+  if (key.startsWith("github-pr:")) {
+    return parseGitHubPrRef(key.slice("github-pr:".length))?.url;
+  }
+  const repos = record.cloudOverride?.repos;
+  if (repos === undefined) {
+    return undefined;
+  }
+  for (const repo of repos) {
+    if (repo.prUrl === undefined) {
+      continue;
+    }
+    const parsed = parseGitHubPrRef(repo.prUrl);
+    if (parsed !== undefined) {
+      return parsed.url;
+    }
+  }
+  return undefined;
+}

package/src/internal/sessions-client.ts

@@ -171,6 +171,7 @@ function parseSessionSummary(value: unknown): SessionSummary | undefined {
     continuationToken,
     externalUrl:
       typeof row.externalUrl === "string" ? row.externalUrl : undefined,
+    prUrl: typeof row.prUrl === "string" ? row.prUrl : undefined,
   };
 }
 

package/src/types.ts

@@ -254,15 +254,14 @@ export interface AgentConfig {
  * - `"resident"` (default): the in-process session engine owns delivery —
  *   today's behavior, unchanged.
  * - `"ledger"`: every delivery coordinates through the KV session ledger
- *   before its turn runs: the event parks durably in the session mailbox
- *   (the source ack point moves after that write), a one-writer-per-session
- *   lease with generation fencing serializes turns, and drained batches
- *   commit through a fenced sequence. A delivery that finds the lease
- *   held walks away; the holder drains the parked event, and the janitor
- *   recovers sessions whose holder died. Requires a store with
- *   conditional writes and prefix listing (the `cas` group on
+ *   before its turn runs: session identity, a one-writer-per-session
+ *   lease with generation fencing, and a fenced commit sequence.
+ *   Requires a store with conditional writes (the `cas` group on
  *   `defineStorage`, or an explicit CAS-capable override); startup fails
- *   fast otherwise.
+ *   fast otherwise. This stage is coordination only — there is no
+ *   durable inbox yet, so an event arriving while the lease is held
+ *   waits in-process and a crash loses it exactly as resident serving
+ *   does. The durable mailbox lands in a follow-up.
  */
 export type AgentServingMode = "resident" | "ledger";
 
@@ -1448,11 +1447,11 @@ export interface SessionSummary {
   /** `<channelId>:<key>` wire token, or null when not addressable. */
   continuationToken: string | null;
   /**
-   * Optional deep link to the external conversation (e.g. Slack thread).
-   * Populated for channel-driven sessions when the principal carries enough
-   * attributes to build a permalink.
+   * Conversation permalink (Slack thread, else GitHub PR).
    */
   externalUrl?: string;
+  /** GitHub PR when the session is about one. */
+  prUrl?: string;
 }
 
 /**
@@ -1907,6 +1906,11 @@ export interface ChannelMeta {
    * to dispatch on. Used to derive `gh webhook forward --events`.
    */
   githubWebhookEvents?: readonly string[];
+  /**
+   * For Origin webhook packs: the Origin event types this channel is wired
+   * to dispatch on. Used by `--cursor-events` to subscribe `provider: "origin"`.
+   */
+  originWebhookEvents?: readonly string[];
   /**
    * For Slack packs with the opt-in channel watch: the allowlisted channels
    * (ids or `#names`) this channel dispatches on without a mention. Surfaced
@@ -2549,6 +2553,8 @@ export interface AgentProjectInfo {
     kind?: string;
     /** GitHub webhook events the channel dispatches on, when declared. */
     githubWebhookEvents?: readonly string[];
+    /** Origin webhook event types the channel dispatches on, when declared. */
+    originWebhookEvents?: readonly string[];
     /** Slack channels watched for posts (opt-in channel watch), when declared. */
     slackChannelPosts?: readonly string[];
   }>;
@@ -2746,7 +2752,8 @@ export interface ServeOptions {
    */
   cloudToolsUrl?: string;
   /**
-   * Pull GitHub webhook metadata from `/v0/scm-events` (Cursor account auth).
+   * Pull SCM webhook metadata from `/v0/scm-events` (Cursor account auth).
+   * GitHub and Origin subscriptions are registered independently.
    * The stream is read as the host's Cursor user, so this requires a signed-in
    * host: `serve` throws when no key resolves from `apiKey` here,
    * {@link ServeOptions.apiKey}, `CURSOR_API_KEY`, or `agent-serve login`.