@cursor/july 0.1.79 → 0.1.82

package/src/internal/discovery.ts

@@ -23,6 +23,7 @@ import { httpChannel } from "../channels.js";
 import type { OtelDefinition } from "../otel.js";
 import type { StorageDefinition } from "../storage.js";
 import {
+  type AgentArchitecture,
   type AgentConcurrencyOptions,
   type AgentConfigDefinition,
   type AgentHostingOptions,
@@ -68,6 +69,7 @@ import {
   builtinTools,
   TAG_ARTIFACT_TOOL_NAME,
 } from "./builtin-tools/index.js";
+import { applyAgentContinuationDefaults } from "./continuation-channel.js";
 import { isValidCron } from "./cron.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import {
@@ -311,12 +313,19 @@ export async function loadAgentProject(
     await warnUnknownSlots(ctx, agentDir);
   }
 
+  const resolvedHttpChannel = httpChannelDefinition ?? httpChannel();
+  applyAgentContinuationDefaults({
+    agent,
+    channels,
+    httpChannel: resolvedHttpChannel,
+  });
+
   return {
     rootDir,
     agentDir,
     name: agent.name,
     agent,
-    httpChannel: httpChannelDefinition ?? httpChannel(),
+    httpChannel: resolvedHttpChannel,
     channels,
     schedules,
     hooks,
@@ -387,6 +396,13 @@ async function loadAgent(
           "tools is not supported on subagents (they keep the harness task-tool toolset); ignoring.",
       });
     }
+    if (config?.architecture !== undefined) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        path: displayPath(ctx, join(agentDir, "agent.ts")),
+        message: "architecture is not supported on subagents; ignoring.",
+      });
+    }
     const artifactsPath = await findModuleFile(agentDir, "artifacts");
     if (artifactsPath !== undefined) {
       ctx.diagnostics.push({
@@ -505,6 +521,7 @@ async function loadAgent(
         };
   const hosting = resolveHosting(ctx, agentDir, config?.hosting);
   const concurrency = resolveConcurrency(ctx, agentDir, config?.concurrency);
+  const architecture = resolveArchitecture(ctx, agentDir, config?.architecture);
 
   if (runtime === "cloud") {
     warnCloudRuntimeLimitations(ctx, agentDir, {
@@ -529,6 +546,7 @@ async function loadAgent(
     ...(allowedTools === undefined ? {} : { allowedTools }),
     hosting,
     concurrency,
+    ...(architecture === undefined ? {} : { architecture }),
     tools,
     skills,
     connections,
@@ -537,6 +555,26 @@ async function loadAgent(
   };
 }
 
+function resolveArchitecture(
+  ctx: DiscoveryContext,
+  agentDir: string,
+  architecture: AgentArchitecture | undefined
+): AgentArchitecture | undefined {
+  if (
+    architecture === undefined ||
+    architecture === "v1" ||
+    architecture === "v2"
+  ) {
+    return architecture;
+  }
+  ctx.diagnostics.push({
+    severity: "error",
+    path: displayPath(ctx, join(agentDir, "agent.ts")),
+    message: `architecture must be "v1" or "v2"; got ${JSON.stringify(architecture)}.`,
+  });
+  return undefined;
+}
+
 /** Absolute harness cwd parent, or undefined when unset / blank. */
 function resolveAgentCwd(
   ctx: DiscoveryContext,
@@ -1549,7 +1587,7 @@ function warnCloudRuntimeLimitations(
       severity: "warning",
       path: displayPath(ctx, join(agentDir, "skills")),
       message:
-        "Authored skills are materialized into the local session workspace only; cloud agents see skills that already exist in the cloud repo.",
+        "Authored skills reach cloud agents on hosted deployments via the deployment store's skills/ directory (native skill discovery). Cloud turns started outside hosting (dev serve/run) see only skills already in the cloud repo.",
     });
   }
   if (counts.seedFiles > 0) {

package/src/internal/review-comments.ts

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import type { HostGitHubClient } from "../types.js";
 
-export type ReviewCommentPublisher = "local_gh" | "host_github";
+export type ReviewCommentPublisher = "local_gh" | "host_github" | "host_origin";
 
 export type ReviewCommentPostResult = {
   posted: boolean;
@@ -57,12 +57,25 @@ export type ReviewCommentPublisherImplementation = {
 };
 
 /**
- * SCMs this module can read review comments back from. Same growth seam as
- * `shallow-clone.ts`'s {@link import("./shallow-clone.js").ScmProvider}:
- * adding GitLab/Bitbucket/Origin means a resolver case plus a reader
- * implementation, and nothing above this line changes.
+ * SCMs this module can address. Same growth seam as `shallow-clone.ts`'s
+ * {@link import("./shallow-clone.js").ScmProvider}: adding a forge means a
+ * resolver case plus a publisher (and, when the public API supports it, a
+ * reader / thread resolver). Callers above this line stay provider-neutral.
  */
-export type ScmReviewProvider = "github";
+export type ScmReviewProvider = "github" | "origin";
+
+/**
+ * Origin public REST client used to post PR reviews (`ctx.origin` /
+ * {@link import("../channels/origin/api.js").createOriginClient}). Narrower
+ * than the full Origin handle so tests and CLI paths can inject `request()`.
+ */
+export type HostOriginReviewClient = {
+  request(input: {
+    method: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    path: string;
+    body?: unknown;
+  }): Promise<unknown>;
+};
 
 /** Which SCM's PR to read review comments from. */
 export type ScmReviewTarget = {
@@ -147,18 +160,12 @@ export type ReviewThreadResolverImplementation = {
   ) => Promise<ResolveReviewThreadsResult>;
 };
 
-/** Parse a PR URL into the SCM target to read comments from. */
+/** Parse a PR URL into the SCM target to read or post comments on. */
 export function resolveScmReviewTarget(
   prUrl: string
 ): ScmReviewTarget | undefined {
-  const parsed = parseGithubPrUrl(prUrl);
-  return parsed.kind === "valid"
-    ? {
-        provider: "github",
-        repo: parsed.value.repo,
-        prNumber: parsed.value.prNumber,
-      }
-    : undefined;
+  const parsed = parseReviewPrUrl(prUrl);
+  return parsed.kind === "valid" ? parsed.value : undefined;
 }
 
 /**
@@ -175,6 +182,10 @@ export function createReviewCommentReader(args: {
       return args.github === undefined
         ? undefined
         : createHostGithubReviewCommentReader(args.github);
+    case "origin":
+      // Public Origin REST lists discussion comments, not diff-anchored
+      // review threads. Stay undefined until a reader can fetch by id.
+      return undefined;
   }
 }
 
@@ -191,6 +202,8 @@ export function createReviewThreadResolver(args: {
       return args.github === undefined
         ? undefined
         : createHostGithubReviewThreadResolver(args.github);
+    case "origin":
+      return undefined;
   }
 }
 
@@ -222,7 +235,11 @@ export async function resolveReviewThreadsForComments(args: {
       github: args.github,
     });
   if (resolver === undefined) {
-    return skippedResolve("no GitHub client bound to resolve threads");
+    return skippedResolve(
+      target.provider === "github"
+        ? "no GitHub client bound to resolve threads"
+        : `no thread resolver for ${target.provider}`
+    );
   }
   return resolver.resolveReviewThreadsForComments({
     target,
@@ -560,6 +577,49 @@ export function createHostGithubReviewPublisher(
   };
 }
 
+/**
+ * Pick the publisher for `prUrl`'s SCM. GitHub falls back to local `gh`
+ * when no host client is bound (CLI). Origin has no local CLI publisher —
+ * returns undefined unless an Origin REST client is provided.
+ */
+export function createReviewCommentPublisher(args: {
+  prUrl: string;
+  github?: HostGitHubClient;
+  origin?: HostOriginReviewClient;
+}): ReviewCommentPublisherImplementation | undefined {
+  const target = resolveScmReviewTarget(args.prUrl);
+  if (target === undefined) {
+    return undefined;
+  }
+  switch (target.provider) {
+    case "github":
+      return args.github !== undefined
+        ? createHostGithubReviewPublisher(args.github)
+        : createLocalGhReviewPublisher();
+    case "origin":
+      return args.origin === undefined
+        ? undefined
+        : createHostOriginReviewPublisher(args.origin);
+  }
+}
+
+/**
+ * Posts a COMMENT-verdict Origin review through the public REST API.
+ *
+ * Public Origin REST has no diff-anchored review comments (those are an
+ * internal CreateCommentThread RPC). Inline comments in the request are
+ * folded into the review body so findings still land on the PR.
+ */
+export function createHostOriginReviewPublisher(
+  origin: HostOriginReviewClient
+): ReviewCommentPublisherImplementation {
+  return {
+    async postReview(args) {
+      return postReviewViaHostOrigin(origin, args);
+    },
+  };
+}
+
 async function postReviewViaHostGithub(
   github: HostGitHubClient,
   args: ReviewCommentPostArgs
@@ -779,6 +839,76 @@ function skippedHost(detail: string): ReviewCommentPostResult {
   };
 }
 
+function skippedOrigin(detail: string): ReviewCommentPostResult {
+  return {
+    posted: false,
+    publisher: "host_origin",
+    mode: "skipped",
+    inlineCommentCount: 0,
+    detail,
+  };
+}
+
+async function postReviewViaHostOrigin(
+  origin: HostOriginReviewClient,
+  args: ReviewCommentPostArgs
+): Promise<ReviewCommentPostResult> {
+  const target = resolveScmReviewTarget(args.prUrl);
+  if (target === undefined || target.provider !== "origin") {
+    return skippedOrigin("host Origin publisher only supports Origin PRs");
+  }
+  const [owner, repo] = target.repo.split("/", 2);
+  if (owner === undefined || repo === undefined || repo === "") {
+    return skippedOrigin("unparseable owner/repo from PR URL");
+  }
+
+  try {
+    args.signal?.throwIfAborted();
+    await origin.request({
+      method: "POST",
+      path: `/v1/origin/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/pulls/${target.prNumber}/reviews`,
+      body: {
+        verdict: "comment",
+        body: originReviewBody(args),
+      },
+    });
+    return {
+      posted: true,
+      publisher: "host_origin",
+      mode: "review_body_only",
+      inlineCommentCount: 0,
+      detail: `posted Origin review on ${target.repo}#${target.prNumber}`,
+    };
+  } catch (error) {
+    if (args.signal?.aborted) {
+      throw error;
+    }
+    return skippedOrigin(
+      `host Origin review post failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+/**
+ * Origin's public CreatePullRequestReview has a body, not inline comments.
+ * Fold attempted anchors into the summary so findings are not dropped.
+ */
+function originReviewBody(args: ReviewCommentPostArgs): string {
+  if (args.comments.length === 0) {
+    return args.message;
+  }
+  const sections = args.comments.map((comment) => {
+    const location =
+      comment.start_line !== undefined &&
+      comment.start_line > 0 &&
+      comment.start_line !== comment.line
+        ? `${comment.file}:${comment.start_line}-${comment.line}`
+        : `${comment.file}:${comment.line}`;
+    return `### \`${location}\`\n\n${comment.body}`;
+  });
+  return [args.message, ...sections].join("\n\n");
+}
+
 function skippedResolve(detail: string): ResolveReviewThreadsResult {
   return {
     requested: 0,
@@ -790,6 +920,117 @@ function skippedResolve(detail: string): ResolveReviewThreadsResult {
   };
 }
 
+const ORIGIN_PR_PAGE_HOST_PATTERN = /^origin(-[a-z0-9]+)?\.cursor\.com$/i;
+
+/**
+ * Provider-neutral PR URL parse. GitHub.com plus the Origin page shapes
+ * `parsePrTarget` in security-review-lib accepts. Duplicated here so
+ * agent-serve does not import that package.
+ */
+function parseReviewPrUrl(
+  prUrl: string
+):
+  | { kind: "valid"; value: ScmReviewTarget }
+  | { kind: "invalid"; detail: string } {
+  let url: URL;
+  try {
+    url = new URL(prUrl);
+  } catch (error) {
+    return {
+      kind: "invalid",
+      detail: `unparseable PR URL: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+
+  const parts = url.pathname.split("/").filter(Boolean);
+  const hostname = url.hostname;
+
+  if (hostname === "github.com" && parts.length >= 4 && parts[2] === "pull") {
+    const prNumber = Number(parts[3]);
+    if (Number.isInteger(prNumber) && prNumber > 0) {
+      return {
+        kind: "valid",
+        value: {
+          provider: "github",
+          repo: `${parts[0]}/${parts[1]}`,
+          prNumber,
+        },
+      };
+    }
+  }
+
+  if (
+    ORIGIN_PR_PAGE_HOST_PATTERN.test(hostname) &&
+    parts.length >= 4 &&
+    parts[2] === "github"
+  ) {
+    const prNumber = Number(parts[3]);
+    if (Number.isInteger(prNumber) && prNumber > 0) {
+      return {
+        kind: "valid",
+        value: {
+          provider: "origin",
+          repo: `${parts[0]}/${parts[1]}`,
+          prNumber,
+        },
+      };
+    }
+  }
+
+  if (
+    /^(www\.)?cursor\.com$/i.test(hostname) &&
+    parts[0] === "codebase" &&
+    parts.length >= 5 &&
+    parts[3] === "pull"
+  ) {
+    const prNumber = Number(parts[4]);
+    if (Number.isInteger(prNumber) && prNumber > 0) {
+      return {
+        kind: "valid",
+        value: {
+          provider: "origin",
+          repo: `${parts[1]}/${parts[2]}`,
+          prNumber,
+        },
+      };
+    }
+  }
+
+  if (hostname === "review.cursor.com" && parts[0] === "pr") {
+    if (parts.length >= 5 && parts[3] === "github") {
+      const prNumber = Number(parts[4]);
+      if (Number.isInteger(prNumber) && prNumber > 0) {
+        return {
+          kind: "valid",
+          value: {
+            provider: "origin",
+            repo: `${parts[1]}/${parts[2]}`,
+            prNumber,
+          },
+        };
+      }
+    }
+    if (parts.length >= 4) {
+      const prNumber = Number(parts[3]);
+      if (Number.isInteger(prNumber) && prNumber > 0) {
+        return {
+          kind: "valid",
+          value: {
+            provider: "origin",
+            repo: `${parts[1]}/${parts[2]}`,
+            prNumber,
+          },
+        };
+      }
+    }
+  }
+
+  return {
+    kind: "invalid",
+    detail: "unparseable PR URL: not a GitHub or Origin pull request",
+  };
+}
+
 function parseGithubPrUrl(
   prUrl: string
 ):