@shipfox/api-runners-dto 2.0.0 → 6.0.0

package/src/schemas/{reconcile-provisioned-runners.test.ts → reconcile-runner-instances.test.ts}

@@ -1,30 +1,30 @@
 import {
-  MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH,
+  MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH,
   MAX_RECONCILE_OBSERVED_RUNNERS,
-  reconcileProvisionedRunnersBodySchema,
-  reconcileProvisionedRunnersResponseSchema,
-} from './reconcile-provisioned-runners.js';
+  reconcileRunnerInstancesBodySchema,
+  reconcileRunnerInstancesResponseSchema,
+} from './reconcile-runner-instances.js';
 
-describe('reconcileProvisionedRunnersBodySchema', () => {
+describe('reconcileRunnerInstancesBodySchema', () => {
   it('accepts observed provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['01JPROVISIONEDRUNNER000001'],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['01JPROVISIONEDRUNNER000001'],
     });
 
     expect(result.success).toBe(true);
   });
 
   it('accepts an empty observed set', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: [],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: [],
     });
 
     expect(result.success).toBe(true);
   });
 
   it('rejects observed sets above the reconcile limit', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: Array.from(
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: Array.from(
         {length: MAX_RECONCILE_OBSERVED_RUNNERS + 1},
         (_, index) => `runner-${index}`,
       ),
@@ -34,24 +34,24 @@ describe('reconcileProvisionedRunnersBodySchema', () => {
   });
 
   it('rejects over-length provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['a'.repeat(MAX_OBSERVED_PROVISIONED_RUNNER_ID_LENGTH + 1)],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['a'.repeat(MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH + 1)],
     });
 
     expect(result.success).toBe(false);
   });
 
   it('rejects duplicate provisioned runner ids', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: ['provisioned-runner-1', 'provisioned-runner-1'],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: ['provisioned-runner-1', 'provisioned-runner-1'],
     });
 
     expect(result.success).toBe(false);
   });
 
   it('rejects extra fields', () => {
-    const result = reconcileProvisionedRunnersBodySchema.safeParse({
-      observed_provisioned_runner_ids: [],
+    const result = reconcileRunnerInstancesBodySchema.safeParse({
+      observed_provider_runner_ids: [],
       provisioner_hostname: 'worker-1',
     });
 
@@ -59,12 +59,12 @@ describe('reconcileProvisionedRunnersBodySchema', () => {
   });
 });
 
-describe('reconcileProvisionedRunnersResponseSchema', () => {
+describe('reconcileRunnerInstancesResponseSchema', () => {
   it('parses reconciled provisioned runner responses', () => {
-    const result = reconcileProvisionedRunnersResponseSchema.safeParse({
+    const result = reconcileRunnerInstancesResponseSchema.safeParse({
       runners: [
         {
-          provisioned_runner_id: 'provisioned-runner-1',
+          provider_runner_id: 'provisioned-runner-1',
           state: 'running',
           reservation_id: crypto.randomUUID(),
           runner_session_id: crypto.randomUUID(),
@@ -77,7 +77,7 @@ describe('reconcileProvisionedRunnersResponseSchema', () => {
           desired_intent: 'keep',
         },
       ],
-      terminated_absent_provisioned_runner_ids: ['provisioned-runner-2'],
+      terminated_absent_provider_runner_ids: ['provisioned-runner-2'],
     });
 
     expect(result.success).toBe(true);

package/src/schemas/reconcile-runner-instances.ts

@@ -0,0 +1,58 @@
+import {z} from 'zod';
+import {providerRunnerStateSchema} from './report-runner-instances.js';
+
+export const MAX_RECONCILE_OBSERVED_RUNNERS = 5000;
+export const MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH = 255;
+
+export const reconcileRunnerInstancesBodySchema = z
+  .object({
+    observed_provider_runner_ids: z
+      .array(z.string().min(1).max(MAX_OBSERVED_PROVIDER_RUNNER_ID_LENGTH))
+      .max(MAX_RECONCILE_OBSERVED_RUNNERS),
+  })
+  .strict()
+  .refine(
+    (body) =>
+      new Set(body.observed_provider_runner_ids).size === body.observed_provider_runner_ids.length,
+    {
+      message: 'observed_provider_runner_ids values must be unique',
+      path: ['observed_provider_runner_ids'],
+    },
+  );
+
+export const reconcileDesiredIntentSchema = z.enum(['keep', 'terminate']);
+
+export const reconciledBoundJobSchema = z
+  .object({
+    job_id: z.string().uuid(),
+    workflow_run_attempt_id: z.string().uuid(),
+    last_heartbeat_at: z.string().datetime(),
+    cancellation_requested_at: z.string().datetime().nullable(),
+  })
+  .strict();
+
+export const reconciledRunnerInstanceSchema = z
+  .object({
+    provider_runner_id: z.string(),
+    state: providerRunnerStateSchema.nullable(),
+    reservation_id: z.string().uuid().nullable(),
+    runner_session_id: z.string().uuid().nullable(),
+    bound_job: reconciledBoundJobSchema.nullable(),
+    desired_intent: reconcileDesiredIntentSchema,
+  })
+  .strict();
+
+export const reconcileRunnerInstancesResponseSchema = z
+  .object({
+    runners: z.array(reconciledRunnerInstanceSchema),
+    terminated_absent_provider_runner_ids: z.array(z.string()),
+  })
+  .strict();
+
+export type ReconcileRunnerInstancesBodyDto = z.infer<typeof reconcileRunnerInstancesBodySchema>;
+export type ReconcileDesiredIntentDto = z.infer<typeof reconcileDesiredIntentSchema>;
+export type ReconciledBoundJobDto = z.infer<typeof reconciledBoundJobSchema>;
+export type ReconciledRunnerInstanceDto = z.infer<typeof reconciledRunnerInstanceSchema>;
+export type ReconcileRunnerInstancesResponseDto = z.infer<
+  typeof reconcileRunnerInstancesResponseSchema
+>;

package/src/schemas/register.ts

@@ -20,7 +20,7 @@ export const registerRunnerBodySchema = z.object({
 export const registerRunnerResponseSchema = z.object({
   session_token: z.string().min(1),
   session_id: z.string().uuid(),
-  mode: z.enum(['manual', 'ephemeral']),
+  mode: z.enum(['manual', 'ephemeral', 'activation']),
   max_claims: z.number().int().positive().nullable(),
 });
 

package/src/schemas/{report-provisioned-runners.test.ts → report-runner-instances.test.ts}

@@ -1,13 +1,13 @@
 import {
-  MAX_PROVISIONED_RUNNER_REPORT_EVENTS,
-  provisionedRunnerReportEventSchema,
-  reportProvisionedRunnersBodySchema,
-} from './report-provisioned-runners.js';
+  MAX_PROVIDER_RUNNER_REPORT_EVENTS,
+  providerRunnerReportEventSchema,
+  reportRunnerInstancesBodySchema,
+} from './report-runner-instances.js';
 
-describe('provisionedRunnerReportEventSchema', () => {
+describe('providerRunnerReportEventSchema', () => {
   it('accepts minimal provider-agnostic lifecycle events', () => {
-    const result = provisionedRunnerReportEventSchema.safeParse({
-      provisioned_runner_id: 'container-1',
+    const result = providerRunnerReportEventSchema.safeParse({
+      provider_runner_id: 'container-1',
       labels: ['linux'],
       state: 'starting',
       reported_at: new Date().toISOString(),
@@ -17,8 +17,8 @@ describe('provisionedRunnerReportEventSchema', () => {
   });
 
   it('accepts cleanup-confirmed terminated lifecycle events', () => {
-    const result = provisionedRunnerReportEventSchema.safeParse({
-      provisioned_runner_id: 'container-1',
+    const result = providerRunnerReportEventSchema.safeParse({
+      provider_runner_id: 'container-1',
       labels: ['linux'],
       state: 'terminated',
       reported_at: new Date().toISOString(),
@@ -28,8 +28,8 @@ describe('provisionedRunnerReportEventSchema', () => {
   });
 
   it('rejects provider-sensitive extra fields', () => {
-    const result = provisionedRunnerReportEventSchema.safeParse({
-      provisioned_runner_id: 'container-1',
+    const result = providerRunnerReportEventSchema.safeParse({
+      provider_runner_id: 'container-1',
       labels: ['linux'],
       state: 'running',
       reported_at: new Date().toISOString(),
@@ -40,19 +40,19 @@ describe('provisionedRunnerReportEventSchema', () => {
   });
 });
 
-describe('reportProvisionedRunnersBodySchema', () => {
+describe('reportRunnerInstancesBodySchema', () => {
   it('enforces the batch size limit', () => {
     const event = {
-      provisioned_runner_id: 'container-1',
+      provider_runner_id: 'container-1',
       labels: ['linux'],
       state: 'running',
       reported_at: new Date().toISOString(),
     };
 
-    const result = reportProvisionedRunnersBodySchema.safeParse({
-      events: Array.from({length: MAX_PROVISIONED_RUNNER_REPORT_EVENTS + 1}, (_, index) => ({
+    const result = reportRunnerInstancesBodySchema.safeParse({
+      events: Array.from({length: MAX_PROVIDER_RUNNER_REPORT_EVENTS + 1}, (_, index) => ({
         ...event,
-        provisioned_runner_id: `container-${index}`,
+        provider_runner_id: `container-${index}`,
       })),
     });
 

package/src/schemas/report-runner-instances.ts

@@ -0,0 +1,91 @@
+import {MAX_RUNNER_LABELS} from '@shipfox/runner-labels';
+import {z} from 'zod';
+import {runnerLabelSchema} from './register.js';
+
+export const MAX_PROVIDER_RUNNER_REPORT_EVENTS = 1000;
+export const MAX_PROVIDER_RUNNER_REASON_LENGTH = 500;
+export const MAX_PROVIDER_KIND_LENGTH = 64;
+
+export const providerRunnerStateSchema = z.enum([
+  'starting',
+  'running',
+  'stopping',
+  'stopped',
+  'failed',
+  'terminated',
+]);
+
+export const providerKindSchema = z.string().min(1).max(MAX_PROVIDER_KIND_LENGTH);
+
+export const providerRunnerReportEventSchema = z
+  .object({
+    provider_runner_id: z.string().min(1).max(255),
+    reservation_id: z.string().uuid().optional(),
+    template_key: z.string().min(1).max(255).optional(),
+    labels: z.array(runnerLabelSchema).min(1).max(MAX_RUNNER_LABELS),
+    state: providerRunnerStateSchema,
+    reason: z.string().min(1).max(MAX_PROVIDER_RUNNER_REASON_LENGTH).optional(),
+    runner_session_id: z.string().uuid().optional(),
+    reported_at: z.string().datetime(),
+    provider_kind: providerKindSchema.optional(),
+  })
+  .strict();
+
+export const reportRunnerInstancesBodySchema = z.object({
+  events: z.array(providerRunnerReportEventSchema).min(1).max(MAX_PROVIDER_RUNNER_REPORT_EVENTS),
+});
+
+export const reportRunnerInstancesResponseSchema = z.object({
+  accepted: z.number().int().min(0),
+  reservations_released: z.number().int().min(0),
+});
+
+export const createPlannedCapacityBodySchema = z
+  .object({
+    provider_kind: providerKindSchema.optional(),
+    template_key: z.string().min(1).max(255).optional(),
+  })
+  .strict();
+
+export const createPlannedCapacityResponseSchema = z.object({
+  capacity_id: z.string().uuid(),
+});
+
+export const attachProviderRunnerBodySchema = z
+  .object({provider_runner_id: z.string().min(1).max(255)})
+  .strict();
+
+export const attachProviderRunnerResponseSchema = z.object({attached: z.boolean()});
+
+export const activeRunnerStateSchema = z.enum(['starting', 'running', 'stopping', 'busy']);
+
+export const activeRunnerDtoSchema = z.object({
+  runner_session_id: z.string().uuid().nullable(),
+  provider_runner_id: z.string().nullable(),
+  provisioner_id: z.string().uuid().nullable(),
+  state: activeRunnerStateSchema,
+  labels: z.array(z.string()),
+  template_key: z.string().nullable(),
+  provider_kind: z.string().nullable(),
+  job_id: z.string().uuid().nullable(),
+  workflow_run_attempt_id: z.string().uuid().nullable(),
+  project_id: z.string().uuid().nullable(),
+  reported_at: z.string().nullable(),
+  last_heartbeat_at: z.string().nullable(),
+});
+
+export const activeRunnersResponseSchema = z.object({
+  runners: z.array(activeRunnerDtoSchema),
+});
+
+export type RunnerInstanceStateDto = z.infer<typeof providerRunnerStateSchema>;
+export type RunnerInstanceReportEventDto = z.infer<typeof providerRunnerReportEventSchema>;
+export type ReportRunnerInstancesBodyDto = z.infer<typeof reportRunnerInstancesBodySchema>;
+export type ReportRunnerInstancesResponseDto = z.infer<typeof reportRunnerInstancesResponseSchema>;
+export type CreatePlannedCapacityBodyDto = z.infer<typeof createPlannedCapacityBodySchema>;
+export type CreatePlannedCapacityResponseDto = z.infer<typeof createPlannedCapacityResponseSchema>;
+export type AttachProviderRunnerBodyDto = z.infer<typeof attachProviderRunnerBodySchema>;
+export type AttachProviderRunnerResponseDto = z.infer<typeof attachProviderRunnerResponseSchema>;
+export type ActiveRunnerStateDto = z.infer<typeof activeRunnerStateSchema>;
+export type ActiveRunnerDto = z.infer<typeof activeRunnerDtoSchema>;
+export type ActiveRunnersResponseDto = z.infer<typeof activeRunnersResponseSchema>;

package/src/schemas/runner-enrollment.ts

@@ -0,0 +1,49 @@
+import {z} from 'zod';
+import {runnerLabelSchema} from './register.js';
+import {runnerToolCapabilitiesSchema} from './tool-capabilities.js';
+
+export const runnerBootstrapExchangeBodySchema = z
+  .object({bootstrap_token: z.string().min(1)})
+  .strict();
+export const createRunnerInstancesBodySchema = z
+  .object({
+    provider_kind: z.string().min(1).max(64).optional(),
+    runner_instances: z
+      .array(z.object({template_key: z.string().min(1).max(255).optional()}).strict())
+      .min(1)
+      .max(500),
+  })
+  .strict();
+export const createRunnerInstancesResponseSchema = z.object({
+  runner_instances: z.array(
+    z.object({runner_instance_id: z.string().uuid(), bootstrap_token: z.string().min(1)}),
+  ),
+});
+export const runnerBootstrapExchangeResponseSchema = z.object({
+  runner_instance_id: z.string().uuid(),
+  control_session_token: z.string().min(1),
+  expires_at: z.string().datetime(),
+});
+export const runnerEnrollmentBodySchema = z
+  .object({
+    labels: z.array(runnerLabelSchema).min(1).max(100),
+    capabilities: runnerToolCapabilitiesSchema.optional(),
+    provider_kind: z.string().min(1).max(64),
+    protocol_version: z.string().min(1).max(64),
+  })
+  .strict();
+export const attachRunnerControlProviderIdBodySchema = z
+  .object({provider_runner_id: z.string().min(1).max(255)})
+  .strict();
+export const runnerControlHeartbeatResponseSchema = z.object({ok: z.literal(true)});
+export const runnerAssignmentPollResponseSchema = z.object({
+  activation_token: z.string().min(1).nullable(),
+});
+
+export type RunnerBootstrapExchangeBodyDto = z.infer<typeof runnerBootstrapExchangeBodySchema>;
+export type CreateRunnerInstancesBodyDto = z.infer<typeof createRunnerInstancesBodySchema>;
+export type CreateRunnerInstancesResponseDto = z.infer<typeof createRunnerInstancesResponseSchema>;
+export type RunnerBootstrapExchangeResponseDto = z.infer<
+  typeof runnerBootstrapExchangeResponseSchema
+>;
+export type RunnerEnrollmentBodyDto = z.infer<typeof runnerEnrollmentBodySchema>;