@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/cursor-account-mcp-auth.ts

@@ -1,303 +0,0 @@
-/**
- * Service-account connector authorization for
- * `defineConnection({ cursorAccount: true })` on hosted deployments.
- *
- * Hosted engines authenticate as their deployment's dedicated service
- * account, whose connector OAuth tokens live backend-side. This flow is the
- * dashboard's Authenticate button as a CLI loop: probe the connectors via
- * `CheckHttpMcpStatus` (which mints a complete OAuth `authUrl` per connector
- * needing auth), open each URL for the human to grant, and poll until the
- * backend reports the token stored. Nothing token-shaped ever touches this
- * process — the cursor.com callback stores tokens against the service
- * account. Used by `agent-sdk mcp oauth <connection>` and the post-deploy
- * hook in `cli-deploy.ts`.
- */
-
-import type {
-  AvailableMcpServer,
-  CursorBackendClient,
-  McpConnectorStatus,
-} from "./cursor/backend-client.js";
-import { LOG_PREFIX } from "./distribution.js";
-import { openBrowser } from "./mcp-oauth.js";
-import { sleep as defaultSleep } from "./sleep.js";
-
-const DEFAULT_POLL_INTERVAL_MS = 3_000;
-const DEFAULT_POLL_TIMEOUT_MS = 5 * 60 * 1000;
-
-/** Same default the dashboard uses; MCP_OAUTH_REDIRECT_URI overrides for dev. */
-export function mcpOauthRedirectUri(): string {
-  const override = process.env.MCP_OAUTH_REDIRECT_URI;
-  if (override !== undefined && override.trim() !== "") {
-    return override.trim();
-  }
-  return "https://www.cursor.com/agents/mcp/oauth/callback";
-}
-
-export interface AuthorizeCursorAccountConnectorsArgs {
-  backendClient: Pick<CursorBackendClient, "getAvailableMcpServers" | "checkHttpMcpStatus">;
-  teamId: number;
-  slug: string;
-  /** The deployment's dedicated service account (`sa_…`). */
-  serviceAccountId: string;
-  /** Connection name, for log lines. */
-  connectionName: string;
-  /** The connection's `servers` filter; undefined = every team connector. */
-  servers?: string[] | undefined;
-  /** Open auth URLs and poll for completion (TTY); false = report only. */
-  interactive: boolean;
-  out: (text: string) => void;
-  err: (text: string) => void;
-  /** Test seams. */
-  openBrowserImpl?: (url: string) => void;
-  sleep?: (ms: number) => Promise<void>;
-  pollIntervalMs?: number;
-  pollTimeoutMs?: number;
-}
-
-export interface AuthorizeCursorAccountConnectorsResult {
-  /** Connectors with a stored credential after the flow. */
-  authorized: string[];
-  /** Connectors still requiring authorization. */
-  pending: string[];
-  /** Connectors the backend could not probe. */
-  errored: Array<{ name: string; error: string }>;
-}
-
-/**
- * Authorize the deployment service account for the connection's connectors.
- * Already-authorized connectors are skipped; the rest get a browser OAuth
- * each (sequentially), polled until the backend stores the token.
- */
-export async function authorizeCursorAccountConnectors(
-  args: AuthorizeCursorAccountConnectorsArgs,
-): Promise<AuthorizeCursorAccountConnectorsResult> {
-  const { backendClient, teamId, serviceAccountId, connectionName, out, err } = args;
-  const open = args.openBrowserImpl ?? openBrowser;
-  const sleep = args.sleep ?? defaultSleep;
-  const pollIntervalMs = args.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const pollTimeoutMs = args.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
-  const redirectUri = mcpOauthRedirectUri();
-
-  // Team-scoped connectors only: the hosted bridge resolves the SA's team
-  // servers, so personal connectors can never apply to a deployment.
-  const available = (await backendClient.getAvailableMcpServers({ teamId })).filter(
-    server => server.isTeamServer,
-  );
-
-  const selected = selectConnectors(available, args.servers);
-  for (const missing of selected.unmatched) {
-    err(
-      `${LOG_PREFIX} Connection "${connectionName}" lists connector ${JSON.stringify(missing)}, but the team has no such connector (dashboard → MCP).\n`,
-    );
-  }
-  if (selected.servers.length === 0) {
-    err(`${LOG_PREFIX} No matching team connectors for connection "${connectionName}".\n`);
-    return { authorized: [], pending: [], errored: [] };
-  }
-
-  const nameById = new Map(selected.servers.map(server => [server.id, server.name]));
-  const statuses = await backendClient.checkHttpMcpStatus({
-    serverIds: selected.servers.map(server => server.id),
-    oauthRedirectUri: redirectUri,
-    serviceAccountId,
-  });
-
-  const result: AuthorizeCursorAccountConnectorsResult = {
-    authorized: [],
-    pending: [],
-    errored: [],
-  };
-
-  for (const status of statuses) {
-    const name = nameById.get(status.id) ?? `#${status.id}`;
-    if (!status.requiresAuth) {
-      if (status.error !== undefined && status.error !== "") {
-        err(`${LOG_PREFIX} ${name}: ${status.error}\n`);
-        result.errored.push({ name, error: status.error });
-        continue;
-      }
-      out(`${LOG_PREFIX} ${name}: already authorized ✓\n`);
-      result.authorized.push(name);
-      continue;
-    }
-    if (status.authUrl === undefined || status.authUrl === "") {
-      const error = status.error ?? "no authorization URL was minted";
-      err(`${LOG_PREFIX} ${name}: ${error}\n`);
-      result.errored.push({ name, error });
-      continue;
-    }
-    if (!args.interactive) {
-      result.pending.push(name);
-      continue;
-    }
-
-    out(
-      `${LOG_PREFIX} ${name}: authorization needed. You'll authorize ${name} as yourself; ` +
-        `anyone who can talk to this agent can act with that access.\n` +
-        `${LOG_PREFIX} Opening (or open manually):\n  ${status.authUrl}\n`,
-    );
-    open(status.authUrl);
-
-    const authorized = await pollUntilAuthorized({
-      backendClient,
-      serverId: status.id,
-      serviceAccountId,
-      redirectUri,
-      sleep,
-      pollIntervalMs,
-      pollTimeoutMs,
-    });
-    if (authorized) {
-      out(`${LOG_PREFIX} ${name}: authorized ✓\n`);
-      result.authorized.push(name);
-    } else {
-      err(`${LOG_PREFIX} ${name}: still waiting on authorization; giving up for now.\n`);
-      result.pending.push(name);
-    }
-  }
-
-  return result;
-}
-
-function selectConnectors(
-  available: AvailableMcpServer[],
-  filter: string[] | undefined,
-): { servers: AvailableMcpServer[]; unmatched: string[] } {
-  if (filter === undefined || filter.length === 0) {
-    return { servers: available, unmatched: [] };
-  }
-  const servers: AvailableMcpServer[] = [];
-  const seen = new Set<number>();
-  const unmatched: string[] = [];
-  for (const name of filter) {
-    const wanted = name.trim().toLowerCase();
-    const matches = available.filter(
-      server =>
-        server.name.toLowerCase() === wanted || server.serverIdentifier?.toLowerCase() === wanted,
-    );
-    if (matches.length === 0) {
-      unmatched.push(name);
-      continue;
-    }
-    for (const match of matches) {
-      if (!seen.has(match.id)) {
-        seen.add(match.id);
-        servers.push(match);
-      }
-    }
-  }
-  return { servers, unmatched };
-}
-
-function uniqueConnectorMatch(
-  available: AvailableMcpServer[],
-  identifier: string,
-): AvailableMcpServer | undefined {
-  const wanted = identifier.trim().toLowerCase();
-  if (wanted === "") {
-    return undefined;
-  }
-  const byIdentifier = available.filter(
-    server => server.serverIdentifier?.toLowerCase() === wanted,
-  );
-  if (byIdentifier.length === 1) {
-    return byIdentifier[0];
-  }
-  if (byIdentifier.length > 1) {
-    return undefined;
-  }
-  const byName = available.filter(server => server.name.toLowerCase() === wanted);
-  if (byName.length === 1) {
-    return byName[0];
-  }
-  return undefined;
-}
-
-/**
- * Mint OAuth `authUrl`s for connectors matching `identifiers` (name or
- * `serverIdentifier`). Omit `serviceAccountId` to probe the signed-in user
- * (local `serve` preflight). Failures return an empty map so the caller
- * can fall back to the dashboard URL.
- */
-export async function probeConnectorAuthUrls(args: {
-  client: Pick<CursorBackendClient, "getAvailableMcpServers" | "checkHttpMcpStatus">;
-  identifiers: readonly string[];
-  serviceAccountId?: string;
-}): Promise<Map<string, string>> {
-  const urls = new Map<string, string>();
-  if (args.identifiers.length === 0) {
-    return urls;
-  }
-  try {
-    const available = await args.client.getAvailableMcpServers();
-    const matched: AvailableMcpServer[] = [];
-    const seen = new Set<number>();
-    for (const identifier of args.identifiers) {
-      const match = uniqueConnectorMatch(available, identifier);
-      if (match === undefined || seen.has(match.id)) {
-        continue;
-      }
-      seen.add(match.id);
-      matched.push(match);
-    }
-    if (matched.length === 0) {
-      return urls;
-    }
-    const statuses = await args.client.checkHttpMcpStatus({
-      serverIds: matched.map(server => server.id),
-      oauthRedirectUri: mcpOauthRedirectUri(),
-      serviceAccountId: args.serviceAccountId,
-    });
-    const statusById = new Map(statuses.map(status => [status.id, status] as const));
-    for (const identifier of args.identifiers) {
-      const match = uniqueConnectorMatch(available, identifier);
-      if (match === undefined) {
-        continue;
-      }
-      const authUrl = statusById.get(match.id)?.authUrl?.trim();
-      if (authUrl !== undefined && authUrl !== "") {
-        urls.set(identifier, authUrl);
-      }
-    }
-    return urls;
-  } catch {
-    return urls;
-  }
-}
-
-async function pollUntilAuthorized(args: {
-  backendClient: Pick<CursorBackendClient, "checkHttpMcpStatus">;
-  serverId: number;
-  serviceAccountId: string;
-  redirectUri: string;
-  sleep: (ms: number) => Promise<void>;
-  pollIntervalMs: number;
-  pollTimeoutMs: number;
-}): Promise<boolean> {
-  const deadline = Date.now() + args.pollTimeoutMs;
-  // Each unauthorized probe is a full backend connect to the provider, so
-  // back off while the human works through the OAuth pages.
-  let intervalMs = args.pollIntervalMs;
-  const maxIntervalMs = Math.max(args.pollIntervalMs, 15_000);
-  while (Date.now() < deadline) {
-    await args.sleep(intervalMs);
-    intervalMs = Math.min(intervalMs * 1.5, maxIntervalMs);
-    let statuses: McpConnectorStatus[];
-    try {
-      statuses = await args.backendClient.checkHttpMcpStatus({
-        serverIds: [args.serverId],
-        oauthRedirectUri: args.redirectUri,
-        serviceAccountId: args.serviceAccountId,
-      });
-    } catch {
-      // Transient probe errors; keep polling until the deadline.
-      continue;
-    }
-    const status = statuses.find(entry => entry.id === args.serverId);
-    if (status !== undefined && !status.requiresAuth) {
-      return true;
-    }
-  }
-  return false;
-}

package/src/internal/cursor-agent-template.ts

@@ -1,50 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const MAX = 64;
-const TEMPLATE_NAMES = [
-  "agentic-owners",
-  "agents-md",
-  "code-wiki",
-  "demo",
-  "grokbot-agents",
-  "pr-autofixer",
-  "security-help",
-  "security-reviewer",
-  "thermo-quality-review",
-  "thermo-review",
-  "triage-linear",
-  "triage-jira",
-] as const;
-export type TemplateName = (typeof TEMPLATE_NAMES)[number];
-const NAMES = new Set<string>(TEMPLATE_NAMES);
-
-export function canonicalTemplateName(name: string): string {
-  return name === "triage" ? "triage-linear" : name;
-}
-
-export function isTemplateName(name: string): name is TemplateName {
-  return NAMES.has(name);
-}
-
-/** Raw scaffold marker. Validation depends on the consuming boundary. */
-export function readCursorAgentTemplate(rootDir: string): string | undefined {
-  try {
-    const pkg = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8")) as {
-      cursorAgentTemplate?: unknown;
-    };
-    const stamp = pkg.cursorAgentTemplate;
-    return typeof stamp === "string" ? stamp : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export function readDeployTemplate(rootDir: string): string | undefined {
-  const stamp = readCursorAgentTemplate(rootDir);
-  if (stamp === undefined || stamp.length === 0 || stamp.length > MAX) {
-    return undefined;
-  }
-  const name = canonicalTemplateName(stamp);
-  return isTemplateName(name) ? name : undefined;
-}

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

@@ -1,315 +0,0 @@
-/**
- * Pull relay for `/v0/deployment-events`.
- *
- * A {@link RelayAdapter} over {@link CursorRelayCore} — the same engine the
- * GitHub SCM and Slack relays use, so registration heartbeats, durable
- * offsets, backoff, and bounded dispatch retry are inherited rather than
- * reimplemented. Only the subscribe/poll paths, the registration body, and
- * the per-event filter differ.
- */
-
-import type {
-  DeploymentEvent,
-  DeploymentEventType,
-  DeploymentSubscription,
-} from "../channels/deployments/types.js";
-import { CursorRelayCore, type RelayAdapter } from "./cursor-relay-core.js";
-
-const DEFAULT_EVENTS: readonly DeploymentEventType[] = ["deployment.succeeded"];
-
-/** One page entry: the event fields plus its stream offset, as the sibling
- * providers spell it. */
-export type DeploymentRelayEvent = DeploymentEvent & { offset: string };
-
-export interface ResolvedSubscription {
-  deploySourceUri: string;
-  environments: string[];
-  events: Set<DeploymentEventType>;
-}
-
-interface SubscriptionStatus {
-  deploySourceUri: string;
-  isSubscribed: boolean;
-  detail?: string;
-}
-
-export type DeploymentSubscriptionSource =
-  | readonly ResolvedSubscription[]
-  | (() => readonly ResolvedSubscription[]);
-
-export interface DeploymentEventRelayOptions {
-  baseUrl: string;
-  apiKey: string;
-  stateDir: string;
-  /**
-   * Snapshot or a getter. A getter is re-read on every registration
-   * heartbeat so a channel that refreshes `deploySourceUris` after start
-   * can add sources without restarting the relay.
-   */
-  subscriptions: DeploymentSubscriptionSource;
-  dispatch: (event: DeploymentEvent) => Promise<void>;
-  logger: (line: string) => void;
-  fetchImpl?: typeof fetch;
-  pollWaitMs?: number;
-}
-
-/** Current subscriptions: a live getter, otherwise the snapshot. */
-export function currentDeploymentSubscriptions(
-  subscriptions: DeploymentSubscriptionSource,
-): readonly ResolvedSubscription[] {
-  return typeof subscriptions === "function" ? subscriptions() : subscriptions;
-}
-
-/**
- * Normalize the channel's `deploySourceUris` option into concrete
- * subscriptions. An omitted or empty option resolves to none, which callers
- * read as "defer to the deploy scope".
- */
-export function resolveDeploymentSubscriptions(options: {
-  deploySourceUris?: readonly (string | DeploymentSubscription)[];
-  environments?: readonly string[];
-  events?: readonly DeploymentEventType[];
-}): ResolvedSubscription[] {
-  const bySource = new Map<string, ResolvedSubscription>();
-  for (const entry of options.deploySourceUris ?? []) {
-    const subscription: DeploymentSubscription =
-      typeof entry === "string" ? { deploySourceUri: entry } : entry;
-    // Case-folded only: `Deployment.deploy_source_uri` has no documented
-    // format, and the server keys subscriptions the same way.
-    const deploySourceUri = subscription.deploySourceUri.trim().toLowerCase();
-    if (deploySourceUri === "") {
-      throw new Error(
-        `deploymentsChannel: invalid deploy source "${subscription.deploySourceUri}".`,
-      );
-    }
-    const environments = [
-      ...new Set(
-        (subscription.environments ?? options.environments ?? [])
-          .map(value => value.trim())
-          .filter(Boolean),
-      ),
-    ];
-    const events = new Set(subscription.events ?? options.events ?? DEFAULT_EVENTS);
-    if (events.size === 0) {
-      throw new Error(
-        `deploymentsChannel: deploy source "${deploySourceUri}" subscribes to no events.`,
-      );
-    }
-    // Later entries for the same deploy source widen the earlier one rather
-    // than silently replacing it.
-    const existing = bySource.get(deploySourceUri);
-    if (existing === undefined) {
-      bySource.set(deploySourceUri, { deploySourceUri, environments, events });
-      continue;
-    }
-    for (const event of events) existing.events.add(event);
-    existing.environments =
-      existing.environments.length === 0 || environments.length === 0
-        ? []
-        : [...new Set([...existing.environments, ...environments])];
-  }
-  // Empty means "this channel names nothing". The relay wire reads that as
-  // deregistration, hosted admission reads it as "defer to the deploy
-  // scope". The host re-resolves on each heartbeat, so a channel that later
-  // fills `deploySourceUris` registers without a restart.
-  return [...bySource.values()];
-}
-
-/**
- * Union per-channel subscriptions, widening events and environments when
- * the same deploy source appears more than once. An empty environment
- * list means every environment and absorbs a narrower list.
- */
-export function mergeResolvedSubscriptions(
-  groups: readonly (readonly ResolvedSubscription[])[],
-): ResolvedSubscription[] {
-  const bySource = new Map<string, ResolvedSubscription>();
-  for (const group of groups) {
-    for (const subscription of group) {
-      const existing = bySource.get(subscription.deploySourceUri);
-      if (existing === undefined) {
-        bySource.set(subscription.deploySourceUri, {
-          deploySourceUri: subscription.deploySourceUri,
-          environments: [...subscription.environments],
-          events: new Set(subscription.events),
-        });
-        continue;
-      }
-      for (const event of subscription.events) existing.events.add(event);
-      existing.environments =
-        existing.environments.length === 0 || subscription.environments.length === 0
-          ? []
-          : [...new Set([...existing.environments, ...subscription.environments])];
-    }
-  }
-  return [...bySource.values()];
-}
-
-/** Whether one confirmed subscription wants this event. */
-export function deploymentEventMatches(
-  subscription: ResolvedSubscription,
-  envelope: DeploymentEvent,
-): boolean {
-  if (!subscription.events.has(envelope.eventType)) {
-    return false;
-  }
-  return (
-    subscription.environments.length === 0 ||
-    subscription.environments.includes(envelope.environment)
-  );
-}
-
-/** One channel the host can deliver a deployment event to. */
-export interface DeploymentDispatchTarget {
-  /** Display name for logs, e.g. `executor/deployments`. */
-  name: string;
-  subscriptions: readonly ResolvedSubscription[];
-  deliver: (event: DeploymentEvent) => Promise<unknown>;
-}
-
-/**
- * Deliver one event to every channel subscribed to it.
- *
- * Each channel is delivered independently: one channel's handler throwing
- * must not skip the channels after it, because the relay core retries the
- * whole dispatch and the channels that already ran would see the event twice.
- * Throws only when every subscribed channel failed, so a retry cannot
- * re-deliver to a channel that succeeded.
- */
-export async function fanOutDeploymentEvent(input: {
-  targets: readonly DeploymentDispatchTarget[];
-  event: DeploymentEvent;
-  logger: (line: string) => void;
-}): Promise<void> {
-  const { event, logger } = input;
-  const matched = input.targets.filter(target =>
-    target.subscriptions.some(
-      subscription =>
-        subscription.deploySourceUri === event.deploySourceUri &&
-        deploymentEventMatches(subscription, event),
-    ),
-  );
-  const failures: string[] = [];
-  for (const target of matched) {
-    try {
-      await target.deliver(event);
-    } catch (error) {
-      failures.push(target.name);
-      logger(
-        `[agent-sdk] deployment-events: ${target.name} failed on ${event.eventId}: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
-    }
-  }
-  logger(
-    `[agent-sdk] deployment-events: ${event.eventType} ${event.deploySourceUri}@${event.deployVersion} (${event.environment}) → ${matched.length - failures.length}/${matched.length} channel(s)`,
-  );
-  if (failures.length > 0 && failures.length === matched.length) {
-    throw new Error(
-      `deployment-events: every subscribed channel failed on ${event.eventId} (${failures.join(", ")})`,
-    );
-  }
-}
-
-export class DeploymentEventRelay {
-  private readonly core: CursorRelayCore<DeploymentRelayEvent>;
-  private subscribed = new Map<string, ResolvedSubscription>();
-  private readonly loggedSkippedSources = new Set<string>();
-
-  constructor(private readonly options: DeploymentEventRelayOptions) {
-    const adapter: RelayAdapter<DeploymentRelayEvent> = {
-      logPrefix: "deployment-events",
-      subscribePath: "/v0/deployment-events/subscriptions",
-      pollPath: "/v0/deployment-events",
-      buildRegistrationBody: consumerId => ({
-        consumerId,
-        subscriptions: currentDeploymentSubscriptions(options.subscriptions).map(subscription => ({
-          deploySourceUri: subscription.deploySourceUri,
-          environments: subscription.environments,
-          events: [...subscription.events],
-        })),
-      }),
-      // Empty subscriptions drop this consumer's registration on clean stop
-      // instead of leaving it to lapse by TTL.
-      buildDeregistrationBody: consumerId => ({
-        consumerId,
-        subscriptions: [],
-      }),
-      applyRegistrationResponse: json => {
-        const result = json as { deploySourceUris?: SubscriptionStatus[] };
-        const wantedSubscriptions = currentDeploymentSubscriptions(options.subscriptions);
-        this.subscribed = new Map();
-        this.loggedSkippedSources.clear();
-        const lines: string[] = [];
-        const confirmed: string[] = [];
-        for (const status of result.deploySourceUris ?? []) {
-          const wanted = wantedSubscriptions.find(
-            subscription => subscription.deploySourceUri === status.deploySourceUri,
-          );
-          if (!status.isSubscribed || wanted === undefined) {
-            lines.push(
-              `not subscribed to ${status.deploySourceUri}: ${status.detail ?? "unknown reason"}`,
-            );
-            continue;
-          }
-          this.subscribed.set(status.deploySourceUri, wanted);
-          confirmed.push(status.deploySourceUri);
-        }
-        if (confirmed.length > 0) {
-          const kinds = [...new Set(wantedSubscriptions.flatMap(s => [...s.events]))];
-          lines.push(`subscribed to ${confirmed.join(", ")} for events: ${kinds.join(", ")}`);
-        }
-        return lines;
-      },
-      shouldDispatch: event => this.shouldDispatch(event),
-      dispatch: ({ offset: _offset, ...envelope }) => options.dispatch(envelope),
-    };
-    this.core = new CursorRelayCore<DeploymentRelayEvent>({
-      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 this principal's stream belongs to THIS relay.
-   * The stream is per-principal, and one API key can back several relays
-   * (other hosts, or an agent running its own alongside the host's), so each
-   * one re-checks the events against the subscriptions the server confirmed
-   * for it.
-   */
-  private shouldDispatch(event: DeploymentRelayEvent): boolean {
-    const envelope = event;
-    if (
-      envelope === null ||
-      typeof envelope !== "object" ||
-      typeof envelope.deploySourceUri !== "string"
-    ) {
-      return false;
-    }
-    const subscription = this.subscribed.get(envelope.deploySourceUri);
-    if (subscription === undefined) {
-      if (!this.loggedSkippedSources.has(envelope.deploySourceUri)) {
-        this.loggedSkippedSources.add(envelope.deploySourceUri);
-        this.options.logger(
-          `[agent-sdk] deployment-events: skipping events for ${envelope.deploySourceUri}: not in this host's subscription (another consumer of this API key likely subscribed it)`,
-        );
-      }
-      return false;
-    }
-    return deploymentEventMatches(subscription, envelope);
-  }
-
-  start(): void {
-    this.core.start();
-  }
-
-  async stop(): Promise<void> {
-    await this.core.stop();
-  }
-}