@shipfox/api-integration-core 10.2.0 → 12.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-integration-core",
   "license": "MIT",
-  "version": "10.2.0",
+  "version": "12.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -23,31 +23,31 @@
     "ajv": "^8.20.0",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.4.3",
-    "@shipfox/api-agent-dto": "10.0.0",
-    "@shipfox/api-auth-context": "10.2.0",
-    "@shipfox/api-workflows-dto": "10.0.0",
-    "@shipfox/api-integration-core-dto": "9.0.2",
-    "@shipfox/api-integration-spi": "0.2.2",
-    "@shipfox/api-workspaces-dto": "10.2.0",
-    "@shipfox/api-integration-gitea": "10.2.0",
-    "@shipfox/api-integration-github": "10.2.0",
-    "@shipfox/api-integration-jira": "10.2.0",
-    "@shipfox/api-integration-linear": "10.2.0",
-    "@shipfox/api-integration-sentry": "10.2.0",
-    "@shipfox/api-integration-slack": "10.2.0",
-    "@shipfox/api-integration-webhook": "10.2.0",
+    "@shipfox/api-agent-dto": "12.0.0",
+    "@shipfox/api-auth-context": "12.0.0",
+    "@shipfox/api-workflows-dto": "12.0.0",
+    "@shipfox/api-integration-core-dto": "12.0.0",
+    "@shipfox/api-integration-spi": "1.0.0",
+    "@shipfox/api-workspaces-dto": "12.0.0",
+    "@shipfox/api-integration-gitea": "12.0.0",
+    "@shipfox/api-integration-github": "12.0.0",
+    "@shipfox/api-integration-jira": "12.0.0",
+    "@shipfox/api-integration-linear": "12.0.0",
+    "@shipfox/api-integration-sentry": "12.0.0",
+    "@shipfox/api-integration-slack": "12.0.0",
+    "@shipfox/api-integration-webhook": "12.0.0",
     "@shipfox/config": "1.2.4",
-    "@shipfox/inter-module": "0.2.2",
-    "@shipfox/node-drizzle": "0.3.4",
-    "@shipfox/node-fastify": "0.4.0",
-    "@shipfox/node-module": "1.0.4",
+    "@shipfox/inter-module": "0.2.3",
+    "@shipfox/node-drizzle": "0.3.5",
+    "@shipfox/node-fastify": "0.4.1",
+    "@shipfox/node-module": "1.0.5",
     "@shipfox/node-opentelemetry": "0.6.3",
     "@shipfox/node-error-monitoring": "0.3.0",
     "@shipfox/node-outbox": "0.2.6",
-    "@shipfox/node-postgres": "0.4.4",
+    "@shipfox/node-postgres": "0.5.0",
     "@shipfox/node-temporal": "0.4.4",
     "@shipfox/regex": "0.2.4",
-    "@shipfox/redact": "0.2.5"
+    "@shipfox/redact": "0.2.6"
   },
   "imports": {
     "#*": "./dist/*"

package/src/core/agent-tool-selection.test.ts

@@ -109,6 +109,7 @@ function sourceProvider(provider: string) {
           await Promise.resolve();
           throw new Error('not used');
         },
+        resolveTriggerReference: () => null,
       },
     },
   };

package/src/core/providers/registry.test.ts

@@ -22,6 +22,7 @@ function sourceControlAdapter() {
       await Promise.resolve();
       throw new Error('not used');
     },
+    resolveTriggerReference: () => null,
   };
 }
 

package/src/core/providers/source-control.ts

@@ -14,4 +14,5 @@ export type {
   RepositoryVisibility,
   ResolveRepositoryInput,
   SourceControlProvider,
+  TriggerReference,
 } from '@shipfox/api-integration-spi';

package/src/core/source-control-service.test.ts

@@ -52,6 +52,7 @@ describe('integration source-control service', () => {
         await Promise.resolve();
         return {path: '.shipfox/workflows/ci.yml', ref: 'main', content: 'name: CI'};
       },
+      resolveTriggerReference: () => null,
       createCheckoutSpec: async (input) => {
         await Promise.resolve();
         return {repositoryUrl: repository.cloneUrl, ref: input.ref ?? repository.defaultBranch};
@@ -91,6 +92,30 @@ describe('integration source-control service', () => {
     expect(result.repository.externalRepositoryId).toBe('gitea:gitea-owner/platform');
   });
 
+  it('resolves a normalized trigger reference through an active source-control connection', async () => {
+    const resolveTriggerReference = vi.fn(() => ({
+      externalRepositoryId: repository.externalRepositoryId,
+      ref: 'refs/heads/main',
+      commit: 'a'.repeat(40),
+      actor: 'octocat',
+    }));
+    const service = createService({resolveTriggerReference});
+
+    await expect(
+      service.resolveTriggerReference({
+        workspaceId,
+        connectionId: connection.id,
+        payload: {ref: 'refs/heads/main'},
+      }),
+    ).resolves.toEqual({
+      externalRepositoryId: repository.externalRepositoryId,
+      ref: 'refs/heads/main',
+      commit: 'a'.repeat(40),
+      actor: 'octocat',
+    });
+    expect(resolveTriggerReference).toHaveBeenCalledWith({ref: 'refs/heads/main'});
+  });
+
   it('rejects a missing connection', async () => {
     const service = createService();
 

package/src/core/source-control-service.ts

@@ -13,12 +13,14 @@ import type {
   FileSnapshot,
   RepositoryPage,
   RepositorySnapshot,
+  TriggerReference,
 } from './providers/source-control.js';
 
 export interface IntegrationSourceControlService {
   getConnection(connectionId: string): Promise<IntegrationConnection>;
   listRepositories(input: ListSourceRepositoriesInput): Promise<RepositoryPage>;
   resolveRepository(input: ResolveSourceRepositoryInput): Promise<ResolvedSourceRepository>;
+  resolveTriggerReference(input: ResolveTriggerReferenceInput): Promise<TriggerReference | null>;
   listFiles(input: ListSourceFilesInput): Promise<FilePage>;
   fetchFile(input: FetchSourceFileInput): Promise<FileSnapshot>;
   createCheckoutSpec(input: CreateSourceCheckoutSpecInput): Promise<CheckoutSpec>;
@@ -37,6 +39,12 @@ export interface ResolveSourceRepositoryInput {
   externalRepositoryId: string;
 }
 
+export interface ResolveTriggerReferenceInput {
+  workspaceId: string;
+  connectionId: string;
+  payload: unknown;
+}
+
 export interface ListSourceFilesInput extends ResolveSourceRepositoryInput {
   ref: string;
   prefix: string;
@@ -108,6 +116,19 @@ export function createSourceControlIntegrationService({
       return {connection, repository};
     },
 
+    async resolveTriggerReference({workspaceId, connectionId, payload}) {
+      const connection = await getConnection(connectionId);
+      if (connection.workspaceId !== workspaceId) {
+        throw new IntegrationConnectionWorkspaceMismatchError(connectionId);
+      }
+
+      // Not every integration source names a repository (for example Linear),
+      // so a missing source-control adapter is a valid null reference rather
+      // than a failed run creation.
+      const sourceControl = registry.get(connection.provider).adapters.source_control;
+      return sourceControl?.resolveTriggerReference(payload) ?? null;
+    },
+
     async listFiles({workspaceId, connectionId, externalRepositoryId, ref, prefix, limit, cursor}) {
       const connection = await getConnection(connectionId);
       if (connection.workspaceId !== workspaceId) {

package/src/db/connections.test.ts

@@ -5,6 +5,7 @@ import {
   createIntegrationConnection,
   deleteIntegrationConnection,
   getIntegrationConnectionById,
+  getIntegrationConnectionBySlug,
   listIntegrationConnections,
   listIntegrationConnectionsByProvider,
   resolveUniqueConnectionSlug,
@@ -63,6 +64,23 @@ describe('integration connection queries', () => {
     expect(result).toHaveLength(2);
   });
 
+  it('resolves a connection by slug within its workspace', async () => {
+    const connection = await upsertIntegrationConnection({
+      workspaceId,
+      provider: 'github',
+      externalAccountId: 'debug-1',
+      slug: 'github_main',
+      displayName: 'GitHub',
+    });
+
+    await expect(
+      getIntegrationConnectionBySlug({workspaceId, slug: 'github_main'}),
+    ).resolves.toMatchObject({id: connection.id, slug: 'github_main'});
+    await expect(
+      getIntegrationConnectionBySlug({workspaceId: crypto.randomUUID(), slug: 'github_main'}),
+    ).resolves.toBeUndefined();
+  });
+
   it('resolves a unique slug in workspace scope', async () => {
     await upsertIntegrationConnection({
       workspaceId,

package/src/db/connections.ts

@@ -191,6 +191,31 @@ export async function getIntegrationConnectionById(
 
 export type GetIntegrationConnectionByIdFn = typeof getIntegrationConnectionById;
 
+export interface GetIntegrationConnectionBySlugParams {
+  workspaceId: string;
+  slug: string;
+}
+
+export async function getIntegrationConnectionBySlug(
+  params: GetIntegrationConnectionBySlugParams,
+): Promise<IntegrationConnection | undefined> {
+  const rows = await db()
+    .select()
+    .from(integrationConnections)
+    .where(
+      and(
+        eq(integrationConnections.workspaceId, params.workspaceId),
+        eq(integrationConnections.slug, params.slug),
+      ),
+    )
+    .limit(1);
+  const row = rows[0];
+  if (!row) return undefined;
+  return toIntegrationConnection(row);
+}
+
+export type GetIntegrationConnectionBySlugFn = typeof getIntegrationConnectionBySlug;
+
 export interface UpdateIntegrationConnectionLifecycleStatusParams {
   id: string;
   lifecycleStatus: IntegrationConnectionLifecycleStatus;

package/src/db/webhook-deliveries.test.ts

@@ -1,8 +1,10 @@
 import {
   INTEGRATION_EVENT_RECEIVED,
   INTEGRATION_SOURCE_COMMIT_PUSHED,
+  INTEGRATION_SOURCE_REPOSITORY_UPDATED,
   type IntegrationEventReceivedEvent,
   type SourcePushPayload,
+  type SourceRepositoryIdentity,
 } from '@shipfox/api-integration-spi';
 import {and, eq, sql} from 'drizzle-orm';
 import {db} from './db.js';
@@ -13,6 +15,7 @@ import {
   publishIntegrationEventReceived,
   publishSourceCommitPushed,
   publishSourcePush,
+  publishSourceRepositoryUpdated,
   recordDeliveryOnly,
 } from './webhook-deliveries.js';
 
@@ -276,3 +279,77 @@ describe('publishSourceCommitPushed', () => {
     expect(await deliveriesFor(params.provider, params.deliveryId)).toHaveLength(0);
   });
 });
+
+describe('publishSourceRepositoryUpdated', () => {
+  function buildParams() {
+    const deliveryId = crypto.randomUUID();
+    const repositories: SourceRepositoryIdentity[] = [
+      {
+        externalRepositoryId: 'github:42',
+        owner: 'acme',
+        name: 'platform-renamed',
+        defaultBranch: 'main',
+      },
+      {
+        externalRepositoryId: 'github:43',
+        owner: 'acme',
+        name: 'runner',
+        defaultBranch: 'trunk',
+      },
+    ];
+    return {
+      provider: 'github',
+      source: 'github_acme_production',
+      workspaceId: crypto.randomUUID(),
+      connectionId: crypto.randomUUID(),
+      connectionName: 'Acme Production',
+      deliveryId,
+      receivedAt: new Date().toISOString(),
+      rawPayload: {action: 'added', repositories_added: repositories},
+      event: 'installation_repositories.added',
+      repositories,
+    };
+  }
+
+  it('writes the generic envelope and one typed event per repository', async () => {
+    const params = buildParams();
+
+    const result = await db().transaction((tx) => publishSourceRepositoryUpdated({tx, ...params}));
+
+    expect(result.published).toBe(true);
+    const outbox = await outboxFor(params.deliveryId);
+    expect(outbox).toHaveLength(3);
+    expect(outbox.filter((row) => row.eventType === INTEGRATION_EVENT_RECEIVED)).toHaveLength(1);
+    expect(
+      outbox.filter((row) => row.eventType === INTEGRATION_SOURCE_REPOSITORY_UPDATED),
+    ).toHaveLength(2);
+    expect(
+      outbox.find((row) => row.eventType === INTEGRATION_EVENT_RECEIVED)?.payload,
+    ).toMatchObject({
+      event: 'installation_repositories.added',
+      payload: params.rawPayload,
+    });
+    expect(
+      outbox
+        .filter((row) => row.eventType === INTEGRATION_SOURCE_REPOSITORY_UPDATED)
+        .map((row) => row.payload),
+    ).toEqual(
+      expect.arrayContaining(
+        params.repositories.map((repository) =>
+          expect.objectContaining({repository, deliveryId: params.deliveryId}),
+        ),
+      ),
+    );
+  });
+
+  it('does not publish a duplicate delivery twice', async () => {
+    const params = buildParams();
+
+    const first = await db().transaction((tx) => publishSourceRepositoryUpdated({tx, ...params}));
+    const second = await db().transaction((tx) => publishSourceRepositoryUpdated({tx, ...params}));
+
+    expect(first.published).toBe(true);
+    expect(second.published).toBe(false);
+    expect(await outboxFor(params.deliveryId)).toHaveLength(3);
+  });
+});

package/src/db/webhook-deliveries.ts

@@ -1,9 +1,11 @@
 import {
   INTEGRATION_EVENT_RECEIVED,
   INTEGRATION_SOURCE_COMMIT_PUSHED,
+  INTEGRATION_SOURCE_REPOSITORY_UPDATED,
   type IntegrationEventReceivedEvent,
   type IntegrationsEventMap,
   type SourcePushPayload,
+  type SourceRepositoryIdentity,
 } from '@shipfox/api-integration-spi';
 import {writeOutboxEvent, writeOutboxEvents} from '@shipfox/node-outbox';
 import {lt} from 'drizzle-orm';
@@ -14,6 +16,12 @@ import {integrationsWebhookDeliveries} from './schema/webhook-deliveries.js';
 type IntegrationDb = ReturnType<typeof db>;
 type IntegrationTx = Parameters<Parameters<IntegrationDb['transaction']>[0]>[0];
 type Executor = IntegrationDb | IntegrationTx;
+type IntegrationOutboxEvent = {
+  [K in keyof IntegrationsEventMap & string]: {
+    type: K;
+    payload: IntegrationsEventMap[K];
+  };
+}[keyof IntegrationsEventMap & string];
 
 function connectionDedupScope(connectionId: string): string {
   return `connection:${connectionId}`;
@@ -66,7 +74,7 @@ export async function publishIntegrationEventReceived(
   return {published: true};
 }
 
-export interface PublishSourcePushParams {
+interface PublishSourceEventsParams {
   tx: IntegrationTx;
   provider: string;
   source: string;
@@ -76,16 +84,12 @@ export interface PublishSourcePushParams {
   deliveryId: string;
   receivedAt: string;
   rawPayload: unknown;
-  push: SourcePushPayload;
+  event: string;
+  typedEvents: IntegrationOutboxEvent[];
 }
 
-// Emits a single source-control push as two outbox rows: the generic
-// `INTEGRATION_EVENT_RECEIVED` envelope with the raw provider payload for triggers, and the
-// typed `INTEGRATION_SOURCE_COMMIT_PUSHED` event for domain modules. One delivery-dedup gates
-// both, so a redelivered webhook writes nothing. Requires a transaction: the dedup insert and
-// both outbox rows must commit or roll back together.
-export async function publishSourcePush(
-  params: PublishSourcePushParams,
+async function publishSourceEvents(
+  params: PublishSourceEventsParams,
 ): Promise<{published: boolean}> {
   const inserted = await params.tx
     .insert(integrationsWebhookDeliveries)
@@ -111,7 +115,7 @@ export async function publishSourcePush(
       payload: {
         provider: params.provider,
         source: params.source,
-        event: 'push',
+        event: params.event,
         workspaceId: params.workspaceId,
         connectionId: params.connectionId,
         connectionName: params.connectionName,
@@ -120,22 +124,106 @@ export async function publishSourcePush(
         payload: params.rawPayload,
       },
     },
-    {
-      type: INTEGRATION_SOURCE_COMMIT_PUSHED,
-      payload: {
-        provider: params.provider,
-        workspaceId: params.workspaceId,
-        connectionId: params.connectionId,
-        deliveryId: params.deliveryId,
-        receivedAt: params.receivedAt,
-        push: params.push,
-      },
-    },
+    ...params.typedEvents,
   ]);
 
   return {published: true};
 }
 
+export interface PublishSourcePushParams {
+  tx: IntegrationTx;
+  provider: string;
+  source: string;
+  workspaceId: string;
+  connectionId: string;
+  connectionName: string;
+  deliveryId: string;
+  receivedAt: string;
+  rawPayload: unknown;
+  push: SourcePushPayload;
+}
+
+// Emits a single source-control push as two outbox rows: the generic
+// `INTEGRATION_EVENT_RECEIVED` envelope with the raw provider payload for triggers, and the
+// typed `INTEGRATION_SOURCE_COMMIT_PUSHED` event for domain modules. One delivery-dedup gates
+// both, so a redelivered webhook writes nothing. Requires a transaction: the dedup insert and
+// both outbox rows must commit or roll back together.
+export function publishSourcePush(params: PublishSourcePushParams): Promise<{published: boolean}> {
+  return publishSourceEvents({
+    tx: params.tx,
+    provider: params.provider,
+    source: params.source,
+    workspaceId: params.workspaceId,
+    connectionId: params.connectionId,
+    connectionName: params.connectionName,
+    deliveryId: params.deliveryId,
+    receivedAt: params.receivedAt,
+    rawPayload: params.rawPayload,
+    event: 'push',
+    typedEvents: [
+      {
+        type: INTEGRATION_SOURCE_COMMIT_PUSHED,
+        payload: {
+          provider: params.provider,
+          workspaceId: params.workspaceId,
+          connectionId: params.connectionId,
+          deliveryId: params.deliveryId,
+          receivedAt: params.receivedAt,
+          push: params.push,
+        },
+      },
+    ],
+  });
+}
+
+export interface PublishSourceRepositoryUpdatedParams {
+  tx: IntegrationTx;
+  provider: string;
+  source: string;
+  workspaceId: string;
+  connectionId: string;
+  connectionName: string;
+  deliveryId: string;
+  receivedAt: string;
+  rawPayload: unknown;
+  event: string;
+  repositories: SourceRepositoryIdentity[];
+}
+
+// Emits the generic provider envelope for triggers and one typed repository event per
+// normalized repository for domain modules. One delivery-dedup gates all rows, so a
+// redelivered webhook writes nothing. Requires a transaction: the dedup insert and all
+// outbox rows must commit or roll back together.
+export function publishSourceRepositoryUpdated(
+  params: PublishSourceRepositoryUpdatedParams,
+): Promise<{published: boolean}> {
+  return publishSourceEvents({
+    tx: params.tx,
+    provider: params.provider,
+    source: params.source,
+    workspaceId: params.workspaceId,
+    connectionId: params.connectionId,
+    connectionName: params.connectionName,
+    deliveryId: params.deliveryId,
+    receivedAt: params.receivedAt,
+    rawPayload: params.rawPayload,
+    event: params.event,
+    typedEvents: params.repositories.map(
+      (repository): IntegrationOutboxEvent => ({
+        type: INTEGRATION_SOURCE_REPOSITORY_UPDATED,
+        payload: {
+          provider: params.provider,
+          workspaceId: params.workspaceId,
+          connectionId: params.connectionId,
+          deliveryId: params.deliveryId,
+          receivedAt: params.receivedAt,
+          repository,
+        },
+      }),
+    ),
+  });
+}
+
 export interface PublishSourceCommitPushedParams {
   provider: string;
   workspaceId: string;
@@ -211,6 +299,7 @@ export async function pruneWebhookDeliveries(
 
 export type PublishIntegrationEventReceivedFn = typeof publishIntegrationEventReceived;
 export type PublishSourcePushFn = typeof publishSourcePush;
+export type PublishSourceRepositoryUpdatedFn = typeof publishSourceRepositoryUpdated;
 export type PublishSourceCommitPushedFn = typeof publishSourceCommitPushed;
 export type ClaimWebhookDeliveryFn = typeof claimWebhookDelivery;
 export type RecordDeliveryOnlyFn = typeof recordDeliveryOnly;

package/src/index.ts

@@ -114,11 +114,15 @@ export type {
   RepositoryVisibility,
   ResolveRepositoryInput,
   SourceControlProvider,
+  TriggerReference,
 } from '#core/providers/source-control.js';
 export type {IntegrationSourceControlService} from '#core/source-control-service.js';
 export {createSourceControlIntegrationService} from '#core/source-control-service.js';
-export type {GetIntegrationConnectionByIdFn} from '#db/connections.js';
-export {getIntegrationConnectionById} from '#db/connections.js';
+export type {
+  GetIntegrationConnectionByIdFn,
+  GetIntegrationConnectionBySlugFn,
+} from '#db/connections.js';
+export {getIntegrationConnectionById, getIntegrationConnectionBySlug} from '#db/connections.js';
 export type {
   ClaimWebhookDeliveryFn,
   PublishIntegrationEventReceivedFn,
@@ -126,10 +130,16 @@ export type {
   PublishIntegrationEventReceivedResult,
   PublishSourcePushFn,
   PublishSourcePushParams,
+  PublishSourceRepositoryUpdatedFn,
+  PublishSourceRepositoryUpdatedParams,
   RecordDeliveryOnlyFn,
   RecordDeliveryOnlyParams,
 } from '#db/webhook-deliveries.js';
-export {claimWebhookDelivery, pruneWebhookDeliveries} from '#db/webhook-deliveries.js';
+export {
+  claimWebhookDelivery,
+  pruneWebhookDeliveries,
+  publishSourceRepositoryUpdated,
+} from '#db/webhook-deliveries.js';
 export {integrationRouteErrorHandler} from '#presentation/routes/errors.js';
 
 export interface CreateIntegrationsModuleOptions {

package/src/presentation/inter-module.ts

@@ -21,7 +21,7 @@ import {
 } from '#core/errors.js';
 import type {IntegrationProviderRegistry} from '#core/providers/registry.js';
 import type {IntegrationSourceControlService} from '#core/source-control-service.js';
-import {getIntegrationConnectionById} from '#db/connections.js';
+import {getIntegrationConnectionById, getIntegrationConnectionBySlug} from '#db/connections.js';
 
 export function createIntegrationsInterModulePresentation(params: {
   registry: IntegrationProviderRegistry;
@@ -41,6 +41,16 @@ export function createIntegrationsInterModulePresentation(params: {
           repository: resolved.repository,
         };
       }),
+    resolveConnection: async (input) => {
+      const resolved = await getIntegrationConnectionBySlug(input);
+      return resolved ? {id: resolved.id, provider: resolved.provider, slug: resolved.slug} : null;
+    },
+    resolveTriggerReference: async (input) =>
+      await known(
+        contract.methods.resolveTriggerReference,
+        input,
+        async () => await params.sourceControl.resolveTriggerReference(input),
+      ),
     listSourceFiles: async (input) =>
       await known(
         contract.methods.listSourceFiles,

package/src/presentation/routes/list-repositories.test.ts

@@ -126,6 +126,7 @@ describe('GET /integration-connections/:connectionId/repositories', () => {
               await Promise.resolve();
               throw new Error('not used');
             },
+            resolveTriggerReference: () => null,
           },
         },
       }),

package/src/providers/github.ts

@@ -10,6 +10,7 @@ import {db} from '#db/db.js';
 import {
   publishIntegrationEventReceived,
   publishSourcePush,
+  publishSourceRepositoryUpdated,
   recordDeliveryOnly,
 } from '#db/webhook-deliveries.js';
 import {retryConnectionSlugCollision, slugifyConnectionSlug} from '#providers/connection-slug.js';
@@ -111,6 +112,7 @@ async function loadGithubModuleParts(
     getExistingGithubConnection,
     connectGithubInstallation,
     publishIntegrationEventReceived,
+    publishSourceRepositoryUpdated,
     publishSourcePush,
     recordDeliveryOnly,
     getIntegrationConnectionById,

package/src/providers/jira.test.ts

@@ -20,6 +20,8 @@ describe('jiraProviderModule', () => {
     const parts = await loadEnabledProviderModules();
     const jiraPart = parts.find((part) => part.provider.provider === 'jira');
     if (!jiraPart?.database) throw new Error('Jira provider database is not configured');
+    expect(jiraPart.provider.routes).toHaveLength(2);
+    expect(jiraPart.webhookProcessors).toEqual([expect.objectContaining({routeIds: ['jira']})]);
     const workspaceId = crypto.randomUUID();
     const cloudId = crypto.randomUUID();