@shipfox/client-projects 0.2.0

package/src/pages/create-project-page.tsx

@@ -0,0 +1,386 @@
+import type {IntegrationConnectionDto} from '@shipfox/api-integration-core-dto';
+import {
+  createProjectBodySchema,
+  type ListProjectsResponseDto,
+  type ProjectResponseDto,
+} from '@shipfox/api-projects-dto';
+import {useMaybeActiveWorkspace} from '@shipfox/client-auth';
+import {
+  ConnectionPicker,
+  IntegrationIcon,
+  RepositoryPicker,
+  useRepositoriesInfiniteQuery,
+  useSourceConnectionsQuery,
+} from '@shipfox/client-integrations';
+import {displayNameFieldError} from '@shipfox/client-ui';
+import {Button} from '@shipfox/react-ui/button';
+import {Callout} from '@shipfox/react-ui/callout';
+import {FormField, FormFieldInput, fieldError} from '@shipfox/react-ui/form-field';
+import {FullPageLoader} from '@shipfox/react-ui/loader';
+import {toast} from '@shipfox/react-ui/toast';
+import {Header, Text} from '@shipfox/react-ui/typography';
+import {useForm} from '@tanstack/react-form';
+import {type QueryClient, useQueryClient} from '@tanstack/react-query';
+import {Link, Navigate, useNavigate} from '@tanstack/react-router';
+import {useEffect, useRef, useState} from 'react';
+import {ModelProviderReminderBanner} from '#components/model-provider-reminder-banner.js';
+import {projectsQueryKeys, useCreateProjectMutation} from '#hooks/api/projects.js';
+import {projectErrorCopy} from '#project-error.js';
+
+const REPOSITORY_NAME_SPLIT_RE = /[/-]/;
+
+export function CreateProjectPage() {
+  const workspace = useMaybeActiveWorkspace();
+  const queryClient = useQueryClient();
+  const navigate = useNavigate();
+  const createProject = useCreateProjectMutation();
+  const errorRef = useRef<HTMLDivElement>(null);
+
+  const connectionsQuery = useSourceConnectionsQuery(workspace?.id);
+  const connections = connectionsQuery.data?.connections ?? [];
+
+  const [selectedConnectionId, setSelectedConnectionId] = useState<string | undefined>();
+  const singleConnectionId = connections.length === 1 ? connections[0]?.id : undefined;
+  const effectiveSelectedConnectionId = selectedConnectionId ?? singleConnectionId;
+  useEffect(() => {
+    if (singleConnectionId && selectedConnectionId !== singleConnectionId) {
+      setSelectedConnectionId(singleConnectionId);
+    }
+  }, [singleConnectionId, selectedConnectionId]);
+
+  const selectedConnection: IntegrationConnectionDto | undefined = connections.find(
+    (connection) => connection.id === effectiveSelectedConnectionId,
+  );
+
+  const [repoFilter, setRepoFilter] = useState('');
+  const debouncedRepoFilter = useDebouncedValue(repoFilter, 250);
+  const trimmedFilter = debouncedRepoFilter.trim();
+
+  const repositoriesQuery = useRepositoriesInfiniteQuery(
+    effectiveSelectedConnectionId,
+    trimmedFilter ? {search: trimmedFilter} : undefined,
+  );
+  const repositories = repositoriesQuery.data?.pages.flatMap((page) => page.repositories) ?? [];
+
+  const [selectedRepositoryId, setSelectedRepositoryId] = useState<string | undefined>();
+  useEffect(() => {
+    if (!selectedRepositoryId && repositories[0]) {
+      setSelectedRepositoryId(repositories[0].external_repository_id);
+    }
+  }, [repositories, selectedRepositoryId]);
+  const selectedRepository = repositories.find(
+    (repository) => repository.external_repository_id === selectedRepositoryId,
+  );
+
+  const [nameTouched, setNameTouched] = useState(false);
+  const defaultProjectName = projectNameFromRepository(
+    selectedRepository?.name ?? selectedRepositoryId ?? '',
+  );
+
+  const [formError, setFormError] = useState<string | undefined>();
+
+  const form = useForm({
+    defaultValues: {name: defaultProjectName},
+    onSubmit: async ({value}) => {
+      await createProjectFromForm(nameTouched ? value.name : defaultProjectName);
+    },
+  });
+
+  useEffect(() => {
+    if (!nameTouched && form.state.values.name !== defaultProjectName) {
+      form.setFieldValue('name', defaultProjectName);
+    }
+  }, [defaultProjectName, form, nameTouched]);
+
+  function selectConnection(connectionId: string) {
+    setSelectedConnectionId(connectionId);
+    setSelectedRepositoryId(undefined);
+  }
+
+  if (connectionsQuery.isPending) {
+    return <FullPageLoader />;
+  }
+
+  if (!workspace) {
+    return <FullPageLoader />;
+  }
+
+  if (!connectionsQuery.isError && connections.length === 0) {
+    return <Navigate to="/workspaces/$wid/integrations" params={{wid: workspace.id}} replace />;
+  }
+
+  async function createProjectFromForm(projectName: string) {
+    setFormError(undefined);
+    if (!workspace) {
+      setFormError('Workspace is still loading. Try again in a moment.');
+      errorRef.current?.focus();
+      return;
+    }
+    if (!selectedConnection) {
+      setFormError('Choose a source integration before creating a project.');
+      errorRef.current?.focus();
+      return;
+    }
+    if (!selectedRepository) {
+      setFormError('Choose a repository before creating a project.');
+      errorRef.current?.focus();
+      return;
+    }
+
+    try {
+      const projectBody = createProjectBodySchema.parse({
+        workspace_id: workspace.id,
+        name: projectName,
+        source: {
+          connection_id: selectedConnection.id,
+          external_repository_id: selectedRepository.external_repository_id,
+        },
+      });
+      const project = await createProject.mutateAsync(projectBody);
+      setWorkspaceProjectExists(queryClient, workspace.id, project);
+      queryClient.setQueryData(projectsQueryKeys.detail(project.id), project);
+      await queryClient.invalidateQueries({queryKey: projectsQueryKeys.list(workspace.id)});
+      toast.success('Project created.');
+      await navigate({
+        to: '/workspaces/$wid/projects/$pid',
+        params: {wid: workspace.id, pid: project.id},
+      });
+    } catch (error) {
+      const copy = projectErrorCopy(error);
+      if (copy.existingProjectId) {
+        await queryClient.invalidateQueries({
+          queryKey: projectsQueryKeys.exists(workspace.id),
+          refetchType: 'active',
+        });
+        await queryClient.invalidateQueries({queryKey: projectsQueryKeys.list(workspace.id)});
+        toast.info('Project already exists.');
+        await navigate({
+          to: '/workspaces/$wid/projects/$pid',
+          params: {wid: workspace.id, pid: copy.existingProjectId},
+        });
+        return;
+      }
+      setFormError(`${copy.title}: ${copy.message}`);
+      requestAnimationFrame(() => errorRef.current?.focus());
+    }
+  }
+
+  const showRepoPicker = Boolean(selectedConnection);
+  const filteredEmptyMessage = trimmedFilter
+    ? `No repositories matching "${repoFilter.trim()}".`
+    : 'No repositories visible to this connection.';
+
+  return (
+    <div className="flex w-full flex-col gap-24">
+      <header className="flex flex-col gap-6">
+        <Header id="create-project-title" variant="h1">
+          Create project
+        </Header>
+        <Text size="sm" className="text-foreground-neutral-muted">
+          A Shipfox project starts from a Git repository. Choose the repository Shipfox should
+          track, then give the project a name.
+        </Text>
+      </header>
+
+      <ModelProviderReminderBanner workspaceId={workspace.id} />
+
+      {connectionsQuery.isError ? (
+        <Callout role="alert" type="error">
+          <div className="flex w-full flex-wrap items-center justify-between gap-12">
+            <Text size="sm" className="min-w-[240px] flex-1">
+              Could not load source integrations. Refresh the integrations list to continue.
+            </Text>
+            <Button
+              size="sm"
+              variant="secondary"
+              onClick={() => connectionsQuery.refetch()}
+              className="shrink-0"
+            >
+              Refresh integrations
+            </Button>
+          </div>
+        </Callout>
+      ) : null}
+
+      <form
+        onSubmit={(event) => {
+          event.preventDefault();
+          event.stopPropagation();
+          void form.handleSubmit();
+        }}
+        noValidate
+        aria-labelledby="create-project-title"
+        className="grid items-start gap-32 lg:grid-cols-[minmax(0,1fr)_340px]"
+      >
+        <div className="flex min-w-0 flex-col gap-32">
+          <section className="flex flex-col gap-16" aria-label="Source integration">
+            <div className="flex items-start justify-between gap-16">
+              <div className="flex flex-col gap-4">
+                <Header variant="h3">Source integration</Header>
+                <Text size="sm" className="text-foreground-neutral-muted">
+                  Choose the integration that can access the repository.
+                </Text>
+              </div>
+
+              {connections.length === 1 ? (
+                <Button asChild variant="transparent" size="sm" className="shrink-0">
+                  <Link to="/workspaces/$wid/integrations" params={{wid: workspace.id}}>
+                    Add another integration
+                  </Link>
+                </Button>
+              ) : null}
+            </div>
+
+            {connections.length > 0 ? (
+              <ConnectionPicker
+                connections={connections}
+                selectedConnectionId={effectiveSelectedConnectionId}
+                onSelect={selectConnection}
+              />
+            ) : null}
+          </section>
+
+          {showRepoPicker ? (
+            <section className="flex flex-col gap-16" aria-label="Repository">
+              <div className="flex flex-col gap-4">
+                <Header variant="h3">Repository</Header>
+                <Text size="sm" className="text-foreground-neutral-muted">
+                  Select the repository this project tracks.
+                </Text>
+              </div>
+
+              <RepositoryPicker
+                repositories={repositories}
+                selectedRepositoryId={selectedRepositoryId}
+                onSelect={setSelectedRepositoryId}
+                isLoading={repositoriesQuery.isPending}
+                isFetchingNextPage={repositoriesQuery.isFetchingNextPage}
+                hasNextPage={repositoriesQuery.hasNextPage}
+                onLoadMore={() => repositoriesQuery.fetchNextPage()}
+                emptyMessage={filteredEmptyMessage}
+                searchValue={repoFilter}
+                onSearchChange={setRepoFilter}
+              />
+            </section>
+          ) : null}
+        </div>
+
+        <aside className="lg:sticky lg:top-32">
+          <div className="flex flex-col gap-18 rounded-8 border border-border-neutral-base bg-background-neutral-base p-20">
+            <div className="flex flex-col gap-4">
+              <Header variant="h3">Project details</Header>
+              <Text size="sm" className="text-foreground-neutral-muted">
+                Confirm the source and create the project.
+              </Text>
+            </div>
+
+            {formError ? (
+              <Callout role="alert" type="error">
+                <div ref={errorRef} tabIndex={-1}>
+                  {formError}
+                </div>
+              </Callout>
+            ) : null}
+
+            <ProjectSummary
+              connection={selectedConnection}
+              repositoryName={selectedRepository?.full_name}
+            />
+
+            <form.Field
+              name="name"
+              validators={{
+                onBlur: ({value}) =>
+                  displayNameFieldError(value, 'Project name', createProjectBodySchema.shape.name),
+                onSubmit: ({value}) =>
+                  displayNameFieldError(value, 'Project name', createProjectBodySchema.shape.name),
+              }}
+            >
+              {(field) => (
+                <FormField label="Project name" id="project-name" error={fieldError(field)}>
+                  <FormFieldInput
+                    name="name"
+                    type="text"
+                    value={field.state.value}
+                    onChange={(event) => {
+                      setNameTouched(true);
+                      field.handleChange(event.target.value);
+                    }}
+                    onBlur={field.handleBlur}
+                    placeholder="Platform"
+                  />
+                </FormField>
+              )}
+            </form.Field>
+
+            <Button
+              type="submit"
+              iconRight="chevronRight"
+              isLoading={createProject.isPending}
+              disabled={!selectedConnection || !selectedRepository}
+              className="w-full"
+            >
+              Create project
+            </Button>
+          </div>
+        </aside>
+      </form>
+    </div>
+  );
+}
+
+function ProjectSummary({
+  connection,
+  repositoryName,
+}: {
+  connection: IntegrationConnectionDto | undefined;
+  repositoryName: string | undefined;
+}) {
+  return (
+    <div className="flex min-w-0 items-center gap-10">
+      {repositoryName ? (
+        <IntegrationIcon
+          source={connection?.provider}
+          aria-hidden
+          className="size-20 shrink-0 text-foreground-neutral-base"
+        />
+      ) : null}
+      <Text
+        size="sm"
+        bold
+        className={repositoryName ? 'min-w-0 truncate' : 'text-foreground-neutral-muted'}
+      >
+        {repositoryName ?? 'Pick a repository'}
+      </Text>
+    </div>
+  );
+}
+
+function projectNameFromRepository(repositoryId: string): string {
+  return repositoryId
+    .trim()
+    .split(REPOSITORY_NAME_SPLIT_RE)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+function useDebouncedValue<T>(value: T, delayMs: number): T {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const handle = setTimeout(() => setDebounced(value), delayMs);
+    return () => clearTimeout(handle);
+  }, [value, delayMs]);
+  return debounced;
+}
+
+function setWorkspaceProjectExists(
+  queryClient: QueryClient,
+  workspaceId: string,
+  project: ProjectResponseDto,
+) {
+  queryClient.setQueryData<ListProjectsResponseDto>(projectsQueryKeys.exists(workspaceId), {
+    projects: [project],
+    next_cursor: null,
+  });
+}

package/src/pages/home-router.test.tsx

@@ -0,0 +1,27 @@
+// @vitest-environment jsdom
+import '@testing-library/jest-dom/vitest';
+import {configureApiClient} from '@shipfox/client-api';
+import {screen} from '@testing-library/react';
+import {jsonResponse, PROJECT_TEST_WID, renderProjectPage} from '#test/pages.js';
+import {HomeRouter} from './home-router.js';
+
+describe('HomeRouter', () => {
+  test('renders the completed-workspace project landing', async () => {
+    const fetchImpl = vi.fn((input: RequestInfo | URL) => {
+      const url = input instanceof Request ? input.url : String(input);
+      if (url.includes('/projects?')) {
+        return Promise.resolve(jsonResponse({projects: [], next_cursor: null}));
+      }
+      return Promise.resolve(jsonResponse({}, {status: 404}));
+    });
+    configureApiClient({fetchImpl});
+
+    renderProjectPage(`/workspaces/${PROJECT_TEST_WID}`, <HomeRouter />);
+
+    expect(await screen.findByRole('heading', {name: 'Projects'})).toBeInTheDocument();
+    const calledUrls = fetchImpl.mock.calls.map(([input]) =>
+      input instanceof Request ? input.url : String(input),
+    );
+    expect(calledUrls.some((url) => url.includes('/integration-connections?'))).toBe(false);
+  });
+});

package/src/pages/home-router.tsx

@@ -0,0 +1,5 @@
+import {ProjectsHubPage} from '#pages/projects-hub-page.js';
+
+export function HomeRouter() {
+  return <ProjectsHubPage />;
+}

package/src/pages/project-workflows-page.test.tsx

@@ -0,0 +1,258 @@
+import {configureApiClient} from '@shipfox/client-api';
+import {fireEvent, screen, waitFor} from '@testing-library/react';
+import {jsonResponse, PROJECT_TEST_WID, renderProjectPage} from '#test/pages.js';
+import {ProjectWorkflowsPage} from './project-workflows-page.js';
+
+const PROJECT_ID = '44444444-4444-4444-8444-444444444444';
+const CONNECTION_ID = '33333333-3333-4333-8333-333333333333';
+
+describe('ProjectWorkflowsPage', () => {
+  test('renders workflow definitions and the source strip', async () => {
+    configureApiClient({fetchImpl: createProjectDetailFetch()});
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    expect(await screen.findByRole('heading', {name: 'Workflows'})).toBeInTheDocument();
+    expect(screen.getAllByText('Deploy production')[0]).toBeInTheDocument();
+    expect(screen.getAllByText('.shipfox/workflows/deploy.yml')[0]).toBeInTheDocument();
+    expect(screen.getByRole('region', {name: 'Project source'})).toBeInTheDocument();
+    // Source strip resolves connection display_name from the integrations
+    // workspace cache; external_repository_id renders as a Code chip.
+    expect(await screen.findByText('Acme GitHub')).toBeInTheDocument();
+    expect(screen.getAllByText('platform')[0]).toBeInTheDocument();
+    expect(screen.getAllByText('succeeded')[0]).toBeInTheDocument();
+    expect(screen.queryByRole('heading', {name: 'Source identity'})).not.toBeInTheDocument();
+  });
+
+  test('shows definitions error while keeping the source strip visible', async () => {
+    configureApiClient({
+      fetchImpl: createProjectDetailFetch({
+        definitions: jsonResponse({code: 'server-error'}, {status: 500}),
+      }),
+    });
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    expect(await screen.findByText("Couldn't load workflows")).toBeInTheDocument();
+    // SyncBadge in the strip falls back to Unavailable when sync is undefined
+    // (definitions errored before providing one).
+    expect(screen.getByText('Unavailable')).toBeInTheDocument();
+    expect(screen.getByRole('region', {name: 'Project source'})).toBeInTheDocument();
+  });
+
+  test('shows failed sync empty state', async () => {
+    configureApiClient({
+      fetchImpl: createProjectDetailFetch({
+        definitions: jsonResponse(
+          definitionsDto({
+            definitions: [],
+            sync: {
+              ref: 'main',
+              status: 'failed',
+              last_sync_at: '2026-05-07T01:00:00.000Z',
+              started_at: '2026-05-07T01:00:00.000Z',
+              finished_at: null,
+              last_error_code: 'no-workflow-files',
+              last_error_message: 'No workflow files found',
+            },
+          }),
+        ),
+      }),
+    });
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    expect(
+      await screen.findByText('No workflow files found under .shipfox/workflows/.'),
+    ).toBeInTheDocument();
+    expect(screen.getByText('Workflow sync failed')).toBeInTheDocument();
+  });
+
+  test('opens and closes the definition drawer by clicking the row', async () => {
+    configureApiClient({fetchImpl: createProjectDetailFetch()});
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    const workflowName = (await screen.findAllByText('Deploy production'))[0];
+    if (!workflowName) throw new Error('Workflow row was not rendered');
+    fireEvent.click(workflowName);
+
+    expect(await screen.findByText('Normalized definition')).toBeInTheDocument();
+    expect(screen.getByText((content) => content.includes('"deploy"'))).toBeInTheDocument();
+
+    fireEvent.keyDown(document, {key: 'Escape'});
+
+    await waitFor(() => {
+      expect(screen.queryByText('Normalized definition')).not.toBeInTheDocument();
+    });
+  });
+
+  test('queues a run from a workflow definition', async () => {
+    configureApiClient({fetchImpl: createProjectDetailFetch()});
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    // Run button lives in the row's hover-reveal slot; getAllByRole still
+    // sees it (opacity-0, not display:none).
+    const [runButton] = await screen.findAllByRole('button', {name: 'Run'});
+    if (!runButton) throw new Error('Run button was not rendered');
+
+    fireEvent.click(runButton);
+
+    expect(await screen.findByText('Run queued')).toBeInTheDocument();
+  });
+
+  test('renders not found state', async () => {
+    configureApiClient({
+      fetchImpl: vi.fn((input) => {
+        const url = new URL(requestInputUrl(input));
+        if (url.pathname === `/projects/${PROJECT_ID}`) {
+          return Promise.resolve(jsonResponse({code: 'not-found'}, {status: 404}));
+        }
+        if (url.pathname === '/integration-connections') {
+          return Promise.resolve(jsonResponse(connectionsDto()));
+        }
+        return Promise.resolve(jsonResponse(definitionsDto()));
+      }),
+    });
+
+    renderProjectPage(
+      `/workspaces/${PROJECT_TEST_WID}/projects/${PROJECT_ID}`,
+      <ProjectWorkflowsPage projectId={PROJECT_ID} />,
+    );
+
+    expect(await screen.findByText('Project not found')).toBeInTheDocument();
+  });
+});
+
+function createProjectDetailFetch({
+  project = jsonResponse(projectDto()),
+  definitions = jsonResponse(definitionsDto()),
+  run = jsonResponse(runDto(), {status: 201}),
+  connections = jsonResponse(connectionsDto()),
+}: {
+  project?: Response;
+  definitions?: Response;
+  run?: Response;
+  connections?: Response;
+} = {}) {
+  return vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+    const url = new URL(requestInputUrl(input));
+    const method = init?.method ?? (input instanceof Request ? input.method : 'GET');
+
+    if (url.pathname === `/projects/${PROJECT_ID}`) {
+      return Promise.resolve(project.clone());
+    }
+    if (url.pathname === '/definitions') {
+      return Promise.resolve(definitions.clone());
+    }
+    if (url.pathname === '/integration-connections') {
+      return Promise.resolve(connections.clone());
+    }
+    if (
+      url.pathname.startsWith('/workflow-definitions/') &&
+      url.pathname.endsWith('/fire-manual') &&
+      method === 'POST'
+    ) {
+      return Promise.resolve(run.clone());
+    }
+    return Promise.resolve(jsonResponse({code: 'not-found'}, {status: 404}));
+  });
+}
+
+function requestInputUrl(input: RequestInfo | URL) {
+  if (input instanceof Request) return input.url;
+  return String(input);
+}
+
+function projectDto() {
+  return {
+    id: PROJECT_ID,
+    workspace_id: PROJECT_TEST_WID,
+    name: 'Platform',
+    source: {
+      connection_id: CONNECTION_ID,
+      external_repository_id: 'platform',
+    },
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  };
+}
+
+function connectionsDto() {
+  return {
+    connections: [
+      {
+        id: CONNECTION_ID,
+        workspace_id: PROJECT_TEST_WID,
+        provider: 'github',
+        external_account_id: 'acme',
+        slug: 'github_acme',
+        display_name: 'Acme GitHub',
+        lifecycle_status: 'active',
+        capabilities: ['source_control'],
+        created_at: '2026-05-07T00:00:00.000Z',
+        updated_at: '2026-05-07T00:00:00.000Z',
+      },
+    ],
+  };
+}
+
+function definitionsDto(overrides: Partial<{definitions: unknown[]; sync: unknown}> = {}) {
+  return {...baseDefinitionsDto(), ...overrides};
+}
+
+function baseDefinitionsDto() {
+  return {
+    definitions: [
+      {
+        id: '55555555-5555-4555-8555-555555555555',
+        project_id: PROJECT_ID,
+        config_path: '.shipfox/workflows/deploy.yml',
+        source: 'vcs',
+        sha: 'abc123',
+        ref: 'main',
+        name: 'Deploy production',
+        workflow_document: {
+          name: 'Deploy production',
+          triggers: {on_demand: {source: 'manual', event: 'fire'}},
+          jobs: {deploy: {steps: [{run: './deploy.sh'}]}},
+        },
+        workflow_model: {kind: 'workflow', name: 'Deploy production'},
+        manual_trigger: {name: 'on_demand'},
+        fetched_at: '2026-05-07T01:00:00.000Z',
+        created_at: '2026-05-07T01:00:00.000Z',
+        updated_at: '2026-05-07T01:00:00.000Z',
+      },
+    ],
+    next_cursor: null,
+    sync: {
+      ref: 'main',
+      status: 'succeeded',
+      last_sync_at: '2026-05-07T01:00:00.000Z',
+      started_at: '2026-05-07T00:59:55.000Z',
+      finished_at: '2026-05-07T01:00:00.000Z',
+      last_error_code: null,
+      last_error_message: null,
+    },
+  };
+}
+
+function runDto() {
+  return {run_id: '66666666-6666-4666-8666-666666666666'};
+}