@cursor/july 0.1.54 → 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`. */
@@ -292,6 +295,8 @@ export async function cmdInit(options: AxCliOptions): Promise<number> {
     return 0;
   }
   let templateDir: string | undefined;
+  let overlayDir: string | undefined;
+  let templateName: string | undefined;
   if (options.template !== undefined) {
     const template = resolveTemplate(options.template);
     if (!template.ok) {
@@ -299,6 +304,8 @@ export async function cmdInit(options: AxCliOptions): Promise<number> {
       return 1;
     }
     templateDir = template.dir;
+    overlayDir = template.overlayDir;
+    templateName = template.name;
   }
   const cwd = options.cwd ?? process.cwd();
   const dir = resolve(cwd, target);
@@ -307,7 +314,32 @@ export async function cmdInit(options: AxCliOptions): Promise<number> {
     process.stderr.write(`${targetCheck.message}\n`);
     return 1;
   }
-  const result = await initProject({ dir, templateDir });
+  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;
 
   // Machine-readable path: install deps (piped), never block on browser login.

package/src/internal/cli-deploy.ts

@@ -223,8 +223,8 @@ export async function resolveDeployAuth(
       `${dim(
         `Using team ${teamId}${
           identity.teamName === undefined ? "" : ` (${identity.teamName})`
-        } — the account's team; pass --team to override.`
-      )}\n`
+        }`
+      )}\n${dim("  the account's team — pass --team to override.")}\n`
     );
   }
 

package/src/internal/cli-slack.ts

@@ -34,6 +34,7 @@ import {
   type SlackWizardMintResult,
   type SlackWizardPollResult,
 } from "./slack-provision-client.js";
+import { stderrPalette, type TerminalPalette } from "./terminal-style.js";
 
 export interface SlackCliOptions {
   dir: string;
@@ -63,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;
@@ -71,6 +74,7 @@ export interface SlackCliOptions {
   doctorImpl?: typeof runSlackDoctor;
   out?: (text: string) => void;
   err?: (text: string) => void;
+  palette?: TerminalPalette;
 }
 
 const SLACK_HELP = `${CLI} slack — Slack channel pack helpers (Socket Mode)
@@ -89,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,
@@ -153,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 {
@@ -198,6 +207,7 @@ interface SlackProvisionContext {
   json: boolean;
   out: (text: string) => void;
   err: (text: string) => void;
+  dim: (s: string) => string;
   openBrowserImpl: (url: string) => void;
   pollIntervalMs: number;
   pollTimeoutMs: number;
@@ -373,6 +383,7 @@ async function prepareProvision(
     json: options.json === true,
     out,
     err,
+    dim: (options.palette ?? stderrPalette()).dim,
     openBrowserImpl: options.openBrowserImpl ?? openBrowser,
     pollIntervalMs:
       options.connectPollIntervalMs ?? DEFAULT_WIZARD_POLL_INTERVAL_MS,
@@ -381,6 +392,40 @@ async function prepareProvision(
   };
 }
 
+function writePendingAdminWait(
+  ctx: SlackProvisionContext,
+  poll: SlackWizardPollResult
+): void {
+  const appSuffix = poll.appId === undefined ? "" : ` (${poll.appId})`;
+  const requestUrl =
+    poll.oauthAuthorizeUrl !== undefined && poll.oauthAuthorizeUrl.length > 0
+      ? poll.oauthAuthorizeUrl
+      : undefined;
+  ctx.err(`Waiting for a Slack admin to approve the app${appSuffix}.\n\n`);
+  if (requestUrl !== undefined) {
+    ctx.err(
+      ctx.dim(
+        `  Slack will notify workspace owners once the request is in their queue.\n` +
+          `  Open this page to file it or send a reminder:\n\n`
+      )
+    );
+    ctx.err(`  ${requestUrl}\n\n`);
+    ctx.openBrowserImpl(requestUrl);
+  } else {
+    ctx.err(
+      ctx.dim(
+        `  Slack will notify workspace owners once the request is in their queue.\n\n`
+      )
+    );
+  }
+  ctx.err(
+    ctx.dim(
+      `  Keep this command running.\n` +
+        `  After an admin approves, click Retry in the dashboard.\n`
+    )
+  );
+}
+
 export async function cmdSlackCreate(
   options: SlackCliOptions
 ): Promise<number> {
@@ -412,7 +457,9 @@ export async function cmdSlackCreate(
     return 1;
   }
   if (wrote.length > 0 && !ctx.json) {
-    ctx.err(`Scaffolded the Slack channel: ${wrote.join(", ")}\n`);
+    ctx.err(
+      `${ctx.dim(`Scaffolded the Slack channel: ${wrote.join(", ")}`)}\n`
+    );
   }
 
   const source = await inferDeployGitSource(target.dir);
@@ -436,10 +483,13 @@ export async function cmdSlackCreate(
     return renderSlackApiError(error, ctx.err);
   }
 
+  const waitMinutes = Math.round(ctx.pollTimeoutMs / 60_000);
+  ctx.err(`Finish Slack setup in the browser:\n\n  ${minted.url}\n\n`);
   ctx.err(
-    `Finish Slack setup in the browser:\n\n  ${minted.url}\n\n` +
-      `Sign in as the same Cursor account that ran this command. ` +
-      `The CLI waits here (up to ${Math.round(ctx.pollTimeoutMs / 60_000)} minutes).\n`
+    ctx.dim(
+      `  Sign in as the same Cursor account that ran this command.\n` +
+        `  The CLI waits here (up to ${waitMinutes} minutes).\n`
+    )
   );
   ctx.openBrowserImpl(minted.url);
 
@@ -465,23 +515,16 @@ export async function cmdSlackCreate(
     }
     if (poll.status === "pending_admin_approval" && !sawPendingAdmin) {
       sawPendingAdmin = true;
-      const appSuffix = poll.appId === undefined ? "" : ` (${poll.appId})`;
-      ctx.err(
-        `Waiting for a Slack admin to approve the app${appSuffix}. Keep this command running.\n` +
-          `Managed install does not file the request. Open Slack to submit it; that same page lets you send a reminder to workspace owners.\n`
-      );
-      if (
-        poll.oauthAuthorizeUrl !== undefined &&
-        poll.oauthAuthorizeUrl.length > 0
-      ) {
-        ctx.err(`  ${poll.oauthAuthorizeUrl}\n`);
-      }
-      ctx.err("After an admin approves, click Retry in the dashboard.\n");
+      writePendingAdminWait(ctx, poll);
     }
     if (Date.now() >= deadline) {
+      ctx.err(`Timed out waiting for Slack setup.\n\n`);
       ctx.err(
-        `Timed out waiting for Slack setup. Finish it in the browser, then re-run \`${CLI} slack create\`.\n  ${minted.url}\n`
+        ctx.dim(
+          `  Finish it in the browser, then re-run \`${CLI} slack create\`.\n\n`
+        )
       );
+      ctx.err(`  ${minted.url}\n`);
       return 1;
     }
     await sleep(ctx.pollIntervalMs);
@@ -518,7 +561,10 @@ export async function cmdSlackCreate(
   }
   if (poll.localEnv.appToken === undefined) {
     ctx.err(
-      `warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written; re-run \`${CLI} slack create\` to recover it.\n`
+      ctx.dim(
+        `warning: Slack did not return an app-level token, so ${target.envKeys.app} was not written.\n` +
+          `  Re-run \`${CLI} slack create\` to recover it.\n`
+      )
     );
   }
 
@@ -840,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"],