@cursor/july 0.1.78 → 0.1.80

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
 ):

package/src/internal/server.ts

@@ -22,9 +22,10 @@ import type { DeploymentsChannelOptions } from "../channels/deployments/types.js
 import {
   type CursorGithubRepoScope,
   createCursorAccountGithubTokenResolver,
+  cursorGithubPermissionsForChannel,
   type GithubCursorAccountRuntime,
   getGithubCursorAccountRuntime,
-  parseCursorGithubRepoScope,
+  resolveCursorGithubCredentialScope,
   resolveCursorGithubPermissions,
   resolveCursorGithubProxyUrl,
 } from "../channels/github/cursor-account.js";
@@ -315,65 +316,101 @@ export async function startServer(
       : requireCursorEventsAuth(effectiveCursorEvents, accountKey);
 
   let cursorGithubCredentials: CursorGithubCredentialProvider | undefined;
-  if (cursorGithubConfig.scope !== undefined) {
-    if (cursorEventsAuth === undefined) {
-      throw new Error(
-        "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
-      );
-    }
-    if (options.allowAnonymous === true) {
-      if (options.allowAnonymousCursorGithub !== true) {
+  if (cursorGithubTargets.length > 0) {
+    const githubProxyRequested = options.cursorGithubProxy === true;
+    const needsGithubAuth =
+      cursorGithubConfig.scope !== undefined || githubProxyRequested;
+    if (needsGithubAuth) {
+      const cursorGithubAuth =
+        cursorEventsAuth ??
+        (accountKey?.apiKey !== undefined && accountKey.apiKey.trim() !== ""
+          ? {
+              apiKey: accountKey.apiKey.trim(),
+              baseUrl: cursorExternalApiUrl(),
+            }
+          : undefined);
+      if (cursorGithubAuth === undefined) {
         throw new Error(
-          "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github."
+          "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
         );
       }
-      logger(
-        "[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
-      );
-    }
-    if (cursorGithubConfig.scope.permissions === "contents-write") {
-      logger(
-        '[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code'
-      );
-    }
-    const provider = new CursorGithubCredentialProvider({
-      client: new CursorBackendClient({
-        backendUrl: cursorEventsAuth.baseUrl,
-        apiKey: cursorEventsAuth.apiKey,
-        logger,
-      }),
-      scope: cursorGithubConfig.scope,
-      logger,
-    });
-    cursorGithubCredentials = provider;
-    const githubProxyUrl =
-      options.cursorGithubProxy === true
-        ? resolveCursorGithubProxyUrl(cursorEventsAuth.baseUrl)
-        : undefined;
-    if (githubProxyUrl !== undefined) {
-      // Proxy mode: channel Octokit calls carry the Cursor API key to the
-      // backend forwarder, which swaps in the installation token server-side
-      // and logs every call with per-deployment attribution. The provider
-      // still runs so child `gh` processes get a `GH_TOKEN` lease (v1).
-      const proxyTransport = {
-        apiBaseUrl: githubProxyUrl,
-        headers: {
-          "x-cursor-github-repos": cursorGithubConfig.scope.repos.join(","),
-          "x-cursor-github-permissions": cursorGithubConfig.scope.permissions,
-        },
-      };
-      for (const target of cursorGithubTargets) {
-        target.accountRuntime.credentials.bind(
-          async () => cursorEventsAuth.apiKey
+      if (options.allowAnonymous === true) {
+        if (options.allowAnonymousCursorGithub !== true) {
+          throw new Error(
+            "githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github."
+          );
+        }
+        logger(
+          "[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
         );
-        target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
       }
-      logger(
-        `[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl}`
-      );
-    } else {
-      for (const target of cursorGithubTargets) {
-        target.accountRuntime.credentials.bind(() => provider.getToken());
+      if (cursorGithubConfig.permissions === "contents-write") {
+        logger(
+          '[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code'
+        );
+      }
+      const githubProxyUrl = githubProxyRequested
+        ? resolveCursorGithubProxyUrl(cursorGithubAuth.baseUrl)
+        : undefined;
+      if (cursorGithubConfig.scope !== undefined) {
+        const provider = new CursorGithubCredentialProvider({
+          client: new CursorBackendClient({
+            backendUrl: cursorGithubAuth.baseUrl,
+            apiKey: cursorGithubAuth.apiKey,
+            logger,
+          }),
+          scope: cursorGithubConfig.scope,
+          logger,
+        });
+        cursorGithubCredentials = provider;
+        if (githubProxyUrl !== undefined) {
+          // Proxy mode: channel Octokit calls carry the Cursor API key to the
+          // backend forwarder, which swaps in the installation token server-side
+          // and logs every call with per-deployment attribution. The provider
+          // still runs so child `gh` processes get a `GH_TOKEN` lease (v1).
+          const proxyTransport = {
+            apiBaseUrl: githubProxyUrl,
+            headers: {
+              "x-cursor-github-repos": cursorGithubConfig.scope.repos.join(","),
+              "x-cursor-github-permissions": cursorGithubConfig.permissions,
+            },
+          };
+          for (const target of cursorGithubTargets) {
+            target.accountRuntime.credentials.bind(
+              async () => cursorGithubAuth.apiKey
+            );
+            target.accountRuntime.credentials.bindProxyTransport(
+              proxyTransport
+            );
+          }
+          logger(
+            `[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl}`
+          );
+        } else {
+          for (const target of cursorGithubTargets) {
+            target.accountRuntime.credentials.bind(() => provider.getToken());
+          }
+        }
+      } else if (githubProxyUrl !== undefined) {
+        // `cursorAccount: true` with no `--repo`: skip the startup token mint
+        // (it requires a repo list) and let github-proxy take the repo from
+        // each Octokit call. Hosted multi-tenant uses this with the
+        // deployment event stream.
+        const proxyTransport = {
+          apiBaseUrl: githubProxyUrl,
+          headers: {
+            "x-cursor-github-permissions": cursorGithubConfig.permissions,
+          },
+        };
+        for (const target of cursorGithubTargets) {
+          target.accountRuntime.credentials.bind(
+            async () => cursorGithubAuth.apiKey
+          );
+          target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
+        }
+        logger(
+          `[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl} (repo scope per request)`
+        );
       }
     }
   }
@@ -2003,6 +2040,20 @@ function collectCursorGithubTargets(
 interface CursorGithubConfigResolution {
   cursorEvents: ServeOptions["cursorEvents"];
   scope: CursorGithubRepoScope | undefined;
+  permissions: CursorGithubRepoScope["permissions"];
+}
+
+function cursorGithubPermissionsForTarget(
+  target: CursorGithubTarget
+): CursorGithubRepoScope["permissions"] {
+  const authored =
+    typeof target.accountRuntime.options.cursorAccount === "object"
+      ? target.accountRuntime.options.cursorAccount.permissions
+      : undefined;
+  return (
+    target.accountRuntime.scope?.permissions ??
+    cursorGithubPermissionsForChannel(target.accountRuntime.options, authored)
+  );
 }
 
 function resolveCursorGithubEventConfig(input: {
@@ -2010,7 +2061,11 @@ function resolveCursorGithubEventConfig(input: {
   targets: CursorGithubTarget[];
 }): CursorGithubConfigResolution {
   if (input.targets.length === 0) {
-    return { cursorEvents: input.configured, scope: undefined };
+    return {
+      cursorEvents: input.configured,
+      scope: undefined,
+      permissions: "pr-write",
+    };
   }
   const repos = [
     ...(input.configured?.repos ?? []),
@@ -2019,17 +2074,23 @@ function resolveCursorGithubEventConfig(input: {
     ]),
   ];
   const permissions = resolveCursorGithubPermissions(
-    input.targets.map(
-      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
-    )
+    input.targets.map(cursorGithubPermissionsForTarget)
   );
-  const scope = parseCursorGithubRepoScope(repos, permissions);
+  const scope = resolveCursorGithubCredentialScope(repos, permissions);
+  if (scope === undefined) {
+    return {
+      cursorEvents: input.configured,
+      scope: undefined,
+      permissions,
+    };
+  }
   return {
     cursorEvents: {
       ...input.configured,
       repos: [...scope.repos],
     },
     scope,
+    permissions,
   };
 }
 
@@ -2078,6 +2139,9 @@ function resolveCursorOriginRepoScope(input: {
       (target) => target.accountRuntime.scope?.repos ?? []
     ),
   ];
+  if (repos.length === 0) {
+    return undefined;
+  }
   return parseCursorOriginRepoScope(repos);
 }
 

package/templates/agentic-owners/agent/lib/owners/match.ts

@@ -1,6 +1,8 @@
 // Vendored from the Agentic Owners policy core; see README.md in this
 // directory. Precedence must stay identical to the source's.
 
+import { posix } from "node:path";
+import { AGENTIC_OWNERS_DIR } from "./constants.js";
 import { patternMatchesFile, patternSpecificity } from "./matching.js";
 import type {
   AgenticOwnersMatchedConfig,
@@ -12,10 +14,63 @@ type PathScopedRule = {
   readonly scopeDepth: number;
   readonly sourcePath: string;
   readonly paths: readonly string[];
-  /** Root-only absolute exemption, produced from `global_exclusions`. */
+  /** Root-only repository-wide exemption, produced from `global_exclusions`. */
   readonly globalExclusion?: boolean;
 };
 
+/**
+ * Convert a repository-relative changed path to the path seen by a policy.
+ *
+ * `foo/.agentic-owners/policy.yml` owns the `foo/` scope, so its `paths`
+ * entries match against filenames relative to `foo/`. Root policies continue
+ * to see repository-relative paths. Explicit leading `../` segments can
+ * address a sibling tree.
+ */
+function filepathRelativeToPolicyScope({
+  sourcePath,
+  filepath,
+}: {
+  sourcePath: string;
+  filepath: string;
+}): string {
+  const normalizedSourcePath = sourcePath.replace(/^\/+/, "");
+  const normalizedFilepath = filepath.replace(/^\/+/, "");
+  const marker = `/${AGENTIC_OWNERS_DIR}/`;
+  const markerIndex = normalizedSourcePath.lastIndexOf(marker);
+  if (markerIndex < 0) {
+    return normalizedFilepath;
+  }
+
+  const scope = normalizedSourcePath.slice(0, markerIndex);
+  return posix.relative(scope, normalizedFilepath);
+}
+
+function patternMatchesFileFromPolicy({
+  rule,
+  pattern,
+  filepath,
+}: {
+  rule: PathScopedRule;
+  pattern: string;
+  filepath: string;
+}): boolean {
+  const relativeFilepath = filepathRelativeToPolicyScope({
+    sourcePath: rule.sourcePath,
+    filepath,
+  });
+  const filepathIsOutsideScope =
+    relativeFilepath === ".." || relativeFilepath.startsWith("../");
+  if (filepathIsOutsideScope && !pattern.startsWith("../")) {
+    return false;
+  }
+  const slashlessPatternMatchesOnlyPolicyRoot =
+    pattern !== "**" && !pattern.includes("/");
+  if (slashlessPatternMatchesOnlyPolicyRoot && relativeFilepath.includes("/")) {
+    return false;
+  }
+  return patternMatchesFile(pattern, relativeFilepath);
+}
+
 function ruleMatchesFile({
   rule,
   filepath,
@@ -23,7 +78,13 @@ function ruleMatchesFile({
   rule: PathScopedRule;
   filepath: string;
 }): boolean {
-  return rule.paths.some((pattern) => patternMatchesFile(pattern, filepath));
+  return rule.paths.some((pattern) =>
+    patternMatchesFileFromPolicy({
+      rule,
+      pattern,
+      filepath,
+    })
+  );
 }
 
 function bestMatchingPatternSpecificity(
@@ -32,7 +93,7 @@ function bestMatchingPatternSpecificity(
 ): number {
   let best = 0;
   for (const pattern of rule.paths) {
-    if (patternMatchesFile(pattern, filepath)) {
+    if (patternMatchesFileFromPolicy({ rule, pattern, filepath })) {
       best = Math.max(best, patternSpecificity(pattern));
     }
   }