@cursor/bdk 0.2.1

package/src/internal/cursor-event-relay.ts

@@ -0,0 +1,675 @@
+/**
+ * Pulls `/v0/scm-events` into agent-serve: register repos+events, long-poll
+ * with a durable offset under `<stateDir>/offset.json`. Registration-gated
+ * so consumption never starts unsubscribed. Shared streams: durable
+ * consumer id + repo/event filtering skip sibling deliveries.
+ *
+ * The long-poll lifecycle (consumer id, registration-gated consume loop,
+ * anchor/offset/backoff) lives in the shared {@link CursorRelayCore}; this
+ * module is the GitHub adapter over it. {@link RelayOffsetStore} and
+ * {@link compareStreamOffsets} are re-exported for stability.
+ */
+
+import { CursorRelayCore, type RelayAdapter, RelayOffsetStore } from "./cursor-relay-core.js";
+
+export { RelayOffsetStore };
+
+/**
+ * Comment snapshot from scm-events compact metadata. Carries what the GitHub
+ * channel's `issue_comment` / `pull_request_review_comment` Zod schemas
+ * require so relayed comment wakes parse without re-fetching the comment.
+ */
+export type CursorScmCommentMeta = {
+  id: number;
+  body: string;
+  htmlUrl: string;
+  authorLogin?: string;
+  /**
+   * GitHub `user.type` ("User", "Bot", …). Carried onto the stubbed
+   * `comment.user` / `sender` so `isGitHubAppBotAuthor` keeps recognizing
+   * the agent's own comments on the relay path (self/bot-loop gate).
+   */
+  authorType?: string;
+  /** Review comments only. */
+  path?: string;
+  line?: number;
+  pullRequestReviewId?: number;
+  inReplyToId?: number;
+};
+
+/** PR snapshot from scm-events compact metadata (Sand-style; no raw body). */
+export type CursorScmPullRequestMeta = {
+  number: number;
+  url: string;
+  title?: string;
+  body?: string | null;
+  draft?: boolean;
+  /** True when the PR was merged — required by closed+merged channel hooks. */
+  merged?: boolean;
+  authorLogin?: string;
+  headRef?: string;
+  headSha?: string;
+  baseRef?: string;
+  baseSha?: string;
+};
+
+/** PR ref on a Checks / Actions webhook object. */
+export type CursorScmCiPullRequestMeta = {
+  number: number;
+  url?: string;
+};
+
+export type CursorScmCiAppMeta = {
+  slug?: string;
+  name?: string;
+};
+
+/** Shared Checks / Actions fields. `id` + `headSha` satisfy the channel Zod schemas. */
+type CursorScmCiBaseMeta = {
+  id: number;
+  headSha: string;
+  status?: string;
+  conclusion?: string | null;
+  htmlUrl?: string;
+  app?: CursorScmCiAppMeta;
+  pullRequests: CursorScmCiPullRequestMeta[];
+};
+
+export type CursorScmCheckRunMeta = CursorScmCiBaseMeta & {
+  name?: string;
+  checkSuiteId?: number;
+};
+
+export type CursorScmCheckSuiteMeta = CursorScmCiBaseMeta;
+
+export type CursorScmWorkflowRunMeta = CursorScmCiBaseMeta & {
+  name?: string;
+  workflowId?: number;
+};
+
+/** One event delivered by `GET /v0/scm-events`. */
+export interface CursorScmEvent {
+  offset: string;
+  provider: string;
+  eventName: string;
+  deliveryId?: string;
+  repo: string;
+  receivedAtMs: number;
+  /** Verified webhook body when the API stored it. */
+  payload?: unknown;
+  /** Webhook `action` when present. */
+  action?: string;
+  /** PR number when the delivery is PR-scoped. */
+  prNumber?: number;
+  /** Canonical PR URL when known. */
+  prUrl?: string;
+  /**
+   * Richer PR snapshot when the backend saw `body.pull_request`. Enough to
+   * stub a Zod-valid GitHub `pull_request` webhook body.
+   */
+  pullRequest?: CursorScmPullRequestMeta;
+  /**
+   * Comment snapshot when the backend saw `body.comment`. Enough to stub a
+   * Zod-valid `issue_comment` / `pull_request_review_comment` webhook body.
+   */
+  comment?: CursorScmCommentMeta;
+  /**
+   * Origin comment snapshot. Ids are Origin string ids, not GitHub integers.
+   */
+  originComment?: CursorScmOriginCommentMeta;
+  /** Origin actor (author / pusher / commenter) when present. */
+  originActor?: CursorScmOriginActorMeta;
+  /** `check_run` snapshot; enough to stub `onCheckRun`. */
+  checkRun?: CursorScmCheckRunMeta;
+  /** `check_suite` snapshot; enough to stub `onCheckSuite`. */
+  checkSuite?: CursorScmCheckSuiteMeta;
+  /** `workflow_run` snapshot; enough to stub `onWorkflowRun`. */
+  workflowRun?: CursorScmWorkflowRunMeta;
+  /** GitHub-side event time from the payload, when present. */
+  occurredAtMs?: number;
+}
+
+export type CursorScmOriginActorMeta = {
+  id: string;
+  kind?: string;
+};
+
+export type CursorScmOriginCommentMeta = {
+  id: string;
+  body?: string;
+  author?: CursorScmOriginActorMeta;
+};
+
+export type CursorScmProvider = "github" | "origin";
+
+export interface CursorScmSubscription {
+  provider: CursorScmProvider;
+  repo: string;
+  events: readonly string[];
+}
+
+interface SubscriptionStatus {
+  provider: string;
+  repo: string;
+  isSubscribed: boolean;
+  detail?: string;
+}
+
+export interface CursorEventRelayOptions {
+  baseUrl: string;
+  apiKey: string;
+  /**
+   * GitHub-only shorthand. Ignored when {@link subscriptions} is set.
+   * Existing `--cursor-events --repo` hosts keep passing these.
+   */
+  repos?: readonly string[];
+  events?: readonly string[];
+  /**
+   * Mixed GitHub + Origin registrations. Provider is part of the
+   * subscription key: mirrored `owner/name` slugs must not collide.
+   */
+  subscriptions?: readonly CursorScmSubscription[];
+  stateDir: string;
+  /**
+   * Called for each matching event; failures retry a bounded number of
+   * times, then log and skip.
+   */
+  dispatch: (event: CursorScmEvent) => Promise<void>;
+  logger: (line: string) => void;
+  /** Test seam. Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Test seam: override long-poll wait (default 25s). */
+  pollWaitMs?: number;
+}
+
+/** Human-readable cursor-events log fragment: event, repo/PR, times, delivery. */
+export function formatCursorScmEventLog(event: {
+  eventName: string;
+  repo: string;
+  action?: string;
+  prNumber?: number;
+  prUrl?: string;
+  receivedAtMs: number;
+  occurredAtMs?: number;
+  deliveryId?: string;
+}): string {
+  const action = event.action !== undefined && event.action !== "" ? `.${event.action}` : "";
+  const pr =
+    event.prUrl !== undefined
+      ? event.prUrl
+      : event.prNumber !== undefined
+        ? `${event.repo}#${event.prNumber}`
+        : event.repo;
+  const received = new Date(event.receivedAtMs).toISOString();
+  const occurred =
+    event.occurredAtMs !== undefined
+      ? ` occurred=${new Date(event.occurredAtMs).toISOString()}`
+      : "";
+  const delivery = event.deliveryId ?? "no delivery id";
+  return `${event.eventName}${action} on ${pr} received=${received}${occurred} (${delivery})`;
+}
+
+/** Relay log suffix for one fan-out target, including parse errors on 4xx. */
+export function formatCursorScmDispatchOutcome(target: {
+  slug: string;
+  status: number;
+  body: unknown;
+}): string {
+  const slug = target.slug === "" ? "default" : target.slug;
+  if (target.status < 400) {
+    return `${slug}:${target.status}`;
+  }
+  const error = readDispatchError(target.body);
+  return error === undefined ? `${slug}:${target.status}` : `${slug}:${target.status} ${error}`;
+}
+
+function readDispatchError(body: unknown): string | undefined {
+  if (typeof body !== "object" || body === null) return undefined;
+  if (!("error" in body)) return undefined;
+  const error = body.error;
+  return typeof error === "string" && error !== "" ? error : undefined;
+}
+
+/** Stored webhook body, or a metadata stub for older stream entries. */
+export function scmEventToGitHubPayload(event: CursorScmEvent): unknown {
+  return event.payload ?? scmMetadataToGitHubPayload(event);
+}
+
+/**
+ * Minimal GitHub webhook body from an SCM-events metadata envelope.
+ * When `pullRequest` has title + head/base refs+shas, emits a Zod-valid
+ * `pull_request` object for `onPullRequest`; otherwise identity-only stubs.
+ * When `comment` is present, emits a Zod-valid `comment` object so relayed
+ * `issue_comment` / `pull_request_review_comment` deliveries dispatch.
+ * When a CI snapshot is present, emits `check_run` / `check_suite` /
+ * `workflow_run` so those typed hooks parse on the `--cursor-events` path.
+ */
+export function scmMetadataToGitHubPayload(event: {
+  repo: string;
+  action?: string;
+  prNumber?: number;
+  prUrl?: string;
+  pullRequest?: CursorScmPullRequestMeta;
+  comment?: CursorScmCommentMeta;
+  checkRun?: CursorScmCheckRunMeta;
+  checkSuite?: CursorScmCheckSuiteMeta;
+  workflowRun?: CursorScmWorkflowRunMeta;
+}): Record<string, unknown> {
+  const slash = event.repo.indexOf("/");
+  const owner = slash === -1 ? "" : event.repo.slice(0, slash);
+  const name = slash === -1 ? event.repo : event.repo.slice(slash + 1);
+  const repoUrl = `https://github.com/${event.repo}`;
+  const prMeta = event.pullRequest;
+  const prNumber = prMeta?.number ?? event.prNumber;
+  const prUrl =
+    prMeta?.url ??
+    event.prUrl ??
+    (prNumber !== undefined ? `${repoUrl}/pull/${prNumber}` : undefined);
+
+  const payload: Record<string, unknown> = {
+    repository: {
+      full_name: event.repo,
+      name,
+      html_url: repoUrl,
+      owner: { login: owner },
+    },
+  };
+  payload.action = event.action;
+
+  const commentMeta = event.comment;
+  if (commentMeta !== undefined) {
+    const comment: Record<string, unknown> = {
+      id: commentMeta.id,
+      body: commentMeta.body,
+      html_url: commentMeta.htmlUrl,
+    };
+    if (commentMeta.authorLogin !== undefined) {
+      const author: Record<string, unknown> = {
+        login: commentMeta.authorLogin,
+      };
+      if (commentMeta.authorType !== undefined) {
+        // Without user.type the isGitHubAppBotAuthor gate fails open and the
+        // agent's own relayed comments could wake it again (bot loop).
+        author.type = commentMeta.authorType;
+      }
+      comment.user = author;
+      // The comment author is the closest thing the envelope has to the
+      // webhook sender; channels use it for self/bot-loop gates.
+      payload.sender = { ...author };
+    }
+    if (commentMeta.path !== undefined) {
+      comment.path = commentMeta.path;
+    }
+    if (commentMeta.line !== undefined) {
+      comment.line = commentMeta.line;
+    }
+    if (commentMeta.pullRequestReviewId !== undefined) {
+      comment.pull_request_review_id = commentMeta.pullRequestReviewId;
+    }
+    if (commentMeta.inReplyToId !== undefined) {
+      comment.in_reply_to_id = commentMeta.inReplyToId;
+    }
+    payload.comment = comment;
+  }
+
+  const checkPullRequests = stubGitHubCiPullRequests({
+    snapshot:
+      event.checkRun?.pullRequests ??
+      event.checkSuite?.pullRequests ??
+      event.workflowRun?.pullRequests,
+    prNumber,
+    prUrl,
+  });
+  if (event.checkRun !== undefined) {
+    payload.check_run = stubGitHubCheckRun(event.checkRun, checkPullRequests);
+  }
+  if (event.checkSuite !== undefined) {
+    payload.check_suite = stubGitHubCheckSuite(event.checkSuite, checkPullRequests);
+  }
+  if (event.workflowRun !== undefined) {
+    payload.workflow_run = stubGitHubWorkflowRun(event.workflowRun, checkPullRequests);
+  }
+
+  const title = prMeta?.title;
+  const headRef = prMeta?.headRef;
+  const headSha = prMeta?.headSha;
+  const baseRef = prMeta?.baseRef;
+  const canStubTypedPr =
+    prNumber !== undefined &&
+    prUrl !== undefined &&
+    title !== undefined &&
+    headRef !== undefined &&
+    headSha !== undefined &&
+    baseRef !== undefined;
+
+  if (canStubTypedPr) {
+    const pullRequest: Record<string, unknown> = {
+      number: prNumber,
+      html_url: prUrl,
+      title,
+      body: prMeta?.body,
+      draft: prMeta?.draft,
+      head: { ref: headRef, sha: headSha },
+      base: { ref: baseRef, sha: prMeta?.baseSha },
+    };
+    if (prMeta?.merged !== undefined) {
+      pullRequest.merged = prMeta.merged;
+    }
+    if (prMeta?.authorLogin !== undefined) {
+      pullRequest.user = { login: prMeta.authorLogin };
+    }
+    payload.pull_request = pullRequest;
+    payload.issue = {
+      number: prNumber,
+      html_url: prUrl,
+      pull_request: {},
+    };
+    return payload;
+  }
+
+  if (prNumber !== undefined) {
+    payload.pull_request = {
+      number: prNumber,
+      html_url: prUrl ?? `${repoUrl}/pull/${prNumber}`,
+    };
+    payload.issue = {
+      number: prNumber,
+      html_url: prUrl ?? `${repoUrl}/pull/${prNumber}`,
+      pull_request: {},
+    };
+  }
+  return payload;
+}
+
+function stubGitHubCiPullRequests(input: {
+  snapshot: CursorScmCiPullRequestMeta[] | undefined;
+  prNumber: number | undefined;
+  prUrl: string | undefined;
+}): Array<{ number: number; html_url?: string }> {
+  if (input.snapshot !== undefined && input.snapshot.length > 0) {
+    return input.snapshot.map(pr => ({
+      number: pr.number,
+      ...(pr.url === undefined ? {} : { html_url: pr.url }),
+    }));
+  }
+  if (input.prNumber === undefined) return [];
+  return [
+    {
+      number: input.prNumber,
+      ...(input.prUrl === undefined ? {} : { html_url: input.prUrl }),
+    },
+  ];
+}
+
+function stubGitHubCiApp(app: CursorScmCiAppMeta | undefined): Record<string, unknown> | undefined {
+  if (app === undefined) return undefined;
+  const out: Record<string, unknown> = {};
+  if (app.slug !== undefined) out.slug = app.slug;
+  if (app.name !== undefined) out.name = app.name;
+  return out;
+}
+
+function stubGitHubCiBase(
+  meta: CursorScmCiBaseMeta,
+  pullRequests: Array<{ number: number; html_url?: string }>,
+): Record<string, unknown> {
+  const object: Record<string, unknown> = {
+    id: meta.id,
+    head_sha: meta.headSha,
+  };
+  if (meta.status !== undefined) object.status = meta.status;
+  if (meta.conclusion !== undefined) object.conclusion = meta.conclusion;
+  if (meta.htmlUrl !== undefined) object.html_url = meta.htmlUrl;
+  const app = stubGitHubCiApp(meta.app);
+  if (app !== undefined) object.app = app;
+  if (pullRequests.length > 0) object.pull_requests = pullRequests;
+  return object;
+}
+
+function stubGitHubCheckRun(
+  meta: CursorScmCheckRunMeta,
+  pullRequests: Array<{ number: number; html_url?: string }>,
+): Record<string, unknown> {
+  const object = stubGitHubCiBase(meta, pullRequests);
+  if (meta.name !== undefined) object.name = meta.name;
+  if (meta.checkSuiteId !== undefined) {
+    object.check_suite = { id: meta.checkSuiteId };
+  }
+  return object;
+}
+
+function stubGitHubCheckSuite(
+  meta: CursorScmCheckSuiteMeta,
+  pullRequests: Array<{ number: number; html_url?: string }>,
+): Record<string, unknown> {
+  return stubGitHubCiBase(meta, pullRequests);
+}
+
+function stubGitHubWorkflowRun(
+  meta: CursorScmWorkflowRunMeta,
+  pullRequests: Array<{ number: number; html_url?: string }>,
+): Record<string, unknown> {
+  const object = stubGitHubCiBase(meta, pullRequests);
+  if (meta.name !== undefined) object.name = meta.name;
+  if (meta.workflowId !== undefined) object.workflow_id = meta.workflowId;
+  return object;
+}
+
+/**
+ * Origin webhook envelope from an SCM-events metadata record. One parser
+ * handles both live Origin deliveries and this stub: `{ deliveryId, event }`.
+ */
+export function scmMetadataToOriginPayload(event: {
+  repo: string;
+  eventName: string;
+  deliveryId?: string;
+  action?: string;
+  prNumber?: number;
+  prUrl?: string;
+  pullRequest?: CursorScmPullRequestMeta;
+  originComment?: CursorScmOriginCommentMeta;
+  originActor?: CursorScmOriginActorMeta;
+  occurredAtMs?: number;
+}): Record<string, unknown> {
+  const slash = event.repo.indexOf("/");
+  const owner = slash === -1 ? "" : event.repo.slice(0, slash);
+  const name = slash === -1 ? event.repo : event.repo.slice(slash + 1);
+  const prMeta = event.pullRequest;
+  const prNumber = prMeta?.number ?? event.prNumber;
+  const prUrl =
+    prMeta?.url ??
+    event.prUrl ??
+    (prNumber !== undefined
+      ? `https://cursor.com/codebase/${owner}/${name}/pull/${prNumber}`
+      : undefined);
+
+  const payload: Record<string, unknown> = {
+    repository: {
+      name,
+      owner: { slug: owner },
+    },
+  };
+
+  if (prNumber !== undefined) {
+    const pullRequest: Record<string, unknown> = {
+      number: prNumber,
+      url: prUrl,
+    };
+    if (prMeta?.title !== undefined) pullRequest.title = prMeta.title;
+    if (prMeta?.body !== undefined) pullRequest.body = prMeta.body;
+    if (prMeta?.draft !== undefined) pullRequest.draft = prMeta.draft;
+    if (prMeta?.merged !== undefined) pullRequest.merged = prMeta.merged;
+    if (prMeta?.headRef !== undefined || prMeta?.headSha !== undefined) {
+      pullRequest.head = {
+        ref: prMeta.headRef,
+        sha: prMeta.headSha,
+      };
+    }
+    if (prMeta?.baseRef !== undefined || prMeta?.baseSha !== undefined) {
+      pullRequest.base = {
+        ref: prMeta.baseRef,
+        sha: prMeta.baseSha,
+      };
+    }
+    if (prMeta?.authorLogin !== undefined) {
+      pullRequest.author = { id: prMeta.authorLogin };
+    }
+    payload.pullRequest = pullRequest;
+  }
+
+  const commentMeta = event.originComment;
+  if (commentMeta !== undefined) {
+    const comment: Record<string, unknown> = { id: commentMeta.id };
+    if (commentMeta.body !== undefined) comment.body = commentMeta.body;
+    if (commentMeta.author !== undefined) comment.author = commentMeta.author;
+    payload.comment = comment;
+  }
+  if (event.originActor !== undefined) {
+    payload.actor = event.originActor;
+  }
+
+  return {
+    deliveryId: event.deliveryId,
+    event: {
+      type: event.eventName,
+      ...(event.occurredAtMs === undefined
+        ? {}
+        : { eventTime: new Date(event.occurredAtMs).toISOString() }),
+      payload,
+    },
+  };
+}
+
+function subscriptionKey(provider: string, repo: string): string {
+  return `${provider}:${repo.toLowerCase()}`;
+}
+
+function subscriptionLabel(provider: string, repo: string): string {
+  return provider === "github" ? repo : `${provider}:${repo}`;
+}
+
+export function resolveCursorScmSubscriptions(
+  options: Pick<CursorEventRelayOptions, "repos" | "events" | "subscriptions">,
+): CursorScmSubscription[] {
+  if (options.subscriptions !== undefined) {
+    return options.subscriptions.map(subscription => ({
+      provider: subscription.provider,
+      repo: subscription.repo.trim().toLowerCase(),
+      events: [...subscription.events],
+    }));
+  }
+  const events = [...(options.events ?? [])];
+  return (options.repos ?? []).map(repo => ({
+    provider: "github" as const,
+    repo: repo.trim().toLowerCase(),
+    events,
+  }));
+}
+
+/**
+ * SCM-events relay: a thin {@link CursorRelayCore} adapter. Consumers
+ * keep the same `new CursorEventRelay(options).start()/.stop()` surface.
+ */
+export class CursorEventRelay {
+  private readonly core: CursorRelayCore<CursorScmEvent>;
+  private readonly subscriptions: CursorScmSubscription[];
+  /**
+   * Confirmed `provider:repo` keys for THIS consumer, with the event kinds
+   * requested for each. The stream is shared with sibling consumers, so
+   * GitHub and Origin deliveries for the same owner/name must not mix.
+   */
+  private subscribedEvents = new Map<string, ReadonlySet<string>>();
+  private readonly loggedSkippedKeys = new Set<string>();
+
+  constructor(private readonly options: CursorEventRelayOptions) {
+    this.subscriptions = resolveCursorScmSubscriptions(options);
+    const requestedEvents = new Map(
+      this.subscriptions.map(subscription => [
+        subscriptionKey(subscription.provider, subscription.repo),
+        new Set(subscription.events),
+      ]),
+    );
+    const adapter: RelayAdapter<CursorScmEvent> = {
+      logPrefix: "cursor-events",
+      subscribePath: "/v0/scm-events/subscriptions",
+      pollPath: "/v0/scm-events",
+      buildRegistrationBody: consumerId => ({
+        consumerId,
+        subscriptions: this.subscriptions.map(subscription => ({
+          provider: subscription.provider,
+          repo: subscription.repo,
+          events: [...subscription.events],
+        })),
+      }),
+      // No deregistration on stop: the backend only records events for a
+      // repo that some consumer is subscribed to, so dropping the
+      // registration leaves a hole in the log until the next process
+      // registers, and the durable offset cannot replay what was never
+      // written. A consumer that does not come back lapses by TTL.
+      applyRegistrationResponse: json => {
+        const result = json as { repos?: SubscriptionStatus[] };
+        const statuses = result.repos ?? [];
+        this.subscribedEvents = new Map();
+        const lines: string[] = [];
+        const confirmed: string[] = [];
+        for (const status of statuses) {
+          const provider = status.provider || "github";
+          const key = subscriptionKey(provider, status.repo);
+          if (!status.isSubscribed) {
+            lines.push(
+              `not subscribed to ${subscriptionLabel(provider, status.repo)}: ${status.detail ?? "unknown reason"}`,
+            );
+            continue;
+          }
+          this.subscribedEvents.set(key, requestedEvents.get(key) ?? new Set());
+          confirmed.push(subscriptionLabel(provider, status.repo));
+        }
+        if (confirmed.length > 0) {
+          const eventKinds = [...new Set(this.subscriptions.flatMap(s => [...s.events]))];
+          lines.push(`subscribed to ${confirmed.join(", ")} for events: ${eventKinds.join(", ")}`);
+        }
+        return lines;
+      },
+      shouldDispatch: event => this.shouldDispatch(event),
+      dispatch: event => this.options.dispatch(event),
+    };
+    this.core = new CursorRelayCore<CursorScmEvent>({
+      baseUrl: options.baseUrl,
+      apiKey: options.apiKey,
+      stateDir: options.stateDir,
+      adapter,
+      logger: options.logger,
+      ...(options.fetchImpl === undefined ? {} : { fetchImpl: options.fetchImpl }),
+      ...(options.pollWaitMs === undefined ? {} : { pollWaitMs: options.pollWaitMs }),
+    });
+  }
+
+  /**
+   * Whether an event from the shared stream belongs to THIS consumer: the
+   * provider+repo must be one the server confirmed for us and the event kind
+   * one that subscription declared. GitHub and Origin share owner/name slugs
+   * on mirrors, so the provider is part of the key.
+   */
+  private shouldDispatch(event: CursorScmEvent): boolean {
+    const key = subscriptionKey(event.provider || "github", event.repo);
+    const events = this.subscribedEvents.get(key);
+    if (events === undefined) {
+      if (!this.loggedSkippedKeys.has(key)) {
+        this.loggedSkippedKeys.add(key);
+        this.options.logger(
+          `[agent-sdk] cursor-events: skipping events for ${subscriptionLabel(event.provider || "github", event.repo)}: not in this host's subscription (another consumer of this API key likely subscribed it)`,
+        );
+      }
+      return false;
+    }
+    return events.has(event.eventName);
+  }
+
+  start(): void {
+    this.core.start();
+  }
+
+  async stop(): Promise<void> {
+    await this.core.stop();
+  }
+}