@cursor/july 0.1.54 → 0.1.61

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,
+  };
+}

package/src/internal/init-interview.ts

@@ -0,0 +1,384 @@
+/**
+ * Template `init.json`: questions `init` asks, and string replacements
+ * it applies while copying the scaffold.
+ */
+
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { parseCursorGithubRepoScope } from "../channels/github/cursor-account.js";
+import { describeError } from "./describe-error.js";
+
+export const TEMPLATE_INIT_FILE = "init.json";
+
+export interface TemplateQuestion {
+  id: string;
+  prompt: string;
+  hint?: string;
+  placeholder?: string;
+  default?: string;
+  choices?: readonly string[];
+  parse?: "owner-repo-list";
+}
+
+export interface TemplateReplace {
+  file: string;
+  find: string;
+  answer: string;
+  as?: "json-array" | "first";
+  template?: string;
+}
+
+export interface TemplateInitSpec {
+  questions: TemplateQuestion[];
+  replace: TemplateReplace[];
+}
+
+export function posixRel(rel: string): string {
+  return rel.replaceAll("\\", "/");
+}
+
+export function isTemplateMetaPath(rel: string): boolean {
+  const normalized = posixRel(rel);
+  const top = normalized.split("/")[0];
+  if (top === "overlays") {
+    return true;
+  }
+  return (
+    normalized === TEMPLATE_INIT_FILE ||
+    normalized.endsWith(`/${TEMPLATE_INIT_FILE}`)
+  );
+}
+
+export function templateFileHasReplacements(
+  spec: TemplateInitSpec,
+  rel: string
+): boolean {
+  const file = posixRel(rel);
+  return spec.replace.some((rule) => posixRel(rule.file) === file);
+}
+
+export async function loadTemplateInitSpec(
+  templateDir: string
+): Promise<TemplateInitSpec | undefined> {
+  try {
+    const text = await readFile(join(templateDir, TEMPLATE_INIT_FILE), "utf8");
+    return parseTemplateInitSpec(JSON.parse(text));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+export function parseTemplateInitSpec(value: unknown): TemplateInitSpec {
+  if (!isRecord(value) || !Array.isArray(value.questions)) {
+    throw new Error(`${TEMPLATE_INIT_FILE} must have a questions array`);
+  }
+  const questions = value.questions.map((item, index) =>
+    parseQuestion(item, index)
+  );
+  const replace = Array.isArray(value.replace)
+    ? value.replace.map((item, index) => parseReplace(item, index))
+    : [];
+  return { questions, replace };
+}
+
+export function parseInitVars(
+  flags: readonly string[] | undefined
+): Record<string, string> {
+  const vars: Record<string, string> = {};
+  if (flags === undefined) {
+    return vars;
+  }
+  for (const flag of flags) {
+    const eq = flag.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(`--var must be id=value (got ${JSON.stringify(flag)})`);
+    }
+    vars[flag.slice(0, eq)] = flag.slice(eq + 1);
+  }
+  return vars;
+}
+
+export type ParseAnswersResult =
+  | { ok: true; answers: Record<string, string> }
+  | { ok: false; error: string };
+
+export type RunTemplateInitResult =
+  | { ok: true; spec?: TemplateInitSpec; answers?: Record<string, string> }
+  | { ok: false; error: string };
+
+/** Load `init.json`, apply `--var`, and prompt on a TTY. */
+export async function runTemplateInit(input: {
+  templateDir: string;
+  vars?: readonly string[];
+  interactive: boolean;
+}): Promise<RunTemplateInitResult> {
+  try {
+    const spec = await loadTemplateInitSpec(input.templateDir);
+    if (spec === undefined) {
+      return { ok: true };
+    }
+    const collected = await collectTemplateAnswers({
+      spec,
+      vars: parseInitVars(input.vars),
+      interactive: input.interactive,
+    });
+    if (!collected.ok) {
+      return collected;
+    }
+    return { ok: true, spec, answers: collected.answers };
+  } catch (error) {
+    return { ok: false, error: describeError(error) };
+  }
+}
+
+export function parseTemplateAnswers(
+  spec: TemplateInitSpec,
+  raw: Record<string, string>
+): ParseAnswersResult {
+  const answers: Record<string, string> = {};
+  for (const question of spec.questions) {
+    if (!(question.id in raw)) {
+      continue;
+    }
+    const parsed = parseQuestionValue(question, raw[question.id] ?? "");
+    if (!parsed.ok) {
+      return parsed;
+    }
+    answers[question.id] = parsed.value;
+  }
+  return { ok: true, answers };
+}
+
+export interface CollectAnswersInput {
+  spec: TemplateInitSpec;
+  vars?: Record<string, string>;
+  interactive: boolean;
+  ask?: (question: TemplateQuestion) => Promise<string>;
+  out?: (text: string) => void;
+}
+
+export async function collectTemplateAnswers(
+  input: CollectAnswersInput
+): Promise<ParseAnswersResult> {
+  const vars = input.vars ?? {};
+  const answers: Record<string, string> = {};
+  const ask = input.ask ?? promptTemplateQuestion;
+  const out = input.out ?? ((text) => process.stdout.write(text));
+
+  for (const question of input.spec.questions) {
+    if (question.id in vars) {
+      const parsed = parseQuestionValue(question, vars[question.id] ?? "");
+      if (!parsed.ok) {
+        return parsed;
+      }
+      answers[question.id] = parsed.value;
+      continue;
+    }
+    if (!input.interactive) {
+      continue;
+    }
+    for (;;) {
+      const line = await ask(question);
+      const value =
+        line.trim() === "" && question.default !== undefined
+          ? question.default
+          : line;
+      const parsed = parseQuestionValue(question, value);
+      if (parsed.ok) {
+        answers[question.id] = parsed.value;
+        break;
+      }
+      out(`${parsed.error}\n`);
+    }
+  }
+
+  return { ok: true, answers };
+}
+
+export function applyInitReplacements(
+  contents: string,
+  rel: string,
+  spec: TemplateInitSpec,
+  answers: Record<string, string>
+): string {
+  const file = posixRel(rel);
+  let next = contents;
+  for (const rule of spec.replace) {
+    if (posixRel(rule.file) !== file) {
+      continue;
+    }
+    const value = formatReplaceValue(rule, answers);
+    if (value === undefined) {
+      continue;
+    }
+    if (!next.includes(rule.find)) {
+      throw new Error(
+        `${TEMPLATE_INIT_FILE}: ${rule.find} not found in ${rel}`
+      );
+    }
+    next = replaceLiteral(next, rule.find, value);
+  }
+  return next;
+}
+
+export async function promptTemplateQuestion(
+  question: TemplateQuestion,
+  options: {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+  } = {}
+): Promise<string> {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const rl = createInterface({ input, output });
+  const suffix = promptSuffix(question);
+  try {
+    if (question.hint !== undefined) {
+      output.write(`  ${question.hint}\n`);
+    }
+    return await new Promise<string>((resolve) => {
+      rl.question(`${question.prompt}${suffix} `, resolve);
+    });
+  } finally {
+    rl.close();
+  }
+}
+
+function replaceLiteral(haystack: string, find: string, value: string): string {
+  return haystack.replaceAll(find, () => value);
+}
+
+function promptSuffix(question: TemplateQuestion): string {
+  if (question.choices !== undefined && question.choices.length > 0) {
+    return ` [${question.choices.join("/")}]`;
+  }
+  if (question.default !== undefined) {
+    return ` [${question.default}]`;
+  }
+  if (question.placeholder !== undefined) {
+    return ` (${question.placeholder})`;
+  }
+  return "";
+}
+
+function parseQuestionValue(
+  question: TemplateQuestion,
+  raw: string
+): { ok: true; value: string } | { ok: false; error: string } {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    return { ok: false, error: `${question.id} is required.` };
+  }
+  if (question.choices !== undefined && question.choices.length > 0) {
+    if (!question.choices.includes(trimmed)) {
+      return {
+        ok: false,
+        error: `${question.id} must be one of ${question.choices.join(", ")}.`,
+      };
+    }
+    return { ok: true, value: trimmed };
+  }
+  if (question.parse === "owner-repo-list") {
+    try {
+      const scope = parseCursorGithubRepoScope(
+        trimmed.split(",").map((repo) => repo.trim())
+      );
+      return { ok: true, value: scope.repos.join(", ") };
+    } catch (error) {
+      return { ok: false, error: describeError(error) };
+    }
+  }
+  return { ok: true, value: trimmed };
+}
+
+function formatReplaceValue(
+  rule: TemplateReplace,
+  answers: Record<string, string>
+): string | undefined {
+  const raw = answers[rule.answer];
+  if (raw === undefined || raw === "") {
+    return undefined;
+  }
+  const parts = raw.split(",").map((part) => part.trim());
+  let value = raw;
+  if (rule.as === "json-array") {
+    value = `[${parts.map((part) => JSON.stringify(part)).join(", ")}]`;
+  } else if (rule.as === "first") {
+    const first = parts[0];
+    if (first === undefined || first === "") {
+      return undefined;
+    }
+    value = first;
+  }
+  if (rule.template !== undefined) {
+    return replaceLiteral(rule.template, "{{value}}", value);
+  }
+  return value;
+}
+
+function parseQuestion(value: unknown, index: number): TemplateQuestion {
+  if (!isRecord(value) || typeof value.id !== "string" || value.id === "") {
+    throw new Error(`${TEMPLATE_INIT_FILE} questions[${index}] needs an id`);
+  }
+  if (typeof value.prompt !== "string" || value.prompt === "") {
+    throw new Error(
+      `${TEMPLATE_INIT_FILE} questions[${value.id}] needs a prompt`
+    );
+  }
+  const question: TemplateQuestion = {
+    id: value.id,
+    prompt: value.prompt,
+  };
+  if (typeof value.hint === "string") {
+    question.hint = value.hint;
+  }
+  if (typeof value.placeholder === "string") {
+    question.placeholder = value.placeholder;
+  }
+  if (typeof value.default === "string") {
+    question.default = value.default;
+  }
+  if (Array.isArray(value.choices)) {
+    question.choices = value.choices.map((choice) => String(choice));
+  }
+  if (value.parse === "owner-repo-list") {
+    question.parse = "owner-repo-list";
+  }
+  return question;
+}
+
+function parseReplace(value: unknown, index: number): TemplateReplace {
+  if (
+    !isRecord(value) ||
+    typeof value.file !== "string" ||
+    value.file === "" ||
+    typeof value.find !== "string" ||
+    value.find === "" ||
+    typeof value.answer !== "string" ||
+    value.answer === ""
+  ) {
+    throw new Error(
+      `${TEMPLATE_INIT_FILE} replace[${index}] needs file, find, and answer`
+    );
+  }
+  const rule: TemplateReplace = {
+    file: value.file,
+    find: value.find,
+    answer: value.answer,
+  };
+  if (value.as === "json-array" || value.as === "first") {
+    rule.as = value.as;
+  }
+  if (typeof value.template === "string") {
+    rule.template = value.template;
+  }
+  return rule;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}