@cursor/july 0.1.55 → 0.1.61

package/src/internal/cli-ax.ts

@@ -40,6 +40,7 @@ import {
   snapshotToEvalRunResults,
   startRemoteEvalRun,
 } from "./evals-client.js";
+import { runTemplateInit, type TemplateInitSpec } from "./init-interview.js";
 import {
   checkInitTarget,
   formatInitNextSteps,
@@ -134,6 +135,8 @@ export interface AxCliOptions {
   /** Scaffold target directory for `init`. */
   initTarget?: string;
   template?: string;
+  /** `init --var id=value` (repeatable). */
+  vars?: string[];
   /** Tool name for `call`. */
   toolName?: string;
   /** JSON input for `call`. */
@@ -311,11 +314,31 @@ export async function cmdInit(options: AxCliOptions): Promise<number> {
     process.stderr.write(`${targetCheck.message}\n`);
     return 1;
   }
+  let answers: Record<string, string> | undefined;
+  let initSpec: TemplateInitSpec | undefined;
+  if (templateDir !== undefined) {
+    const interview = await runTemplateInit({
+      templateDir,
+      vars: options.vars,
+      interactive:
+        options.json !== true &&
+        process.stdin.isTTY === true &&
+        process.stdout.isTTY === true,
+    });
+    if (!interview.ok) {
+      process.stderr.write(`${interview.error}\n`);
+      return 1;
+    }
+    answers = interview.answers;
+    initSpec = interview.spec;
+  }
   const result = await initProject({
     dir,
     templateDir,
     overlayDir,
     templateName,
+    answers,
+    initSpec,
   });
   let signedIn = (await resolveApiKey()) !== undefined;
 

package/src/internal/cli-slack.ts

@@ -64,6 +64,8 @@ export interface SlackCliOptions {
   manual?: boolean;
   /** `slack icon <source>` positional (same URL-or-file forms as --icon). */
   iconSource?: string;
+  /** doctor: watched channel ids (`C…`) to verify visibility/membership. */
+  channels?: string[];
   /** Test seams. */
   fetchImpl?: typeof fetch;
   openBrowserImpl?: (url: string) => void;
@@ -91,6 +93,7 @@ Usage:
   ${CLI} slack manifest --env dev|prod|both [--dir .] [--name NAME]
                                 [--print]
   ${CLI} slack doctor [--dir .] [--prefix PREFIX | --no-prefix] [--json]
+                                [--channel C0123ABCD]...
 
 create/destroy/icon — dedicated Socket Mode app via the Cursor dashboard:
   create   Opens the signed-in dashboard wizard. Finish name, workspace,
@@ -155,7 +158,11 @@ async function runDoctor(options: SlackCliOptions): Promise<number> {
   loadAgentLocalEnv(dir);
   const envPrefix = resolveDoctorEnvPrefix(options, dir);
   const doctor = options.doctorImpl ?? runSlackDoctor;
-  const result = await doctor(envPrefix === undefined ? {} : { envPrefix });
+  const channels = options.channels ?? [];
+  const result = await doctor({
+    envPrefix,
+    channels: channels.length > 0 ? channels : undefined,
+  });
   if (options.json) {
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
   } else {
@@ -879,6 +886,9 @@ function renderDoctorReport(result: SlackDoctorResult): string {
     text += `${check.ok ? "ok" : "!!"}  ${check.id}: ${check.message}\n`;
   }
   text += result.ok ? "doctor: pass\n" : "doctor: fail\n";
+  for (const note of result.notes ?? []) {
+    text += `\nnote: ${note}\n`;
+  }
   return text;
 }
 

package/src/internal/cursor-event-relay.ts

@@ -115,6 +115,12 @@ export interface CursorScmEvent {
    * Zod-valid `issue_comment` / `pull_request_review_comment` webhook body.
    */
   comment?: CursorScmCommentMeta;
+  /**
+   * Origin comment snapshot. Ids are Origin string ids, not GitHub integers.
+   */
+  originComment?: CursorScmOriginCommentMeta;
+  /** Origin actor (author / pusher / commenter) when present. */
+  originActor?: CursorScmOriginActorMeta;
   /** `check_run` snapshot; enough to stub `onCheckRun`. */
   checkRun?: CursorScmCheckRunMeta;
   /** `check_suite` snapshot; enough to stub `onCheckSuite`. */
@@ -125,6 +131,25 @@ export interface CursorScmEvent {
   occurredAtMs?: number;
 }
 
+export type CursorScmOriginActorMeta = {
+  id: string;
+  kind?: string;
+};
+
+export type CursorScmOriginCommentMeta = {
+  id: string;
+  body?: string;
+  author?: CursorScmOriginActorMeta;
+};
+
+export type CursorScmProvider = "github" | "origin";
+
+export interface CursorScmSubscription {
+  provider: CursorScmProvider;
+  repo: string;
+  events: readonly string[];
+}
+
 interface SubscriptionStatus {
   provider: string;
   repo: string;
@@ -135,8 +160,17 @@ interface SubscriptionStatus {
 export interface CursorEventRelayOptions {
   baseUrl: string;
   apiKey: string;
-  repos: readonly string[];
-  events: readonly string[];
+  /**
+   * GitHub-only shorthand. Ignored when {@link subscriptions} is set.
+   * Existing `--cursor-events --repo` hosts keep passing these.
+   */
+  repos?: readonly string[];
+  events?: readonly string[];
+  /**
+   * Mixed GitHub + Origin registrations. Provider is part of the
+   * subscription key: mirrored `owner/name` slugs must not collide.
+   */
+  subscriptions?: readonly CursorScmSubscription[];
   stateDir: string;
   /**
    * Called for each matching event; failures retry a bounded number of
@@ -430,30 +464,149 @@ function stubGitHubWorkflowRun(
 }
 
 /**
- * GitHub SCM-events relay: a thin {@link CursorRelayCore} adapter. Consumers
+ * Origin webhook envelope from an SCM-events metadata record. One parser
+ * handles both live Origin deliveries and this stub: `{ deliveryId, event }`.
+ */
+export function scmMetadataToOriginPayload(event: {
+  repo: string;
+  eventName: string;
+  deliveryId?: string;
+  action?: string;
+  prNumber?: number;
+  prUrl?: string;
+  pullRequest?: CursorScmPullRequestMeta;
+  originComment?: CursorScmOriginCommentMeta;
+  originActor?: CursorScmOriginActorMeta;
+  occurredAtMs?: number;
+}): Record<string, unknown> {
+  const slash = event.repo.indexOf("/");
+  const owner = slash === -1 ? "" : event.repo.slice(0, slash);
+  const name = slash === -1 ? event.repo : event.repo.slice(slash + 1);
+  const prMeta = event.pullRequest;
+  const prNumber = prMeta?.number ?? event.prNumber;
+  const prUrl =
+    prMeta?.url ??
+    event.prUrl ??
+    (prNumber !== undefined
+      ? `https://cursor.com/codebase/${owner}/${name}/pull/${prNumber}`
+      : undefined);
+
+  const payload: Record<string, unknown> = {
+    repository: {
+      name,
+      owner: { slug: owner },
+    },
+  };
+
+  if (prNumber !== undefined) {
+    const pullRequest: Record<string, unknown> = {
+      number: prNumber,
+      url: prUrl,
+    };
+    if (prMeta?.title !== undefined) pullRequest.title = prMeta.title;
+    if (prMeta?.body !== undefined) pullRequest.body = prMeta.body;
+    if (prMeta?.draft !== undefined) pullRequest.draft = prMeta.draft;
+    if (prMeta?.merged !== undefined) pullRequest.merged = prMeta.merged;
+    if (prMeta?.headRef !== undefined || prMeta?.headSha !== undefined) {
+      pullRequest.head = {
+        ref: prMeta.headRef,
+        sha: prMeta.headSha,
+      };
+    }
+    if (prMeta?.baseRef !== undefined || prMeta?.baseSha !== undefined) {
+      pullRequest.base = {
+        ref: prMeta.baseRef,
+        sha: prMeta.baseSha,
+      };
+    }
+    if (prMeta?.authorLogin !== undefined) {
+      pullRequest.author = { id: prMeta.authorLogin };
+    }
+    payload.pullRequest = pullRequest;
+  }
+
+  const commentMeta = event.originComment;
+  if (commentMeta !== undefined) {
+    const comment: Record<string, unknown> = { id: commentMeta.id };
+    if (commentMeta.body !== undefined) comment.body = commentMeta.body;
+    if (commentMeta.author !== undefined) comment.author = commentMeta.author;
+    payload.comment = comment;
+  }
+  if (event.originActor !== undefined) {
+    payload.actor = event.originActor;
+  }
+
+  return {
+    deliveryId: event.deliveryId,
+    event: {
+      type: event.eventName,
+      ...(event.occurredAtMs === undefined
+        ? {}
+        : { eventTime: new Date(event.occurredAtMs).toISOString() }),
+      payload,
+    },
+  };
+}
+
+function subscriptionKey(provider: string, repo: string): string {
+  return `${provider}:${repo.toLowerCase()}`;
+}
+
+function subscriptionLabel(provider: string, repo: string): string {
+  return provider === "github" ? repo : `${provider}:${repo}`;
+}
+
+export function resolveCursorScmSubscriptions(
+  options: Pick<CursorEventRelayOptions, "repos" | "events" | "subscriptions">
+): CursorScmSubscription[] {
+  if (options.subscriptions !== undefined) {
+    return options.subscriptions.map((subscription) => ({
+      provider: subscription.provider,
+      repo: subscription.repo.trim().toLowerCase(),
+      events: [...subscription.events],
+    }));
+  }
+  const events = [...(options.events ?? [])];
+  return (options.repos ?? []).map((repo) => ({
+    provider: "github" as const,
+    repo: repo.trim().toLowerCase(),
+    events,
+  }));
+}
+
+/**
+ * SCM-events relay: a thin {@link CursorRelayCore} adapter. Consumers
  * keep the same `new CursorEventRelay(options).start()/.stop()` surface.
  */
 export class CursorEventRelay {
   private readonly core: CursorRelayCore<CursorScmEvent>;
+  private readonly subscriptions: CursorScmSubscription[];
   /**
-   * Normalized repos the server confirmed for THIS consumer. The stream is
-   * shared with sibling consumers of the same principal, so only events for
-   * these repos may dispatch.
+   * Confirmed `provider:repo` keys for THIS consumer, with the event kinds
+   * requested for each. The stream is shared with sibling consumers, so
+   * GitHub and Origin deliveries for the same owner/name must not mix.
    */
-  private subscribedRepos = new Set<string>();
-  private readonly loggedSkippedRepos = new Set<string>();
+  private subscribedEvents = new Map<string, ReadonlySet<string>>();
+  private readonly loggedSkippedKeys = new Set<string>();
 
   constructor(private readonly options: CursorEventRelayOptions) {
+    this.subscriptions = resolveCursorScmSubscriptions(options);
+    const requestedEvents = new Map(
+      this.subscriptions.map((subscription) => [
+        subscriptionKey(subscription.provider, subscription.repo),
+        new Set(subscription.events),
+      ])
+    );
     const adapter: RelayAdapter<CursorScmEvent> = {
       logPrefix: "cursor-events",
       subscribePath: "/v0/scm-events/subscriptions",
       pollPath: "/v0/scm-events",
       buildRegistrationBody: (consumerId) => ({
         consumerId,
-        subscriptions: this.options.repos.map((repo) => ({
-          provider: "github",
-          repo,
-          events: [...this.options.events],
+        subscriptions: this.subscriptions.map((subscription) => ({
+          provider: subscription.provider,
+          repo: subscription.repo,
+          events: [...subscription.events],
         })),
       }),
       // Empty subscriptions drop this consumer's registration on clean stop
@@ -465,20 +618,27 @@ export class CursorEventRelay {
       applyRegistrationResponse: (json) => {
         const result = json as { repos?: SubscriptionStatus[] };
         const statuses = result.repos ?? [];
-        this.subscribedRepos = new Set(
-          statuses
-            .filter((status) => status.isSubscribed)
-            .map((status) => status.repo)
-        );
+        this.subscribedEvents = new Map();
         const lines: string[] = [];
-        for (const status of statuses.filter((s) => !s.isSubscribed)) {
-          lines.push(
-            `not subscribed to ${status.repo}: ${status.detail ?? "unknown reason"}`
-          );
+        const confirmed: string[] = [];
+        for (const status of statuses) {
+          const provider = status.provider || "github";
+          const key = subscriptionKey(provider, status.repo);
+          if (!status.isSubscribed) {
+            lines.push(
+              `not subscribed to ${subscriptionLabel(provider, status.repo)}: ${status.detail ?? "unknown reason"}`
+            );
+            continue;
+          }
+          this.subscribedEvents.set(key, requestedEvents.get(key) ?? new Set());
+          confirmed.push(subscriptionLabel(provider, status.repo));
         }
-        if (this.subscribedRepos.size > 0) {
+        if (confirmed.length > 0) {
+          const eventKinds = [
+            ...new Set(this.subscriptions.flatMap((s) => [...s.events])),
+          ];
           lines.push(
-            `subscribed to ${[...this.subscribedRepos].join(", ")} for events: ${this.options.events.join(", ")}`
+            `subscribed to ${confirmed.join(", ")} for events: ${eventKinds.join(", ")}`
           );
         }
         return lines;
@@ -503,21 +663,23 @@ export class CursorEventRelay {
 
   /**
    * Whether an event from the shared stream belongs to THIS consumer: the
-   * repo must be one the server confirmed for us and the event kind one the
-   * mounted channels declared. Anything else came from a sibling consumer's
-   * subscription and must not fire this host's hooks.
+   * provider+repo must be one the server confirmed for us and the event kind
+   * one that subscription declared. GitHub and Origin share owner/name slugs
+   * on mirrors, so the provider is part of the key.
    */
   private shouldDispatch(event: CursorScmEvent): boolean {
-    if (!this.subscribedRepos.has(event.repo)) {
-      if (!this.loggedSkippedRepos.has(event.repo)) {
-        this.loggedSkippedRepos.add(event.repo);
+    const key = subscriptionKey(event.provider || "github", event.repo);
+    const events = this.subscribedEvents.get(key);
+    if (events === undefined) {
+      if (!this.loggedSkippedKeys.has(key)) {
+        this.loggedSkippedKeys.add(key);
         this.options.logger(
-          `[agent-sdk] cursor-events: skipping events for ${event.repo}: not in this host's subscription (another consumer of this API key likely subscribed it)`
+          `[agent-sdk] cursor-events: skipping events for ${subscriptionLabel(event.provider || "github", event.repo)}: not in this host's subscription (another consumer of this API key likely subscribed it)`
         );
       }
       return false;
     }
-    return this.options.events.includes(event.eventName);
+    return events.has(event.eventName);
   }
 
   start(): void {

package/src/internal/discovery.ts

@@ -16,6 +16,7 @@ import {
   relative,
   resolve,
 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { type ABConfigFile, resolveABMaxPlaygroundSessions } from "../ab.js";
 import { resolveArtifactsMax } from "../artifacts.js";
 import { httpChannel } from "../channels.js";
@@ -60,10 +61,7 @@ import {
   type ToolDefinition,
   toPublicCloudInfo,
 } from "../types.js";
-import {
-  importAuthoredModule,
-  registerAuthoredModuleLoaders,
-} from "./authored-loaders.js";
+import { registerAuthoredModuleLoaders } from "./authored-loaders.js";
 import { normalizePositiveInt } from "./bounded-int.js";
 import { getDefinitionKind } from "./brand.js";
 import {
@@ -96,6 +94,15 @@ export interface LoadAgentProjectOptions {
 
 type ImportModule = (absolutePath: string) => Promise<Record<string, unknown>>;
 
+async function defaultImportModule(
+  absolutePath: string
+): Promise<Record<string, unknown>> {
+  return (await import(pathToFileURL(absolutePath).href)) as Record<
+    string,
+    unknown
+  >;
+}
+
 interface DiscoveryContext {
   rootDir: string;
   diagnostics: Diagnostic[];
@@ -275,7 +282,7 @@ export async function loadAgentProject(
   const ctx: DiscoveryContext = {
     rootDir,
     diagnostics,
-    importModule: options.importModule ?? importAuthoredModule,
+    importModule: options.importModule ?? defaultImportModule,
   };
 
   const name = (await readPackageName(rootDir)) ?? basename(rootDir);
@@ -1998,6 +2005,9 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
         if (meta?.githubWebhookEvents !== undefined) {
           info.githubWebhookEvents = meta.githubWebhookEvents;
         }
+        if (meta?.originWebhookEvents !== undefined) {
+          info.originWebhookEvents = meta.originWebhookEvents;
+        }
         if (meta?.slackChannelPosts !== undefined) {
           info.slackChannelPosts = meta.slackChannelPosts;
         }

package/src/internal/distribution.ts

@@ -96,6 +96,7 @@ export const AUTHORING_ENTRY_FILES: ReadonlyArray<
   ["channels", "channels.js"],
   ["channels/slack", "channels/slack/index.js"],
   ["channels/github", "channels/github/index.js"],
+  ["channels/origin", "channels/origin/index.js"],
   ["skills", "skills.js"],
   ["schedules", "schedules.js"],
   ["reminders", "reminders.js"],

package/src/internal/handleAgentServeTrigger.ts

@@ -1,11 +1,12 @@
 /**
  * Unified entry for dispatching agent-serve triggers from an external ingress
- * (e.g. the Cursor backend GitHub webhook). Mirrors Automations'
- * `handleAutomationTrigger`, but only GitHub is supported for now.
+ * (e.g. the Cursor backend GitHub webhook or Origin cursor-internal tap).
+ * Mirrors Automations' `handleAutomationTrigger`.
  *
  * Callers must authenticate the delivery before invoking this (the backend
- * verifies GitHub HMAC at `/github_webhook`). This fan-out does not re-check
- * signatures — same trust model as Bugbot after `verifyGithubRequest`.
+ * verifies GitHub HMAC at `/github_webhook` and Origin v1ed at the
+ * cursor-internal app). This fan-out does not re-check signatures — same
+ * trust model as Bugbot after `verifyGithubRequest`.
  *
  * Each agent's `onPullRequest` / `onComment` / … hooks decide whether to run.
  */
@@ -15,6 +16,12 @@ import {
   getGitHubChannelOptions,
 } from "../channels/github/github-channel.js";
 import type { GitHubChannelOptions } from "../channels/github/types.js";
+import {
+  dispatchOriginWebhook,
+  getOriginChannelOptions,
+  parseOriginWebhookEnvelope,
+} from "../channels/origin/origin-channel.js";
+import type { OriginChannelOptions } from "../channels/origin/types.js";
 import type { ChannelHandlerArgs } from "../types.js";
 
 export interface AgentServeGitHubTriggerTarget {
@@ -35,7 +42,22 @@ export interface AgentServeGitHubTriggerEvent {
   targets: AgentServeGitHubTriggerTarget[];
 }
 
-export type AgentServeTriggerEvent = AgentServeGitHubTriggerEvent;
+export interface AgentServeOriginTriggerTarget {
+  slug: string;
+  options: OriginChannelOptions;
+  args: ChannelHandlerArgs;
+}
+
+export interface AgentServeOriginTriggerEvent {
+  type: "origin";
+  /** Origin envelope JSON (signature already verified by the caller). */
+  bodyText: string;
+  targets: AgentServeOriginTriggerTarget[];
+}
+
+export type AgentServeTriggerEvent =
+  | AgentServeGitHubTriggerEvent
+  | AgentServeOriginTriggerEvent;
 
 export interface AgentServeTriggerTargetResult {
   slug: string;
@@ -78,17 +100,46 @@ export function collectGitHubTriggerTargets(input: {
 }
 
 /**
- * Dispatch an agent-serve trigger. GitHub only for now.
+ * Build fan-out targets from mounted agent projects that export an origin
+ * channel created via {@link originChannel}.
+ */
+export function collectOriginTriggerTargets(input: {
+  mounts: Array<{
+    slug: string;
+    channels: Array<{ id: string; definition: object }>;
+    buildHandlerArgs: (channelId: string) => ChannelHandlerArgs;
+  }>;
+}): AgentServeOriginTriggerTarget[] {
+  const targets: AgentServeOriginTriggerTarget[] = [];
+  for (const mount of input.mounts) {
+    for (const channel of mount.channels) {
+      const options = getOriginChannelOptions(channel.definition);
+      if (options === undefined) {
+        continue;
+      }
+      targets.push({
+        slug: mount.slug,
+        options,
+        args: mount.buildHandlerArgs(channel.id),
+      });
+    }
+  }
+  return targets;
+}
+
+/**
+ * Dispatch an agent-serve trigger. GitHub and Origin webhook fan-out.
  */
 export async function handleAgentServeTrigger(
   event: AgentServeTriggerEvent
 ): Promise<AgentServeTriggerResult> {
   switch (event.type) {
-    // TODO: Add support for other event types (e.g. Linear, Slack, etc.).
     case "github":
       return handleAgentServeGitHubTrigger(event);
+    case "origin":
+      return handleAgentServeOriginTrigger(event);
     default: {
-      const _: never = event.type;
+      const _: never = event;
       throw new Error(
         `handleAgentServeTrigger: unknown event type: ${String(_)}`
       );
@@ -133,17 +184,7 @@ async function handleAgentServeGitHubTrigger(
       deliveryId: event.deliveryId,
       args: target.args,
     });
-    let body: unknown;
-    try {
-      body = await response.json();
-    } catch {
-      body = { ok: false, error: "invalid_response_json" };
-    }
-    targets.push({
-      slug: target.slug,
-      status: response.status,
-      body,
-    });
+    targets.push(await triggerTargetResult(target.slug, response));
   }
 
   return {
@@ -152,3 +193,72 @@ async function handleAgentServeGitHubTrigger(
     targets,
   };
 }
+
+async function handleAgentServeOriginTrigger(
+  event: AgentServeOriginTriggerEvent
+): Promise<AgentServeTriggerResult> {
+  let payload: unknown;
+  try {
+    payload = JSON.parse(event.bodyText) as unknown;
+  } catch {
+    return {
+      ok: false,
+      event: null,
+      targets: [
+        {
+          slug: "",
+          status: 400,
+          body: { ok: false, error: "invalid_json" },
+        },
+      ],
+    };
+  }
+
+  const envelope = parseOriginWebhookEnvelope(payload);
+  if (envelope === null) {
+    return {
+      ok: false,
+      event: null,
+      targets: [
+        {
+          slug: "",
+          status: 400,
+          body: { ok: false, error: "invalid_origin_payload" },
+        },
+      ],
+    };
+  }
+
+  const targets: AgentServeTriggerTargetResult[] = [];
+  for (const target of event.targets) {
+    const response = await dispatchOriginWebhook({
+      options: target.options,
+      envelope,
+      args: target.args,
+    });
+    targets.push(await triggerTargetResult(target.slug, response));
+  }
+
+  return {
+    ok: true,
+    event: envelope.event.type,
+    targets,
+  };
+}
+
+async function triggerTargetResult(
+  slug: string,
+  response: Response
+): Promise<AgentServeTriggerTargetResult> {
+  let body: unknown;
+  try {
+    body = await response.json();
+  } catch {
+    body = { ok: false, error: "invalid_response_json" };
+  }
+  return {
+    slug,
+    status: response.status,
+    body,
+  };
+}