@shipfox/api-integration-jira 11.0.0 → 12.1.0

package/src/db/schema/installations.ts

@@ -1,5 +1,5 @@
 import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
-import {jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import {index, jsonb, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
 import type {JiraInstallation} from '#db/installations.js';
 import {pgTable} from './common.js';
 
@@ -17,12 +17,30 @@ export const jiraInstallations = pgTable(
     webhookExpiresAt: timestamp('webhook_expires_at', {withTimezone: true}),
     status: text('status').notNull().$type<JiraInstallation['status']>(),
     tokenExpiresAt: timestamp('token_expires_at', {withTimezone: true}),
+    refreshTokenLastUsedAt: timestamp('refresh_token_last_used_at', {
+      withTimezone: true,
+    })
+      .notNull()
+      .defaultNow(),
+    refreshTokenLastAttemptedAt: timestamp('refresh_token_last_attempted_at', {
+      withTimezone: true,
+    })
+      .notNull()
+      .defaultNow(),
     createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
   },
   (table) => [
     uniqueIndex('integrations_jira_installations_connection_unique').on(table.connectionId),
     uniqueIndex('integrations_jira_installations_cloud_id_unique').on(table.cloudId),
+    index('integrations_jira_installations_token_refresh_due_idx').on(
+      table.status,
+      table.refreshTokenLastUsedAt,
+    ),
+    index('integrations_jira_installations_token_refresh_attempt_idx').on(
+      table.status,
+      table.refreshTokenLastAttemptedAt,
+    ),
   ],
 );
 
@@ -42,6 +60,8 @@ export function toJiraInstallation(row: JiraInstallationDb): JiraInstallation {
     webhookExpiresAt: row.webhookExpiresAt,
     status: row.status,
     tokenExpiresAt: row.tokenExpiresAt,
+    refreshTokenLastUsedAt: row.refreshTokenLastUsedAt,
+    refreshTokenLastAttemptedAt: row.refreshTokenLastAttemptedAt,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
   };

package/src/index.test.ts

@@ -1,4 +1,6 @@
+import {createOutboxRegistry} from '@shipfox/node-module';
 import {createJiraIntegrationProvider} from '#index.js';
+import {createJiraMaintenanceWorker} from '#temporal/worker.js';
 
 describe('createJiraIntegrationProvider', () => {
   it('creates the Jira provider', () => {
@@ -11,4 +13,44 @@ describe('createJiraIntegrationProvider', () => {
       routes: [],
     });
   });
+
+  it('mounts the in-process agent-tools adapter and advertises its capability', () => {
+    const getAccessToken = vi.fn().mockResolvedValue('access-token');
+    const provider = createJiraIntegrationProvider({
+      agentTools: {tokenStore: {getAccessToken}},
+    });
+
+    expect(provider.adapters.agent_tools).toBeDefined();
+    expect(provider.routes).toEqual([]);
+  });
+
+  it('rejects incomplete receiver wiring instead of mounting registration without a receiver', () => {
+    expect(() =>
+      createJiraIntegrationProvider({
+        routes: {tokenStore: {} as never} as never,
+      }),
+    ).toThrow('requires all webhook receiver dependencies');
+  });
+});
+
+describe('createJiraMaintenanceWorker', () => {
+  it('describes the Jira proactive token refresh worker', () => {
+    const worker = createJiraMaintenanceWorker({
+      tokenStore: {getAccessToken: vi.fn()},
+      resolveConnection: vi.fn(),
+    });
+
+    expect(worker.taskQueue).toBe('integrations-jira-maintenance');
+    expect(worker.workflowsPath.endsWith('dist/temporal/workflows/index.js')).toBe(true);
+    expect(Object.keys(worker.activities({outboxRegistry: createOutboxRegistry()}))).toContain(
+      'refreshJiraTokensActivity',
+    );
+    expect(worker.workflows).toEqual([
+      {
+        name: 'refreshJiraTokensCron',
+        id: 'jira-refresh-tokens',
+        cronSchedule: '0 */6 * * *',
+      },
+    ]);
+  });
 });

package/src/index.ts

@@ -1,6 +1,15 @@
 import {JIRA_PROVIDER} from '@shipfox/api-integration-jira-dto';
-import {createJiraApiClient, type JiraApiClient} from '#api/client.js';
+import {
+  createJiraAgentToolsClient,
+  createJiraApiClient,
+  type JiraAgentToolsClient,
+  type JiraApiClient,
+} from '#api/client.js';
 import {config} from '#config.js';
+import {JiraAgentToolsProvider} from '#core/agent-tools-provider.js';
+import type {JiraTokenStore} from '#core/tokens.js';
+import {createJiraWebhookProcessor} from '#core/webhook-processor.js';
+import {registerJiraWebhook} from '#core/webhook-registration.js';
 import {closeDb, db} from '#db/db.js';
 import {getJiraInstallationByConnectionId} from '#db/installations.js';
 import {migrationsPath} from '#db/migrations.js';
@@ -8,15 +17,49 @@ import {
   type CreateJiraIntegrationRoutesOptions,
   createJiraIntegrationRoutes,
 } from '#presentation/routes/install.js';
+import {
+  type CreateJiraWebhookRoutesOptions,
+  createJiraWebhookRoutes,
+  JIRA_WEBHOOK_ROUTE_PREFIX,
+} from '#presentation/routes/webhooks.js';
+
+const TRAILING_SLASHES_RE = /\/+$/;
 
 export type {JiraProvider} from '@shipfox/api-integration-jira-dto';
 export type {
   JiraAccessibleResource,
+  JiraAgentToolHttpMethod,
+  JiraAgentToolQueryValue,
+  JiraAgentToolRequest,
+  JiraAgentToolResponse,
+  JiraAgentToolsClient,
   JiraApiClient,
   JiraAuthorization,
+  JiraDynamicWebhookRegistration,
   JiraIdentity,
 } from '#api/client.js';
-export {createJiraApiClient, mapJiraError} from '#api/client.js';
+export {
+  createJiraAgentToolsClient,
+  createJiraApiClient,
+  JIRA_DYNAMIC_WEBHOOK_EVENTS,
+  JIRA_DYNAMIC_WEBHOOK_JQL,
+  mapJiraError,
+} from '#api/client.js';
+export type {
+  JiraAgentToolCatalogEntry,
+  JiraAgentToolId,
+  JiraAgentToolRequiredScope,
+} from '#core/agent-tools.js';
+export {
+  jiraAgentToolCatalog,
+  jiraAgentToolSelectionCatalog,
+  jiraPlainTextToAdf,
+} from '#core/agent-tools.js';
+export type {
+  JiraAgentToolsProviderOptions,
+  JiraToolCallResult,
+} from '#core/agent-tools-provider.js';
+export {JiraAgentToolsProvider} from '#core/agent-tools-provider.js';
 export type {DisconnectJiraInstallationParams} from '#core/disconnect.js';
 export {disconnectJiraInstallation} from '#core/disconnect.js';
 export {
@@ -58,9 +101,18 @@ export type {
   StoreJiraTokensParams,
 } from '#core/tokens.js';
 export {createJiraTokenStore, jiraSecretsNamespace} from '#core/tokens.js';
+export type {
+  CreateJiraWebhookProcessorOptions,
+  JiraWebhookProcessor,
+} from '#core/webhook-processor.js';
+export {createJiraWebhookProcessor} from '#core/webhook-processor.js';
+export type {RegisterJiraWebhookParams} from '#core/webhook-registration.js';
+export {JIRA_WEBHOOK_TTL_MS, registerJiraWebhook} from '#core/webhook-registration.js';
 export type {
   JiraInstallation,
+  JiraInstallationLock,
   JiraInstallationStatus,
+  UpdateJiraInstallationWebhookParams,
   UpsertJiraInstallationParams,
 } from '#db/installations.js';
 export {
@@ -68,33 +120,124 @@ export {
   getJiraInstallationByCloudId,
   getJiraInstallationByConnectionId,
   getJiraInstallationByWebhookId,
+  listJiraInstallationsDueForTokenRefresh,
   markJiraInstallationRevoked,
   updateJiraInstallationTokenExpiry,
+  updateJiraInstallationWebhook,
   upsertJiraInstallation,
   withJiraRefreshLock,
+  withJiraWebhookRegistrationLock,
 } from '#db/installations.js';
+export type {CreateJiraWebhookRoutesOptions} from '#presentation/routes/webhooks.js';
+export {createJiraWebhookRoutes} from '#presentation/routes/webhooks.js';
+export {createJiraMaintenanceWorker} from '#temporal/worker.js';
 export {closeDb, config, db, migrationsPath};
 
 export interface CreateJiraIntegrationProviderOptions {
   jira?: JiraApiClient | undefined;
+  agentTools?:
+    | {
+        tokenStore: Pick<JiraTokenStore, 'getAccessToken'>;
+        jira?: JiraAgentToolsClient | undefined;
+      }
+    | undefined;
   getJiraInstallationByConnectionId?: typeof getJiraInstallationByConnectionId | undefined;
-  routes?: Omit<CreateJiraIntegrationRoutesOptions, 'jira' | 'connectionCapabilities'> | undefined;
+  routes?: JiraIntegrationProviderRoutesOptions | undefined;
 }
 
+type JiraIntegrationProviderRoutesOptions = Omit<
+  CreateJiraIntegrationRoutesOptions,
+  'jira' | 'connectionCapabilities' | 'registerJiraWebhook'
+> &
+  Omit<CreateJiraWebhookRoutesOptions, 'processor'>;
+
 export function createJiraIntegrationProvider(options: CreateJiraIntegrationProviderOptions = {}) {
   const jira = options.jira ?? createJiraApiClient();
   const getInstallationByConnectionId =
     options.getJiraInstallationByConnectionId ?? getJiraInstallationByConnectionId;
+  const adapters = options.agentTools
+    ? {
+        agent_tools: new JiraAgentToolsProvider({
+          jira: options.agentTools.jira ?? createJiraAgentToolsClient(),
+          tokenStore: options.agentTools.tokenStore,
+        }),
+      }
+    : {};
+  const webhookOptions = toJiraWebhookOptions(options.routes);
+  const webhookProcessor = webhookOptions ? createJiraWebhookProcessor(webhookOptions) : undefined;
+  const webhookRoutes = webhookOptions
+    ? [
+        createJiraWebhookRoutes({
+          coreDb: webhookOptions.coreDb,
+          publishIntegrationEventReceived: webhookOptions.publishIntegrationEventReceived,
+          recordDeliveryOnly: webhookOptions.recordDeliveryOnly,
+          getIntegrationConnectionById: webhookOptions.getIntegrationConnectionById,
+          processor: webhookProcessor,
+        }),
+      ]
+    : [];
   const routes = options.routes
-    ? [createJiraIntegrationRoutes({jira, connectionCapabilities: [], ...options.routes})]
+    ? [
+        createJiraIntegrationRoutes({
+          jira,
+          connectionCapabilities: adapters.agent_tools ? ['agent_tools'] : [],
+          ...options.routes,
+          registerJiraWebhook: (input) =>
+            registerJiraWebhook({
+              jira,
+              connectionId: input.connectionId,
+              cloudId: input.cloudId,
+              accessToken: input.accessToken,
+              webhookUrl: jiraWebhookUrl(input.connectionId),
+              ...(input.withRegistrationLock
+                ? {withRegistrationLock: input.withRegistrationLock}
+                : {}),
+              ...(input.onRegistrationSuccess
+                ? {onRegistrationSuccess: input.onRegistrationSuccess}
+                : {}),
+              ...(input.onRegistrationFailure
+                ? {onRegistrationFailure: input.onRegistrationFailure}
+                : {}),
+            }).then(() => undefined),
+        }),
+        ...webhookRoutes,
+      ]
     : [];
   return {
     provider: JIRA_PROVIDER,
     displayName: 'Jira',
-    adapters: {},
+    adapters,
     async connectionExternalUrl(connection: {id: string}): Promise<string | undefined> {
       return (await getInstallationByConnectionId(connection.id))?.siteUrl;
     },
     routes,
+    webhookProcessors: webhookProcessor
+      ? [{routeIds: ['jira'] as const, processor: webhookProcessor}]
+      : undefined,
+  };
+}
+
+function jiraWebhookUrl(connectionId: string): string {
+  return `${config.JIRA_WEBHOOK_BASE_URL.replace(TRAILING_SLASHES_RE, '')}${JIRA_WEBHOOK_ROUTE_PREFIX}/${connectionId}`;
+}
+
+function toJiraWebhookOptions(
+  routes: CreateJiraIntegrationProviderOptions['routes'],
+): CreateJiraWebhookRoutesOptions | undefined {
+  if (!routes) return undefined;
+  if (
+    routes.coreDb === undefined ||
+    routes.publishIntegrationEventReceived === undefined ||
+    routes.recordDeliveryOnly === undefined ||
+    routes.getIntegrationConnectionById === undefined
+  )
+    throw new Error(
+      'Jira integration provider requires all webhook receiver dependencies: coreDb, publishIntegrationEventReceived, recordDeliveryOnly, and getIntegrationConnectionById',
+    );
+  return {
+    coreDb: routes.coreDb,
+    publishIntegrationEventReceived: routes.publishIntegrationEventReceived,
+    recordDeliveryOnly: routes.recordDeliveryOnly,
+    getIntegrationConnectionById: routes.getIntegrationConnectionById,
   };
 }

package/src/presentation/routes/install.ts

@@ -25,6 +25,7 @@ import type {JiraPendingSelectionStore} from '#core/pending.js';
 import {formatJiraOAuthScopes} from '#core/scopes.js';
 import {signJiraInstallState} from '#core/state.js';
 import type {JiraTokenStore} from '#core/tokens.js';
+import type {JiraInstallationLock} from '#db/installations.js';
 import {toIntegrationConnectionDto} from '#presentation/dto/integrations.js';
 import {jiraRouteErrorHandler} from './errors.js';
 
@@ -38,6 +39,17 @@ export interface CreateJiraIntegrationRoutesOptions {
   connectJiraInstallation(
     input: ConnectJiraInstallationInput,
   ): Promise<IntegrationConnection<'jira'>>;
+  registerJiraWebhook(input: {
+    connectionId: string;
+    cloudId: string;
+    accessToken: string;
+    withRegistrationLock?: JiraInstallationLock;
+    onRegistrationSuccess: (input: {tx?: unknown}) => Promise<void>;
+    onRegistrationFailure: (input: {tx?: unknown}) => Promise<void>;
+  }): Promise<void>;
+  withJiraInstallationLock?: JiraInstallationLock;
+  markConnectionActive(input: {connectionId: string; tx?: unknown}): Promise<void>;
+  markConnectionError(input: {connectionId: string; tx?: unknown}): Promise<void>;
   disconnectJiraInstallation(input: {connectionId: string}): Promise<void>;
   connectionCapabilities: IntegrationCapability[];
   requireActiveWorkspaceMembership?: (input: {

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

@@ -0,0 +1,132 @@
+import {Buffer} from 'node:buffer';
+import {WEBHOOK_MAX_RAW_BODY_BYTES} from '@shipfox/api-integration-spi';
+import {closeApp, createApp} from '@shipfox/node-fastify';
+import type {FastifyInstance} from 'fastify';
+import type {JiraWebhookProcessor} from '#core/webhook-processor.js';
+import {createJiraWebhookRoutes} from './webhooks.js';
+
+function createTestApp(processor: JiraWebhookProcessor): Promise<FastifyInstance> {
+  return createApp({
+    routes: [
+      createJiraWebhookRoutes({
+        coreDb: vi.fn() as never,
+        publishIntegrationEventReceived: vi.fn() as never,
+        recordDeliveryOnly: vi.fn() as never,
+        getIntegrationConnectionById: vi.fn() as never,
+        processor,
+      }),
+    ],
+    swagger: false,
+  });
+}
+
+describe('Jira webhook route', () => {
+  afterEach(async () => {
+    await closeApp();
+  });
+
+  it('stores the connection path and lower-case authorization header', async () => {
+    const process = vi.fn().mockResolvedValue({outcome: 'processed', deliveryId: 'delivery-1'});
+    const processor = {process: process as JiraWebhookProcessor['process']};
+    const app = await createTestApp(processor);
+    const connectionId = 'c0a8012e-0b6d-4d8f-8d5c-6d74102602b0';
+
+    const response = await app.inject({
+      method: 'POST',
+      url: `/webhooks/integrations/jira/${connectionId}`,
+      headers: {
+        authorization: 'Bearer signed-token',
+        'content-type': 'application/json',
+        'x-atlassian-webhook-identifier': 'jira-delivery-1',
+      },
+      payload: '{}',
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(process).toHaveBeenCalledWith(
+      expect.objectContaining({
+        route_id: 'jira',
+        path_parameters: {connection_id: connectionId},
+        headers: {
+          authorization: 'Bearer signed-token',
+          'content-type': 'application/json',
+          'x-atlassian-webhook-identifier': 'jira-delivery-1',
+        },
+      }),
+    );
+  });
+
+  it('returns 401 for an authentication failure without recording a delivery', async () => {
+    const process = vi.fn().mockResolvedValue({
+      outcome: 'discarded',
+      reason: 'invalid_signature',
+      deliveryId: 'delivery-1',
+    });
+    const processor = {process: process as JiraWebhookProcessor['process']};
+    const app = await createTestApp(processor);
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/jira/c0a8012e-0b6d-4d8f-8d5c-6d74102602b0',
+      headers: {'content-type': 'application/json'},
+      payload: '{}',
+    });
+
+    expect(response.statusCode).toBe(401);
+    expect(response.json()).toEqual({error: 'invalid authorization'});
+  });
+
+  it.each([
+    ['a processed delivery', {outcome: 'processed', deliveryId: 'delivery-1'}],
+    ['a duplicate delivery', {outcome: 'duplicate', deliveryId: 'delivery-1'}],
+    ['a deliberate drop', {outcome: 'discarded', reason: 'connection_unavailable'}],
+  ] as const)('returns 200 for %s', async (_description, result) => {
+    const process = vi.fn().mockResolvedValue(result);
+    const app = await createTestApp({process: process as JiraWebhookProcessor['process']});
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/jira/c0a8012e-0b6d-4d8f-8d5c-6d74102602b0',
+      headers: {authorization: 'Bearer signed-token', 'content-type': 'application/json'},
+      payload: '{}',
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(process).toHaveBeenCalledOnce();
+  });
+
+  it('returns 400 for a malformed payload result', async () => {
+    const process = vi.fn().mockResolvedValue({
+      outcome: 'discarded',
+      reason: 'malformed_payload',
+      deliveryId: 'delivery-1',
+    });
+    const app = await createTestApp({process: process as JiraWebhookProcessor['process']});
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/jira/c0a8012e-0b6d-4d8f-8d5c-6d74102602b0',
+      headers: {authorization: 'Bearer signed-token', 'content-type': 'application/json'},
+      payload: '{}',
+    });
+
+    expect(response.statusCode).toBe(400);
+    expect(response.json()).toEqual({error: 'malformed JSON'});
+    expect(process).toHaveBeenCalledOnce();
+  });
+
+  it('returns 413 for oversized input without invoking the processor', async () => {
+    const process = vi.fn();
+    const app = await createTestApp({process: process as JiraWebhookProcessor['process']});
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/webhooks/integrations/jira/c0a8012e-0b6d-4d8f-8d5c-6d74102602b0',
+      headers: {authorization: 'Bearer signed-token', 'content-type': 'application/json'},
+      payload: Buffer.alloc(WEBHOOK_MAX_RAW_BODY_BYTES + 1, 97),
+    });
+
+    expect(response.statusCode).toBe(413);
+    expect(process).not.toHaveBeenCalled();
+  });
+});

package/src/presentation/routes/webhooks.ts

@@ -0,0 +1,115 @@
+import {randomUUID} from 'node:crypto';
+import type {StoredWebhookRequest, WebhookProcessingResult} from '@shipfox/api-integration-spi';
+import {createStoredWebhookRequest, WEBHOOK_MAX_RAW_BODY_BYTES} from '@shipfox/api-integration-spi';
+import {
+  ClientError,
+  defineRoute,
+  type RouteGroup,
+  rawBodyPlugin,
+  WEBHOOK_BODY_LIMIT,
+} from '@shipfox/node-fastify';
+import {z} from 'zod';
+import {
+  type CreateJiraWebhookProcessorOptions,
+  createJiraWebhookProcessor,
+  type JiraWebhookProcessor,
+} from '#core/webhook-processor.js';
+
+const jiraWebhookParamsSchema = z.object({connectionId: z.string().uuid()});
+export const JIRA_WEBHOOK_ROUTE_PREFIX = '/webhooks/integrations/jira';
+
+export interface CreateJiraWebhookRoutesOptions
+  extends Omit<CreateJiraWebhookProcessorOptions, 'getJiraInstallationByConnectionId'> {
+  processor?: JiraWebhookProcessor | undefined;
+}
+
+export function createJiraWebhookRoutes(options: CreateJiraWebhookRoutesOptions): RouteGroup {
+  const processor = options.processor ?? createJiraWebhookProcessor(options);
+  const route = defineRoute({
+    method: 'POST',
+    path: '/:connectionId',
+    auth: [],
+    description: 'Jira dynamic webhook receiver.',
+    options: {bodyLimit: WEBHOOK_BODY_LIMIT},
+    schema: {params: jiraWebhookParamsSchema},
+    handler: async (request, reply) => {
+      const body = request.body;
+      if (!(body instanceof Uint8Array)) {
+        throw new ClientError('Expected raw JSON body', 'invalid-webhook-request', {status: 400});
+      }
+      const result = await processor.process(
+        createJiraStoredWebhookRequest({
+          body,
+          connectionId: request.params.connectionId,
+          headers: request.headers,
+          rawQueryString: request.raw.url?.split('?')[1] ?? '',
+        }),
+      );
+      return sendJiraWebhookResponse(reply, result);
+    },
+  });
+
+  return {
+    prefix: JIRA_WEBHOOK_ROUTE_PREFIX,
+    auth: [],
+    plugins: [rawBodyPlugin],
+    routes: [route],
+  };
+}
+
+function createJiraStoredWebhookRequest(input: {
+  body: Uint8Array;
+  connectionId: string;
+  headers: Record<string, string | string[] | undefined>;
+  rawQueryString: string;
+}): StoredWebhookRequest {
+  if (input.body.byteLength > WEBHOOK_MAX_RAW_BODY_BYTES) {
+    throw new ClientError('Webhook request body is too large', 'body-too-large', {status: 413});
+  }
+  try {
+    return createStoredWebhookRequest({
+      requestId: randomUUID(),
+      routeId: 'jira',
+      receivedAt: new Date().toISOString(),
+      rawQueryString: input.rawQueryString,
+      headers: jiraWebhookHeaders(input.headers),
+      body: input.body,
+      connectionId: input.connectionId,
+    });
+  } catch (error) {
+    throw new ClientError('Webhook request metadata is invalid', 'invalid-webhook-request', {
+      cause: error,
+    });
+  }
+}
+
+function jiraWebhookHeaders(
+  headers: Record<string, string | string[] | undefined>,
+): Record<string, string> {
+  return Object.fromEntries(
+    ['authorization', 'content-type', 'x-atlassian-webhook-identifier'].flatMap((name) => {
+      const value = headers[name];
+      return typeof value === 'string' ? [[name, value]] : [];
+    }),
+  );
+}
+
+function sendJiraWebhookResponse(
+  reply: {code(statusCode: number): void},
+  result: WebhookProcessingResult,
+) {
+  if (result.outcome !== 'discarded') {
+    reply.code(200);
+    return null;
+  }
+  if (result.reason === 'invalid_signature' || result.reason === 'missing_required_input') {
+    reply.code(401);
+    return {error: 'invalid authorization'};
+  }
+  if (result.reason === 'malformed_payload') {
+    reply.code(400);
+    return {error: 'malformed JSON'};
+  }
+  reply.code(200);
+  return null;
+}

package/src/temporal/activities/index.ts

@@ -0,0 +1,5 @@
+export {
+  type CreateJiraMaintenanceActivitiesOptions,
+  createJiraMaintenanceActivities,
+  type JiraTokenRefreshActivityResult,
+} from './refresh-jira-tokens.js';