@shipfox/api-runners 2.0.0

package/src/presentation/dto/provisioner-token.ts

@@ -0,0 +1,29 @@
+import type {ProvisionerToken} from '#core/entities/provisioner-token.js';
+
+export function toProvisionerTokenDto(token: ProvisionerToken): {
+  id: string;
+  workspace_id: string;
+  prefix: string;
+  name: string | null;
+  created_by_user_id: string;
+  revoked_by_user_id: string | null;
+  expires_at: string | null;
+  revoked_at: string | null;
+  last_seen_at: string | null;
+  created_at: string;
+  updated_at: string;
+} {
+  return {
+    id: token.id,
+    workspace_id: token.workspaceId,
+    prefix: token.prefix,
+    name: token.name,
+    created_by_user_id: token.createdByUserId,
+    revoked_by_user_id: token.revokedByUserId,
+    expires_at: token.expiresAt?.toISOString() ?? null,
+    revoked_at: token.revokedAt?.toISOString() ?? null,
+    last_seen_at: token.lastSeenAt?.toISOString() ?? null,
+    created_at: token.createdAt.toISOString(),
+    updated_at: token.updatedAt.toISOString(),
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,6 @@
+export {
+  createProvisionerTokenAuthMethod,
+  createRunnerRegistrationTokenAuthMethod,
+} from './auth/index.js';
+export {runnerRoutes as routes} from './routes/index.js';
+export {onWorkflowsJobExecutionTimedOut} from './subscribers/on-workflows-job-execution-timed-out.js';

package/src/presentation/routes/create-manual-registration-token.ts

@@ -0,0 +1,43 @@
+import {
+  createManualRegistrationTokenBodySchema,
+  createManualRegistrationTokenResponseSchema,
+} from '@shipfox/api-runners-dto';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {createWorkspaceManualRegistrationToken} from '#core/index.js';
+import {requireManualRegistrationTokenWorkspaceMembership} from './workspace-membership.js';
+
+export const createManualRegistrationTokenRoute = defineRoute({
+  method: 'POST',
+  path: '/',
+  description: 'Create a token that lets a runner connect to your account',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    body: createManualRegistrationTokenBodySchema,
+    response: {
+      201: createManualRegistrationTokenResponseSchema,
+    },
+  },
+  handler: async (request, reply) => {
+    const {workspaceId} = request.params;
+    requireManualRegistrationTokenWorkspaceMembership({request, workspaceId});
+    const {name, ttl_seconds} = request.body;
+
+    const {token, rawToken} = await createWorkspaceManualRegistrationToken({
+      workspaceId,
+      name,
+      ttlSeconds: ttl_seconds,
+    });
+
+    reply.code(201);
+    return {
+      id: token.id,
+      raw_token: rawToken,
+      prefix: token.prefix,
+      name: token.name,
+      workspace_id: token.workspaceId,
+      expires_at: token.expiresAt?.toISOString() ?? null,
+      created_at: token.createdAt.toISOString(),
+    };
+  },
+});

package/src/presentation/routes/create-provisioner-token.ts

@@ -0,0 +1,41 @@
+import {requireUserContext, requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {
+  createProvisionerTokenBodySchema,
+  createProvisionerTokenResponseSchema,
+} from '@shipfox/api-runners-dto';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {createWorkspaceProvisionerToken} from '#core/index.js';
+import {toProvisionerTokenDto} from '#presentation/dto/index.js';
+
+export const createProvisionerTokenRoute = defineRoute({
+  method: 'POST',
+  path: '/',
+  description: 'Create a token that lets a provisioner connect to your account',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    body: createProvisionerTokenBodySchema,
+    response: {
+      201: createProvisionerTokenResponseSchema,
+    },
+  },
+  handler: async (request, reply) => {
+    const {workspaceId} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+    const user = requireUserContext(request);
+    const {name, ttl_seconds} = request.body;
+
+    const {token, rawToken} = await createWorkspaceProvisionerToken({
+      workspaceId,
+      createdByUserId: user.userId,
+      name,
+      ttlSeconds: ttl_seconds,
+    });
+
+    reply.code(201);
+    return {
+      ...toProvisionerTokenDto(token),
+      raw_token: rawToken,
+    };
+  },
+});

package/src/presentation/routes/get-provisioner-me.ts

@@ -0,0 +1,22 @@
+import {requireProvisionerContext} from '@shipfox/api-auth-context';
+import {provisionerIdentityResponseSchema} from '@shipfox/api-runners-dto';
+import {defineRoute} from '@shipfox/node-fastify';
+
+export const getProvisionerMeRoute = defineRoute({
+  method: 'GET',
+  path: '/me',
+  description: 'Return the authenticated provisioner token identity',
+  schema: {
+    response: {
+      200: provisionerIdentityResponseSchema,
+    },
+  },
+  handler: (request) => {
+    const context = requireProvisionerContext(request);
+
+    return {
+      id: context.provisionerTokenId,
+      workspace_id: context.workspaceId,
+    };
+  },
+});

package/src/presentation/routes/heartbeat.test.ts

@@ -0,0 +1,325 @@
+import {
+  createLeaseTokenAuthMethod,
+  createRunnerSessionAuthMethod,
+  issueJobLeaseToken,
+  jobLeaseParamsFrom,
+  verifyJobLeaseToken,
+} from '@shipfox/api-auth';
+import {AUTH_PROVISIONER_TOKEN, AUTH_USER} from '@shipfox/api-auth-context';
+import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';
+import type {AuthMethod} from '@shipfox/node-fastify';
+import {closeApp, createApp} from '@shipfox/node-fastify';
+import {eq} from 'drizzle-orm';
+import type {FastifyInstance} from 'fastify';
+import {claimJobExecution} from '#core/job-executions.js';
+import {db} from '#db/db.js';
+import {requestJobExecutionCancellation} from '#db/job-executions.js';
+import {runnerSessions} from '#db/schema/runner-sessions.js';
+import {runningJobExecutions} from '#db/schema/running-job-executions.js';
+import {createRunnerRegistrationTokenAuthMethod} from '#presentation/auth/index.js';
+import {pendingJobFactory, runnerSessionFactory} from '#test/index.js';
+import {runnerRoutes} from './index.js';
+
+const fakeUserAuth: AuthMethod = {
+  name: AUTH_USER,
+  authenticate: () => Promise.resolve(),
+};
+
+const fakeProvisionerAuth: AuthMethod = {
+  name: AUTH_PROVISIONER_TOKEN,
+  authenticate: () => Promise.resolve(),
+};
+
+const fullCapabilities: RunnerToolCapabilitiesDto = {
+  harnesses: {
+    pi: {tools: ['read', 'bash', 'web_search']},
+    claude: {tools: ['Read', 'Bash', 'WebSearch']},
+  },
+};
+
+const partialCapabilities: RunnerToolCapabilitiesDto = {
+  harnesses: {
+    pi: {tools: ['read']},
+  },
+};
+
+describe('POST /runners/jobs/:jobId/heartbeat', () => {
+  let app: FastifyInstance;
+  let workspaceId: string;
+  let runnerSessionId: string;
+
+  beforeAll(async () => {
+    app = await createApp({
+      auth: [
+        fakeUserAuth,
+        createRunnerRegistrationTokenAuthMethod(),
+        createRunnerSessionAuthMethod(),
+        createLeaseTokenAuthMethod(),
+        fakeProvisionerAuth,
+      ],
+      routes: runnerRoutes,
+      swagger: false,
+    });
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await closeApp();
+  });
+
+  beforeEach(async () => {
+    workspaceId = crypto.randomUUID();
+    const session = await runnerSessionFactory.create({workspaceId});
+    runnerSessionId = session.id;
+  });
+
+  async function claimAvailableJob(): Promise<{
+    jobId: string;
+    jobExecutionId: string;
+    workflowRunId: string;
+    workflowRunAttemptId: string;
+    leaseToken: string;
+  }> {
+    const pending = await pendingJobFactory.create({workspaceId});
+    const claimed = await claimJobExecution({
+      workspaceId,
+      runnerSessionId,
+      sessionLabels: ['linux', 'x64'],
+      maxClaims: null,
+    });
+    expect(claimed).not.toBeNull();
+    return {
+      jobId: pending.jobId,
+      jobExecutionId: claimed?.jobExecutionId as string,
+      workflowRunId: pending.workflowRunId,
+      workflowRunAttemptId: pending.workflowRunAttemptId,
+      leaseToken: claimed?.leaseToken as string,
+    };
+  }
+
+  it('returns 401 without authorization', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${crypto.randomUUID()}/heartbeat`,
+    });
+
+    expect(res.statusCode).toBe(401);
+  });
+
+  it('returns 200 + cancel:false on a fresh row', async () => {
+    const {jobId, jobExecutionId, workflowRunId, workflowRunAttemptId, leaseToken} =
+      await claimAvailableJob();
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json<{cancel: boolean; lease_token: string}>();
+    expect(body).toEqual({cancel: false, lease_token: expect.any(String)});
+    const refreshedLease = await verifyJobLeaseToken(body.lease_token);
+    expect(refreshedLease).toMatchObject({
+      jobId,
+      jobExecutionId,
+      workflowRunId,
+      workflowRunAttemptId,
+      runnerSessionId,
+    });
+    expect(refreshedLease?.currentStepId).toBeUndefined();
+    expect(refreshedLease?.currentStepAttempt).toBeUndefined();
+    const [running] = await db()
+      .select()
+      .from(runningJobExecutions)
+      .where(eq(runningJobExecutions.jobExecutionId, jobExecutionId));
+    expect(running?.firstHeartbeatAt).toBeInstanceOf(Date);
+  });
+
+  it('refreshes job heartbeat and runner capability report', async () => {
+    const {jobId, jobExecutionId, leaseToken} = await claimAvailableJob();
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+      payload: {capabilities: fullCapabilities},
+    });
+
+    expect(res.statusCode).toBe(200);
+    const [running] = await db()
+      .select()
+      .from(runningJobExecutions)
+      .where(eq(runningJobExecutions.jobExecutionId, jobExecutionId));
+    const [session] = await db()
+      .select()
+      .from(runnerSessions)
+      .where(eq(runnerSessions.id, runnerSessionId));
+    expect(running?.firstHeartbeatAt).toBeInstanceOf(Date);
+    expect(session?.toolCapabilities).toEqual(fullCapabilities);
+    expect(session?.toolCapabilitiesReportedAt).toBeInstanceOf(Date);
+  });
+
+  it('clears the stored capability report when heartbeat omits capabilities', async () => {
+    const {jobId, leaseToken} = await claimAvailableJob();
+    await db()
+      .update(runnerSessions)
+      .set({
+        toolCapabilities: partialCapabilities,
+        toolCapabilitiesReportedAt: new Date('2026-01-01T00:00:00.000Z'),
+      })
+      .where(eq(runnerSessions.id, runnerSessionId));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    const [session] = await db()
+      .select()
+      .from(runnerSessions)
+      .where(eq(runnerSessions.id, runnerSessionId));
+    expect(session?.toolCapabilities).toBeNull();
+    expect(session?.toolCapabilitiesReportedAt).toBeNull();
+  });
+
+  it('rejects malformed capability reports without liveness or capability side effects', async () => {
+    const {jobId, jobExecutionId, leaseToken} = await claimAvailableJob();
+    await db()
+      .update(runnerSessions)
+      .set({
+        toolCapabilities: partialCapabilities,
+        toolCapabilitiesReportedAt: new Date('2026-01-01T00:00:00.000Z'),
+      })
+      .where(eq(runnerSessions.id, runnerSessionId));
+    const [beforeRunning] = await db()
+      .select()
+      .from(runningJobExecutions)
+      .where(eq(runningJobExecutions.jobExecutionId, jobExecutionId));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+      payload: {capabilities: {harnesses: {pi: {tools: ['read', 'read']}}}},
+    });
+
+    expect(res.statusCode).toBe(400);
+    const [afterRunning] = await db()
+      .select()
+      .from(runningJobExecutions)
+      .where(eq(runningJobExecutions.jobExecutionId, jobExecutionId));
+    const [session] = await db()
+      .select()
+      .from(runnerSessions)
+      .where(eq(runnerSessions.id, runnerSessionId));
+    expect(afterRunning?.firstHeartbeatAt).toEqual(beforeRunning?.firstHeartbeatAt);
+    expect(afterRunning?.lastHeartbeatAt).toEqual(beforeRunning?.lastHeartbeatAt);
+    expect(session?.toolCapabilities).toEqual(partialCapabilities);
+    expect(session?.toolCapabilitiesReportedAt).toEqual(new Date('2026-01-01T00:00:00.000Z'));
+  });
+
+  it('returns 200 + cancel:true after requestJobExecutionCancellation', async () => {
+    const {jobId, jobExecutionId, workflowRunId, workflowRunAttemptId, leaseToken} =
+      await claimAvailableJob();
+    await requestJobExecutionCancellation({jobExecutionId});
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json<{cancel: boolean; lease_token: string}>();
+    expect(body).toEqual({cancel: true, lease_token: expect.any(String)});
+    const refreshedLease = await verifyJobLeaseToken(body.lease_token);
+    expect(refreshedLease).toMatchObject({
+      jobId,
+      jobExecutionId,
+      workflowRunId,
+      workflowRunAttemptId,
+      runnerSessionId,
+    });
+  });
+
+  it('preserves current step scope when renewing a step-scoped lease', async () => {
+    const {jobId, leaseToken} = await claimAvailableJob();
+    const lease = await verifyJobLeaseToken(leaseToken);
+    if (!lease) throw new Error('Expected valid lease token');
+    const stepScope = {currentStepId: crypto.randomUUID(), currentStepAttempt: 3};
+    const stepScopedLeaseToken = await issueJobLeaseToken(jobLeaseParamsFrom(lease, stepScope));
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${stepScopedLeaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(200);
+    const body = res.json<{cancel: boolean; lease_token: string}>();
+    const refreshedLease = await verifyJobLeaseToken(body.lease_token);
+    expect(refreshedLease).toMatchObject(stepScope);
+  });
+
+  it('returns 404 when the jobId is unknown', async () => {
+    const jobId = crypto.randomUUID();
+    const jobExecutionId = crypto.randomUUID();
+    const leaseToken = await issueJobLeaseToken({
+      jobId,
+      jobExecutionId,
+      workflowRunId: crypto.randomUUID(),
+      workflowRunAttemptId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workspaceId,
+      runnerSessionId,
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('running-job-execution-not-found');
+  });
+
+  it('returns 404 when the job belongs to a different session', async () => {
+    const {jobId, jobExecutionId} = await claimAvailableJob();
+    const otherSession = await runnerSessionFactory.create({workspaceId});
+    const leaseToken = await issueJobLeaseToken({
+      jobId,
+      jobExecutionId,
+      workflowRunId: crypto.randomUUID(),
+      workflowRunAttemptId: crypto.randomUUID(),
+      projectId: crypto.randomUUID(),
+      workspaceId,
+      runnerSessionId: otherSession.id,
+    });
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${jobId}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('running-job-execution-not-found');
+  });
+
+  it('returns 404 when the path job id does not match the lease token job id', async () => {
+    const {leaseToken} = await claimAvailableJob();
+
+    const res = await app.inject({
+      method: 'POST',
+      url: `/runners/jobs/${crypto.randomUUID()}/heartbeat`,
+      headers: {authorization: `Bearer ${leaseToken}`},
+    });
+
+    expect(res.statusCode).toBe(404);
+    expect(res.json().code).toBe('lease-job-mismatch');
+  });
+});

package/src/presentation/routes/heartbeat.ts

@@ -0,0 +1,80 @@
+import {issueJobLeaseToken, jobLeaseParamsFrom} from '@shipfox/api-auth';
+import {requireLeasedJobContext} from '@shipfox/api-auth-context';
+import {heartbeatBodySchema, heartbeatResponseSchema} from '@shipfox/api-runners-dto';
+import {ClientError, defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {RunningJobExecutionNotFoundError} from '#core/errors.js';
+import {recordHeartbeat} from '#db/job-executions.js';
+
+export const heartbeatRoute = defineRoute({
+  method: 'POST',
+  path: '/:jobId/heartbeat',
+  description:
+    'Keeps a running job execution alive while the runner is still working on it. Returns whether the server has asked the runner to cancel.',
+  schema: {
+    params: z.object({jobId: z.string().uuid()}),
+    body: heartbeatBodySchema.nullish(),
+    response: {
+      200: heartbeatResponseSchema,
+    },
+  },
+  errorHandler: (error) => {
+    if (error instanceof RunningJobExecutionNotFoundError) {
+      throw new ClientError(error.message, 'running-job-execution-not-found', {status: 404});
+    }
+    throw error;
+  },
+  handler: async (request) => {
+    const {jobId} = request.params;
+    const lease = requireLeasedJobContext(request);
+    if (lease.jobId !== jobId) {
+      throw new ClientError('Lease token does not match job', 'lease-job-mismatch', {
+        status: 404,
+      });
+    }
+
+    const heartbeatResult = await recordHeartbeat({
+      jobExecutionId: lease.jobExecutionId,
+      runnerSessionId: lease.runnerSessionId,
+      toolCapabilities: request.body?.capabilities ?? null,
+    });
+
+    if (
+      heartbeatResult.previousToolCapabilities &&
+      !sameToolCapabilities(
+        heartbeatResult.previousToolCapabilities,
+        heartbeatResult.currentToolCapabilities,
+      )
+    ) {
+      request.log.info(
+        {
+          runnerSessionId: lease.runnerSessionId,
+          jobExecutionId: lease.jobExecutionId,
+          previousHarnesses: Object.keys(heartbeatResult.previousToolCapabilities.harnesses),
+          currentHarnesses: heartbeatResult.currentToolCapabilities
+            ? Object.keys(heartbeatResult.currentToolCapabilities.harnesses)
+            : [],
+        },
+        'Runner heartbeat changed advertised tool capabilities',
+      );
+    }
+
+    const leaseToken = await issueJobLeaseToken(
+      jobLeaseParamsFrom(
+        heartbeatResult.runningJobExecution,
+        lease.currentStepId && lease.currentStepAttempt !== undefined
+          ? {
+              currentStepId: lease.currentStepId,
+              currentStepAttempt: lease.currentStepAttempt,
+            }
+          : undefined,
+      ),
+    );
+
+    return {cancel: heartbeatResult.cancellationRequested, lease_token: leaseToken};
+  },
+});
+
+function sameToolCapabilities(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}

package/src/presentation/routes/index.ts

@@ -0,0 +1,86 @@
+import {
+  AUTH_LEASED_JOB,
+  AUTH_PROVISIONER_TOKEN,
+  AUTH_RUNNER_REGISTRATION_TOKEN,
+  AUTH_RUNNER_SESSION,
+  AUTH_USER,
+} from '@shipfox/api-auth-context';
+import type {RouteGroup} from '@shipfox/node-fastify';
+import {createManualRegistrationTokenRoute} from './create-manual-registration-token.js';
+import {createProvisionerTokenRoute} from './create-provisioner-token.js';
+import {getProvisionerMeRoute} from './get-provisioner-me.js';
+import {heartbeatRoute} from './heartbeat.js';
+import {listActiveProvisionersRoute} from './list-active-provisioners.js';
+import {listActiveRunnersRoute} from './list-active-runners.js';
+import {listManualRegistrationTokensRoute} from './list-manual-registration-tokens.js';
+import {listProvisionerTokensRoute} from './list-provisioner-tokens.js';
+import {mintRegistrationTokensRoute} from './mint-registration-tokens.js';
+import {pollDemandRoute} from './poll-demand.js';
+import {reconcileProvisionedRunnersRoute} from './reconcile-provisioned-runners.js';
+import {registerRoute} from './register.js';
+import {reportProvisionedRunnersRoute} from './report-provisioned-runners.js';
+import {requestJobRoute} from './request-job.js';
+import {revokeManualRegistrationTokenRoute} from './revoke-manual-registration-token.js';
+import {revokeProvisionerTokenRoute} from './revoke-provisioner-token.js';
+
+const runnerOnlyRoutes: RouteGroup[] = [
+  {
+    prefix: '/workspaces/:workspaceId/runners/manual-registration-tokens',
+    auth: AUTH_USER,
+    routes: [
+      listManualRegistrationTokensRoute,
+      createManualRegistrationTokenRoute,
+      revokeManualRegistrationTokenRoute,
+    ],
+  },
+  {
+    prefix: '/workspaces/:workspaceId/runners/active',
+    auth: AUTH_USER,
+    routes: [listActiveRunnersRoute],
+  },
+  {
+    prefix: '/runners',
+    auth: AUTH_RUNNER_REGISTRATION_TOKEN,
+    routes: [registerRoute],
+  },
+  {
+    prefix: '/runners/jobs',
+    auth: AUTH_RUNNER_SESSION,
+    routes: [requestJobRoute],
+  },
+  {
+    prefix: '/runners/jobs',
+    auth: AUTH_LEASED_JOB,
+    routes: [heartbeatRoute],
+  },
+  {
+    prefix: '/provisioners',
+    auth: AUTH_PROVISIONER_TOKEN,
+    routes: [
+      pollDemandRoute,
+      mintRegistrationTokensRoute,
+      reportProvisionedRunnersRoute,
+      reconcileProvisionedRunnersRoute,
+    ],
+  },
+];
+
+export const provisionerRoutes: RouteGroup[] = [
+  {
+    prefix: '/workspaces/:workspaceId/provisioners/tokens',
+    auth: AUTH_USER,
+    routes: [listProvisionerTokensRoute, createProvisionerTokenRoute, revokeProvisionerTokenRoute],
+  },
+  {
+    prefix: '/workspaces/:workspaceId/provisioners/active',
+    auth: AUTH_USER,
+    routes: [listActiveProvisionersRoute],
+  },
+  {
+    prefix: '/provisioners',
+    auth: AUTH_PROVISIONER_TOKEN,
+    routes: [getProvisionerMeRoute],
+  },
+];
+
+export const runnerRoutes: RouteGroup[] = [...runnerOnlyRoutes, ...provisionerRoutes];

package/src/presentation/routes/list-active-provisioners.ts

@@ -0,0 +1,25 @@
+import {requireWorkspaceAccess} from '@shipfox/api-auth-context';
+import {listActiveProvisionersResponseSchema} from '@shipfox/api-runners-dto';
+import {defineRoute} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {listActiveProvisioners} from '#core/index.js';
+import {toActiveProvisionerDto} from '#presentation/dto/index.js';
+
+export const listActiveProvisionersRoute = defineRoute({
+  method: 'GET',
+  path: '/',
+  description: 'List active provisioners for a workspace',
+  schema: {
+    params: z.object({workspaceId: z.string().uuid()}),
+    response: {
+      200: listActiveProvisionersResponseSchema,
+    },
+  },
+  handler: async (request) => {
+    const {workspaceId} = request.params;
+    requireWorkspaceAccess({request, workspaceId});
+
+    const provisioners = await listActiveProvisioners(workspaceId);
+    return {provisioners: provisioners.map(toActiveProvisionerDto)};
+  },
+});