@shipfox/api-runners 4.0.0 → 6.0.0

package/src/db/runner-sessions.test.ts

@@ -41,6 +41,19 @@ describe('deleteExpiredRunnerSessions', () => {
     expect(remaining).toEqual([active]);
   });
 
+  it('deletes activation sessions using the ephemeral retention window', async () => {
+    const expired = await insertRunnerSession({kind: 'activation', createdDaysAgo: 8});
+    const active = await insertRunnerSession({kind: 'activation', createdDaysAgo: 6});
+
+    await deleteExpiredRunnerSessions({
+      manualRetentionDays: 30,
+      ephemeralRetentionDays: 7,
+      limit: 100,
+    });
+
+    expect(await listRunnerSessionIds([expired, active])).toEqual([active]);
+  });
+
   it('applies the retention window for each registration token kind independently', async () => {
     const manualExpired = await insertRunnerSession({kind: 'manual', createdDaysAgo: 31});
     const manualActive = await insertRunnerSession({kind: 'manual', createdDaysAgo: 8});
@@ -94,15 +107,14 @@ describe('deleteExpiredRunnerSessions', () => {
   });
 
   async function insertRunnerSession(params: {
-    kind: 'manual' | 'ephemeral';
+    kind: 'manual' | 'ephemeral' | 'activation';
     createdDaysAgo: number;
   }): Promise<string> {
     const id = crypto.randomUUID();
     const registrationTokenId = crypto.randomUUID();
     const createdAt = new Date(Date.now() - params.createdDaysAgo * 24 * 60 * 60 * 1000);
-    const provisionerId = params.kind === 'ephemeral' ? crypto.randomUUID() : null;
-    const provisionedRunnerId =
-      params.kind === 'ephemeral' ? `provisioned-${crypto.randomUUID()}` : null;
+    const provisionerId = params.kind === 'manual' ? null : crypto.randomUUID();
+    const providerRunnerId = params.kind === 'manual' ? null : `provisioned-${crypto.randomUUID()}`;
 
     await db()
       .insert(runnerSessions)
@@ -112,10 +124,11 @@ describe('deleteExpiredRunnerSessions', () => {
         scope: 'workspace',
         registrationTokenId,
         registrationTokenKind: params.kind,
+        runnerInstanceId: params.kind === 'activation' ? crypto.randomUUID() : null,
         provisionerId,
-        provisionedRunnerId,
+        providerRunnerId,
         labels: ['linux'],
-        maxClaims: params.kind === 'ephemeral' ? 1 : null,
+        maxClaims: params.kind === 'manual' ? null : 1,
         claimsUsed: 0,
         createdAt,
         updatedAt: createdAt,

package/src/db/runner-sessions.ts

@@ -1,7 +1,10 @@
 import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';
-import {and, asc, eq, inArray, lt, notExists, or, sql} from 'drizzle-orm';
+import {and, asc, eq, gt, inArray, isNull, lt, notExists, or, sql} from 'drizzle-orm';
 import type {RunnerSession} from '#core/entities/runner-session.js';
 import {db} from './db.js';
+import {runnerActivationTokens} from './schema/runner-activation-tokens.js';
+import {runnerControlSessions} from './schema/runner-control-sessions.js';
+import {providerRunners} from './schema/runner-instances.js';
 import {runnerSessions, toRunnerSession} from './schema/runner-sessions.js';
 import {runningJobExecutions} from './schema/running-job-executions.js';
 
@@ -47,6 +50,79 @@ export async function getRunnerSessionById(runnerSessionId: string): Promise<Run
   return row ? toRunnerSession(row) : null;
 }
 
+export async function createRunnerSessionConsumingActivationToken(params: {
+  activationTokenId: string;
+  labels: string[];
+  toolCapabilities?: RunnerToolCapabilitiesDto | null;
+}) {
+  return await db().transaction(async (tx) => {
+    const [token] = await tx
+      .select({
+        id: runnerActivationTokens.id,
+        runnerInstanceId: runnerActivationTokens.runnerInstanceId,
+        workspaceId: providerRunners.workspaceId,
+        provisionerId: providerRunners.provisionerId,
+        providerRunnerId: providerRunners.providerRunnerId,
+      })
+      .from(runnerActivationTokens)
+      .innerJoin(providerRunners, eq(providerRunners.id, runnerActivationTokens.runnerInstanceId))
+      .where(
+        and(
+          eq(runnerActivationTokens.id, params.activationTokenId),
+          isNull(runnerActivationTokens.consumedAt),
+          isNull(runnerActivationTokens.revokedAt),
+          gt(runnerActivationTokens.expiresAt, sql`now()`),
+          isNull(providerRunners.runnerSessionId),
+        ),
+      )
+      .limit(1)
+      .for('update');
+    if (!token?.workspaceId || !token.providerRunnerId)
+      throw new Error('Runner activation token is invalid, expired, or has already been used');
+    const [session] = await tx
+      .insert(runnerSessions)
+      .values({
+        workspaceId: token.workspaceId,
+        scope: 'workspace',
+        registrationTokenId: token.id,
+        registrationTokenKind: 'activation',
+        runnerInstanceId: token.runnerInstanceId,
+        provisionerId: token.provisionerId,
+        providerRunnerId: token.providerRunnerId,
+        labels: params.labels,
+        toolCapabilities: params.toolCapabilities ?? null,
+        toolCapabilitiesReportedAt: params.toolCapabilities ? sql`now()` : null,
+        maxClaims: 1,
+        claimsUsed: 0,
+      })
+      .returning();
+    if (!session) throw new Error('Runner activation session insert returned no row');
+    await tx
+      .update(runnerActivationTokens)
+      .set({consumedAt: sql`now()`, consumedSessionId: session.id})
+      .where(eq(runnerActivationTokens.id, token.id));
+    await tx
+      .update(providerRunners)
+      .set({runnerSessionId: session.id, updatedAt: sql`now()`})
+      .where(
+        and(
+          eq(providerRunners.id, token.runnerInstanceId),
+          isNull(providerRunners.runnerSessionId),
+        ),
+      );
+    await tx
+      .update(runnerControlSessions)
+      .set({closedAt: sql`now()`, closeReason: 'activated'})
+      .where(
+        and(
+          eq(runnerControlSessions.runnerInstanceId, token.runnerInstanceId),
+          isNull(runnerControlSessions.closedAt),
+        ),
+      );
+    return toRunnerSession(session);
+  });
+}
+
 export interface DeleteExpiredRunnerSessionsParams {
   manualRetentionDays: number;
   ephemeralRetentionDays: number;
@@ -70,7 +146,7 @@ export async function deleteExpiredRunnerSessions(
             ),
           ),
           and(
-            eq(runnerSessions.registrationTokenKind, 'ephemeral'),
+            inArray(runnerSessions.registrationTokenKind, ['ephemeral', 'activation']),
             lt(
               runnerSessions.createdAt,
               sql`now() - (${params.ephemeralRetentionDays} || ' days')::interval`,

package/src/db/schema/capacity-assignments.ts

@@ -0,0 +1,34 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {CapacityAssignment} from '#core/entities/capacity-assignment.js';
+import {pgTable} from './common.js';
+
+export const capacityAssignments = pgTable(
+  'capacity_assignments',
+  {
+    id: uuidv7PrimaryKey(),
+    capacityId: uuid('capacity_id').notNull(),
+    reservationId: uuid('reservation_id').notNull(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('runners_capacity_assignments_capacity_unique').on(table.capacityId),
+    index('runners_capacity_assignments_reservation_idx').on(table.reservationId),
+    index('runners_capacity_assignments_workspace_idx').on(table.workspaceId),
+  ],
+);
+
+export type CapacityAssignmentDb = typeof capacityAssignments.$inferSelect;
+
+export function toCapacityAssignment(row: CapacityAssignmentDb): CapacityAssignment {
+  return {
+    id: row.id,
+    capacityId: row.capacityId,
+    reservationId: row.reservationId,
+    workspaceId: row.workspaceId,
+    provisionerId: row.provisionerId,
+    createdAt: row.createdAt,
+  };
+}

package/src/db/schema/ephemeral-registration-tokens.ts

@@ -11,7 +11,7 @@ export const ephemeralRegistrationTokens = pgTable(
     workspaceId: uuid('workspace_id').notNull(),
     provisionerId: uuid('provisioner_id').notNull(),
     reservationId: uuid('reservation_id'),
-    provisionedRunnerId: text('provisioned_runner_id').notNull(),
+    providerRunnerId: text('provider_runner_id').notNull(),
     hashedToken: text('hashed_token').notNull(),
     prefix: text('prefix').notNull(),
     expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
@@ -22,10 +22,10 @@ export const ephemeralRegistrationTokens = pgTable(
   (table) => [
     uniqueIndex('runners_ephemeral_registration_tokens_hashed_token_unique').on(table.hashedToken),
     index('runners_ephemeral_registration_tokens_reservation_id_idx').on(table.reservationId),
-    index('runners_ephemeral_registration_tokens_active_provisioned_runner_idx').on(
+    index('runners_ephemeral_registration_tokens_active_provider_runner_idx').on(
       table.workspaceId,
       table.provisionerId,
-      table.provisionedRunnerId,
+      table.providerRunnerId,
       table.consumedAt,
       table.expiresAt,
     ),
@@ -47,7 +47,7 @@ export function toEphemeralRegistrationToken(
     workspaceId: row.workspaceId,
     provisionerId: row.provisionerId,
     reservationId: row.reservationId,
-    provisionedRunnerId: row.provisionedRunnerId,
+    providerRunnerId: row.providerRunnerId,
     hashedToken: row.hashedToken,
     prefix: row.prefix,
     expiresAt: row.expiresAt,

package/src/db/schema/provisioner-capability-snapshots.ts

@@ -0,0 +1,46 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, integer, text, timestamp, uuid} from 'drizzle-orm/pg-core';
+import type {ProvisionerCapabilitySnapshot} from '#core/entities/provisioner-capability-snapshot.js';
+import {pgTable} from './common.js';
+
+export const provisionerCapabilitySnapshots = pgTable(
+  'provisioner_capability_snapshots',
+  {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    templateKey: text('template_key').notNull(),
+    labels: text('labels').array().notNull(),
+    availableSlots: integer('available_slots').notNull(),
+    starting: integer('starting').notNull(),
+    running: integer('running').notNull(),
+    advertisedAt: timestamp('advertised_at', {withTimezone: true}).notNull().defaultNow(),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    index('runners_provisioner_capability_snapshots_workspace_active_idx').on(
+      table.workspaceId,
+      table.advertisedAt,
+    ),
+    index('runners_provisioner_capability_snapshots_provisioner_idx').on(table.provisionerId),
+  ],
+);
+
+export type ProvisionerCapabilitySnapshotDb = typeof provisionerCapabilitySnapshots.$inferSelect;
+
+export function toProvisionerCapabilitySnapshot(
+  row: ProvisionerCapabilitySnapshotDb,
+): ProvisionerCapabilitySnapshot {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    provisionerId: row.provisionerId,
+    templateKey: row.templateKey,
+    labels: row.labels,
+    availableSlots: row.availableSlots,
+    starting: row.starting,
+    running: row.running,
+    advertisedAt: row.advertisedAt,
+    createdAt: row.createdAt,
+  };
+}

package/src/db/schema/provisioner-tokens.ts

@@ -1,13 +1,20 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
-import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {sql} from 'drizzle-orm';
+import {check, index, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import type {ProvisionerToken} from '#core/entities/provisioner-token.js';
 import {pgTable} from './common.js';
 
+export const provisionerScopeEnum = pgEnum('runners_provisioner_scope', [
+  'workspace',
+  'installation',
+]);
+
 export const provisionerTokens = pgTable(
   'provisioner_tokens',
   {
     id: uuidv7PrimaryKey(),
-    workspaceId: uuid('workspace_id').notNull(),
+    scope: provisionerScopeEnum('scope').notNull(),
+    workspaceId: uuid('workspace_id'),
     hashedToken: text('hashed_token').notNull(),
     prefix: text('prefix').notNull(),
     name: text('name'),
@@ -26,6 +33,10 @@ export const provisionerTokens = pgTable(
       table.lastSeenAt.desc(),
       table.id.desc(),
     ),
+    check(
+      'runners_provisioner_tokens_scope_workspace_ck',
+      sql`(scope = 'workspace' AND workspace_id IS NOT NULL) OR (scope = 'installation' AND workspace_id IS NULL)`,
+    ),
   ],
 );
 
@@ -33,8 +44,28 @@ export type ProvisionerTokenDb = typeof provisionerTokens.$inferSelect;
 export type ProvisionerTokenInsertDb = typeof provisionerTokens.$inferInsert;
 
 export function toProvisionerToken(row: ProvisionerTokenDb): ProvisionerToken {
+  if (row.scope === 'installation') {
+    return {
+      id: row.id,
+      scope: 'installation',
+      workspaceId: null,
+      hashedToken: row.hashedToken,
+      prefix: row.prefix,
+      name: row.name,
+      createdByUserId: row.createdByUserId,
+      revokedByUserId: row.revokedByUserId,
+      expiresAt: row.expiresAt,
+      revokedAt: row.revokedAt,
+      lastSeenAt: row.lastSeenAt,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  if (!row.workspaceId) throw new Error('Workspace provisioner token has no workspace');
   return {
     id: row.id,
+    scope: 'workspace',
     workspaceId: row.workspaceId,
     hashedToken: row.hashedToken,
     prefix: row.prefix,

package/src/db/schema/runner-activation-tokens.ts

@@ -0,0 +1,22 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {pgTable} from './common.js';
+
+export const runnerActivationTokens = pgTable(
+  'runner_activation_tokens',
+  {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
+    consumedAt: timestamp('consumed_at', {withTimezone: true}),
+    revokedAt: timestamp('revoked_at', {withTimezone: true}),
+    consumedSessionId: uuid('consumed_session_id'),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('runners_runner_activation_tokens_hashed_token_unique').on(table.hashedToken),
+    index('runners_runner_activation_tokens_runner_instance_idx').on(table.runnerInstanceId),
+  ],
+);

package/src/db/schema/runner-control-sessions.ts

@@ -0,0 +1,46 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {sql} from 'drizzle-orm';
+import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {pgTable} from './common.js';
+
+export const runnerBootstrapTokens = pgTable(
+  'runner_bootstrap_tokens',
+  {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
+    consumedAt: timestamp('consumed_at', {withTimezone: true}),
+    revokedAt: timestamp('revoked_at', {withTimezone: true}),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('runners_runner_bootstrap_tokens_hashed_token_unique').on(table.hashedToken),
+    index('runners_runner_bootstrap_tokens_runner_instance_idx').on(table.runnerInstanceId),
+  ],
+);
+
+export const runnerControlSessions = pgTable(
+  'runner_control_sessions',
+  {
+    id: uuidv7PrimaryKey(),
+    runnerInstanceId: uuid('runner_instance_id').notNull(),
+    provisionerId: uuid('provisioner_id').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    prefix: text('prefix').notNull(),
+    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
+    lastSeenAt: timestamp('last_seen_at', {withTimezone: true}).notNull().defaultNow(),
+    closedAt: timestamp('closed_at', {withTimezone: true}),
+    closeReason: text('close_reason'),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('runners_runner_control_sessions_hashed_token_unique').on(table.hashedToken),
+    uniqueIndex('runners_runner_control_sessions_active_runner_instance_unique')
+      .on(table.runnerInstanceId)
+      .where(sql`"closed_at" is null`),
+    index('runners_runner_control_sessions_runner_instance_idx').on(table.runnerInstanceId),
+  ],
+);

package/src/db/schema/{provisioned-runners.ts → runner-instances.ts}

@@ -1,10 +1,11 @@
+import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
 import {sql} from 'drizzle-orm';
-import {index, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
-import type {ProvisionedRunner} from '#core/entities/provisioned-runner.js';
+import {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {RunnerInstance} from '#core/entities/runner-instance.js';
 import {pgTable} from './common.js';
 
-export const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_state', [
+export const providerRunnerStateEnum = pgEnum('runners_provider_runner_state', [
   'starting',
   'running',
   'stopping',
@@ -13,20 +14,24 @@ export const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_sta
   'terminated',
 ]);
 
-export const provisionedRunners = pgTable(
-  'provisioned_runners',
+export const providerRunners = pgTable(
+  'runner_instances',
   {
     id: uuidv7PrimaryKey(),
-    workspaceId: uuid('workspace_id').notNull(),
+    // Kept during the protocol migration for legacy workspace capacity. New capacity is owned
+    // only by its provisioner and has no workspace assignment.
+    workspaceId: uuid('workspace_id'),
     provisionerId: uuid('provisioner_id').notNull(),
-    provisionedRunnerId: text('provisioned_runner_id').notNull(),
+    providerRunnerId: text('provider_runner_id'),
     reservationId: uuid('reservation_id'),
     templateKey: text('template_key'),
-    labels: text('labels').array().notNull(),
-    state: provisionedRunnerStateEnum('state').notNull(),
+    labels: text('labels').array().notNull().default([]),
+    state: providerRunnerStateEnum('state').notNull(),
     reason: text('reason'),
     runnerSessionId: uuid('runner_session_id'),
     providerKind: text('provider_kind'),
+    protocolVersion: text('protocol_version'),
+    capabilities: jsonb('capabilities').$type<RunnerToolCapabilitiesDto | null>(),
     reportedAt: timestamp('reported_at', {withTimezone: true}).notNull(),
     startedAt: timestamp('started_at', {withTimezone: true}),
     stoppingAt: timestamp('stopping_at', {withTimezone: true}),
@@ -38,37 +43,31 @@ export const provisionedRunners = pgTable(
     updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
   },
   (table) => [
-    uniqueIndex('runners_provisioned_runners_workspace_provisioner_runner_unique').on(
-      table.workspaceId,
-      table.provisionerId,
-      table.provisionedRunnerId,
-    ),
-    index('runners_provisioned_runners_workspace_state_updated_idx').on(
-      table.workspaceId,
-      table.state,
-      table.updatedAt,
-    ),
-    index('runners_provisioned_runners_stale_reaper_idx').on(
+    uniqueIndex('runners_runner_instances_provisioner_runner_unique')
+      .on(table.provisionerId, table.providerRunnerId)
+      .where(sql`${table.providerRunnerId} is not null`),
+    index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),
+    index('runners_runner_instances_stale_reaper_idx').on(
       table.state,
       table.updatedAt,
       table.reportedAt,
-      table.workspaceId,
     ),
-    index('runners_provisioned_runners_active_template_counts_idx')
-      .on(table.workspaceId, table.provisionerId, table.state, table.templateKey)
+    index('runners_runner_instances_active_template_counts_idx')
+      .on(table.provisionerId, table.state, table.templateKey)
       .where(sql`"state" in ('starting', 'running') and "template_key" is not null`),
   ],
 );
 
-export type ProvisionedRunnerDb = typeof provisionedRunners.$inferSelect;
-export type ProvisionedRunnerInsertDb = typeof provisionedRunners.$inferInsert;
+export type RunnerInstanceDb = typeof providerRunners.$inferSelect;
+export type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;
 
-export function toProvisionedRunner(row: ProvisionedRunnerDb): ProvisionedRunner {
+export function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance {
+  if (!row.providerRunnerId) throw new Error('Planned capacity has no provider runner identity');
   return {
     id: row.id,
     workspaceId: row.workspaceId,
     provisionerId: row.provisionerId,
-    provisionedRunnerId: row.provisionedRunnerId,
+    providerRunnerId: row.providerRunnerId,
     reservationId: row.reservationId,
     templateKey: row.templateKey,
     labels: row.labels,

package/src/db/schema/runner-sessions.ts

@@ -8,7 +8,7 @@ import {pgTable} from './common.js';
 export const runnerSessionScopeEnum = pgEnum('runners_runner_session_scope', ['workspace']);
 export const runnerSessionRegistrationTokenKindEnum = pgEnum(
   'runners_runner_session_registration_token_kind',
-  ['manual', 'ephemeral'],
+  ['manual', 'ephemeral', 'activation'],
 );
 
 export const runnerSessions = pgTable(
@@ -20,13 +20,15 @@ export const runnerSessions = pgTable(
     registrationTokenId: uuid('registration_token_id').notNull(),
     registrationTokenKind:
       runnerSessionRegistrationTokenKindEnum('registration_token_kind').notNull(),
+    runnerInstanceId: uuid('runner_instance_id'),
     provisionerId: uuid('provisioner_id'),
-    provisionedRunnerId: text('provisioned_runner_id'),
+    providerRunnerId: text('provider_runner_id'),
     labels: text('labels').array().notNull(),
     toolCapabilities: jsonb('tool_capabilities').$type<RunnerToolCapabilitiesDto | null>(),
     toolCapabilitiesReportedAt: timestamp('tool_capabilities_reported_at', {withTimezone: true}),
     maxClaims: integer('max_claims'),
     claimsUsed: integer('claims_used').notNull().default(0),
+    revokedAt: timestamp('revoked_at', {withTimezone: true}),
     createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
   },
@@ -38,14 +40,14 @@ export const runnerSessions = pgTable(
     ),
     check(
       'runners_runner_sessions_claims_ck',
-      sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`,
+      sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} in ('ephemeral', 'activation') AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`,
     ),
     check(
       'runners_runner_sessions_link_ck',
-      sql`((${table.registrationTokenKind} = 'manual' AND ${table.provisionerId} IS NULL AND ${table.provisionedRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.provisionerId} IS NOT NULL AND ${table.provisionedRunnerId} IS NOT NULL))`,
+      sql`((${table.registrationTokenKind} = 'manual' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NULL AND ${table.providerRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL) OR (${table.registrationTokenKind} = 'activation' AND ${table.runnerInstanceId} IS NOT NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL))`,
     ),
-    index('runners_runner_sessions_provisioned_runner_updated_idx')
-      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.updatedAt)
+    index('runners_runner_sessions_provider_runner_updated_idx')
+      .on(table.workspaceId, table.provisionerId, table.providerRunnerId, table.updatedAt)
       .where(sql`"provisioner_id" IS NOT NULL`),
   ],
 );
@@ -64,13 +66,15 @@ export function toRunnerSession(row: RunnerSessionDb): RunnerSession {
     scope: row.scope,
     registrationTokenId: row.registrationTokenId,
     registrationTokenKind: row.registrationTokenKind,
+    runnerInstanceId: row.runnerInstanceId,
     provisionerId: row.provisionerId,
-    provisionedRunnerId: row.provisionedRunnerId,
+    providerRunnerId: row.providerRunnerId,
     labels: row.labels,
     toolCapabilities: row.toolCapabilities,
     toolCapabilitiesReportedAt: row.toolCapabilitiesReportedAt,
     maxClaims: row.maxClaims,
     claimsUsed: row.claimsUsed,
+    revokedAt: row.revokedAt,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   };

package/src/db/schema/running-job-executions.ts

@@ -18,7 +18,7 @@ export const runningJobExecutions = pgTable(
       .notNull()
       .references(() => runnerSessions.id),
     provisionerId: uuid('provisioner_id'),
-    provisionedRunnerId: text('provisioned_runner_id'),
+    providerRunnerId: text('provider_runner_id'),
     requiredLabels: text('required_labels').array().notNull(),
     runnerLabels: text('runner_labels').array().notNull(),
     startedAt: timestamp('started_at', {withTimezone: true}).notNull().defaultNow(),
@@ -31,17 +31,17 @@ export const runningJobExecutions = pgTable(
       .on(table.startedAt)
       .where(sql`"first_heartbeat_at" IS NULL`),
     index('runners_running_jobs_last_heartbeat_at_idx').on(table.lastHeartbeatAt),
-    index('runners_running_jobs_provisioned_runner_started_idx')
-      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.startedAt.desc())
+    index('runners_running_jobs_provider_runner_started_idx')
+      .on(table.workspaceId, table.provisionerId, table.providerRunnerId, table.startedAt.desc())
       .where(sql`"provisioner_id" IS NOT NULL`),
     index('runners_running_jobs_cancellation_requested_idx')
-      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId)
+      .on(table.workspaceId, table.provisionerId, table.providerRunnerId)
       .where(sql`"cancellation_requested_at" IS NOT NULL`),
     index('runners_running_jobs_job_id_idx').on(table.jobId),
     index('runners_running_jobs_runner_session_id_idx').on(table.runnerSessionId),
     check(
       'runners_running_jobs_link_ck',
-      sql`(${table.provisionerId} IS NULL) = (${table.provisionedRunnerId} IS NULL)`,
+      sql`(${table.provisionerId} IS NULL) = (${table.providerRunnerId} IS NULL)`,
     ),
   ],
 );

package/src/index.test.ts

@@ -0,0 +1,26 @@
+import type {AuthInterModuleClient} from '@shipfox/api-auth-dto/inter-module';
+import {createRunnersModule} from './index.js';
+
+const auth = {} as AuthInterModuleClient;
+
+describe('createRunnersModule', () => {
+  it('preserves the default module composition when options are absent', () => {
+    const module = createRunnersModule({auth});
+
+    expect(module.name).toBe('runners');
+    expect(module.auth).toHaveLength(3);
+    expect(module.routes).toHaveLength(11);
+    expect(module.workers).toHaveLength(1);
+  });
+
+  it('accepts an instance-local installation provisioning policy', () => {
+    const policy = {
+      filterEligibleWorkspaceIds: vi.fn().mockResolvedValue(new Set<string>()),
+    };
+
+    const module = createRunnersModule({auth, installationProvisioning: {policy}});
+
+    expect(module.name).toBe('runners');
+    expect(policy.filterEligibleWorkspaceIds).not.toHaveBeenCalled();
+  });
+});