@mastra/factory 0.0.0 → 0.1.0-alpha.3

package/dist/integrations/platform/github/event-worker.js

@@ -0,0 +1,585 @@
+// src/integrations/platform/github/event-worker.ts
+import { randomUUID } from "crypto";
+import { isLeaseProvider, NoopLeaseProvider } from "@mastra/core/events";
+import { MastraWorker } from "@mastra/core/worker";
+
+// src/integrations/github/subscriptions.ts
+function changeRequestTargetKey(input) {
+  return `change-request:${input.installationExternalId}:${input.repositoryExternalId}:${input.changeRequestId}`;
+}
+async function listPullRequestSubscriptionsForWebhook(input, options, storage) {
+  const rows = await storage.subscriptions.listByTarget(changeRequestTargetKey(input));
+  return options?.includeTerminal ? rows : rows.filter((row) => row.status === "open");
+}
+function retirePullRequestSubscription(id, status, storage) {
+  return storage.subscriptions.updateStatus(id, status);
+}
+
+// src/integrations/github/webhook.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function getObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function getString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function getNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function getBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function normalizeGithubWebhookMetadata(parsed) {
+  const { event, deliveryId, payload } = parsed;
+  const repository = getObject(payload.repository);
+  const issue = getObject(payload.issue);
+  const pullRequest = getObject(payload.pull_request);
+  const sender = getObject(payload.sender);
+  const installation = getObject(payload.installation);
+  const issuePullRequest = getObject(issue?.pull_request);
+  return {
+    event,
+    action: getString(payload.action),
+    deliveryId,
+    repository: getString(repository?.full_name),
+    repositoryId: getNumber(repository?.id),
+    issueNumber: getNumber(issue?.number),
+    pullRequestNumber: getNumber(pullRequest?.number) ?? (event === "issue_comment" && issuePullRequest ? getNumber(issue?.number) : void 0),
+    sender: getString(sender?.login),
+    senderType: getString(sender?.type),
+    installationId: getNumber(installation?.id)
+  };
+}
+function notificationSummary(metadata, label) {
+  const actor = metadata.sender ? `${metadata.sender} ` : "";
+  return `${actor}${label} on ${metadata.repository}#${metadata.pullRequestNumber}`;
+}
+function notificationTargetUrl(event, payload) {
+  if (event === "issue_comment" || event === "pull_request_review_comment") {
+    return getString(getObject(payload.comment)?.html_url);
+  }
+  if (event === "pull_request_review") {
+    return getString(getObject(payload.review)?.html_url);
+  }
+  return getString(getObject(payload.pull_request)?.html_url);
+}
+function classifyGithubWebhook(parsed) {
+  const metadata = normalizeGithubWebhookMetadata(parsed);
+  const { event, payload } = parsed;
+  const action = metadata.action;
+  if (!action || !metadata.repositoryId || !metadata.installationId || !metadata.pullRequestNumber || !metadata.repository) {
+    return void 0;
+  }
+  let priority;
+  let kind;
+  let label;
+  let terminal = false;
+  if (event === "pull_request_review" && action === "submitted") {
+    const state = getString(getObject(payload.review)?.state)?.toLowerCase().replaceAll("_", "-");
+    priority = state === "approved" || state === "changes-requested" ? "urgent" : "high";
+    kind = state === "approved" ? "review-approved" : state === "changes-requested" ? "review-changes-requested" : "review-submitted";
+    label = state === "approved" ? "approved the pull request" : state === "changes-requested" ? "requested changes" : "submitted a review";
+  } else if (event === "pull_request" && action === "closed") {
+    const merged = getBoolean(getObject(payload.pull_request)?.merged) === true;
+    priority = "urgent";
+    kind = merged ? "pull-request-merged" : "pull-request-closed";
+    label = merged ? "merged the pull request" : "closed the pull request";
+    terminal = true;
+  } else if (event === "issue_comment" && action === "created") {
+    priority = "high";
+    kind = "issue-comment-created";
+    label = "commented";
+  } else if (event === "pull_request_review_comment" && action === "created") {
+    priority = "high";
+    kind = "review-comment-created";
+    label = "left a review comment";
+  } else if (event === "pull_request" && action === "reopened") {
+    priority = "high";
+    kind = "pull-request-reopened";
+    label = "reopened the pull request";
+  } else if (event === "pull_request_review" && action === "dismissed") {
+    priority = "high";
+    kind = "review-dismissed";
+    label = "dismissed a review";
+  } else if (event === "pull_request" && [
+    "synchronize",
+    "ready_for_review",
+    "converted_to_draft",
+    "assigned",
+    "unassigned",
+    "review_requested",
+    "review_request_removed"
+  ].includes(action)) {
+    priority = "medium";
+    kind = `pull-request-${action.replaceAll("_", "-")}`;
+    label = action.replaceAll("_", " ");
+  } else if (event === "pull_request" && ["edited", "labeled", "unlabeled", "milestoned", "demilestoned"].includes(action)) {
+    priority = "low";
+    kind = `pull-request-${action.replaceAll("_", "-")}`;
+    label = action.replaceAll("_", " ");
+  } else {
+    return void 0;
+  }
+  return {
+    action,
+    kind,
+    priority,
+    summary: notificationSummary(metadata, label),
+    terminal,
+    metadata: {
+      ...metadata,
+      pullRequestNumber: metadata.pullRequestNumber,
+      repositoryId: metadata.repositoryId,
+      installationId: metadata.installationId
+    },
+    payload
+  };
+}
+async function resolveSubscriptionSession(controller, subscription) {
+  const { sessionId, resourceId, threadId } = subscription;
+  if (!sessionId || !resourceId || !threadId) {
+    throw new Error(`GitHub subscription ${subscription.id} is missing its session binding.`);
+  }
+  const scope = subscription.sessionScope || void 0;
+  let session = await controller.getSessionByResource(resourceId, scope);
+  if (!session) {
+    const tags = {
+      factoryProjectId: resourceId,
+      projectRepositoryId: subscription.data.projectRepositoryId,
+      ...scope ? { worktreePath: scope } : {}
+    };
+    session = await controller.createSession({
+      id: sessionId,
+      ownerId: subscription.data.ownerId,
+      resourceId,
+      scope,
+      tags
+    });
+  }
+  if (session.thread.getId() !== threadId) {
+    await session.thread.switch({ threadId, emitEvent: false });
+  }
+  if (session.thread.getId() !== threadId) {
+    throw new Error(`Session ${sessionId} did not bind thread ${threadId}.`);
+  }
+  return session;
+}
+var AUTHORIZED_BOTS = /* @__PURE__ */ new Set(["coderabbitai[bot]", "devin-ai-integration[bot]"]);
+var AUTHORIZED_PERMISSIONS = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var PERMISSION_CHECK_TIMEOUT_MS = 5e3;
+var AUTHOR_GATED_KINDS = /* @__PURE__ */ new Set([
+  "issue-comment-created",
+  "review-comment-created",
+  "review-submitted",
+  "review-approved",
+  "review-changes-requested",
+  "review-dismissed"
+]);
+async function isAuthorizedGithubSender(notification, github) {
+  if (!AUTHOR_GATED_KINDS.has(notification.kind)) return true;
+  const sender = notification.metadata.sender;
+  const repository = notification.metadata.repository;
+  if (!sender || !repository) return false;
+  const normalizedSender = sender.toLowerCase();
+  if (notification.metadata.senderType?.toLowerCase() === "bot" || normalizedSender.endsWith("[bot]")) {
+    return AUTHORIZED_BOTS.has(normalizedSender);
+  }
+  if (!github) return false;
+  const abortController = new AbortController();
+  let timeout;
+  try {
+    const permission = await Promise.race([
+      github.getRepositoryCollaboratorPermission(
+        notification.metadata.installationId,
+        repository,
+        sender,
+        abortController.signal
+      ),
+      new Promise((resolve) => {
+        timeout = setTimeout(() => {
+          abortController.abort();
+          resolve(void 0);
+        }, PERMISSION_CHECK_TIMEOUT_MS);
+      })
+    ]);
+    return permission !== void 0 && AUTHORIZED_PERMISSIONS.has(permission);
+  } catch {
+    return false;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+async function dispatchGithubWebhook(parsed, dependencies) {
+  const notification = classifyGithubWebhook(parsed);
+  if (!notification) return { delivered: 0, failed: 0, ignored: true };
+  const isAuthorizedSender = dependencies.isAuthorizedSender ?? ((n) => isAuthorizedGithubSender(n, dependencies.github));
+  if (!await isAuthorizedSender(notification)) {
+    return { delivered: 0, failed: 0, ignored: true };
+  }
+  const target = {
+    installationExternalId: notification.metadata.installationId.toString(),
+    repositoryExternalId: notification.metadata.repositoryId.toString(),
+    changeRequestId: notification.metadata.pullRequestNumber.toString()
+  };
+  const listSubscriptions = dependencies.listSubscriptions ?? ((subscriptionTarget, options) => {
+    if (!dependencies.github) throw new Error("GitHub integration is required to load webhook subscriptions.");
+    return listPullRequestSubscriptionsForWebhook(
+      subscriptionTarget,
+      options,
+      dependencies.github.integrationStorage
+    );
+  });
+  const retireSubscription = dependencies.retireSubscription ?? ((id, status) => {
+    if (!dependencies.github) throw new Error("GitHub integration is required to retire webhook subscriptions.");
+    return retirePullRequestSubscription(id, status, dependencies.github.integrationStorage);
+  });
+  const subscriptions = await listSubscriptions(target, { includeTerminal: notification.action === "reopened" });
+  let delivered = 0;
+  let failed = 0;
+  for (const subscription of subscriptions) {
+    try {
+      const session = await resolveSubscriptionSession(dependencies.controller, subscription);
+      const result = await session.sendNotificationSignal({
+        source: "github",
+        kind: notification.kind,
+        summary: notification.summary,
+        priority: notification.priority,
+        payload: notification.payload,
+        sourceId: parsed.deliveryId,
+        dedupeKey: `${parsed.deliveryId}:${subscription.sessionId}:${subscription.threadId}`,
+        coalesceKey: `github:${subscription.data.repositoryExternalId}:pull-request:${subscription.data.changeRequestId}`,
+        metadata: {
+          event: notification.metadata.event,
+          action: notification.action,
+          repository: notification.metadata.repository,
+          issueNumber: notification.metadata.issueNumber,
+          pullRequestNumber: notification.metadata.pullRequestNumber,
+          targetUrl: notificationTargetUrl(parsed.event, parsed.payload),
+          deliveryId: parsed.deliveryId
+        }
+      });
+      await Promise.all([result.persisted, result.accepted].filter(Boolean));
+      if (notification.terminal) {
+        await retireSubscription(subscription.id, notification.kind === "pull-request-merged" ? "merged" : "closed");
+      } else if (notification.action === "reopened") {
+        await retireSubscription(subscription.id, "open");
+      }
+      delivered += 1;
+    } catch (error) {
+      failed += 1;
+      dependencies.onTargetError?.(subscription, error);
+    }
+  }
+  return { delivered, failed, ignored: false };
+}
+
+// src/integrations/platform/api-client.ts
+var PlatformApiError = class extends Error {
+  status;
+  retryAfterSeconds;
+  constructor(message, status, retryAfterSeconds = null) {
+    super(message);
+    this.name = "PlatformApiError";
+    this.status = status;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+
+// src/integrations/platform/github/event-worker.ts
+var API_PREFIX = "/v1/server/github-app";
+var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var EVENT_PAGE_SIZE = 500;
+var MIN_LEASE_TTL_MS = 3e4;
+var CURSOR_ORG_ID = "__platform_github_event_worker__";
+var CURSOR_USER_ID = "worker";
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+  "issues",
+  "issue_comment",
+  "pull_request",
+  "pull_request_review",
+  "pull_request_review_comment"
+]);
+var AUTHOR_GATED_KINDS2 = /* @__PURE__ */ new Set([
+  "issue-comment",
+  "pull-request-comment",
+  "pull-request-review",
+  "pull-request-review-comment"
+]);
+var AUTHORIZED_BOTS2 = /* @__PURE__ */ new Set(["coderabbitai[bot]", "devin-ai-integration[bot]"]);
+var AUTHORIZED_PERMISSIONS2 = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var PERMISSION_CHECK_TIMEOUT_MS2 = 5e3;
+var PlatformGithubEventWorker = class extends MastraWorker {
+  name = "platform-github-events";
+  #client;
+  #controller;
+  #github;
+  #storage;
+  #ingestFactoryEvent;
+  #intervalMs;
+  #now;
+  #dispatch;
+  #leaseOwner = randomUUID();
+  #running = false;
+  #timer;
+  #leaseRenewalTimer;
+  #inFlight;
+  #leaseProvider = NoopLeaseProvider;
+  #leaseTtlMs;
+  #hasLease = false;
+  #startedAt = 0;
+  #settings = { version: 1, repositories: {} };
+  constructor(config) {
+    super();
+    this.#client = config.client;
+    this.#controller = config.controller;
+    this.#github = config.github;
+    this.#storage = config.storage;
+    this.#ingestFactoryEvent = config.ingestFactoryEvent;
+    this.#intervalMs = config.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    if (!Number.isFinite(this.#intervalMs) || this.#intervalMs <= 0) {
+      throw new Error("Platform GitHub event polling interval must be a positive number.");
+    }
+    this.#leaseTtlMs = Math.max(MIN_LEASE_TTL_MS, this.#intervalMs * 3);
+    this.#now = config.now ?? Date.now;
+    this.#dispatch = config.dispatch ?? dispatchGithubWebhook;
+  }
+  async init(deps) {
+    await super.init(deps);
+    this.#leaseProvider = getLeaseProvider(deps.pubsub);
+  }
+  async start() {
+    if (this.#running) return;
+    if (!this.deps) throw new Error("PlatformGithubEventWorker: call init() before start()");
+    this.#startedAt = this.#now() - 1;
+    this.#settings = normalizeSettings(await this.#storage.settings.get(CURSOR_ORG_ID, CURSOR_USER_ID));
+    this.#running = true;
+    this.deps.logger.info("Platform GitHub event polling started", {
+      intervalMs: this.#intervalMs,
+      leaseTtlMs: this.#leaseTtlMs
+    });
+    this.#schedule(0);
+  }
+  async stop() {
+    if (!this.#running) return;
+    this.#running = false;
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = void 0;
+    this.#stopLeaseRenewal();
+    await this.#inFlight;
+    if (this.#hasLease) {
+      await this.#leaseProvider.releaseLease(this.#leaseKey(), this.#leaseOwner).catch(() => void 0);
+      this.#hasLease = false;
+    }
+  }
+  get isRunning() {
+    return this.#running;
+  }
+  #schedule(delayMs) {
+    if (!this.#running) return;
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      const run = this.#tick();
+      this.#inFlight = run;
+      void run.finally(() => {
+        if (this.#inFlight === run) this.#inFlight = void 0;
+      });
+    }, delayMs);
+    this.#timer.unref?.();
+  }
+  async #tick() {
+    let nextDelay = this.#intervalMs;
+    try {
+      if (!await this.#ensureLease()) return;
+      nextDelay = await this.#poll();
+    } catch (error) {
+      nextDelay = retryDelay(error, this.#intervalMs);
+      this.deps?.logger.error("Platform GitHub event polling cycle failed", {
+        error: error instanceof Error ? error.message : String(error),
+        retryInMs: nextDelay
+      });
+    } finally {
+      this.#schedule(nextDelay);
+    }
+  }
+  async #ensureLease() {
+    if (this.#hasLease) return true;
+    const result = await this.#leaseProvider.acquireLease(this.#leaseKey(), this.#leaseOwner, this.#leaseTtlMs);
+    this.#hasLease = result.acquired;
+    if (this.#hasLease) this.#startLeaseRenewal();
+    return this.#hasLease;
+  }
+  #startLeaseRenewal() {
+    if (this.#leaseRenewalTimer) return;
+    this.#leaseRenewalTimer = setInterval(
+      () => {
+        void this.#leaseProvider.renewLease(this.#leaseKey(), this.#leaseOwner, this.#leaseTtlMs).then((renewed) => {
+          if (!renewed) {
+            this.#hasLease = false;
+            this.#stopLeaseRenewal();
+          }
+        }).catch((error) => {
+          this.#hasLease = false;
+          this.#stopLeaseRenewal();
+          this.deps?.logger.warn("Platform GitHub event polling lease renewal failed", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      },
+      Math.floor(this.#leaseTtlMs / 3)
+    );
+    this.#leaseRenewalTimer.unref?.();
+  }
+  #stopLeaseRenewal() {
+    if (this.#leaseRenewalTimer) clearInterval(this.#leaseRenewalTimer);
+    this.#leaseRenewalTimer = void 0;
+  }
+  async #poll() {
+    const repositories = await this.#discoverRepositories();
+    let retryInMs = this.#intervalMs;
+    for (const repository of repositories) {
+      if (!this.#running || !this.#hasLease) break;
+      try {
+        await this.#pollRepository(repository.id);
+      } catch (error) {
+        const delay = retryDelay(error, this.#intervalMs);
+        retryInMs = Math.max(retryInMs, delay);
+        this.deps?.logger.error("Platform GitHub repository event polling failed", {
+          repositoryId: repository.id,
+          error: error instanceof Error ? error.message : String(error),
+          retryInMs: delay
+        });
+        if (error instanceof PlatformApiError && error.status === 429) break;
+      }
+    }
+    return retryInMs;
+  }
+  async #discoverRepositories() {
+    const result = await this.#client.request("GET", `${API_PREFIX}/installations`);
+    const repositories = /* @__PURE__ */ new Map();
+    for (const installation of result.installations) {
+      if (!installation.usable || installation.suspendedAt) continue;
+      const page = await this.#client.request(
+        "GET",
+        `${API_PREFIX}/installations/${installation.installationId}/repositories`
+      );
+      for (const repository of page.repositories) repositories.set(repository.id, repository);
+    }
+    return [...repositories.values()];
+  }
+  async #pollRepository(repositoryId) {
+    const key = String(repositoryId);
+    if (!this.#settings.repositories[key]) {
+      this.#settings.repositories[key] = { afterTimestamp: this.#startedAt };
+      await this.#saveSettings();
+    }
+    while (this.#running && this.#hasLease) {
+      const cursor = this.#settings.repositories[key];
+      const query = new URLSearchParams({ limit: String(EVENT_PAGE_SIZE) });
+      if ("afterEventId" in cursor) query.set("afterEventId", cursor.afterEventId);
+      else query.set("afterTimestamp", String(cursor.afterTimestamp));
+      const page = await this.#client.request(
+        "GET",
+        `${API_PREFIX}/repositories/${repositoryId}/events?${query}`
+      );
+      if (page.events.length === 0 || !page.nextCursor) return;
+      for (const event of page.events) {
+        if (!this.#running || !this.#hasLease) return;
+        const parsed = parseEvent(event);
+        if (!parsed) {
+          this.deps?.logger.warn("Platform GitHub event log returned a malformed event", {
+            repositoryId,
+            eventId: event.id
+          });
+          continue;
+        }
+        if (isFactoryClosureEvent(parsed)) {
+          await this.#ingestFactoryEvent?.(parsed);
+        }
+        const result = await this.#dispatch(parsed, {
+          controller: this.#controller,
+          listSubscriptions: (target, options) => listPullRequestSubscriptionsForWebhook(target, options, this.#github.integrationStorage),
+          retireSubscription: (id, status) => retirePullRequestSubscription(id, status, this.#github.integrationStorage),
+          isAuthorizedSender: (notification) => this.#isAuthorizedSender(notification),
+          onTargetError: (subscription, error) => {
+            this.deps?.logger.error("Platform GitHub event delivery failed for a subscription", {
+              subscriptionId: subscription.id,
+              resourceId: subscription.resourceId,
+              threadId: subscription.threadId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        });
+        if (result.failed > 0) {
+          throw new Error(
+            `Platform GitHub event ${event.deliveryId} failed for ${result.failed} subscribed target(s).`
+          );
+        }
+      }
+      if (page.nextCursor === ("afterEventId" in cursor ? cursor.afterEventId : void 0)) return;
+      this.#settings.repositories[key] = { afterEventId: page.nextCursor };
+      await this.#saveSettings();
+    }
+  }
+  async #isAuthorizedSender(notification) {
+    if (!AUTHOR_GATED_KINDS2.has(notification.kind)) return true;
+    const sender = notification.metadata.sender;
+    const repository = notification.metadata.repository;
+    if (!sender || !repository) return false;
+    if (AUTHORIZED_BOTS2.has(sender)) return true;
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), PERMISSION_CHECK_TIMEOUT_MS2);
+    try {
+      const permission = await this.#github.getRepositoryCollaboratorPermission(
+        notification.metadata.installationId,
+        repository,
+        sender,
+        abortController.signal
+      );
+      return permission !== void 0 && AUTHORIZED_PERMISSIONS2.has(permission);
+    } catch {
+      return false;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async #saveSettings() {
+    await this.#storage.settings.save(CURSOR_ORG_ID, CURSOR_USER_ID, this.#settings);
+  }
+  #leaseKey() {
+    return `${this.name}:${this.#storage.integrationId}`;
+  }
+};
+function getLeaseProvider(pubsub) {
+  const getProvider = pubsub.getLeaseProvider;
+  if (typeof getProvider === "function") return getProvider.call(pubsub) ?? NoopLeaseProvider;
+  return isLeaseProvider(pubsub) ? pubsub : NoopLeaseProvider;
+}
+function normalizeSettings(value) {
+  if (!value || value.version !== 1 || !value.repositories || typeof value.repositories !== "object") {
+    return { version: 1, repositories: {} };
+  }
+  return { version: 1, repositories: { ...value.repositories } };
+}
+function isFactoryClosureEvent(event) {
+  return (event.event === "issues" || event.event === "pull_request") && event.payload.action === "closed";
+}
+function parseEvent(event) {
+  if (!event.id || !event.deliveryId || !SUPPORTED_EVENTS.has(event.event) || !event.payload || typeof event.payload !== "object" || Array.isArray(event.payload)) {
+    return null;
+  }
+  return {
+    event: event.event,
+    deliveryId: event.deliveryId,
+    payload: event.payload
+  };
+}
+function retryDelay(error, fallbackMs) {
+  if (error instanceof PlatformApiError && error.status === 429 && error.retryAfterSeconds !== null) {
+    return Math.max(fallbackMs, error.retryAfterSeconds * 1e3);
+  }
+  return fallbackMs;
+}
+export {
+  PlatformGithubEventWorker
+};
+//# sourceMappingURL=event-worker.js.map