@shipfox/client-runners 5.0.0 → 6.0.2

package/src/components/token-expiration-select.tsx

@@ -26,6 +26,12 @@ export const expirationOptions: Array<{value: TokenExpirationOption; label: stri
   {value: 'never', label: 'Never'},
 ];
 
+export function expirationCommand(expiration: TokenExpirationOption) {
+  return expiration === 'never'
+    ? ({kind: 'never'} as const)
+    : ({kind: 'expires-after', seconds: Number(expiration)} as const);
+}
+
 export function expirationHint(expiration: TokenExpirationOption): string {
   if (expiration === 'never') return 'Token will not expire.';
   const expiresAt = new Date(Date.now() + Number(expiration) * 1000);

package/src/components/token-settings-sections.stories.tsx

@@ -7,6 +7,11 @@ import type {Decorator, Meta, StoryObj} from '@storybook/react';
 import {QueryClient, QueryClientProvider} from '@tanstack/react-query';
 import type {ReactNode} from 'react';
 import {within} from 'storybook/test';
+import type {
+  CreatedProvisionerToken,
+  ManualRegistrationToken,
+  ProvisionerToken,
+} from '#core/token.js';
 import {CreatedManualRegistrationTokenPanel} from './create-manual-registration-token-form.js';
 import {CreatedProvisionerTokenPanel} from './create-provisioner-token-form.js';
 import {
@@ -115,20 +120,20 @@ export const Statuses: Story = {
       <ProvisionerTokenList
         workspaceId={WORKSPACE_ID}
         tokens={[
-          provisionerToken({
+          provisionerTokenModel({
             id: '33333333-3333-4333-8333-333333333333',
             name: 'Docker autoscaler',
-            last_seen_at: NOW,
+            lastSeenAt: NOW,
           }),
-          provisionerToken({
+          provisionerTokenModel({
             id: '44444444-4444-4444-8444-444444444444',
             name: 'Kubernetes spot pool',
-            last_seen_at: EIGHT_MINUTES_AGO,
+            lastSeenAt: EIGHT_MINUTES_AGO,
           }),
-          provisionerToken({
+          provisionerTokenModel({
             id: '55555555-5555-4555-8555-555555555555',
             name: 'Buildkite migration pool',
-            last_seen_at: null,
+            lastSeenAt: null,
           }),
         ]}
         activeIds={new Set(['33333333-3333-4333-8333-333333333333'])}
@@ -151,18 +156,18 @@ export const Content: Story = {
           <ManualRegistrationTokenList
             workspaceId={WORKSPACE_ID}
             tokens={[
-              manualToken({name: 'Deploy runner', prefix: 'sf_mrt_deploy'}),
-              manualToken({
+              manualRegistrationToken({name: 'Deploy runner', prefix: 'sf_mrt_deploy'}),
+              manualRegistrationToken({
                 id: '66666666-6666-4666-8666-666666666666',
                 name: 'macOS build host',
                 prefix: 'sf_mrt_macos',
-                expires_at: null,
+                expiresAt: null,
               }),
             ]}
           />
           <ProvisionerTokenList
             workspaceId={WORKSPACE_ID}
-            tokens={provisionerTokens()}
+            tokens={provisionerTokenModels()}
             activeIds={new Set(['33333333-3333-4333-8333-333333333333'])}
           />
         </div>
@@ -172,7 +177,7 @@ export const Content: Story = {
           <ManualRegistrationTokenList
             workspaceId={WORKSPACE_ID}
             tokens={[
-              manualToken({
+              manualRegistrationToken({
                 name: 'self-hosted-runner-for-production-release-candidate-validation-on-metal',
                 prefix: 'sf_mrt_release_candidate_validation',
               }),
@@ -181,10 +186,10 @@ export const Content: Story = {
           <ProvisionerTokenList
             workspaceId={WORKSPACE_ID}
             tokens={[
-              provisionerToken({
+              provisionerTokenModel({
                 name: 'docker-provisioner-for-west-coast-gpu-burst-capacity-and-fallback',
                 prefix: 'sf_pt_west_coast_gpu_burst',
-                last_seen_at: EIGHT_MINUTES_AGO,
+                lastSeenAt: EIGHT_MINUTES_AGO,
               }),
             ]}
             activeIds={new Set()}
@@ -202,22 +207,17 @@ export const CreatedTokenPanels: Story = {
         <CreatedManualRegistrationTokenPanel
           token={{
             id: '77777777-7777-4777-8777-777777777777',
-            raw_token: 'sf_mrt_4nJvNrs23ExampleManualTokenValue',
+            token: 'sf_mrt_4nJvNrs23ExampleManualTokenValue',
             prefix: 'sf_mrt_4nJv',
             name: 'Deploy runner',
-            workspace_id: WORKSPACE_ID,
-            expires_at: EXPIRES_AT,
-            created_at: CREATED_AT,
+            workspaceId: WORKSPACE_ID,
+            expiresAt: EXPIRES_AT,
+            createdAt: CREATED_AT,
           }}
         />
       </StateExample>
       <StateExample label="Provisioner token reveal">
-        <CreatedProvisionerTokenPanel
-          token={{
-            ...provisionerToken({name: 'Docker autoscaler'}),
-            raw_token: 'sf_pt_Rv8YwrExampleProvisionerTokenValue',
-          }}
-        />
+        <CreatedProvisionerTokenPanel token={createdProvisionerToken()} />
       </StateExample>
     </StorySurface>
   ),
@@ -308,6 +308,55 @@ function provisionerTokens(): ProvisionerTokenDto[] {
   ];
 }
 
+function manualRegistrationToken(
+  overrides: Partial<ManualRegistrationToken> = {},
+): ManualRegistrationToken {
+  return {
+    id: '22222222-2222-4222-8222-222222222222',
+    workspaceId: WORKSPACE_ID,
+    prefix: 'sf_mrt_deploy',
+    name: 'Deploy runner',
+    expiresAt: EXPIRES_AT,
+    revokedAt: null,
+    createdAt: CREATED_AT,
+    updatedAt: CREATED_AT,
+    ...overrides,
+  };
+}
+
+function provisionerTokenModel(overrides: Partial<ProvisionerToken> = {}): ProvisionerToken {
+  return {
+    ...manualRegistrationToken(),
+    createdByUserId: '99999999-9999-4999-8999-999999999999',
+    revokedByUserId: null,
+    lastSeenAt: NOW,
+    ...overrides,
+  };
+}
+
+function provisionerTokenModels(): ProvisionerToken[] {
+  return [
+    provisionerTokenModel({id: '33333333-3333-4333-8333-333333333333', name: 'Docker autoscaler'}),
+    provisionerTokenModel({
+      id: '44444444-4444-4444-8444-444444444444',
+      name: 'Kubernetes spot pool',
+      lastSeenAt: EIGHT_MINUTES_AGO,
+    }),
+    provisionerTokenModel({
+      id: '55555555-5555-4555-8555-555555555555',
+      name: 'Buildkite migration pool',
+      lastSeenAt: null,
+    }),
+  ];
+}
+
+function createdProvisionerToken(): CreatedProvisionerToken {
+  return {
+    ...provisionerTokenModel({name: 'Docker autoscaler'}),
+    token: 'sf_pt_Rv8YwrExampleProvisionerTokenValue',
+  };
+}
+
 function manualToken(
   overrides: Partial<ManualRegistrationTokenDto> = {},
 ): ManualRegistrationTokenDto {

package/src/core/token.test.ts

@@ -0,0 +1,30 @@
+import {
+  createTokenCommand,
+  provisionerConnectionStatus,
+  provisionerTokenDisplayName,
+} from './token.js';
+
+describe('token domain policies', () => {
+  test('omits a blank token name while keeping its expiration policy', () => {
+    const result = createTokenCommand('  ', {kind: 'expires-after', seconds: 86_400});
+
+    expect(result).toEqual({expiration: {kind: 'expires-after', seconds: 86_400}});
+  });
+
+  test('derives provisioner status from active and last-seen state', () => {
+    const token = {id: 'token-1', name: null, lastSeenAt: '2026-07-22T10:00:00.000Z'};
+
+    expect(provisionerConnectionStatus(token, new Set(['token-1']))).toEqual({
+      kind: 'connected',
+      dotVariant: 'success',
+      label: 'Connected',
+    });
+    expect(provisionerConnectionStatus(token, new Set())).toEqual({
+      kind: 'last-seen',
+      dotVariant: 'neutral',
+      label: 'Last seen',
+      lastSeenAt: token.lastSeenAt,
+    });
+    expect(provisionerTokenDisplayName(token)).toBe('Unnamed provisioner');
+  });
+});

package/src/core/token.ts

@@ -0,0 +1,83 @@
+export interface ManualRegistrationToken {
+  id: string;
+  workspaceId: string;
+  prefix: string;
+  name: string | null;
+  expiresAt: string | null;
+  revokedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ProvisionerToken extends ManualRegistrationToken {
+  createdByUserId: string;
+  revokedByUserId: string | null;
+  lastSeenAt: string | null;
+}
+
+export interface ActiveProvisioner {
+  id: string;
+  name: string | null;
+  prefix: string;
+  lastSeenAt: string;
+}
+
+export interface CreatedManualRegistrationToken {
+  token: string;
+  id: string;
+  prefix: string;
+  name: string | null;
+  workspaceId: string;
+  expiresAt: string | null;
+  createdAt: string;
+}
+
+export interface CreatedProvisionerToken extends CreatedManualRegistrationToken {
+  createdByUserId: string;
+  revokedByUserId: string | null;
+  revokedAt: string | null;
+  lastSeenAt: string | null;
+  updatedAt: string;
+}
+
+export type TokenExpiration = {kind: 'never'} | {kind: 'expires-after'; seconds: number};
+
+export interface CreateTokenCommand {
+  name?: string;
+  expiration: TokenExpiration;
+}
+
+export type ProvisionerConnectionStatus =
+  | {kind: 'connected'; dotVariant: 'success'; label: 'Connected'}
+  | {kind: 'last-seen'; dotVariant: 'neutral'; label: 'Last seen'; lastSeenAt: string}
+  | {kind: 'never-connected'; dotVariant: 'neutral'; label: 'Never connected'};
+
+export function createTokenCommand(name: string, expiration: TokenExpiration): CreateTokenCommand {
+  const trimmedName = name.trim();
+  return {expiration, ...(trimmedName ? {name: trimmedName} : {})};
+}
+
+export function tokenDisplayName(token: Pick<ManualRegistrationToken, 'name'>): string {
+  return token.name || 'Unnamed token';
+}
+
+export function provisionerTokenDisplayName(token: Pick<ProvisionerToken, 'name'>): string {
+  return token.name || 'Unnamed provisioner';
+}
+
+export function provisionerConnectionStatus(
+  token: Pick<ProvisionerToken, 'id' | 'lastSeenAt'>,
+  activeIds: ReadonlySet<string>,
+): ProvisionerConnectionStatus {
+  if (activeIds.has(token.id))
+    return {kind: 'connected', dotVariant: 'success', label: 'Connected'};
+  if (token.lastSeenAt) {
+    return {
+      kind: 'last-seen',
+      dotVariant: 'neutral',
+      label: 'Last seen',
+      lastSeenAt: token.lastSeenAt,
+    };
+  }
+  return {kind: 'never-connected', dotVariant: 'neutral', label: 'Never connected'};
+}

package/src/feature.ts

@@ -1,4 +1,21 @@
-import {defineClientFeature} from '@shipfox/client-shell';
+import {defineClientFeature, type SettingsSectionEntry} from '@shipfox/client-shell';
+
+export const runnersSettingsSections = [
+  {
+    id: 'settings.runners',
+    pathSegment: 'runners',
+    label: 'Runners',
+    icon: 'settings3Line',
+    order: 200,
+  },
+  {
+    id: 'settings.provisioners',
+    pathSegment: 'provisioners',
+    label: 'Runner provisioners',
+    icon: 'serverLine',
+    order: 300,
+  },
+] as const satisfies readonly SettingsSectionEntry[];
 
 export const runnersFeature = defineClientFeature({
   id: 'shipfox.runners',
@@ -14,20 +31,5 @@ export const runnersFeature = defineClientFeature({
       impl: '@shipfox/client-runners/routes/provisioners-settings',
     },
   ],
-  settingsSections: [
-    {
-      id: 'settings.runners',
-      pathSegment: 'runners',
-      label: 'Runners',
-      icon: 'settings3Line',
-      order: 200,
-    },
-    {
-      id: 'settings.provisioners',
-      pathSegment: 'provisioners',
-      label: 'Runner provisioners',
-      icon: 'serverLine',
-      order: 300,
-    },
-  ],
+  settingsSections: runnersSettingsSections,
 });

package/src/hooks/api/manual-registration-tokens.test.ts

@@ -35,20 +35,23 @@ describe('createManualRegistrationToken', () => {
       );
     });
     configureApiClient({fetchImpl});
-    const body = {name: 'Local runner', ttl_seconds: 86_400};
+    const command = {
+      name: 'Local runner',
+      expiration: {kind: 'expires-after' as const, seconds: 86_400},
+    };
 
     const result = await createManualRegistrationToken({
       workspaceId: '11111111-1111-4111-8111-111111111111',
-      body,
+      command,
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.raw_token).toBe('sf_mrt_raw-created-token');
+    expect(result.token).toBe('sf_mrt_raw-created-token');
     expect(request.url).toBe(
       'https://api.example.test/workspaces/11111111-1111-4111-8111-111111111111/runners/manual-registration-tokens',
     );
     expect(request.method).toBe('POST');
-    expect(requestBody).toEqual(body);
+    expect(requestBody).toEqual({name: 'Local runner', ttl_seconds: 86_400});
   });
 });
 
@@ -78,7 +81,7 @@ describe('revokeManualRegistrationToken', () => {
     });
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.revoked_at).toBe('2026-05-08T01:00:00.000Z');
+    expect(result.revokedAt).toBe('2026-05-08T01:00:00.000Z');
     expect(request.url).toBe(
       'https://api.example.test/workspaces/11111111-1111-4111-8111-111111111111/runners/manual-registration-tokens/33333333-3333-4333-8333-333333333333/revoke',
     );

package/src/hooks/api/manual-registration-tokens.ts

@@ -1,11 +1,26 @@
-import type {
-  CreateManualRegistrationTokenBodyDto,
-  CreateManualRegistrationTokenResponseDto,
-  ListManualRegistrationTokensResponseDto,
-  RevokeManualRegistrationTokenResponseDto,
+import {
+  createManualRegistrationTokenResponseSchema,
+  listManualRegistrationTokensResponseSchema,
+  revokeManualRegistrationTokenResponseSchema,
 } from '@shipfox/api-runners-dto';
-import {apiRequest} from '@shipfox/client-api';
-import {useMutation, useQuery} from '@tanstack/react-query';
+import {checkedApiRequest} from '@shipfox/client-api';
+import {
+  type FetchQueryOptions,
+  queryOptions,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+import type {
+  CreatedManualRegistrationToken,
+  CreateTokenCommand,
+  ManualRegistrationToken,
+} from '#core/token.js';
+import {
+  toCreatedManualRegistrationToken,
+  toCreateTokenBody,
+  toManualRegistrationToken,
+} from './token-mapper.js';
 
 export const manualRegistrationTokenQueryKeys = {
   all: ['manual-registration-tokens'] as const,
@@ -13,30 +28,41 @@ export const manualRegistrationTokenQueryKeys = {
     [...manualRegistrationTokenQueryKeys.all, 'list', workspaceId] as const,
 };
 
+type ManualRegistrationTokensQueryOptions = FetchQueryOptions<
+  ManualRegistrationToken[],
+  Error,
+  ManualRegistrationToken[],
+  ReturnType<typeof manualRegistrationTokenQueryKeys.list>
+>;
+
 export async function listManualRegistrationTokens({
   workspaceId,
   signal,
 }: {
   workspaceId: string;
   signal?: AbortSignal;
-}) {
-  return await apiRequest<ListManualRegistrationTokensResponseDto>(
+}): Promise<ManualRegistrationToken[]> {
+  const response = await checkedApiRequest(
+    listManualRegistrationTokensResponseSchema,
     `/workspaces/${workspaceId}/runners/manual-registration-tokens`,
     {signal},
   );
+  return response.manual_registration_tokens.map(toManualRegistrationToken);
 }
 
 export async function createManualRegistrationToken({
   workspaceId,
-  body,
+  command,
 }: {
   workspaceId: string;
-  body: CreateManualRegistrationTokenBodyDto;
-}) {
-  return await apiRequest<CreateManualRegistrationTokenResponseDto>(
+  command: CreateTokenCommand;
+}): Promise<CreatedManualRegistrationToken> {
+  const response = await checkedApiRequest(
+    createManualRegistrationTokenResponseSchema,
     `/workspaces/${workspaceId}/runners/manual-registration-tokens`,
-    {method: 'POST', body},
+    {method: 'POST', body: toCreateTokenBody(command)},
   );
+  return toCreatedManualRegistrationToken(response);
 }
 
 export async function revokeManualRegistrationToken({
@@ -45,27 +71,48 @@ export async function revokeManualRegistrationToken({
 }: {
   workspaceId: string;
   tokenId: string;
-}) {
-  return await apiRequest<RevokeManualRegistrationTokenResponseDto>(
+}): Promise<ManualRegistrationToken> {
+  const response = await checkedApiRequest(
+    revokeManualRegistrationTokenResponseSchema,
     `/workspaces/${workspaceId}/runners/manual-registration-tokens/${tokenId}/revoke`,
     {method: 'POST'},
   );
+  return toManualRegistrationToken(response);
+}
+
+export function manualRegistrationTokensQueryOptions(
+  workspaceId: string,
+): ManualRegistrationTokensQueryOptions {
+  return queryOptions({
+    queryKey: manualRegistrationTokenQueryKeys.list(workspaceId),
+    queryFn: ({signal}) => listManualRegistrationTokens({workspaceId, signal}),
+  });
 }
 
 export function useManualRegistrationTokensQuery(workspaceId: string | undefined) {
   return useQuery({
-    queryKey: workspaceId
-      ? manualRegistrationTokenQueryKeys.list(workspaceId)
-      : [...manualRegistrationTokenQueryKeys.all, 'list'],
+    ...manualRegistrationTokensQueryOptions(workspaceId ?? ''),
     enabled: Boolean(workspaceId),
-    queryFn: ({signal}) => listManualRegistrationTokens({workspaceId: workspaceId ?? '', signal}),
   });
 }
 
-export function useCreateManualRegistrationTokenMutation() {
-  return useMutation({mutationFn: createManualRegistrationToken});
+export function useCreateManualRegistrationTokenMutation(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (command: CreateTokenCommand) =>
+      createManualRegistrationToken({workspaceId, command}),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(manualRegistrationTokensQueryOptions(workspaceId));
+    },
+  });
 }
 
-export function useRevokeManualRegistrationTokenMutation() {
-  return useMutation({mutationFn: revokeManualRegistrationToken});
+export function useRevokeManualRegistrationTokenMutation(workspaceId: string) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (tokenId: string) => revokeManualRegistrationToken({workspaceId, tokenId}),
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(manualRegistrationTokensQueryOptions(workspaceId));
+    },
+  });
 }

package/src/hooks/api/provisioner-tokens.test.ts

@@ -29,7 +29,7 @@ describe('provisioner token transports', () => {
     const result = await listProvisionerTokens({workspaceId});
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.tokens).toEqual([]);
+    expect(result).toEqual([]);
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${workspaceId}/provisioners/tokens`,
     );
@@ -60,17 +60,20 @@ describe('provisioner token transports', () => {
       );
     });
     configureApiClient({fetchImpl});
-    const body = {name: 'Docker provisioner', ttl_seconds: 86_400};
+    const command = {
+      name: 'Docker provisioner',
+      expiration: {kind: 'expires-after' as const, seconds: 86_400},
+    };
 
-    const result = await createProvisionerToken({workspaceId, body});
+    const result = await createProvisionerToken({workspaceId, command});
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.raw_token).toBe('sf_pt_raw-created-token');
+    expect(result.token).toBe('sf_pt_raw-created-token');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${workspaceId}/provisioners/tokens`,
     );
     expect(request.method).toBe('POST');
-    expect(requestBody).toEqual(body);
+    expect(requestBody).toEqual({name: 'Docker provisioner', ttl_seconds: 86_400});
   });
 
   test('posts to the token revoke endpoint', async () => {
@@ -95,7 +98,7 @@ describe('provisioner token transports', () => {
     const result = await revokeProvisionerToken({workspaceId, tokenId});
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.revoked_at).toBe('2026-05-08T01:00:00.000Z');
+    expect(result.revokedAt).toBe('2026-05-08T01:00:00.000Z');
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${workspaceId}/provisioners/tokens/${tokenId}/revoke`,
     );
@@ -120,7 +123,7 @@ describe('provisioner token transports', () => {
     const result = await listActiveProvisioners({workspaceId});
 
     const request = fetchImpl.mock.calls[0]?.[0] as Request;
-    expect(result.provisioners).toHaveLength(1);
+    expect(result).toHaveLength(1);
     expect(request.url).toBe(
       `https://api.example.test/workspaces/${workspaceId}/provisioners/active`,
     );