@shipfox/api-runners 12.2.0 → 12.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-runners",
   "license": "MIT",
-  "version": "12.2.0",
+  "version": "12.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -25,19 +25,19 @@
     "@shipfox/api-auth-context": "12.2.0",
     "@shipfox/api-auth-dto": "12.0.0",
     "@shipfox/api-runners-dto": "12.2.0",
-    "@shipfox/api-workflows-dto": "12.2.0",
+    "@shipfox/api-workflows-dto": "12.3.0",
     "@shipfox/config": "1.2.4",
     "@shipfox/inter-module": "0.2.3",
     "@shipfox/node-drizzle": "0.3.5",
     "@shipfox/node-error-monitoring": "0.3.0",
     "@shipfox/node-auth-root-key": "0.2.3",
     "@shipfox/node-fastify": "0.4.2",
+    "@shipfox/node-module": "1.0.6",
     "@shipfox/node-opentelemetry": "0.6.4",
     "@shipfox/node-outbox": "0.2.6",
     "@shipfox/node-postgres": "0.5.0",
     "@shipfox/node-rate-limit": "0.4.0",
     "@shipfox/node-temporal": "0.4.5",
-    "@shipfox/node-module": "1.0.6",
     "@shipfox/node-tokens": "0.3.2",
     "@shipfox/runner-labels": "0.2.0"
   },

package/src/config.test.ts

@@ -104,12 +104,12 @@ describe('reservation TTL ceiling validation', () => {
     await expect(import('#config.js')).rejects.toThrow('RESERVATION_TTL_MAX_SECONDS');
   });
 
-  it('defaults high enough for the EC2 registration deadline', async () => {
+  it('defaults high enough for provider registration deadlines and launch headroom', async () => {
     vi.resetModules();
 
     const {config} = await import('#config.js');
 
-    expect(config.RESERVATION_TTL_MAX_SECONDS).toBe(300);
+    expect(config.RESERVATION_TTL_MAX_SECONDS).toBe(600);
   });
 
   it('accepts a whole-second ceiling inside the hard maximum', async () => {

package/src/config.ts

@@ -62,12 +62,12 @@ export const config = createConfig({
     default: 250,
   }),
   RESERVATION_TTL_SECONDS: num({
-    desc: 'Default lifetime of a count-based runner reservation, in seconds. Used when a provisioner does not request a provider-specific value. Expired reservations stop counting against queued demand.',
+    desc: 'Default lifetime and activation grace period of a count-based runner reservation, in seconds. A runner without a session can be rebound only after this deadline. Used when a provisioner does not request a provider-specific value. Expired reservations stop counting against queued demand.',
     default: 60,
   }),
   RESERVATION_TTL_MAX_SECONDS: num({
-    desc: `Server-side ceiling for a count-based runner reservation lifetime, in seconds. Set it at least as high as every provider registration deadline so provider-specific values can cover boot and enrollment. Set this between 1 and ${RESERVATION_TTL_HARD_MAX_SECONDS}.`,
-    default: 300,
+    desc: `Server-side ceiling for a count-based runner reservation lifetime and activation grace period, in seconds. Set it at least as high as every provider registration deadline plus its launch headroom so provider-specific values can cover the launch gap, boot, and enrollment. Set this between 1 and ${RESERVATION_TTL_HARD_MAX_SECONDS}.`,
+    default: 600,
   }),
   RESERVATION_LONG_POLL_MAX_WAIT_SECONDS: num({
     desc: 'Maximum time the provisioner demand poll endpoint waits for reservable demand before returning, in seconds.',

package/src/core/runner-control-sessions.test.ts

@@ -1,6 +1,8 @@
+import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';
 import {afterEach, vi} from '@shipfox/vitest/vi';
-import {inArray} from 'drizzle-orm';
+import {eq, inArray} from 'drizzle-orm';
 import {db} from '#db/db.js';
+import {provisionerTokens} from '#db/schema/provisioner-tokens.js';
 import {reservations} from '#db/schema/reservations.js';
 import {runnerActivationTokens} from '#db/schema/runner-activation-tokens.js';
 import {runnerControlSessions} from '#db/schema/runner-control-sessions.js';
@@ -12,6 +14,7 @@ import {
 import {enrollRunnerControlSession} from './runner-control-sessions.js';
 
 const createdReservationIds = new Set<string>();
+const createdProvisionerTokenIds = new Set<string>();
 const createdRunnerInstanceIds = new Set<string>();
 
 afterEach(async () => {
@@ -29,9 +32,14 @@ afterEach(async () => {
   }
   if (reservationIds.length > 0)
     await db().delete(reservations).where(inArray(reservations.id, reservationIds));
+  if (createdProvisionerTokenIds.size > 0)
+    await db()
+      .delete(provisionerTokens)
+      .where(inArray(provisionerTokens.id, [...createdProvisionerTokenIds]));
 
   createdRunnerInstanceIds.clear();
   createdReservationIds.clear();
+  createdProvisionerTokenIds.clear();
 });
 
 describe('enrollRunnerControlSession', () => {
@@ -110,6 +118,139 @@ describe('enrollRunnerControlSession', () => {
     }
   });
 
+  it('preserves committed assignment metadata during a later enrollment', async () => {
+    const provisionerId = crypto.randomUUID();
+    const reservation = await createReservation({provisionerId});
+    const committedCapabilities: RunnerToolCapabilitiesDto = {
+      harnesses: {pi: {tools: ['read']}},
+    };
+    const runnerInstanceId = await createRunner({
+      provisionerId,
+      intendedReservationId: reservation.id,
+      reservationId: reservation.id,
+      workspaceId: reservation.workspaceId,
+      assignedAt: new Date(),
+      labels: ['linux'],
+      providerKind: 'ec2',
+      protocolVersion: '1',
+      capabilities: committedCapabilities,
+    });
+
+    const activationToken = await enrollRunnerControlSession({
+      runnerInstanceId,
+      provisionerId,
+      labels: ['gpu'],
+      capabilities: {harnesses: {claude: {tools: ['bash']}}},
+      providerKind: 'docker',
+      protocolVersion: '2',
+    });
+    const [runner] = await db()
+      .select({
+        reservationId: providerRunners.reservationId,
+        labels: providerRunners.labels,
+        providerKind: providerRunners.providerKind,
+        protocolVersion: providerRunners.protocolVersion,
+        capabilities: providerRunners.capabilities,
+        state: providerRunners.state,
+      })
+      .from(providerRunners)
+      .where(eq(providerRunners.id, runnerInstanceId));
+
+    expect(activationToken).toEqual(expect.any(String));
+    expect(runner).toEqual({
+      reservationId: reservation.id,
+      labels: ['linux'],
+      providerKind: 'ec2',
+      protocolVersion: '1',
+      capabilities: committedCapabilities,
+      state: 'running',
+    });
+  });
+
+  it('updates metadata when a provider report precedes assignment commit', async () => {
+    const provisionerId = crypto.randomUUID();
+    const reservation = await createReservation({provisionerId});
+    const capabilities: RunnerToolCapabilitiesDto = {
+      harnesses: {pi: {tools: ['read']}},
+    };
+    const runnerInstanceId = await createRunner({
+      provisionerId,
+      intendedReservationId: reservation.id,
+      reservationId: reservation.id,
+      assignedAt: null,
+    });
+
+    const activationToken = await enrollRunnerControlSession({
+      runnerInstanceId,
+      provisionerId,
+      labels: ['linux'],
+      capabilities,
+      providerKind: 'ec2',
+      protocolVersion: '1',
+    });
+    const [runner] = await db()
+      .select({
+        reservationId: providerRunners.reservationId,
+        assignedAt: providerRunners.assignedAt,
+        labels: providerRunners.labels,
+        providerKind: providerRunners.providerKind,
+        protocolVersion: providerRunners.protocolVersion,
+        capabilities: providerRunners.capabilities,
+        state: providerRunners.state,
+      })
+      .from(providerRunners)
+      .where(eq(providerRunners.id, runnerInstanceId));
+
+    expect(activationToken).toBeNull();
+    expect(runner).toEqual({
+      reservationId: reservation.id,
+      assignedAt: null,
+      labels: ['linux'],
+      providerKind: 'ec2',
+      protocolVersion: '1',
+      capabilities,
+      state: 'running',
+    });
+  });
+
+  it('updates metadata during enrollment for an unassigned runner', async () => {
+    const provisionerId = crypto.randomUUID();
+    const capabilities: RunnerToolCapabilitiesDto = {
+      harnesses: {pi: {tools: ['read']}},
+    };
+    const runnerInstanceId = await createRunner({provisionerId});
+
+    const activationToken = await enrollRunnerControlSession({
+      runnerInstanceId,
+      provisionerId,
+      labels: ['linux'],
+      capabilities,
+      providerKind: 'docker',
+      protocolVersion: '1',
+    });
+    const [runner] = await db()
+      .select({
+        reservationId: providerRunners.reservationId,
+        labels: providerRunners.labels,
+        providerKind: providerRunners.providerKind,
+        protocolVersion: providerRunners.protocolVersion,
+        capabilities: providerRunners.capabilities,
+        state: providerRunners.state,
+      })
+      .from(providerRunners)
+      .where(eq(providerRunners.id, runnerInstanceId));
+
+    expect(activationToken).toBeNull();
+    expect(runner).toEqual({
+      reservationId: null,
+      labels: ['linux'],
+      providerKind: 'docker',
+      protocolVersion: '1',
+      capabilities,
+      state: 'running',
+    });
+  });
+
   it('keeps unexpected promotion failures on the error-log path', async () => {
     const provisionerId = crypto.randomUUID();
     const reservation = await createReservation({provisionerId});
@@ -207,18 +348,42 @@ async function createReservation(params: {
 
 async function createRunner(params: {
   provisionerId: string;
-  intendedReservationId: string;
-  reservationId?: string;
+  intendedReservationId?: string | null;
+  reservationId?: string | null;
+  workspaceId?: string | null;
   labels?: string[];
+  providerKind?: string | null;
+  protocolVersion?: string | null;
+  capabilities?: RunnerToolCapabilitiesDto | null;
+  assignedAt?: Date | null;
 }): Promise<string> {
+  const defaultAssignedAt = params.reservationId ? new Date() : null;
+
+  if (!createdProvisionerTokenIds.has(params.provisionerId)) {
+    await db().insert(provisionerTokens).values({
+      id: params.provisionerId,
+      scope: 'installation',
+      workspaceId: null,
+      hashedToken: crypto.randomUUID(),
+      prefix: 'test',
+      createdByUserId: crypto.randomUUID(),
+    });
+    createdProvisionerTokenIds.add(params.provisionerId);
+  }
+
   const [runner] = await db()
     .insert(providerRunners)
     .values({
       provisionerId: params.provisionerId,
-      intendedReservationId: params.intendedReservationId,
+      intendedReservationId: params.intendedReservationId ?? null,
       reservationId: params.reservationId ?? null,
+      workspaceId: params.workspaceId ?? null,
       providerRunnerId: crypto.randomUUID(),
       labels: params.labels ?? [],
+      providerKind: params.providerKind ?? null,
+      protocolVersion: params.protocolVersion ?? null,
+      capabilities: params.capabilities ?? null,
+      assignedAt: params.assignedAt === undefined ? defaultAssignedAt : params.assignedAt,
       state: 'starting',
       reportedAt: new Date(),
     })

package/src/core/runner-control-sessions.ts

@@ -163,7 +163,9 @@ export async function enrollRunnerControlSession(params: {
         sql`select pg_advisory_xact_lock(hashtext(${`runners_assignment:${params.provisionerId}:${current.intendedReservationId}`}))`,
       );
 
-    const [updated] = await tx
+    // Provider reports may populate reservationId before the assignment commits. assignedAt is
+    // written by the assignment transaction, so keep the guard on that write boundary.
+    const [metadataUpdated] = await tx
       .update(providerRunners)
       .set({
         labels: sanitizeRunnerLabels(params.labels, {
@@ -173,6 +175,25 @@ export async function enrollRunnerControlSession(params: {
         providerKind: params.providerKind,
         protocolVersion: params.protocolVersion,
         capabilities: params.capabilities ?? null,
+      })
+      .where(
+        and(
+          eq(providerRunners.id, params.runnerInstanceId),
+          eq(providerRunners.provisionerId, params.provisionerId),
+          isNull(providerRunners.assignedAt),
+          notInArray(providerRunners.state, [...terminalStates]),
+        ),
+      )
+      .returning({id: providerRunners.id});
+    if (!metadataUpdated)
+      logger().debug(
+        {runnerInstanceId: params.runnerInstanceId, provisionerId: params.provisionerId},
+        'Runner enrollment metadata update skipped for assigned or terminal runner',
+      );
+
+    const [updated] = await tx
+      .update(providerRunners)
+      .set({
         state: 'running',
         reportedAt: sql`now()`,
         updatedAt: sql`now()`,

package/src/db/index.ts

@@ -90,6 +90,7 @@ export type {
 } from './runner-instances.js';
 export {
   attachRunnerInstanceProviderId,
+  countStaleEnrolledRunnerInstances,
   isTerminalState,
   listActiveRunnerInstanceCountsByTemplateTx,
   listActiveRunnerInstances,