@shipfox/api-runners 2.0.0

package/src/core/demand.ts

@@ -0,0 +1,239 @@
+import {setTimeout as sleep} from 'node:timers/promises';
+import {logger} from '@shipfox/node-opentelemetry';
+import {config} from '#config.js';
+import {db} from '#db/db.js';
+import {
+  type ActiveProvisionedRunnerTemplateCount,
+  listActiveProvisionedRunnerCountsByTemplateTx,
+  listProvisionerTerminateIntentRowsTx,
+  type ProvisionedRunnerTerminateIntent,
+} from '#db/provisioned-runners.js';
+import {
+  type DemandStat,
+  deleteReservationsByIds,
+  pollDemandAndReserveTx,
+  type ReservationGrant,
+  type ReservationTemplate,
+} from '#db/reservations.js';
+import {
+  provisionedRunnerCountDivergenceCount,
+  provisionedRunnerTerminateIntentIssuedCount,
+} from '#metrics/instance.js';
+
+export interface PollDemandParams {
+  workspaceId: string;
+  provisionerId: string;
+  maxReservations: number;
+  waitSeconds?: number | undefined;
+  ttlSeconds: number;
+  terminateIntentLimit: number;
+  templates: ReservationTemplate[];
+  signal: AbortSignal;
+}
+
+export interface PollDemandResult {
+  stats: DemandStat[];
+  reservations: ReservationGrant[];
+  terminateProvisionedRunnerIds: string[];
+}
+
+export interface ProvisionedRunnerCountDivergence {
+  templateKey: string;
+  state: 'starting' | 'running';
+  direction: 'backend-higher' | 'advertised-higher';
+  delta: number;
+}
+
+interface PollDemandSnapshot {
+  result: PollDemandResult;
+  divergences: ProvisionedRunnerCountDivergence[];
+  terminateIntents: ProvisionedRunnerTerminateIntent[];
+}
+
+export async function pollDemand(params: PollDemandParams): Promise<PollDemandResult> {
+  const waitSeconds = Math.min(
+    params.waitSeconds ?? config.RESERVATION_LONG_POLL_MAX_WAIT_SECONDS,
+    config.RESERVATION_LONG_POLL_MAX_WAIT_SECONDS,
+  );
+  const deadlineMs = Date.now() + Math.max(0, waitSeconds) * 1000;
+  const totalCapacity = params.templates.reduce(
+    (total, template) => total + template.availableSlots,
+    0,
+  );
+  let interval = config.RESERVATION_POLL_INTERVAL_MS;
+  let lastSnapshot: PollDemandSnapshot = {
+    result: {stats: [], reservations: [], terminateProvisionedRunnerIds: []},
+    divergences: [],
+    terminateIntents: [],
+  };
+
+  while (true) {
+    if (params.signal.aborted) return lastSnapshot.result;
+
+    const previousSnapshot = lastSnapshot;
+    const deadlinePassed = Date.now() >= deadlineMs;
+    const snapshot = await db().transaction(async (tx) => {
+      const demand = await pollDemandAndReserveTx(tx, {
+        workspaceId: params.workspaceId,
+        provisionerId: params.provisionerId,
+        maxReservations: params.maxReservations,
+        ttlSeconds: params.ttlSeconds,
+        templates: params.templates,
+      });
+      const terminateIntents = await listProvisionerTerminateIntentRowsTx(tx, {
+        workspaceId: params.workspaceId,
+        provisionerId: params.provisionerId,
+        limit: params.terminateIntentLimit,
+      });
+      const result: PollDemandResult = {
+        ...demand,
+        terminateProvisionedRunnerIds: terminateIntents.map((intent) => intent.provisionedRunnerId),
+      };
+
+      if (!shouldReturn(result, params.maxReservations, totalCapacity, deadlinePassed)) {
+        return {result, terminateIntents, divergences: []};
+      }
+
+      return {
+        result,
+        terminateIntents,
+        divergences: calculateProvisionedRunnerCountDivergences({
+          advertisedTemplates: params.templates,
+          backendCounts: await listActiveProvisionedRunnerCountsByTemplateTx(tx, {
+            workspaceId: params.workspaceId,
+            provisionerId: params.provisionerId,
+          }),
+        }),
+      };
+    });
+    if (params.signal.aborted) {
+      await releaseReservationGrants(snapshot.result.reservations);
+      return previousSnapshot.result;
+    }
+
+    lastSnapshot = snapshot;
+
+    if (shouldReturn(lastSnapshot.result, params.maxReservations, totalCapacity, deadlinePassed)) {
+      recordPollDemandMetrics(params, lastSnapshot);
+      return lastSnapshot.result;
+    }
+
+    const remainingWaitMs = Math.max(0, deadlineMs - Date.now());
+    try {
+      await sleep(Math.min(withJitter(interval), remainingWaitMs), undefined, {
+        signal: params.signal,
+      });
+    } catch (error) {
+      if (params.signal.aborted) return lastSnapshot.result;
+      throw error;
+    }
+    interval = nextBackoffInterval(interval);
+  }
+}
+
+export async function releaseReservationGrants(reservations: ReservationGrant[]): Promise<void> {
+  await deleteReservationsByIds(reservations.map((reservation) => reservation.reservationId));
+}
+
+export function shouldReturn(
+  result: PollDemandResult,
+  maxReservations: number,
+  totalCapacity: number,
+  deadlinePassed: boolean,
+): boolean {
+  return (
+    maxReservations === 0 ||
+    totalCapacity === 0 ||
+    result.reservations.length > 0 ||
+    result.terminateProvisionedRunnerIds.length > 0 ||
+    deadlinePassed
+  );
+}
+
+export function nextBackoffInterval(ms: number): number {
+  return Math.min(ms * 1.5, config.RESERVATION_POLL_MAX_INTERVAL_MS);
+}
+
+export function withJitter(ms: number): number {
+  return Math.random() * ms;
+}
+
+export function calculateProvisionedRunnerCountDivergences(params: {
+  advertisedTemplates: ReservationTemplate[];
+  backendCounts: ActiveProvisionedRunnerTemplateCount[];
+}): ProvisionedRunnerCountDivergence[] {
+  const advertisedCounts = new Map<string, number>();
+  const backendCounts = new Map<string, number>();
+
+  for (const template of params.advertisedTemplates) {
+    addCount(advertisedCounts, countKey(template.templateKey, 'starting'), template.starting);
+    addCount(advertisedCounts, countKey(template.templateKey, 'running'), template.running);
+  }
+  for (const count of params.backendCounts) {
+    addCount(backendCounts, countKey(count.templateKey, count.state), count.count);
+  }
+
+  const keys = [...new Set([...advertisedCounts.keys(), ...backendCounts.keys()])].sort();
+  return keys.flatMap((key) => {
+    const advertised = advertisedCounts.get(key) ?? 0;
+    const backend = backendCounts.get(key) ?? 0;
+    if (advertised === backend) return [];
+
+    const [templateKey, state] = splitCountKey(key);
+    return [
+      {
+        templateKey,
+        state,
+        direction: backend > advertised ? 'backend-higher' : 'advertised-higher',
+        delta: Math.abs(backend - advertised),
+      },
+    ];
+  });
+}
+
+function recordPollDemandMetrics(params: PollDemandParams, snapshot: PollDemandSnapshot): void {
+  for (const divergence of snapshot.divergences) {
+    logger().debug(
+      {
+        workspaceId: params.workspaceId,
+        provisionerId: params.provisionerId,
+        templateKey: divergence.templateKey,
+        state: divergence.state,
+        direction: divergence.direction,
+        delta: divergence.delta,
+      },
+      'provisioned runner count divergence observed',
+    );
+
+    const attributes = {
+      state: divergence.state,
+      direction: divergence.direction,
+      ...(config.PROVISIONED_RUNNER_COUNT_DIVERGENCE_TEMPLATE_KEY_LABEL_ENABLED
+        ? {template_key: divergence.templateKey}
+        : {}),
+    };
+    provisionedRunnerCountDivergenceCount.add(divergence.delta, attributes);
+  }
+  for (const intent of snapshot.terminateIntents) {
+    provisionedRunnerTerminateIntentIssuedCount.add(1, {
+      surface: 'poll-demand',
+      reason: intent.reason,
+    });
+  }
+}
+
+function addCount(counts: Map<string, number>, key: string, count: number): void {
+  counts.set(key, (counts.get(key) ?? 0) + count);
+}
+
+function countKey(templateKey: string, state: 'starting' | 'running'): string {
+  return `${templateKey}\0${state}`;
+}
+
+function splitCountKey(key: string): [string, 'starting' | 'running'] {
+  const [templateKey, state] = key.split('\0');
+  if (!templateKey || (state !== 'starting' && state !== 'running')) {
+    throw new Error(`Invalid provisioned runner count key: ${key}`);
+  }
+  return [templateKey, state];
+}

package/src/core/entities/ephemeral-registration-token.ts

@@ -0,0 +1,13 @@
+export interface EphemeralRegistrationToken {
+  id: string;
+  workspaceId: string;
+  provisionerId: string;
+  reservationId: string | null;
+  provisionedRunnerId: string;
+  hashedToken: string;
+  prefix: string;
+  expiresAt: Date;
+  consumedAt: Date | null;
+  consumedSessionId: string | null;
+  createdAt: Date;
+}

package/src/core/entities/manual-registration-token.ts

@@ -0,0 +1,11 @@
+export interface ManualRegistrationToken {
+  id: string;
+  workspaceId: string;
+  hashedToken: string;
+  prefix: string;
+  name: string | null;
+  expiresAt: Date | null;
+  revokedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/core/entities/provisioned-runner.ts

@@ -0,0 +1,30 @@
+export type ProvisionedRunnerState =
+  | 'starting'
+  | 'running'
+  | 'stopping'
+  | 'stopped'
+  | 'failed'
+  | 'terminated';
+
+export interface ProvisionedRunner {
+  id: string;
+  workspaceId: string;
+  provisionerId: string;
+  provisionedRunnerId: string;
+  reservationId: string | null;
+  templateKey: string | null;
+  labels: string[];
+  state: ProvisionedRunnerState;
+  reason: string | null;
+  runnerSessionId: string | null;
+  providerKind: string | null;
+  reportedAt: Date;
+  startedAt: Date | null;
+  stoppingAt: Date | null;
+  stoppedAt: Date | null;
+  failedAt: Date | null;
+  terminatedAt: Date | null;
+  reservationReleasedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/core/entities/provisioner-token.ts

@@ -0,0 +1,16 @@
+export interface ProvisionerToken {
+  id: string;
+  workspaceId: string;
+  hashedToken: string;
+  prefix: string;
+  name: string | null;
+  createdByUserId: string;
+  revokedByUserId: string | null;
+  expiresAt: Date | null;
+  revokedAt: Date | null;
+  lastSeenAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export type ActiveProvisionerToken = ProvisionerToken & {lastSeenAt: Date};

package/src/core/entities/reservation.ts

@@ -0,0 +1,9 @@
+export interface Reservation {
+  id: string;
+  workspaceId: string;
+  provisionerId: string;
+  requiredLabels: string[];
+  count: number;
+  createdAt: Date;
+  expiresAt: Date;
+}

package/src/core/entities/runner-session.ts

@@ -0,0 +1,18 @@
+import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';
+
+export interface RunnerSession {
+  id: string;
+  workspaceId: string;
+  scope: 'workspace';
+  registrationTokenId: string;
+  registrationTokenKind: 'manual' | 'ephemeral';
+  provisionerId: string | null;
+  provisionedRunnerId: string | null;
+  labels: string[];
+  toolCapabilities: RunnerToolCapabilitiesDto | null;
+  toolCapabilitiesReportedAt: Date | null;
+  maxClaims: number | null;
+  claimsUsed: number;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/core/ephemeral-registration-tokens.test.ts

@@ -0,0 +1,108 @@
+import {hashOpaqueToken, tokenTypeParts} from '@shipfox/node-tokens';
+import {eq} from 'drizzle-orm';
+import {db} from '#db/db.js';
+import {ephemeralRegistrationTokens} from '#db/schema/ephemeral-registration-tokens.js';
+import {mintEphemeralRegistrationToken} from './ephemeral-registration-tokens.js';
+import {ActiveEphemeralRegistrationTokenExistsError} from './errors.js';
+
+describe('mintEphemeralRegistrationToken', () => {
+  it('mints a token, stores only the hash, and carries the ert prefix', async () => {
+    const workspaceId = crypto.randomUUID();
+    const provisionerId = crypto.randomUUID();
+
+    const result = await mintEphemeralRegistrationToken({
+      workspaceId,
+      provisionerId,
+      provisionedRunnerId: 'gh-runner-7',
+      ttlSeconds: 600,
+    });
+
+    expect(result.rawToken.startsWith(`sf_${tokenTypeParts.ephemeralRegistrationToken}_`)).toBe(
+      true,
+    );
+    expect(result.token.workspaceId).toBe(workspaceId);
+    expect(result.token.provisionerId).toBe(provisionerId);
+    expect(result.token.provisionedRunnerId).toBe('gh-runner-7');
+    expect(result.token.reservationId).toBeNull();
+    expect(result.token.prefix).toBe(result.rawToken.slice(0, 12));
+    const [row] = await db()
+      .select()
+      .from(ephemeralRegistrationTokens)
+      .where(eq(ephemeralRegistrationTokens.id, result.token.id));
+    expect(row?.hashedToken).toBe(hashOpaqueToken(result.rawToken));
+    expect(row?.hashedToken).not.toBe(result.rawToken);
+  });
+
+  it('derives expiresAt from ttlSeconds', async () => {
+    const ttlSeconds = 900;
+    const before = Date.now();
+
+    const result = await mintEphemeralRegistrationToken({
+      workspaceId: crypto.randomUUID(),
+      provisionerId: crypto.randomUUID(),
+      provisionedRunnerId: 'gh-runner-7',
+      ttlSeconds,
+    });
+
+    const after = Date.now();
+    const expiresMs = result.token.expiresAt.getTime();
+    expect(expiresMs).toBeGreaterThanOrEqual(before + ttlSeconds * 1000);
+    expect(expiresMs).toBeLessThanOrEqual(after + ttlSeconds * 1000);
+  });
+
+  it('passes through a reservationId when provided', async () => {
+    const reservationId = crypto.randomUUID();
+
+    const result = await mintEphemeralRegistrationToken({
+      workspaceId: crypto.randomUUID(),
+      provisionerId: crypto.randomUUID(),
+      provisionedRunnerId: 'gh-runner-7',
+      reservationId,
+      ttlSeconds: 600,
+    });
+
+    expect(result.token.reservationId).toBe(reservationId);
+  });
+
+  it('rejects a second active token for the same provisioned runner', async () => {
+    const workspaceId = crypto.randomUUID();
+    const provisionerId = crypto.randomUUID();
+    const provisionedRunnerId = 'gh-runner-7';
+    await mintEphemeralRegistrationToken({
+      workspaceId,
+      provisionerId,
+      provisionedRunnerId,
+      ttlSeconds: 600,
+    });
+
+    await expect(
+      mintEphemeralRegistrationToken({
+        workspaceId,
+        provisionerId,
+        provisionedRunnerId,
+        ttlSeconds: 600,
+      }),
+    ).rejects.toBeInstanceOf(ActiveEphemeralRegistrationTokenExistsError);
+  });
+
+  it('allows minting a replacement after the previous token expires', async () => {
+    const workspaceId = crypto.randomUUID();
+    const provisionerId = crypto.randomUUID();
+    const provisionedRunnerId = 'gh-runner-7';
+    await mintEphemeralRegistrationToken({
+      workspaceId,
+      provisionerId,
+      provisionedRunnerId,
+      ttlSeconds: -1,
+    });
+
+    const replacement = await mintEphemeralRegistrationToken({
+      workspaceId,
+      provisionerId,
+      provisionedRunnerId,
+      ttlSeconds: 600,
+    });
+
+    expect(replacement.token.provisionedRunnerId).toBe(provisionedRunnerId);
+  });
+});

package/src/core/ephemeral-registration-tokens.ts

@@ -0,0 +1,112 @@
+import {extractDisplayPrefix, generateOpaqueToken, hashOpaqueToken} from '@shipfox/node-tokens';
+import {
+  createEphemeralRegistrationToken,
+  createEphemeralRegistrationTokensBatch,
+} from '#db/ephemeral-registration-tokens.js';
+import type {EphemeralRegistrationToken} from './entities/ephemeral-registration-token.js';
+import {RegistrationTokenBatchTooLargeError} from './errors.js';
+
+export interface MintEphemeralRegistrationTokenParams {
+  workspaceId: string;
+  provisionerId: string;
+  provisionedRunnerId: string;
+  reservationId?: string | null | undefined;
+  ttlSeconds: number;
+}
+
+export interface MintEphemeralRegistrationTokenResult {
+  token: EphemeralRegistrationToken;
+  rawToken: string;
+}
+
+export interface MintEphemeralRegistrationTokensBatchProvisionedRunner {
+  provisionedRunnerId: string;
+}
+
+export interface MintEphemeralRegistrationTokensBatchParams {
+  workspaceId: string;
+  provisionerId: string;
+  reservationId: string;
+  provisionedRunners: MintEphemeralRegistrationTokensBatchProvisionedRunner[];
+  ttlSeconds: number;
+  maxBatchSize: number;
+}
+
+export interface MintEphemeralRegistrationTokensBatchResult {
+  provisionedRunnerId: string;
+  token: EphemeralRegistrationToken;
+  rawToken: string;
+}
+
+export async function mintEphemeralRegistrationToken(
+  params: MintEphemeralRegistrationTokenParams,
+): Promise<MintEphemeralRegistrationTokenResult> {
+  const expiresAt = new Date(Date.now() + params.ttlSeconds * 1000);
+  const row = buildEphemeralTokenRow(params.provisionedRunnerId, expiresAt);
+  const token = await createEphemeralRegistrationToken({
+    workspaceId: params.workspaceId,
+    provisionerId: params.provisionerId,
+    reservationId: params.reservationId ?? null,
+    provisionedRunnerId: params.provisionedRunnerId,
+    hashedToken: row.hashedToken,
+    prefix: row.prefix,
+    expiresAt: row.expiresAt,
+  });
+
+  return {token, rawToken: row.rawToken};
+}
+
+export async function mintEphemeralRegistrationTokensBatch(
+  params: MintEphemeralRegistrationTokensBatchParams,
+): Promise<MintEphemeralRegistrationTokensBatchResult[]> {
+  if (params.provisionedRunners.length > params.maxBatchSize) {
+    throw new RegistrationTokenBatchTooLargeError(
+      params.provisionedRunners.length,
+      params.maxBatchSize,
+    );
+  }
+
+  const expiresAt = new Date(Date.now() + params.ttlSeconds * 1000);
+  const rows = params.provisionedRunners.map((provisionedRunner) =>
+    buildEphemeralTokenRow(provisionedRunner.provisionedRunnerId, expiresAt),
+  );
+  const tokens = await createEphemeralRegistrationTokensBatch({
+    workspaceId: params.workspaceId,
+    provisionerId: params.provisionerId,
+    reservationId: params.reservationId,
+    expiresAt,
+    rows,
+  });
+  const tokensByProvisionedRunnerId = new Map(
+    tokens.map((token) => [token.provisionedRunnerId, token]),
+  );
+
+  return rows.map((row) => {
+    const token = tokensByProvisionedRunnerId.get(row.provisionedRunnerId);
+    if (!token) {
+      throw new Error(
+        `Inserted token not returned for provisioned runner: ${row.provisionedRunnerId}`,
+      );
+    }
+    return {provisionedRunnerId: row.provisionedRunnerId, rawToken: row.rawToken, token};
+  });
+}
+
+interface EphemeralTokenRow {
+  provisionedRunnerId: string;
+  rawToken: string;
+  hashedToken: string;
+  prefix: string;
+  expiresAt: Date;
+}
+
+function buildEphemeralTokenRow(provisionedRunnerId: string, expiresAt: Date): EphemeralTokenRow {
+  const rawToken = generateOpaqueToken('ephemeralRegistrationToken');
+  return {
+    provisionedRunnerId,
+    rawToken,
+    hashedToken: hashOpaqueToken(rawToken),
+    prefix: extractDisplayPrefix(rawToken),
+    expiresAt,
+  };
+}

package/src/core/errors.ts

@@ -0,0 +1,128 @@
+export class RunningJobExecutionNotFoundError extends Error {
+  constructor(jobExecutionId: string) {
+    super(`Running job execution not found: ${jobExecutionId}`);
+    this.name = 'RunningJobExecutionNotFoundError';
+  }
+}
+
+export class ManualRegistrationTokenNotFoundError extends Error {
+  constructor(tokenId: string) {
+    super(`Manual registration token not found: ${tokenId}`);
+    this.name = 'ManualRegistrationTokenNotFoundError';
+  }
+}
+
+export class ProvisionerTokenNotFoundError extends Error {
+  constructor(tokenId: string) {
+    super(`Provisioner token not found: ${tokenId}`);
+    this.name = 'ProvisionerTokenNotFoundError';
+  }
+}
+
+export class EmptyRunnerLabelsError extends Error {
+  constructor() {
+    super('Runner labels cannot be empty');
+    this.name = 'EmptyRunnerLabelsError';
+  }
+}
+
+export class EmptyRequiredLabelsError extends Error {
+  constructor() {
+    super('Required labels cannot be empty');
+    this.name = 'EmptyRequiredLabelsError';
+  }
+}
+
+export class RegistrationTokenConsumedError extends Error {
+  constructor(public readonly ephemeralTokenId: string) {
+    super(`Ephemeral registration token has already been consumed: ${ephemeralTokenId}`);
+    this.name = 'RegistrationTokenConsumedError';
+  }
+}
+
+export class RegistrationTokenExpiredError extends Error {
+  constructor(public readonly ephemeralTokenId: string) {
+    super(`Ephemeral registration token has expired: ${ephemeralTokenId}`);
+    this.name = 'RegistrationTokenExpiredError';
+  }
+}
+
+export class RegistrationTokenWorkspaceMismatchError extends Error {
+  constructor(
+    public readonly ephemeralTokenId: string,
+    public readonly workspaceId: string,
+  ) {
+    super(
+      `Ephemeral registration token ${ephemeralTokenId} does not belong to workspace ${workspaceId}`,
+    );
+    this.name = 'RegistrationTokenWorkspaceMismatchError';
+  }
+}
+
+export class ActiveEphemeralRegistrationTokenExistsError extends Error {
+  constructor(
+    public readonly workspaceId: string,
+    public readonly provisionerId: string,
+    public readonly provisionedRunnerId: string,
+  ) {
+    super(
+      `Active ephemeral registration token already exists for provisioned runner ${provisionedRunnerId} in workspace ${workspaceId}`,
+    );
+    this.name = 'ActiveEphemeralRegistrationTokenExistsError';
+  }
+}
+
+export class ReservationNotFoundError extends Error {
+  constructor(public readonly reservationId: string) {
+    super(`Reservation not found: ${reservationId}`);
+    this.name = 'ReservationNotFoundError';
+  }
+}
+
+export class ReservationExpiredError extends Error {
+  constructor(public readonly reservationId: string) {
+    super(`Reservation has expired: ${reservationId}`);
+    this.name = 'ReservationExpiredError';
+  }
+}
+
+export class RegistrationTokenBatchTooLargeError extends Error {
+  constructor(
+    public readonly requested: number,
+    public readonly max: number,
+  ) {
+    super(
+      `Registration token batch requested ${requested} provisioned runners, exceeding max ${max}`,
+    );
+    this.name = 'RegistrationTokenBatchTooLargeError';
+  }
+}
+
+export class RegistrationTokenBatchExceedsReservationError extends Error {
+  constructor(
+    public readonly requested: number,
+    public readonly reservationCount: number,
+    public readonly alreadyMinted: number = 0,
+  ) {
+    super(
+      `Registration token batch requested ${requested} provisioned runners with ${alreadyMinted} already minted, exceeding reservation count ${reservationCount}`,
+    );
+    this.name = 'RegistrationTokenBatchExceedsReservationError';
+  }
+}
+
+export class ActiveEphemeralRegistrationTokensExistError extends Error {
+  constructor(public readonly provisionedRunnerIds: string[]) {
+    super(
+      `Active ephemeral registration tokens already exist for provisioned runners: ${provisionedRunnerIds.join(', ')}`,
+    );
+    this.name = 'ActiveEphemeralRegistrationTokensExistError';
+  }
+}
+
+export class RunnerSessionExhaustedError extends Error {
+  constructor(public readonly runnerSessionId: string) {
+    super(`Runner session claim limit exhausted: ${runnerSessionId}`);
+    this.name = 'RunnerSessionExhaustedError';
+  }
+}