@cursor/july 0.1.101 → 0.1.103

package/dist/channels/bitbucket/defaults.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Default dispatch decisions for the Bitbucket channel: turn auth derived
+ * from the delivery's actor, the title / message a turn starts with, and
+ * which pull-request events dispatch when no `onPullRequest` hook exists.
+ */
+import type { AuthContext } from "../../types.js";
+import type { BitbucketEventContext, BitbucketPullRequestEvent, BitbucketTurnDispatch } from "./types.js";
+type DispatchContext = Omit<BitbucketEventContext, "host" | "artifacts" | "bitbucket" | "send">;
+/**
+ * Derive the turn's auth from the actor that triggered the delivery — the
+ * standard `{ auth: defaultBitbucketAuth(ctx) }` dispatch from an inbound
+ * hook. The subscriber's Cursor identity is not the turn principal (same
+ * pattern as `defaultGitHubAuth` / `defaultGitLabAuth`).
+ */
+export declare function defaultBitbucketAuth(ctx: DispatchContext): AuthContext;
+export declare function defaultBitbucketTitle(ctx: Pick<BitbucketEventContext, "repository" | "pullRequestId" | "eventType">): string;
+export declare function defaultBitbucketPullRequestMessage(ctx: DispatchContext, pullRequest: BitbucketPullRequestEvent): string;
+/**
+ * Default gate when no `onPullRequest` hook is declared: a new pull request,
+ * or an `updated` that pushed commits (Data Center `pr:from_ref_updated`
+ * carries `previousFromHash`; Cloud `pullrequest:updated` has no diff, so
+ * only a changed head dispatches), starts a turn as the actor.
+ */
+export declare function defaultBitbucketPullRequestDispatch(ctx: DispatchContext, pullRequest: BitbucketPullRequestEvent): BitbucketTurnDispatch | null;
+export {};
+//# sourceMappingURL=defaults.d.ts.map

package/dist/channels/bitbucket/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/channels/bitbucket/defaults.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EACV,qBAAqB,EACrB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAEpB,KAAK,eAAe,GAAG,IAAI,CACzB,qBAAqB,EACrB,MAAM,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,CAC5C,CAAC;AAeF;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,eAAe,GAAG,WAAW,CAuBtE;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,IAAI,CAAC,qBAAqB,EAAE,YAAY,GAAG,eAAe,GAAG,WAAW,CAAC,GAC7E,MAAM,CAIR;AAED,wBAAgB,kCAAkC,CAChD,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,yBAAyB,GACrC,MAAM,CAeR;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CACjD,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,yBAAyB,GACrC,qBAAqB,GAAG,IAAI,CAU9B"}

package/dist/channels/bitbucket/defaults.js

@@ -0,0 +1,73 @@
+/**
+ * Default dispatch decisions for the Bitbucket channel: turn auth derived
+ * from the delivery's actor, the title / message a turn starts with, and
+ * which pull-request events dispatch when no `onPullRequest` hook exists.
+ */
+function issuerHost(ctx) {
+    if (ctx.repository.htmlUrl !== undefined) {
+        try {
+            return new URL(ctx.repository.htmlUrl).host;
+        }
+        catch (_a) {
+            // fall through to the dialect default
+        }
+    }
+    return ctx.repository.dialect === "cloud"
+        ? "bitbucket.org"
+        : "bitbucket-data-center";
+}
+/**
+ * Derive the turn's auth from the actor that triggered the delivery — the
+ * standard `{ auth: defaultBitbucketAuth(ctx) }` dispatch from an inbound
+ * hook. The subscriber's Cursor identity is not the turn principal (same
+ * pattern as `defaultGitHubAuth` / `defaultGitLabAuth`).
+ */
+export function defaultBitbucketAuth(ctx) {
+    const sender = ctx.sender;
+    return {
+        authenticator: "bitbucket-webhook",
+        principalId: sender === undefined ? "bitbucket" : sender.id,
+        principalType: "user",
+        attributes: Object.assign(Object.assign(Object.assign({ conversation_kind: ctx.pullRequestId === undefined ? ctx.eventType : "pull_request", repo: ctx.repository.fullName, dialect: ctx.repository.dialect }, (ctx.deliveryId === undefined ? {} : { delivery_id: ctx.deliveryId })), (sender === undefined
+            ? {}
+            : Object.assign({ subject: sender.id }, (sender.username === undefined
+                ? {}
+                : { username: sender.username })))), { issuer: `bitbucket:${issuerHost(ctx)}` }),
+    };
+}
+export function defaultBitbucketTitle(ctx) {
+    return ctx.pullRequestId === undefined
+        ? `Bitbucket ${ctx.repository.fullName} ${ctx.eventType}`
+        : `Bitbucket ${ctx.repository.fullName}#${ctx.pullRequestId}`;
+}
+export function defaultBitbucketPullRequestMessage(ctx, pullRequest) {
+    const head = pullRequest.sourceBranch !== undefined && pullRequest.headSha !== undefined
+        ? `Head: ${pullRequest.sourceBranch} (${pullRequest.headSha})`
+        : undefined;
+    return [
+        `Bitbucket pull request trigger: ${ctx.repository.fullName}#${pullRequest.id}`,
+        `Action: ${pullRequest.action}`,
+        ...(pullRequest.htmlUrl === undefined
+            ? []
+            : [`URL: ${pullRequest.htmlUrl}`]),
+        ...(pullRequest.title === undefined ? [] : [`Title: ${pullRequest.title}`]),
+        ...(head === undefined ? [] : [head]),
+        "Handle this pull request event.",
+    ].join("\n");
+}
+/**
+ * Default gate when no `onPullRequest` hook is declared: a new pull request,
+ * or an `updated` that pushed commits (Data Center `pr:from_ref_updated`
+ * carries `previousFromHash`; Cloud `pullrequest:updated` has no diff, so
+ * only a changed head dispatches), starts a turn as the actor.
+ */
+export function defaultBitbucketPullRequestDispatch(ctx, pullRequest) {
+    const dispatches = pullRequest.action === "created" ||
+        (pullRequest.action === "updated" &&
+            pullRequest.previousHeadSha !== undefined &&
+            pullRequest.previousHeadSha !== pullRequest.headSha);
+    if (!dispatches) {
+        return null;
+    }
+    return { auth: defaultBitbucketAuth(ctx) };
+}

package/dist/channels/bitbucket/events.d.ts

@@ -0,0 +1,22 @@
+/** {@link ChannelMeta.kind} value used by {@link bitbucketChannel}. */
+export declare const BITBUCKET_CHANNEL_KIND = "bitbucket";
+/**
+ * Data Center `X-Event-Key`s → the Cloud vocabulary the channel dispatches
+ * on. Pure copy of the backend ingress normalizer so local HTTP deliveries
+ * (which arrive raw) and hosted admission (already normalized) agree.
+ */
+export declare const BITBUCKET_DATA_CENTER_EVENT_KEYS: Readonly<Record<string, string>>;
+/** `pr:opened` → `pullrequest:created`; Cloud keys pass through unchanged. */
+export declare function normalizeBitbucketEventKey(eventKey: string): string;
+/** Cloud pull-request event keys, grouped by the hook that receives them. */
+export declare const BITBUCKET_PULL_REQUEST_EVENTS: readonly ["pullrequest:created", "pullrequest:updated", "pullrequest:approved", "pullrequest:unapproved", "pullrequest:changes_request_created", "pullrequest:fulfilled", "pullrequest:rejected"];
+export declare const BITBUCKET_COMMENT_EVENTS: readonly ["pullrequest:comment_created"];
+export declare const BITBUCKET_PUSH_EVENTS: readonly ["repo:push"];
+export interface BitbucketWebhookEventOptions {
+    webhookEvents?: readonly string[];
+    onPullRequest?: unknown;
+    onPullRequestComment?: unknown;
+    onPush?: unknown;
+}
+export declare function deriveBitbucketWebhookEvents(options: BitbucketWebhookEventOptions): string[];
+//# sourceMappingURL=events.d.ts.map

package/dist/channels/bitbucket/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/channels/bitbucket/events.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CACrD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWvB,CAAC;AAEF,8EAA8E;AAC9E,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,YACxC,qBAAqB,EACrB,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,qCAAqC,EACrC,uBAAuB,EACvB,sBAAsB,CACd,CAAC;AAEX,eAAO,MAAM,wBAAwB,YACnC,6BAA6B,CACrB,CAAC;AACX,eAAO,MAAM,qBAAqB,YAAI,WAAW,CAAU,CAAC;AAe5D,MAAM,WAAW,4BAA4B;IAC3C,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,4BAA4B,GACpC,MAAM,EAAE,CAiBV"}

package/dist/channels/bitbucket/events.js

@@ -0,0 +1,64 @@
+/** {@link ChannelMeta.kind} value used by {@link bitbucketChannel}. */
+export const BITBUCKET_CHANNEL_KIND = "bitbucket";
+/**
+ * Data Center `X-Event-Key`s → the Cloud vocabulary the channel dispatches
+ * on. Pure copy of the backend ingress normalizer so local HTTP deliveries
+ * (which arrive raw) and hosted admission (already normalized) agree.
+ */
+export const BITBUCKET_DATA_CENTER_EVENT_KEYS = {
+    "pr:opened": "pullrequest:created",
+    "pr:modified": "pullrequest:updated",
+    "pr:from_ref_updated": "pullrequest:updated",
+    "pr:merged": "pullrequest:fulfilled",
+    "pr:declined": "pullrequest:rejected",
+    "pr:comment:added": "pullrequest:comment_created",
+    "pr:reviewer:approved": "pullrequest:approved",
+    "pr:reviewer:needs_work": "pullrequest:changes_request_created",
+    "repo:refs_changed": "repo:push",
+};
+/** `pr:opened` → `pullrequest:created`; Cloud keys pass through unchanged. */
+export function normalizeBitbucketEventKey(eventKey) {
+    var _a;
+    const trimmed = eventKey.trim();
+    return (_a = BITBUCKET_DATA_CENTER_EVENT_KEYS[trimmed]) !== null && _a !== void 0 ? _a : trimmed;
+}
+/** Cloud pull-request event keys, grouped by the hook that receives them. */
+export const BITBUCKET_PULL_REQUEST_EVENTS = [
+    "pullrequest:created",
+    "pullrequest:updated",
+    "pullrequest:approved",
+    "pullrequest:unapproved",
+    "pullrequest:changes_request_created",
+    "pullrequest:fulfilled",
+    "pullrequest:rejected",
+];
+export const BITBUCKET_COMMENT_EVENTS = [
+    "pullrequest:comment_created",
+];
+export const BITBUCKET_PUSH_EVENTS = ["repo:push"];
+/**
+ * `pullrequest:created` / `:updated` are always declared: they are the
+ * default dispatch when no `onPullRequest` hook exists. Other hooks add
+ * their event keys.
+ */
+const HOOK_EVENTS = [
+    ["onPullRequest", BITBUCKET_PULL_REQUEST_EVENTS],
+    ["onPullRequestComment", BITBUCKET_COMMENT_EVENTS],
+    ["onPush", BITBUCKET_PUSH_EVENTS],
+];
+export function deriveBitbucketWebhookEvents(options) {
+    if (options.webhookEvents !== undefined) {
+        return [
+            ...new Set(options.webhookEvents
+                .map((event) => normalizeBitbucketEventKey(event))
+                .filter(Boolean)),
+        ];
+    }
+    const events = ["pullrequest:created", "pullrequest:updated"];
+    for (const [hook, hookEvents] of HOOK_EVENTS) {
+        if (options[hook] !== undefined) {
+            events.push(...hookEvents);
+        }
+    }
+    return [...new Set(events)];
+}

package/dist/channels/bitbucket/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bitbucket webhook channel pack for agent-serve (Cloud and Data Center).
+ *
+ * ```ts
+ * import { bitbucketChannel, defaultBitbucketAuth } from "@cursor/july/channels/bitbucket";
+ *
+ * export default bitbucketChannel({
+ *   webhookSecret: () => process.env.BITBUCKET_WEBHOOK_SECRET,
+ *   onPullRequest: (ctx) => ({ auth: defaultBitbucketAuth(ctx) }),
+ *   onPullRequestComment: (ctx) => ({ auth: defaultBitbucketAuth(ctx) }),
+ * });
+ * ```
+ *
+ * Direct webhook mode verifies the hook's `X-Hub-Signature` (`sha256=` HMAC
+ * over the raw body) against {@link BitbucketChannelOptions.webhookSecret}
+ * (or `BITBUCKET_WEBHOOK_SECRET`). Data Center `X-Event-Key`s (`pr:opened`)
+ * are normalized to the Cloud vocabulary (`pullrequest:created`) before
+ * hooks run, and payload fields from either dialect land on one shape.
+ * Hosted deployments receive deliveries the Cursor backend already verified
+ * and normalized. The turn principal is `bitbucket-webhook` plus the
+ * Bitbucket actor — not the Cursor subscriber.
+ */
+export * from "./api.js";
+export { type BitbucketHandle, bitbucketCommentFromPayload, bitbucketDialectOf, bitbucketPullRequestFromPayload, bitbucketPullRequestUrl, bitbucketPushFromPayload, bitbucketRepositoryFromPayload, bitbucketUser, buildBitbucketBinding, } from "./binding.js";
+export * from "./bitbucket-channel.js";
+export * from "./bitbucket-webhook.js";
+export * from "./checks.js";
+export { CURSOR_BITBUCKET_MAX_REPOS, type CursorBitbucketRepoScope, parseCursorBitbucketRepoScope, resolveCursorBitbucketProxyUrl, } from "./cursor-account.js";
+export * from "./defaults.js";
+export * from "./events.js";
+export * from "./replay.js";
+export * from "./state.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/channels/bitbucket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/channels/bitbucket/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,cAAc,UAAU,CAAC;AACzB,OAAO,EACL,KAAK,eAAe,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,+BAA+B,EAC/B,uBAAuB,EACvB,wBAAwB,EACxB,8BAA8B,EAC9B,aAAa,EACb,qBAAqB,GACtB,MAAM,cAAc,CAAC;AACtB,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,OAAO,EACL,0BAA0B,EAC1B,KAAK,wBAAwB,EAC7B,6BAA6B,EAC7B,8BAA8B,GAC/B,MAAM,qBAAqB,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/channels/bitbucket/index.js

@@ -0,0 +1,33 @@
+/**
+ * Bitbucket webhook channel pack for agent-serve (Cloud and Data Center).
+ *
+ * ```ts
+ * import { bitbucketChannel, defaultBitbucketAuth } from "@cursor/july/channels/bitbucket";
+ *
+ * export default bitbucketChannel({
+ *   webhookSecret: () => process.env.BITBUCKET_WEBHOOK_SECRET,
+ *   onPullRequest: (ctx) => ({ auth: defaultBitbucketAuth(ctx) }),
+ *   onPullRequestComment: (ctx) => ({ auth: defaultBitbucketAuth(ctx) }),
+ * });
+ * ```
+ *
+ * Direct webhook mode verifies the hook's `X-Hub-Signature` (`sha256=` HMAC
+ * over the raw body) against {@link BitbucketChannelOptions.webhookSecret}
+ * (or `BITBUCKET_WEBHOOK_SECRET`). Data Center `X-Event-Key`s (`pr:opened`)
+ * are normalized to the Cloud vocabulary (`pullrequest:created`) before
+ * hooks run, and payload fields from either dialect land on one shape.
+ * Hosted deployments receive deliveries the Cursor backend already verified
+ * and normalized. The turn principal is `bitbucket-webhook` plus the
+ * Bitbucket actor — not the Cursor subscriber.
+ */
+export * from "./api.js";
+export { bitbucketCommentFromPayload, bitbucketDialectOf, bitbucketPullRequestFromPayload, bitbucketPullRequestUrl, bitbucketPushFromPayload, bitbucketRepositoryFromPayload, bitbucketUser, buildBitbucketBinding, } from "./binding.js";
+export * from "./bitbucket-channel.js";
+export * from "./bitbucket-webhook.js";
+export * from "./checks.js";
+export { CURSOR_BITBUCKET_MAX_REPOS, parseCursorBitbucketRepoScope, resolveCursorBitbucketProxyUrl, } from "./cursor-account.js";
+export * from "./defaults.js";
+export * from "./events.js";
+export * from "./replay.js";
+export * from "./state.js";
+export * from "./types.js";

package/dist/channels/bitbucket/replay.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Synthesize Bitbucket webhook payloads from data you can *read* about a
+ * pull request, so `agent-sdk bitbucket replay` can exercise a
+ * `bitbucketChannel()` without admin access to the repository hook and
+ * without a tunnel.
+ *
+ * Payloads are shaped in the dialect of the pull request's host — Cloud
+ * (`pullrequest`, `repository.full_name`) or Data Center (`pullRequest`,
+ * `repository.project.key`, `eventKey`) — so the channel's dialect detection
+ * and the Data Center → Cloud event-key normalizer both run on the local
+ * loop exactly as they do for a real delivery.
+ */
+import type { BitbucketApiPullRequest } from "./api.js";
+import type { BitbucketDialect, BitbucketRepositoryRef } from "./types.js";
+/** A parsed pull request reference. */
+export interface BitbucketPrRef {
+    dialect: BitbucketDialect;
+    /** `https://bitbucket.org` or the Data Center origin. */
+    origin: string;
+    repository: BitbucketRepositoryRef;
+    id: number;
+    /** Web URL of the pull request. */
+    url: string;
+    /** `workspace/repo#N` / `PROJECT/repo#N`. */
+    label: string;
+}
+/**
+ * Parse a Cloud PR URL (`https://bitbucket.org/<ws>/<repo>/pull-requests/N`),
+ * a Data Center PR URL (`https://<host>/projects/<KEY>/repos/<repo>/pull-requests/N`),
+ * or `workspace/repo#N` (Cloud). Returns undefined otherwise.
+ */
+export declare function parseBitbucketPrRef(raw: string): BitbucketPrRef | undefined;
+/** Cloud-vocabulary event keys replay knows how to synthesize. */
+export declare const BITBUCKET_SYNTHESIZABLE_EVENTS: readonly ["pullrequest:created", "pullrequest:updated", "pullrequest:comment_created", "repo:push"];
+export type BitbucketSynthesizableEvent = (typeof BITBUCKET_SYNTHESIZABLE_EVENTS)[number];
+export declare function isBitbucketSynthesizableEvent(event: string): event is BitbucketSynthesizableEvent;
+export interface SynthesizedBitbucketEvent {
+    /** Cloud-normalized event key (`pullrequest:created`). */
+    eventType: BitbucketSynthesizableEvent;
+    /** `X-Event-Key` header value: Cloud key, or the raw Data Center key. */
+    header: string;
+    payload: Record<string, unknown>;
+}
+/** Build one Bitbucket-shaped payload for `event` in the ref's dialect. */
+export declare function synthesizeBitbucketEvent(input: {
+    /** Cloud or Data Center event key; DC keys are normalized first. */
+    event: string;
+    ref: BitbucketPrRef;
+    pullRequest: BitbucketApiPullRequest;
+    /** comment body (default `@cursor please take a look`). */
+    comment?: string;
+}): SynthesizedBitbucketEvent | {
+    error: string;
+};
+/**
+ * Choose events to replay: explicit list (either dialect's keys), `*` for
+ * every declared, else `pullrequest:created`.
+ */
+export declare function selectBitbucketReplayEvents(requested: readonly string[] | undefined, declared: readonly string[]): {
+    events: BitbucketSynthesizableEvent[];
+    unsupported: string[];
+};
+//# sourceMappingURL=replay.d.ts.map

package/dist/channels/bitbucket/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../../src/channels/bitbucket/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE3E,uCAAuC;AACvC,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,gBAAgB,CAAC;IAC1B,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,sBAAsB,CAAC;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,mCAAmC;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAqC3E;AAwBD,kEAAkE;AAClE,eAAO,MAAM,8BAA8B,YACzC,qBAAqB,EACrB,qBAAqB,EACrB,6BAA6B,EAC7B,WAAW,CACH,CAAC;AAEX,MAAM,MAAM,2BAA2B,GACrC,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAElD,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,MAAM,GACZ,KAAK,IAAI,2BAA2B,CAEtC;AAED,MAAM,WAAW,yBAAyB;IACxC,0DAA0D;IAC1D,SAAS,EAAE,2BAA2B,CAAC;IACvC,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AA+JD,2EAA2E;AAC3E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,cAAc,CAAC;IACpB,WAAW,EAAE,uBAAuB,CAAC;IACrC,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,yBAAyB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CA2HhD;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EACxC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAC1B;IAAE,MAAM,EAAE,2BAA2B,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAoBlE"}

package/dist/channels/bitbucket/replay.js

@@ -0,0 +1,304 @@
+/**
+ * Synthesize Bitbucket webhook payloads from data you can *read* about a
+ * pull request, so `agent-sdk bitbucket replay` can exercise a
+ * `bitbucketChannel()` without admin access to the repository hook and
+ * without a tunnel.
+ *
+ * Payloads are shaped in the dialect of the pull request's host — Cloud
+ * (`pullrequest`, `repository.full_name`) or Data Center (`pullRequest`,
+ * `repository.project.key`, `eventKey`) — so the channel's dialect detection
+ * and the Data Center → Cloud event-key normalizer both run on the local
+ * loop exactly as they do for a real delivery.
+ */
+import { normalizeBitbucketEventKey } from "./events.js";
+/**
+ * Parse a Cloud PR URL (`https://bitbucket.org/<ws>/<repo>/pull-requests/N`),
+ * a Data Center PR URL (`https://<host>/projects/<KEY>/repos/<repo>/pull-requests/N`),
+ * or `workspace/repo#N` (Cloud). Returns undefined otherwise.
+ */
+export function parseBitbucketPrRef(raw) {
+    const text = raw.trim();
+    const dc = text.match(/^(https?:\/\/[^/]+)(?:\/.*?)?\/projects\/([^/]+)\/repos\/([^/]+)\/pull-requests\/(\d+)(?:[/?#].*)?$/i);
+    if (dc !== null) {
+        return build("data-center", dc[1], dc[2], dc[3], Number(dc[4]));
+    }
+    const cloud = text.match(/^(https?:\/\/[^/]+)\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)(?:[/?#].*)?$/i);
+    if (cloud !== null) {
+        return build("cloud", cloud[1], cloud[2], cloud[3], Number(cloud[4]));
+    }
+    const hash = text.match(/^([\w.-]+)\/([\w.-]+)#(\d+)$/);
+    if (hash !== null) {
+        return build("cloud", "https://bitbucket.org", hash[1], hash[2], Number(hash[3]));
+    }
+    return undefined;
+}
+function build(dialect, origin, owner, slug, id) {
+    const fullName = `${owner}/${slug}`;
+    const htmlUrl = dialect === "cloud"
+        ? `${origin}/${fullName}`
+        : `${origin}/projects/${owner}/repos/${slug}`;
+    return {
+        dialect,
+        origin,
+        repository: { dialect, fullName, owner, slug, htmlUrl },
+        id,
+        url: `${htmlUrl}/pull-requests/${id}`,
+        label: `${fullName}#${id}`,
+    };
+}
+/** Cloud-vocabulary event keys replay knows how to synthesize. */
+export const BITBUCKET_SYNTHESIZABLE_EVENTS = [
+    "pullrequest:created",
+    "pullrequest:updated",
+    "pullrequest:comment_created",
+    "repo:push",
+];
+export function isBitbucketSynthesizableEvent(event) {
+    return BITBUCKET_SYNTHESIZABLE_EVENTS.includes(event);
+}
+/** Cloud key → the Data Center `X-Event-Key` that normalizes to it. */
+const DATA_CENTER_HEADER = {
+    "pullrequest:created": "pr:opened",
+    "pullrequest:updated": "pr:from_ref_updated",
+    "pullrequest:comment_created": "pr:comment:added",
+    "repo:push": "repo:refs_changed",
+};
+const ZERO_SHA = "0000000000000000000000000000000000000000";
+const FALLBACK_ACTOR = {
+    id: "agent-sdk-replay",
+    username: "agent-sdk-replay",
+    displayName: "agent-sdk replay",
+};
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function str(value) {
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+/** PR author from the raw REST record (Cloud `author`, DC `author.user`). */
+function actorFromPullRequest(raw) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const record = asRecord(raw);
+    const author = asRecord(record === null || record === void 0 ? void 0 : record.author);
+    const user = (_a = asRecord(author === null || author === void 0 ? void 0 : author.user)) !== null && _a !== void 0 ? _a : author;
+    if (user === undefined) {
+        return FALLBACK_ACTOR;
+    }
+    const id = (_c = (_b = str(user.uuid)) !== null && _b !== void 0 ? _b : str(user.account_id)) !== null && _c !== void 0 ? _c : (typeof user.id === "number" ? String(user.id) : undefined);
+    const username = (_e = (_d = str(user.nickname)) !== null && _d !== void 0 ? _d : str(user.name)) !== null && _e !== void 0 ? _e : str(user.slug);
+    const displayName = (_f = str(user.display_name)) !== null && _f !== void 0 ? _f : str(user.displayName);
+    return {
+        id: id !== null && id !== void 0 ? id : FALLBACK_ACTOR.id,
+        username: username !== null && username !== void 0 ? username : FALLBACK_ACTOR.username,
+        displayName: (_g = displayName !== null && displayName !== void 0 ? displayName : username) !== null && _g !== void 0 ? _g : FALLBACK_ACTOR.displayName,
+    };
+}
+function cloudActor(actor) {
+    return {
+        type: "user",
+        uuid: actor.id,
+        nickname: actor.username,
+        display_name: actor.displayName,
+    };
+}
+function dcActor(actor) {
+    const numeric = Number(actor.id);
+    return {
+        id: Number.isInteger(numeric) && numeric > 0 ? numeric : 1,
+        name: actor.username,
+        displayName: actor.displayName,
+        slug: actor.username,
+    };
+}
+function cloudRepository(repository) {
+    var _a;
+    return Object.assign(Object.assign({ type: "repository", full_name: repository.fullName, name: repository.slug }, (repository.uuid === undefined ? {} : { uuid: repository.uuid })), { links: {
+            html: {
+                href: (_a = repository.htmlUrl) !== null && _a !== void 0 ? _a : `https://bitbucket.org/${repository.fullName}`,
+            },
+        } });
+}
+function dcRepository(repository) {
+    return Object.assign(Object.assign(Object.assign({ slug: repository.slug }, (repository.id === undefined ? {} : { id: repository.id })), { name: repository.slug, project: { key: repository.owner } }), (repository.htmlUrl === undefined
+        ? {}
+        : { links: { self: [{ href: `${repository.htmlUrl}/browse` }] } }));
+}
+function cloudPullRequest(pullRequest, actor, url) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    return {
+        id: pullRequest.id,
+        title: (_a = pullRequest.title) !== null && _a !== void 0 ? _a : "",
+        description: (_b = pullRequest.description) !== null && _b !== void 0 ? _b : "",
+        state: (_c = pullRequest.state) !== null && _c !== void 0 ? _c : "OPEN",
+        author: cloudActor(actor),
+        source: {
+            branch: { name: (_d = pullRequest.sourceBranch) !== null && _d !== void 0 ? _d : "" },
+            commit: { hash: (_e = pullRequest.headSha) !== null && _e !== void 0 ? _e : ZERO_SHA },
+        },
+        destination: {
+            branch: { name: (_f = pullRequest.targetBranch) !== null && _f !== void 0 ? _f : "" },
+            commit: { hash: (_g = pullRequest.baseSha) !== null && _g !== void 0 ? _g : ZERO_SHA },
+        },
+        links: { html: { href: (_h = pullRequest.htmlUrl) !== null && _h !== void 0 ? _h : url } },
+    };
+}
+function dcPullRequest(pullRequest, repository, actor, url) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const repo = dcRepository(repository);
+    return {
+        id: pullRequest.id,
+        title: (_a = pullRequest.title) !== null && _a !== void 0 ? _a : "",
+        description: (_b = pullRequest.description) !== null && _b !== void 0 ? _b : "",
+        state: (_c = pullRequest.state) !== null && _c !== void 0 ? _c : "OPEN",
+        author: { user: dcActor(actor), role: "AUTHOR", approved: false },
+        fromRef: {
+            id: `refs/heads/${(_d = pullRequest.sourceBranch) !== null && _d !== void 0 ? _d : ""}`,
+            displayId: (_e = pullRequest.sourceBranch) !== null && _e !== void 0 ? _e : "",
+            latestCommit: (_f = pullRequest.headSha) !== null && _f !== void 0 ? _f : ZERO_SHA,
+            repository: repo,
+        },
+        toRef: {
+            id: `refs/heads/${(_g = pullRequest.targetBranch) !== null && _g !== void 0 ? _g : ""}`,
+            displayId: (_h = pullRequest.targetBranch) !== null && _h !== void 0 ? _h : "",
+            latestCommit: (_j = pullRequest.baseSha) !== null && _j !== void 0 ? _j : ZERO_SHA,
+            repository: repo,
+        },
+        links: { self: [{ href: (_k = pullRequest.htmlUrl) !== null && _k !== void 0 ? _k : url }] },
+    };
+}
+/** Build one Bitbucket-shaped payload for `event` in the ref's dialect. */
+export function synthesizeBitbucketEvent(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const event = normalizeBitbucketEventKey(input.event);
+    if (!isBitbucketSynthesizableEvent(event)) {
+        return { error: `cannot synthesize ${input.event}` };
+    }
+    const { ref, pullRequest } = input;
+    const actor = actorFromPullRequest(pullRequest.raw);
+    const headSha = (_a = pullRequest.headSha) !== null && _a !== void 0 ? _a : ZERO_SHA;
+    const baseSha = (_b = pullRequest.baseSha) !== null && _b !== void 0 ? _b : ZERO_SHA;
+    const comment = (_c = input.comment) !== null && _c !== void 0 ? _c : "@cursor please take a look";
+    const commentId = Date.now() % 1000000000;
+    if (ref.dialect === "cloud") {
+        const base = {
+            repository: cloudRepository(ref.repository),
+            actor: cloudActor(actor),
+        };
+        const pullrequest = cloudPullRequest(pullRequest, actor, ref.url);
+        switch (event) {
+            case "pullrequest:created":
+            case "pullrequest:updated":
+                return {
+                    eventType: event,
+                    header: event,
+                    payload: Object.assign(Object.assign({}, base), { pullrequest }),
+                };
+            case "pullrequest:comment_created":
+                return {
+                    eventType: event,
+                    header: event,
+                    payload: Object.assign(Object.assign({}, base), { pullrequest, comment: {
+                            id: commentId,
+                            content: { raw: comment },
+                            user: cloudActor(actor),
+                            links: { html: { href: `${ref.url}#comment-${commentId}` } },
+                        } }),
+                };
+            case "repo:push":
+                return {
+                    eventType: event,
+                    header: event,
+                    payload: Object.assign(Object.assign({}, base), { push: {
+                            changes: [
+                                {
+                                    new: {
+                                        type: "branch",
+                                        name: (_d = pullRequest.sourceBranch) !== null && _d !== void 0 ? _d : "",
+                                        target: { hash: headSha },
+                                    },
+                                    old: {
+                                        type: "branch",
+                                        name: (_e = pullRequest.sourceBranch) !== null && _e !== void 0 ? _e : "",
+                                        target: { hash: baseSha },
+                                    },
+                                },
+                            ],
+                        } }),
+                };
+        }
+    }
+    const header = DATA_CENTER_HEADER[event];
+    const base = {
+        eventKey: header,
+        date: new Date().toISOString(),
+        actor: dcActor(actor),
+    };
+    const dcPr = dcPullRequest(pullRequest, ref.repository, actor, ref.url);
+    switch (event) {
+        case "pullrequest:created":
+            return {
+                eventType: event,
+                header,
+                payload: Object.assign(Object.assign({}, base), { pullRequest: dcPr }),
+            };
+        case "pullrequest:updated":
+            // `pr:from_ref_updated` carries the previous head; the default dispatch
+            // keys on it to tell a push from a title edit.
+            return {
+                eventType: event,
+                header,
+                payload: Object.assign(Object.assign({}, base), { pullRequest: dcPr, previousFromHash: baseSha }),
+            };
+        case "pullrequest:comment_created":
+            return {
+                eventType: event,
+                header,
+                payload: Object.assign(Object.assign({}, base), { pullRequest: dcPr, comment: { id: commentId, text: comment, author: dcActor(actor) } }),
+            };
+        case "repo:push":
+            return {
+                eventType: event,
+                header,
+                payload: Object.assign(Object.assign({}, base), { repository: dcRepository(ref.repository), changes: [
+                        {
+                            ref: {
+                                id: `refs/heads/${(_f = pullRequest.sourceBranch) !== null && _f !== void 0 ? _f : ""}`,
+                                displayId: (_g = pullRequest.sourceBranch) !== null && _g !== void 0 ? _g : "",
+                                type: "BRANCH",
+                            },
+                            refId: `refs/heads/${(_h = pullRequest.sourceBranch) !== null && _h !== void 0 ? _h : ""}`,
+                            fromHash: baseSha,
+                            toHash: headSha,
+                            type: "UPDATE",
+                        },
+                    ] }),
+            };
+    }
+}
+/**
+ * Choose events to replay: explicit list (either dialect's keys), `*` for
+ * every declared, else `pullrequest:created`.
+ */
+export function selectBitbucketReplayEvents(requested, declared) {
+    const wanted = requested === undefined
+        ? ["pullrequest:created"]
+        : requested.includes("*")
+            ? [...declared]
+            : [...requested];
+    const events = [];
+    const unsupported = [];
+    for (const raw of new Set(wanted)) {
+        const event = normalizeBitbucketEventKey(raw);
+        if (isBitbucketSynthesizableEvent(event)) {
+            if (!events.includes(event)) {
+                events.push(event);
+            }
+        }
+        else {
+            unsupported.push(raw);
+        }
+    }
+    return { events, unsupported };
+}