@shipfox/api-definitions 11.0.0 → 12.2.0

package/src/presentation/subscribers/on-integration-connection-available.test.ts

@@ -0,0 +1,132 @@
+import type {IntegrationConnectionAvailableEvent} from '@shipfox/api-integration-core-dto';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {createOnIntegrationConnectionAvailable} from './on-integration-connection-available.js';
+
+const startMock = vi.fn();
+
+vi.mock('@shipfox/node-temporal', () => ({
+  temporalClient: () => ({workflow: {start: startMock}}),
+}));
+
+function project(name: string, workspaceId: string) {
+  return {
+    id: crypto.randomUUID(),
+    workspaceId,
+    sourceConnectionId: crypto.randomUUID(),
+    sourceExternalRepositoryId: `github:${name}`,
+    sourceRepositoryOwner: 'shipfox',
+    name,
+  };
+}
+
+describe('onIntegrationConnectionAvailable', () => {
+  beforeEach(() => {
+    startMock.mockReset();
+    startMock.mockResolvedValue({});
+  });
+
+  it('paginates workspace projects and starts an event-keyed sync for each one', async () => {
+    const workspaceId = crypto.randomUUID();
+    const first = project('first', workspaceId);
+    const second = project('second', workspaceId);
+    const cursor = {createdAt: '2026-08-05T12:00:00.000Z', id: first.id};
+    const listProjectsByWorkspace = vi
+      .fn()
+      .mockResolvedValueOnce({projects: [first], nextCursor: cursor})
+      .mockResolvedValueOnce({projects: [second], nextCursor: null});
+    const handler = createOnIntegrationConnectionAvailable({listProjectsByWorkspace} as never);
+    const payload: IntegrationConnectionAvailableEvent = {
+      provider: 'linear',
+      workspaceId: first.workspaceId,
+      connectionId: crypto.randomUUID(),
+      slug: 'linear_shipfox',
+    };
+    const event: DomainEvent<IntegrationConnectionAvailableEvent> = {
+      id: crypto.randomUUID(),
+      type: 'integrations.connection.available',
+      payload,
+      createdAt: new Date(),
+    };
+
+    await handler(payload, event);
+
+    expect(listProjectsByWorkspace).toHaveBeenNthCalledWith(1, {
+      workspaceId: payload.workspaceId,
+      limit: 100,
+    });
+    expect(listProjectsByWorkspace).toHaveBeenNthCalledWith(2, {
+      workspaceId: payload.workspaceId,
+      limit: 100,
+      cursor,
+    });
+    expect(startMock).toHaveBeenCalledTimes(2);
+    for (const candidate of [first, second]) {
+      expect(startMock).toHaveBeenCalledWith('definitionSyncWorkflow', {
+        taskQueue: 'definitions-sync',
+        workflowId: `definition-sync:${candidate.id}:integration:${event.id}`,
+        workflowIdConflictPolicy: 'USE_EXISTING',
+        workflowIdReusePolicy: 'REJECT_DUPLICATE',
+        args: [
+          {
+            projectId: candidate.id,
+            workspaceId: candidate.workspaceId,
+            sourceConnectionId: candidate.sourceConnectionId,
+            sourceExternalRepositoryId: candidate.sourceExternalRepositoryId,
+            sourceRef: undefined,
+            sourceCommitSha: undefined,
+          },
+        ],
+      });
+    }
+  });
+
+  it('treats an already-started event-keyed sync as successfully delivered', async () => {
+    const workspaceId = crypto.randomUUID();
+    const candidate = project('first', workspaceId);
+    const alreadyStarted = new Error('Workflow execution already started');
+    alreadyStarted.name = 'WorkflowExecutionAlreadyStartedError';
+    startMock.mockRejectedValue(alreadyStarted);
+    const handler = createOnIntegrationConnectionAvailable({
+      listProjectsByWorkspace: vi.fn(() =>
+        Promise.resolve({projects: [candidate], nextCursor: null}),
+      ),
+    } as never);
+    const payload: IntegrationConnectionAvailableEvent = {
+      provider: 'linear',
+      workspaceId,
+      connectionId: crypto.randomUUID(),
+      slug: 'linear_shipfox',
+    };
+
+    await expect(
+      handler(payload, {
+        id: crypto.randomUUID(),
+        type: 'integrations.connection.available',
+        payload,
+        createdAt: new Date(),
+      }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('rethrows project lookup failures so the outbox event can retry', async () => {
+    const failure = new Error('projects unavailable');
+    const handler = createOnIntegrationConnectionAvailable({
+      listProjectsByWorkspace: vi.fn(() => Promise.reject(failure)),
+    } as never);
+    const payload: IntegrationConnectionAvailableEvent = {
+      provider: 'linear',
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      slug: 'linear_shipfox',
+    };
+
+    await expect(
+      handler(payload, {
+        id: crypto.randomUUID(),
+        type: 'integrations.connection.available',
+        payload,
+        createdAt: new Date(),
+      }),
+    ).rejects.toBe(failure);
+  });
+});

package/src/presentation/subscribers/on-integration-connection-available.ts

@@ -0,0 +1,44 @@
+import type {IntegrationConnectionAvailableEvent} from '@shipfox/api-integration-core-dto';
+import type {ProjectsModuleClient} from '@shipfox/api-projects-dto/inter-module';
+import {boundedMap} from '@shipfox/node-module';
+import type {DomainEvent} from '@shipfox/node-outbox';
+import {startDefinitionSync} from './start-definition-sync.js';
+
+const PROJECT_PAGE_SIZE = 100;
+const SYNC_START_CONCURRENCY = 10;
+
+export function createOnIntegrationConnectionAvailable(
+  projects: Pick<ProjectsModuleClient, 'listProjectsByWorkspace'>,
+) {
+  return async function onIntegrationConnectionAvailable(
+    payload: IntegrationConnectionAvailableEvent,
+    event: DomainEvent<IntegrationConnectionAvailableEvent>,
+  ): Promise<void> {
+    let cursor: {createdAt: string; id: string} | undefined;
+
+    do {
+      const page = await projects.listProjectsByWorkspace({
+        workspaceId: payload.workspaceId,
+        limit: PROJECT_PAGE_SIZE,
+        ...(cursor ? {cursor} : {}),
+      });
+
+      await boundedMap(
+        page.projects,
+        SYNC_START_CONCURRENCY,
+        async (project) => {
+          await startDefinitionSync({
+            projectId: project.id,
+            workspaceId: project.workspaceId,
+            sourceConnectionId: project.sourceConnectionId,
+            externalRepositoryId: project.sourceExternalRepositoryId,
+            requestId: `integration:${event.id}`,
+          });
+        },
+        {stopOnError: true},
+      );
+
+      cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+  };
+}

package/src/presentation/subscribers/start-definition-sync.ts

@@ -8,31 +8,47 @@ export interface StartDefinitionSyncParams {
   externalRepositoryId: string;
   sourceRef?: string | undefined;
   sourceCommitSha?: string | undefined;
+  requestId?: string | undefined;
 }
 
 export async function startDefinitionSync(params: StartDefinitionSyncParams): Promise<void> {
   const workflowId = buildWorkflowId(params);
 
-  await temporalClient().workflow.start(DEFINITION_SYNC_WORKFLOW, {
-    taskQueue: DEFINITIONS_TASK_QUEUE,
-    workflowId,
-    workflowIdConflictPolicy: 'USE_EXISTING',
-    workflowIdReusePolicy: 'ALLOW_DUPLICATE',
-    args: [
-      {
-        projectId: params.projectId,
-        workspaceId: params.workspaceId,
-        sourceConnectionId: params.sourceConnectionId,
-        sourceExternalRepositoryId: params.externalRepositoryId,
-        sourceRef: params.sourceRef,
-        sourceCommitSha: params.sourceCommitSha,
-      },
-    ],
-  });
+  try {
+    await temporalClient().workflow.start(DEFINITION_SYNC_WORKFLOW, {
+      taskQueue: DEFINITIONS_TASK_QUEUE,
+      workflowId,
+      workflowIdConflictPolicy: 'USE_EXISTING',
+      workflowIdReusePolicy: params.requestId ? 'REJECT_DUPLICATE' : 'ALLOW_DUPLICATE',
+      args: [
+        {
+          projectId: params.projectId,
+          workspaceId: params.workspaceId,
+          sourceConnectionId: params.sourceConnectionId,
+          sourceExternalRepositoryId: params.externalRepositoryId,
+          sourceRef: params.sourceRef,
+          sourceCommitSha: params.sourceCommitSha,
+        },
+      ],
+    });
+  } catch (error) {
+    if (
+      params.requestId &&
+      error instanceof Error &&
+      error.name === 'WorkflowExecutionAlreadyStartedError'
+    ) {
+      return;
+    }
+    throw error;
+  }
 }
 
 function buildWorkflowId(params: StartDefinitionSyncParams): string {
-  return params.sourceCommitSha
-    ? `definition-sync:${params.projectId}:${params.sourceCommitSha}`
-    : `definition-sync:${params.projectId}:bind`;
+  if (params.sourceCommitSha) {
+    return `definition-sync:${params.projectId}:${params.sourceCommitSha}`;
+  }
+  if (params.requestId) {
+    return `definition-sync:${params.projectId}:${params.requestId}`;
+  }
+  return `definition-sync:${params.projectId}:bind`;
 }

package/src/temporal/activities/sync-activities.test.ts

@@ -224,6 +224,7 @@ describe('definition sync activities', () => {
 
       expect(result.appliedCount).toBe(1);
       expect(result.deletedCount).toBe(0);
+      expect(result.warnings).toEqual([]);
     });
 
     it('translates DefinitionSyncPermanentError into a non-retryable ApplicationFailure', async () => {
@@ -308,6 +309,7 @@ describe('definition sync activities', () => {
       expect(rows[0]?.status).toBe('failed');
       expect(rows[0]?.lastErrorCode).toBe('invalid-definition');
       expect(rows[0]?.lastErrorMessage).toBe('Invalid workflow at .shipfox/workflows/bad.yml');
+      expect(rows[0]?.warnings).toEqual([]);
       expect(rows[0]?.finishedAt).not.toBeNull();
     });
 
@@ -362,6 +364,13 @@ describe('definition sync activities', () => {
         sourceConnectionId,
         sourceExternalRepositoryId: 'gitea:gitea-owner/platform',
         sourceRef: 'main',
+        warnings: [
+          {
+            code: 're-evaluating-command',
+            message: 'Workflow data is re-executed as shell code.',
+            path: 'jobs.build.steps.0.run',
+          },
+        ],
       });
       await result;
 
@@ -372,6 +381,13 @@ describe('definition sync activities', () => {
       expect(rows[0]?.status).toBe('succeeded');
       expect(rows[0]?.lastErrorCode).toBeNull();
       expect(rows[0]?.lastErrorMessage).toBeNull();
+      expect(rows[0]?.warnings).toEqual([
+        {
+          code: 're-evaluating-command',
+          message: 'Workflow data is re-executed as shell code.',
+          path: 'jobs.build.steps.0.run',
+        },
+      ]);
     });
   });
 });

package/src/temporal/activities/sync-activities.ts

@@ -3,7 +3,7 @@ import type {IntegrationsModuleClient} from '@shipfox/api-integration-core-dto/i
 import {markErrorReported} from '@shipfox/node-error-monitoring';
 import {Context} from '@temporalio/activity';
 import {ApplicationFailure} from '@temporalio/common';
-import type {DefinitionSyncErrorCode} from '#core/entities/sync-state.js';
+import type {DefinitionSyncErrorCode, DefinitionSyncWarning} from '#core/entities/sync-state.js';
 import {
   classifySyncFailure,
   discoverWorkflowFiles,
@@ -50,6 +50,11 @@ export interface DiscoverWorkflowsActivityResult {
 export interface FetchAndApplyActivityResult {
   appliedCount: number;
   deletedCount: number;
+  warnings: DefinitionSyncWarning[];
+}
+
+export interface MarkSyncSucceededActivityInput extends SyncRefScopedInput {
+  warnings?: readonly DefinitionSyncWarning[] | undefined;
 }
 
 export interface DefinitionSyncActivityOptions {
@@ -93,6 +98,7 @@ function createPrepareDefinitionSyncActivity(sourceControl: DefinitionsSourceCon
         status: 'syncing',
         lastErrorCode: null,
         lastErrorMessage: null,
+        warnings: [],
         startedAt: new Date(),
         finishedAt: null,
       });
@@ -147,7 +153,7 @@ function createFetchAndApplyActivity(
               },
       });
 
-      return await applyVcsDefinitionsBatch({
+      const result = await applyVcsDefinitionsBatch({
         projectId: input.projectId,
         workspaceId: input.workspaceId,
         ref: input.sourceRef,
@@ -160,12 +166,19 @@ function createFetchAndApplyActivity(
           contentHash: entry.contentHash,
         })),
       });
+
+      return {
+        ...result,
+        warnings: definitions.flatMap((entry) => entry.warnings),
+      };
     });
   };
 }
 
 function createMarkSyncSucceededActivity() {
-  return async function markDefinitionSyncSucceeded(input: SyncRefScopedInput): Promise<void> {
+  return async function markDefinitionSyncSucceeded(
+    input: MarkSyncSucceededActivityInput,
+  ): Promise<void> {
     await markDefinitionSyncState({
       projectId: input.projectId,
       sourceConnectionId: input.sourceConnectionId,
@@ -174,6 +187,7 @@ function createMarkSyncSucceededActivity() {
       status: 'succeeded',
       lastErrorCode: null,
       lastErrorMessage: null,
+      warnings: input.warnings ?? [],
       finishedAt: new Date(),
     });
   };
@@ -191,6 +205,7 @@ function createMarkSyncFailedActivity() {
       status: 'failed',
       lastErrorCode: input.code,
       lastErrorMessage: input.message,
+      warnings: [],
       finishedAt: new Date(),
     });
   };

package/src/temporal/workflows/definition-sync.ts

@@ -65,7 +65,7 @@ export async function definitionSyncWorkflow(
     const {paths} = await discoverDefinitionWorkflows(source);
     const applied = await fetchAndApplyDefinitionWorkflows({...source, paths});
 
-    await markDefinitionSyncSucceeded(source);
+    await markDefinitionSyncSucceeded({...source, warnings: applied.warnings});
 
     return {
       sourceRef,

package/test/agent-validation-catalog.ts

@@ -7,6 +7,21 @@ import {
 } from '@shipfox/api-agent-dto';
 import type {AgentValidationCatalog} from '@shipfox/api-agent-dto/inter-module';
 
+const piModelIdsByProvider = Object.fromEntries(
+  MODEL_PROVIDER_CATALOG_SEED.filter((entry) => entry.support_status === 'supported').map(
+    (entry) => [
+      entry.id,
+      entry.id === 'anthropic'
+        ? ['claude-opus-4-8']
+        : entry.id === 'openai'
+          ? ['gpt-4.1', 'gpt-5.5-pro']
+          : entry.default_model === null
+            ? []
+            : [entry.default_model],
+    ],
+  ),
+);
+
 export const agentValidationCatalog: AgentValidationCatalog = {
   version: 1,
   providers: MODEL_PROVIDER_IDS.map((id) => ({
@@ -17,6 +32,8 @@ export const agentValidationCatalog: AgentValidationCatalog = {
   harnesses: listHarnessDescriptors().map((harness) => ({
     id: harness.id,
     supported_provider_ids: [...harness.supportedProviderIds],
+    model_ids_by_provider:
+      harness.id === 'pi' ? piModelIdsByProvider : {anthropic: ['claude-opus-4-8']},
     thinking_levels: [...harness.thinkingLevels],
     effective_tools: listEnabledHarnessTools(
       harness.id,

package/test/fixtures/valid-listening-job.yml

@@ -2,7 +2,8 @@ name: Listening workflow
 runner: ubuntu-latest
 jobs:
   review:
-    name: Review batch ${{ execution.index }}
+    name: Review batch
+    execution_name: Review batch ${{ execution.index }}
     listening:
       on:
         - source: github