@cursor/july 0.1.1

package/dist/internal/event-mapper.js

@@ -0,0 +1,226 @@
+/**
+ * Maps the Cursor harness's streaming delta vocabulary
+ * (`InteractionUpdate`) onto the framework's channel event vocabulary
+ * (`SessionEvent` payloads). One mapper instance covers one turn.
+ */
+const CUSTOM_TOOLS_PROVIDER = "custom-user-tools";
+export class TurnEventMapper {
+    constructor(emit) {
+        this.emit = emit;
+        this.textAccumulator = "";
+        this.reasoningAccumulator = "";
+    }
+    /** Per-turn token usage summed across model steps. */
+    get usage() {
+        return this.usageTotal;
+    }
+    /** The final assistant text block of the turn, when one was produced. */
+    get finalText() {
+        return this.lastAssistantText;
+    }
+    /** Conversation summary produced by the harness (used as session title). */
+    get title() {
+        return this.summaryTitle;
+    }
+    handleUpdate(update) {
+        switch (update.type) {
+            case "text-delta": {
+                this.textAccumulator += update.text;
+                this.emit({
+                    type: "message.appended",
+                    data: { delta: update.text, text: this.textAccumulator },
+                });
+                return;
+            }
+            case "thinking-delta": {
+                this.reasoningAccumulator += update.text;
+                this.emit({
+                    type: "reasoning.appended",
+                    data: { delta: update.text, text: this.reasoningAccumulator },
+                });
+                return;
+            }
+            case "thinking-completed": {
+                if (this.reasoningAccumulator !== "") {
+                    this.reasoningAccumulator = "";
+                }
+                this.emit({
+                    type: "reasoning.completed",
+                    data: { durationMs: update.thinkingDurationMs },
+                });
+                return;
+            }
+            case "tool-call-started": {
+                this.flushAssistantText("tool_call");
+                const description = describeToolCall(update.toolCall);
+                this.emit({
+                    type: "actions.requested",
+                    data: {
+                        calls: [
+                            {
+                                callId: update.callId,
+                                toolName: description.toolName,
+                                args: description.args,
+                            },
+                        ],
+                    },
+                });
+                if (description.subagent !== undefined) {
+                    this.emit({
+                        type: "subagent.called",
+                        data: {
+                            callId: update.callId,
+                            name: description.subagent.name,
+                            description: description.subagent.description,
+                        },
+                    });
+                }
+                return;
+            }
+            case "tool-call-completed": {
+                const description = describeToolCall(update.toolCall);
+                const result = describeToolResult(update.toolCall);
+                this.emit({
+                    type: "action.result",
+                    data: {
+                        callId: update.callId,
+                        toolName: description.toolName,
+                        output: result.output,
+                        isError: result.isError,
+                    },
+                });
+                if (description.subagent !== undefined) {
+                    this.emit({
+                        type: "subagent.completed",
+                        data: { callId: update.callId, name: description.subagent.name },
+                    });
+                }
+                return;
+            }
+            case "step-started": {
+                this.emit({ type: "step.started", data: { stepId: update.stepId } });
+                return;
+            }
+            case "step-completed": {
+                this.emit({
+                    type: "step.completed",
+                    data: { stepId: update.stepId, durationMs: update.stepDurationMs },
+                });
+                return;
+            }
+            case "turn-ended": {
+                if (update.usage !== undefined) {
+                    this.usageTotal = addUsage(this.usageTotal, update.usage);
+                }
+                return;
+            }
+            case "summary": {
+                this.summaryTitle = update.summary;
+                return;
+            }
+            case "user-message-appended":
+            case "partial-tool-call":
+            case "token-delta":
+            case "summary-started":
+            case "summary-completed":
+            case "shell-output-delta":
+                return;
+            default: {
+                // Future harness update types are ignored rather than fatal.
+                return;
+            }
+        }
+    }
+    /** Close out the turn: finalize any open assistant text block. */
+    finish() {
+        this.flushAssistantText("stop");
+    }
+    flushAssistantText(finishReason) {
+        if (this.textAccumulator === "") {
+            return;
+        }
+        const text = this.textAccumulator;
+        this.textAccumulator = "";
+        this.lastAssistantText = text;
+        this.emit({
+            type: "message.completed",
+            data: { text, finishReason },
+        });
+    }
+}
+/**
+ * Human-meaningful tool identity for stream events. In-process tools calls
+ * arrive as MCP calls against the synthetic `custom-user-tools` server; they
+ * surface under the customer's bare tool name.
+ */
+export function describeToolCall(toolCall) {
+    var _a;
+    switch (toolCall.type) {
+        case "mcp": {
+            const providerIdentifier = toolCall.args.providerIdentifier;
+            const toolName = toolCall.args.toolName;
+            if (providerIdentifier === CUSTOM_TOOLS_PROVIDER) {
+                return {
+                    toolName: toolName !== null && toolName !== void 0 ? toolName : "custom-tool",
+                    args: toolCall.args.args,
+                };
+            }
+            const bareName = toolName !== null && toolName !== void 0 ? toolName : "tool";
+            return {
+                toolName: providerIdentifier === undefined || providerIdentifier === ""
+                    ? bareName
+                    : `${providerIdentifier}:${bareName}`,
+                args: toolCall.args.args,
+            };
+        }
+        case "task": {
+            const subagentType = toolCall.args.subagentType;
+            const subagentName = (_a = subagentType === null || subagentType === void 0 ? void 0 : subagentType.name) !== null && _a !== void 0 ? _a : subagentType === null || subagentType === void 0 ? void 0 : subagentType.kind;
+            return {
+                toolName: "task",
+                args: Object.assign({ description: toolCall.args.description }, (subagentName === undefined ? {} : { subagentType: subagentName })),
+                subagent: Object.assign(Object.assign({}, (subagentName === undefined ? {} : { name: subagentName })), { description: toolCall.args.description }),
+            };
+        }
+        default: {
+            return {
+                toolName: toolCall.type,
+                args: toolCall.args,
+            };
+        }
+    }
+}
+export function describeToolResult(toolCall) {
+    var _a;
+    const result = toolCall.result;
+    if (result === undefined || result === null) {
+        return { isError: false };
+    }
+    if (result.status === "error") {
+        return { output: result.error, isError: true };
+    }
+    if (toolCall.type === "mcp") {
+        const value = result.value;
+        const text = ((_a = value.content) !== null && _a !== void 0 ? _a : [])
+            .map((item) => { var _a; var _b; return (_b = (_a = item.text) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : ""; })
+            .filter((part) => part !== "")
+            .join("\n");
+        return {
+            output: text === "" ? value : text,
+            isError: value.isError === true,
+        };
+    }
+    return { output: result.value, isError: false };
+}
+function addUsage(total, usage) {
+    var _a, _b;
+    if (total === undefined) {
+        return Object.assign({}, usage);
+    }
+    return Object.assign({ inputTokens: total.inputTokens + usage.inputTokens, outputTokens: total.outputTokens + usage.outputTokens, cacheReadTokens: total.cacheReadTokens + usage.cacheReadTokens, cacheWriteTokens: total.cacheWriteTokens + usage.cacheWriteTokens }, (total.reasoningTokens !== undefined ||
+        usage.reasoningTokens !== undefined
+        ? {
+            reasoningTokens: ((_a = total.reasoningTokens) !== null && _a !== void 0 ? _a : 0) + ((_b = usage.reasoningTokens) !== null && _b !== void 0 ? _b : 0),
+        }
+        : {}));
+}

package/dist/internal/frontmatter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Minimal frontmatter parser. Supports the flat `key: value` scalar subset
+ * used by authored markdown (skill descriptions, schedule cron expressions)
+ * without pulling in a YAML dependency.
+ */
+export interface ParsedFrontmatter {
+    data: Record<string, string>;
+    body: string;
+}
+export declare function parseFrontmatter(source: string): ParsedFrontmatter;
+export declare function serializeFrontmatter(data: Record<string, string>): string;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/internal/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/internal/frontmatter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd;AAID,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAsClE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAKzE"}

package/dist/internal/frontmatter.js

@@ -0,0 +1,61 @@
+/**
+ * Minimal frontmatter parser. Supports the flat `key: value` scalar subset
+ * used by authored markdown (skill descriptions, schedule cron expressions)
+ * without pulling in a YAML dependency.
+ */
+const FRONTMATTER_OPEN = /^---\s*$/;
+export function parseFrontmatter(source) {
+    var _a, _b;
+    const lines = source.split(/\r?\n/);
+    if (lines.length === 0 || !FRONTMATTER_OPEN.test((_a = lines[0]) !== null && _a !== void 0 ? _a : "")) {
+        return { data: {}, body: source };
+    }
+    let closeIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (FRONTMATTER_OPEN.test((_b = lines[i]) !== null && _b !== void 0 ? _b : "")) {
+            closeIndex = i;
+            break;
+        }
+    }
+    if (closeIndex === -1) {
+        return { data: {}, body: source };
+    }
+    const data = {};
+    for (const line of lines.slice(1, closeIndex)) {
+        if (line.trim() === "" || line.trim().startsWith("#")) {
+            continue;
+        }
+        const separator = line.indexOf(":");
+        if (separator === -1) {
+            continue;
+        }
+        const key = line.slice(0, separator).trim();
+        if (key === "") {
+            continue;
+        }
+        data[key] = unquote(line.slice(separator + 1).trim());
+    }
+    const body = lines
+        .slice(closeIndex + 1)
+        .join("\n")
+        .replace(/^\n+/, "");
+    return { data, body };
+}
+export function serializeFrontmatter(data) {
+    const lines = Object.entries(data).map(([key, value]) => `${key}: ${quoteIfNeeded(value)}`);
+    return `---\n${lines.join("\n")}\n---\n`;
+}
+function unquote(value) {
+    if (value.length >= 2 &&
+        ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'")))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function quoteIfNeeded(value) {
+    if (/[:#'"\n]/.test(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}

package/dist/internal/github-fanout.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Local fan-out proxy for `agent-serve github forward`.
+ *
+ * `gh webhook forward` can only target a single URL, and GitHub allows just one
+ * forwarder per repo/org. To feed several GitHub channels at once, we run one
+ * forwarder into this loopback proxy, which re-posts each delivery — raw body
+ * and signature headers intact, so per-channel `X-Hub-Signature-256` checks
+ * still pass — to every channel whose declared event set matches the
+ * delivery's `x-github-event`.
+ */
+import { type IncomingMessage } from "node:http";
+import { type GitHubForwardTarget } from "../channels/github/forward.js";
+/** Request headers copied verbatim from gh onto each fanned-out delivery. */
+export declare const FANOUT_FORWARD_HEADERS: readonly string[];
+export interface FanoutServer {
+    /** Loopback URL to point `gh webhook forward --url` at. */
+    url: string;
+    close(): void;
+}
+export interface FanoutOptions {
+    /** Sink for per-delivery failures. Defaults to `process.stderr`. */
+    logger?: (line: string) => void;
+}
+/** Start a loopback proxy that fans deliveries out to {@link targets}. */
+export declare function startFanoutServer(targets: readonly GitHubForwardTarget[], options?: FanoutOptions): Promise<FanoutServer>;
+/**
+ * Re-post a single delivery to the matching targets, returning the labels that
+ * accepted it. Only targets whose event set includes the delivery's
+ * `x-github-event` receive it (all of them when the header is absent).
+ */
+export declare function fanoutDelivery(body: Buffer, headers: IncomingMessage["headers"], targets: readonly GitHubForwardTarget[], options?: FanoutOptions): Promise<string[]>;
+//# sourceMappingURL=github-fanout.d.ts.map

package/dist/internal/github-fanout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github-fanout.d.ts","sourceRoot":"","sources":["../../src/internal/github-fanout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAEnB,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,+BAA+B,CAAC;AAEvC,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EASnD,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,2DAA2D;IAC3D,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,0EAA0E;AAC1E,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAiBvB;AA8BD;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,CAAC,SAAS,CAAC,EACnC,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,MAAM,EAAE,CAAC,CAoDnB"}

package/dist/internal/github-fanout.js

@@ -0,0 +1,122 @@
+/**
+ * Local fan-out proxy for `agent-serve github forward`.
+ *
+ * `gh webhook forward` can only target a single URL, and GitHub allows just one
+ * forwarder per repo/org. To feed several GitHub channels at once, we run one
+ * forwarder into this loopback proxy, which re-posts each delivery — raw body
+ * and signature headers intact, so per-channel `X-Hub-Signature-256` checks
+ * still pass — to every channel whose declared event set matches the
+ * delivery's `x-github-event`.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createServer, } from "node:http";
+import { targetLabel, } from "../channels/github/forward.js";
+/** Request headers copied verbatim from gh onto each fanned-out delivery. */
+export const FANOUT_FORWARD_HEADERS = [
+    "content-type",
+    "x-github-event",
+    "x-github-delivery",
+    "x-github-hook-id",
+    "x-hub-signature",
+    "x-hub-signature-256",
+    "user-agent",
+    "accept",
+];
+/** Start a loopback proxy that fans deliveries out to {@link targets}. */
+export function startFanoutServer(targets_1) {
+    return __awaiter(this, arguments, void 0, function* (targets, options = {}) {
+        const server = createServer((req, res) => {
+            handleFanoutRequest(req, res, targets, options);
+        });
+        yield new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", () => {
+                resolve();
+            });
+        });
+        const address = server.address();
+        return {
+            url: `http://127.0.0.1:${address.port}`,
+            close: () => {
+                server.close();
+            },
+        };
+    });
+}
+function handleFanoutRequest(req, res, targets, options) {
+    const chunks = [];
+    req.on("data", (chunk) => {
+        chunks.push(chunk);
+    });
+    req.on("end", () => {
+        void fanoutDelivery(Buffer.concat(chunks), req.headers, targets, options)
+            .then((delivered) => {
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(JSON.stringify({ ok: true, delivered }));
+        })
+            .catch((error) => {
+            res.writeHead(502, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        });
+    });
+}
+/**
+ * Re-post a single delivery to the matching targets, returning the labels that
+ * accepted it. Only targets whose event set includes the delivery's
+ * `x-github-event` receive it (all of them when the header is absent).
+ */
+export function fanoutDelivery(body_1, headers_1, targets_1) {
+    return __awaiter(this, arguments, void 0, function* (body, headers, targets, options = {}) {
+        var _a;
+        const log = (_a = options.logger) !== null && _a !== void 0 ? _a : ((line) => process.stderr.write(line));
+        const event = typeof headers["x-github-event"] === "string"
+            ? headers["x-github-event"]
+            : undefined;
+        const outbound = {};
+        for (const name of FANOUT_FORWARD_HEADERS) {
+            const value = headers[name];
+            if (typeof value === "string") {
+                outbound[name] = value;
+            }
+        }
+        const recipients = targets.filter((target) => event === undefined || target.events.includes(event));
+        // Reuse one Uint8Array view across recipients (Buffer isn't a BodyInit).
+        const payload = new Uint8Array(body);
+        const delivered = [];
+        // Bounded by the number of GitHub channels in the project (a handful), so
+        // unbounded-concurrency concerns do not apply here.
+        yield Promise.all(recipients.map((target) => __awaiter(this, void 0, void 0, function* () {
+            const label = targetLabel(target);
+            try {
+                const response = yield fetch(target.url, {
+                    method: "POST",
+                    headers: outbound,
+                    body: payload,
+                });
+                if (!response.ok) {
+                    log(`[agent-serve] delivery to ${label} failed: HTTP ${response.status}\n`);
+                    return;
+                }
+                delivered.push(label);
+            }
+            catch (error) {
+                log(`[agent-serve] delivery to ${label} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        })));
+        if (recipients.length > 0 && delivered.length === 0) {
+            throw new Error(`fan-out delivery failed for all ${recipients.length} matching channel(s)`);
+        }
+        return delivered;
+    });
+}

package/dist/internal/handleAgentServeTrigger.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * 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`.
+ *
+ * Each agent's `onPullRequest` / `onComment` / … hooks decide whether to run.
+ */
+import type { GitHubChannelOptions } from "../channels/github/types.js";
+import type { ChannelHandlerArgs } from "../types.js";
+export interface AgentServeGitHubTriggerTarget {
+    /** Agent mount slug (empty string in single-agent mode). */
+    slug: string;
+    /** Options from the agent's `githubChannel({ ... })` definition. */
+    options: GitHubChannelOptions;
+    /** Per-agent channel handler args (`send`, `waitUntil`, `host`, …). */
+    args: ChannelHandlerArgs;
+}
+export interface AgentServeGitHubTriggerEvent {
+    type: "github";
+    /** Raw webhook body (signature already verified by the caller). */
+    bodyText: string;
+    eventName: string | null;
+    deliveryId?: string;
+    targets: AgentServeGitHubTriggerTarget[];
+}
+export type AgentServeTriggerEvent = AgentServeGitHubTriggerEvent;
+export interface AgentServeTriggerTargetResult {
+    slug: string;
+    status: number;
+    body: unknown;
+}
+export interface AgentServeTriggerResult {
+    ok: boolean;
+    event: string | null;
+    targets: AgentServeTriggerTargetResult[];
+}
+/**
+ * Build fan-out targets from mounted agent projects that export a github
+ * channel created via {@link githubChannel}.
+ */
+export declare function collectGitHubTriggerTargets(input: {
+    mounts: Array<{
+        slug: string;
+        channels: Array<{
+            id: string;
+            definition: object;
+        }>;
+        buildHandlerArgs: (channelId: string) => ChannelHandlerArgs;
+    }>;
+}): AgentServeGitHubTriggerTarget[];
+/**
+ * Dispatch an agent-serve trigger. GitHub only for now.
+ */
+export declare function handleAgentServeTrigger(event: AgentServeTriggerEvent): Promise<AgentServeTriggerResult>;
+//# sourceMappingURL=handleAgentServeTrigger.d.ts.map

package/dist/internal/handleAgentServeTrigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleAgentServeTrigger.d.ts","sourceRoot":"","sources":["../../src/internal/handleAgentServeTrigger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,6BAA6B;IAC5C,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,OAAO,EAAE,oBAAoB,CAAC;IAC9B,uEAAuE;IACvE,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IAC3C,IAAI,EAAE,QAAQ,CAAC;IACf,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,6BAA6B,EAAE,CAAC;CAC1C;AAED,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,CAAC;AAElE,MAAM,WAAW,6BAA6B;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,6BAA6B,EAAE,CAAC;CAC1C;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,KAAK,CAAC;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QACpD,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,kBAAkB,CAAC;KAC7D,CAAC,CAAC;CACJ,GAAG,6BAA6B,EAAE,CAkBlC;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CAYlC"}

package/dist/internal/handleAgentServeTrigger.js

@@ -0,0 +1,115 @@
+/**
+ * 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.
+ *
+ * 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`.
+ *
+ * Each agent's `onPullRequest` / `onComment` / … hooks decide whether to run.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { dispatchGitHubWebhook, getGitHubChannelOptions, } from "../channels/github/github-channel.js";
+/**
+ * Build fan-out targets from mounted agent projects that export a github
+ * channel created via {@link githubChannel}.
+ */
+export function collectGitHubTriggerTargets(input) {
+    const targets = [];
+    for (const mount of input.mounts) {
+        const github = mount.channels.find((channel) => channel.id === "github");
+        if (github === undefined) {
+            continue;
+        }
+        const options = getGitHubChannelOptions(github.definition);
+        if (options === undefined) {
+            continue;
+        }
+        targets.push({
+            slug: mount.slug,
+            options,
+            args: mount.buildHandlerArgs("github"),
+        });
+    }
+    return targets;
+}
+/**
+ * Dispatch an agent-serve trigger. GitHub only for now.
+ */
+export function handleAgentServeTrigger(event) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (event.type) {
+            // TODO: Add support for other event types (e.g. Linear, Slack, etc.).
+            case "github":
+                return handleAgentServeGitHubTrigger(event);
+            default: {
+                const _ = event.type;
+                throw new Error(`handleAgentServeTrigger: unknown event type: ${String(_)}`);
+            }
+        }
+    });
+}
+function handleAgentServeGitHubTrigger(event) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (event.eventName === "ping") {
+            return {
+                ok: true,
+                event: "ping",
+                targets: [],
+            };
+        }
+        let payload;
+        try {
+            payload = JSON.parse(event.bodyText);
+        }
+        catch (_a) {
+            return {
+                ok: false,
+                event: event.eventName,
+                targets: [
+                    {
+                        slug: "",
+                        status: 400,
+                        body: { ok: false, error: "invalid_json" },
+                    },
+                ],
+            };
+        }
+        const targets = [];
+        for (const target of event.targets) {
+            const response = yield dispatchGitHubWebhook({
+                options: target.options,
+                eventName: event.eventName,
+                payload,
+                deliveryId: event.deliveryId,
+                args: target.args,
+            });
+            let body;
+            try {
+                body = yield response.json();
+            }
+            catch (_b) {
+                body = { ok: false, error: "invalid_response_json" };
+            }
+            targets.push({
+                slug: target.slug,
+                status: response.status,
+                body,
+            });
+        }
+        return {
+            ok: true,
+            event: event.eventName,
+            targets,
+        };
+    });
+}