@shipfox/api-integration-core 3.0.0 → 5.0.0

package/src/providers/linear.test.ts

@@ -0,0 +1,136 @@
+import {
+  getLinearInstallationByConnectionId,
+  upsertLinearInstallation,
+} from '@shipfox/api-integration-linear';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {getIntegrationConnectionById, upsertIntegrationConnection} from '#db/connections.js';
+import {db} from '#db/db.js';
+import {linearProviderModule} from '#providers/linear.js';
+import {createTestApp, useIntegrationRouteTest} from '#test/route-utils.js';
+
+describe('linearProviderModule', () => {
+  const context = useIntegrationRouteTest();
+
+  it('deletes the installation and tokens through the generic route before allowing a reinstall', async () => {
+    const deleteSecrets = vi.fn(() => Promise.resolve(2));
+    const scopedSecrets = {
+      getSecret: vi.fn(() => Promise.resolve(null)),
+      setSecrets: vi.fn(() => Promise.resolve()),
+      deleteSecrets,
+    };
+    const linearPart = await linearProviderModule.load({
+      secrets: {linear: scopedSecrets, deleteSecrets},
+    });
+    if (!linearPart.database) throw new Error('Linear provider database is not configured');
+    const organizationId = crypto.randomUUID();
+
+    await runMigrations(
+      linearPart.database.db(),
+      linearPart.database.migrationsPath,
+      linearPart.database.migrationsTableName,
+    );
+    const app = await createTestApp([linearPart.provider]);
+    const connection = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'linear',
+      externalAccountId: organizationId,
+      slug: 'linear_acme',
+      displayName: 'Linear Acme',
+    });
+    await upsertLinearInstallation({
+      connectionId: connection.id,
+      organizationId,
+      organizationUrlKey: 'acme',
+      appUserId: 'user-1',
+      scopes: ['read'],
+      status: 'installed',
+      tokenExpiresAt: null,
+    });
+
+    const res = await app.inject({
+      method: 'DELETE',
+      url: `/integration-connections/${connection.id}`,
+      headers: {authorization: 'Bearer user'},
+    });
+
+    expect(res.statusCode).toBe(204);
+    await expect(getIntegrationConnectionById(connection.id)).resolves.toBeUndefined();
+    await expect(getLinearInstallationByConnectionId(connection.id)).resolves.toBeUndefined();
+    expect(deleteSecrets).toHaveBeenCalledWith({
+      workspaceId: context.workspaceId,
+      namespace: connection.id,
+    });
+
+    const replacement = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'linear',
+      externalAccountId: organizationId,
+      slug: 'linear_acme_again',
+      displayName: 'Linear Acme',
+    });
+    await upsertLinearInstallation({
+      connectionId: replacement.id,
+      organizationId,
+      organizationUrlKey: 'acme',
+      appUserId: 'user-1',
+      scopes: ['read'],
+      status: 'installed',
+      tokenExpiresAt: null,
+    });
+
+    await expect(getLinearInstallationByConnectionId(replacement.id)).resolves.toMatchObject({
+      organizationId,
+    });
+  });
+
+  it('rolls back provider record cleanup when its transaction fails', async () => {
+    const deleteSecrets = vi.fn(() => Promise.resolve(2));
+    const scopedSecrets = {
+      getSecret: vi.fn(() => Promise.resolve(null)),
+      setSecrets: vi.fn(() => Promise.resolve()),
+      deleteSecrets,
+    };
+    const linearPart = await linearProviderModule.load({
+      secrets: {linear: scopedSecrets, deleteSecrets},
+    });
+    if (!linearPart.database) throw new Error('Linear provider database is not configured');
+    const organizationId = crypto.randomUUID();
+
+    await runMigrations(
+      linearPart.database.db(),
+      linearPart.database.migrationsPath,
+      linearPart.database.migrationsTableName,
+    );
+    const connection = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'linear',
+      externalAccountId: organizationId,
+      slug: 'linear_acme',
+      displayName: 'Linear Acme',
+    });
+    await upsertLinearInstallation({
+      connectionId: connection.id,
+      organizationId,
+      organizationUrlKey: 'acme',
+      appUserId: 'user-1',
+      scopes: ['read'],
+      status: 'installed',
+      tokenExpiresAt: null,
+    });
+
+    await expect(
+      db().transaction(async (tx) => {
+        await linearPart.provider.deleteConnectionRecords?.(connection, {tx});
+        throw new Error('transaction failed');
+      }),
+    ).rejects.toThrow('transaction failed');
+
+    await expect(getIntegrationConnectionById(connection.id)).resolves.toMatchObject({
+      id: connection.id,
+    });
+    await expect(getLinearInstallationByConnectionId(connection.id)).resolves.toMatchObject({
+      connectionId: connection.id,
+    });
+    expect(deleteSecrets).not.toHaveBeenCalled();
+  });
+});

package/src/providers/linear.ts

@@ -32,9 +32,11 @@ async function loadLinearModuleParts(
     createLinearE2eRoutes,
     createLinearIntegrationProvider,
     config: linearConfig,
+    deleteLinearInstallationByConnectionId,
     disconnectLinearInstallation: disconnectLinearInstallationRecords,
     getLinearInstallationByOrganizationId,
     db: linearDb,
+    linearSecretsNamespace,
     migrationsPath: linearMigrationsPath,
     upsertLinearInstallation,
   } = await import('@shipfox/api-integration-linear');
@@ -137,6 +139,18 @@ async function loadLinearModuleParts(
   return {
     provider: createLinearIntegrationProvider({
       agentTools: {tokenStore, endpoint: linearConfig.LINEAR_MCP_ENDPOINT},
+      cleanup: {
+        deleteConnectionRecords: async (connection, {tx}) => {
+          await deleteLinearInstallationByConnectionId(connection.id, {tx});
+        },
+        deleteConnectionSecrets: async (connection) => {
+          // Scoped secrets accept the provider-local suffix, after this helper validates its prefix.
+          await (options.secrets?.linear?.deleteSecrets({
+            workspaceId: connection.workspaceId,
+            namespace: linearNamespaceSuffix(linearSecretsNamespace(connection.id)),
+          }) ?? Promise.resolve());
+        },
+      },
       routes: {
         tokenStore,
         getExistingLinearConnection,

package/src/providers/modules.test.ts

@@ -37,4 +37,30 @@ describe('loadEnabledProviderModules', () => {
       adapters: {},
     });
   });
+
+  it('loads Slack when the provider is enabled', async () => {
+    vi.stubEnv('INTEGRATIONS_ENABLE_SLACK_PROVIDER', 'true');
+    vi.resetModules();
+
+    const {loadEnabledProviderModules} = await import('#providers/modules.js');
+    const parts = await loadEnabledProviderModules();
+
+    expect(parts.map((part) => part.provider.provider)).toEqual(['slack', 'cron', 'webhook']);
+    expect(parts[0]?.provider).toMatchObject({
+      provider: 'slack',
+      displayName: 'Slack',
+    });
+    expect(parts[0]?.provider.adapters?.agent_tools).toBeDefined();
+  });
+
+  it('loads Jira when the provider is enabled', async () => {
+    vi.stubEnv('INTEGRATIONS_ENABLE_JIRA_PROVIDER', 'true');
+    vi.resetModules();
+
+    const {loadEnabledProviderModules} = await import('#providers/modules.js');
+    const parts = await loadEnabledProviderModules();
+
+    expect(parts.map((part) => part.provider.provider)).toEqual(['jira', 'cron', 'webhook']);
+    expect(parts[0]?.provider).toMatchObject({provider: 'jira', displayName: 'Jira'});
+  });
 });

package/src/providers/modules.ts

@@ -1,8 +1,10 @@
 import {cronProviderModule} from '#providers/cron.js';
 import {giteaProviderModule} from '#providers/gitea.js';
 import {githubProviderModule} from '#providers/github.js';
+import {jiraProviderModule} from '#providers/jira.js';
 import {linearProviderModule} from '#providers/linear.js';
 import {sentryProviderModule} from '#providers/sentry.js';
+import {slackProviderModule} from '#providers/slack.js';
 import type {
   IntegrationModuleParts,
   IntegrationProviderModuleLoadOptions,
@@ -14,6 +16,8 @@ import {webhookProviderModule} from '#providers/webhook.js';
 const providerModules = [
   githubProviderModule,
   linearProviderModule,
+  slackProviderModule,
+  jiraProviderModule,
   sentryProviderModule,
   giteaProviderModule,
   cronProviderModule,

package/src/providers/slack.test.ts

@@ -0,0 +1,196 @@
+import {
+  getSlackInstallationByConnectionId,
+  upsertSlackInstallation,
+} from '@shipfox/api-integration-slack';
+import {runMigrations} from '@shipfox/node-drizzle';
+import {getIntegrationConnectionById, upsertIntegrationConnection} from '#db/connections.js';
+import {db} from '#db/db.js';
+import {createTestApp, useIntegrationRouteTest} from '#test/route-utils.js';
+
+describe('slackProviderModule', () => {
+  const context = useIntegrationRouteTest();
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.resetModules();
+  });
+
+  it('loads its database descriptor and persists a core connection with its Slack installation', async () => {
+    vi.stubEnv('INTEGRATIONS_ENABLE_SLACK_PROVIDER', 'true');
+    vi.resetModules();
+    const {createPostgresClient} = await import('@shipfox/node-postgres');
+    createPostgresClient();
+    const {loadEnabledProviderModules} = await import('#providers/modules.js');
+    const parts = await loadEnabledProviderModules();
+    const slackPart = parts.find((part) => part.provider.provider === 'slack');
+    if (!slackPart?.database) throw new Error('Slack provider database is not configured');
+    const workspaceId = crypto.randomUUID();
+    const teamId = `T${crypto.randomUUID()}`;
+
+    await runMigrations(
+      slackPart.database.db(),
+      slackPart.database.migrationsPath,
+      slackPart.database.migrationsTableName,
+    );
+    const connection = await upsertIntegrationConnection({
+      workspaceId,
+      provider: 'slack',
+      externalAccountId: teamId,
+      slug: `slack_${teamId}`,
+      displayName: 'Slack Acme',
+    });
+    await upsertSlackInstallation({
+      connectionId: connection.id,
+      teamId,
+      teamName: 'Acme',
+      appId: 'A123',
+      botUserId: 'U123',
+      scopes: ['app_mentions:read'],
+      status: 'installed',
+    });
+
+    await expect(getIntegrationConnectionById(connection.id)).resolves.toMatchObject({
+      id: connection.id,
+      provider: 'slack',
+    });
+    await expect(getSlackInstallationByConnectionId(connection.id)).resolves.toMatchObject({
+      connectionId: connection.id,
+      teamId,
+    });
+  });
+
+  it('deletes the installation and token through the generic route before allowing a reinstall', async () => {
+    vi.stubEnv('INTEGRATIONS_ENABLE_SLACK_PROVIDER', 'true');
+    vi.resetModules();
+    const deleteSecrets = vi.fn(() => Promise.resolve(1));
+    const scopedSecrets = {
+      getSecret: vi.fn(() => Promise.resolve(null)),
+      setSecrets: vi.fn(() => Promise.resolve()),
+      deleteSecrets,
+    };
+    const {createPostgresClient} = await import('@shipfox/node-postgres');
+    createPostgresClient();
+    const {loadEnabledProviderModules} = await import('#providers/modules.js');
+    const parts = await loadEnabledProviderModules({
+      secrets: {slack: scopedSecrets, deleteSecrets},
+    });
+    const slackPart = parts.find((part) => part.provider.provider === 'slack');
+    if (!slackPart?.database) throw new Error('Slack provider database is not configured');
+    const teamId = `T${crypto.randomUUID()}`;
+
+    await runMigrations(
+      slackPart.database.db(),
+      slackPart.database.migrationsPath,
+      slackPart.database.migrationsTableName,
+    );
+    const app = await createTestApp([slackPart.provider]);
+    const connection = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'slack',
+      externalAccountId: teamId,
+      slug: `slack_${teamId}`,
+      displayName: 'Slack Acme',
+    });
+    await upsertSlackInstallation({
+      connectionId: connection.id,
+      teamId,
+      teamName: 'Acme',
+      appId: 'A123',
+      botUserId: 'U123',
+      scopes: ['app_mentions:read'],
+      status: 'installed',
+    });
+
+    const res = await app.inject({
+      method: 'DELETE',
+      url: `/integration-connections/${connection.id}`,
+      headers: {authorization: 'Bearer user'},
+    });
+
+    expect(res.statusCode).toBe(204);
+    await expect(getIntegrationConnectionById(connection.id)).resolves.toBeUndefined();
+    await expect(getSlackInstallationByConnectionId(connection.id)).resolves.toBeUndefined();
+    expect(deleteSecrets).toHaveBeenCalledWith({
+      workspaceId: context.workspaceId,
+      namespace: connection.id,
+    });
+
+    const replacement = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'slack',
+      externalAccountId: teamId,
+      slug: `slack_${teamId}_again`,
+      displayName: 'Slack Acme',
+    });
+    await upsertSlackInstallation({
+      connectionId: replacement.id,
+      teamId,
+      teamName: 'Acme',
+      appId: 'A123',
+      botUserId: 'U123',
+      scopes: ['app_mentions:read'],
+      status: 'installed',
+    });
+
+    await expect(getSlackInstallationByConnectionId(replacement.id)).resolves.toMatchObject({
+      teamId,
+    });
+  });
+
+  it('rolls back provider record cleanup when its transaction fails', async () => {
+    vi.stubEnv('INTEGRATIONS_ENABLE_SLACK_PROVIDER', 'true');
+    vi.resetModules();
+    const deleteSecrets = vi.fn(() => Promise.resolve(1));
+    const scopedSecrets = {
+      getSecret: vi.fn(() => Promise.resolve(null)),
+      setSecrets: vi.fn(() => Promise.resolve()),
+      deleteSecrets,
+    };
+    const {createPostgresClient} = await import('@shipfox/node-postgres');
+    createPostgresClient();
+    const {loadEnabledProviderModules} = await import('#providers/modules.js');
+    const parts = await loadEnabledProviderModules({
+      secrets: {slack: scopedSecrets, deleteSecrets},
+    });
+    const slackPart = parts.find((part) => part.provider.provider === 'slack');
+    if (!slackPart?.database) throw new Error('Slack provider database is not configured');
+    const teamId = `T${crypto.randomUUID()}`;
+
+    await runMigrations(
+      slackPart.database.db(),
+      slackPart.database.migrationsPath,
+      slackPart.database.migrationsTableName,
+    );
+    const connection = await upsertIntegrationConnection({
+      workspaceId: context.workspaceId,
+      provider: 'slack',
+      externalAccountId: teamId,
+      slug: `slack_${teamId}`,
+      displayName: 'Slack Acme',
+    });
+    await upsertSlackInstallation({
+      connectionId: connection.id,
+      teamId,
+      teamName: 'Acme',
+      appId: 'A123',
+      botUserId: 'U123',
+      scopes: ['app_mentions:read'],
+      status: 'installed',
+    });
+
+    await expect(
+      db().transaction(async (tx) => {
+        await slackPart.provider.deleteConnectionRecords?.(connection, {tx});
+        throw new Error('transaction failed');
+      }),
+    ).rejects.toThrow('transaction failed');
+
+    await expect(getIntegrationConnectionById(connection.id)).resolves.toMatchObject({
+      id: connection.id,
+    });
+    await expect(getSlackInstallationByConnectionId(connection.id)).resolves.toMatchObject({
+      connectionId: connection.id,
+    });
+    expect(deleteSecrets).not.toHaveBeenCalled();
+  });
+});

package/src/providers/slack.ts

@@ -0,0 +1,196 @@
+import {
+  type IntegrationConnection as CoreIntegrationConnection,
+  slugifyConnectionSlug,
+} from '@shipfox/api-integration-core-dto';
+import type {
+  ConnectSlackInstallationInput,
+  SlackSecretsStore,
+} from '@shipfox/api-integration-slack';
+import {config} from '#config.js';
+import {
+  deleteIntegrationConnection,
+  getIntegrationConnectionById,
+  resolveUniqueConnectionSlug,
+  upsertIntegrationConnection,
+} from '#db/connections.js';
+import {db} from '#db/db.js';
+import {
+  claimWebhookDelivery,
+  publishIntegrationEventReceived,
+  recordDeliveryOnly,
+} from '#db/webhook-deliveries.js';
+import {retryConnectionSlugCollision} from '#providers/connection-slug.js';
+import type {IntegrationModuleParts, IntegrationProviderModule} from '#providers/types.js';
+
+const SLACK_MIGRATIONS_TABLE = '__drizzle_migrations_integrations_slack';
+const SLACK_SECRETS_NAMESPACE_PREFIX = 'system/integrations/slack/';
+
+type IntegrationDb = ReturnType<typeof db>;
+type IntegrationTx = Parameters<Parameters<IntegrationDb['transaction']>[0]>[0];
+
+async function loadSlackModuleParts(
+  options: Parameters<IntegrationProviderModule['load']>[0] = {},
+): Promise<IntegrationModuleParts> {
+  const {
+    createSlackE2eRoutes,
+    createSlackIntegrationProvider,
+    createSlackTokenStore,
+    db: slackDb,
+    deleteSlackInstallationByConnectionId,
+    disconnectSlackInstallation: disconnectSlackInstallationRecords,
+    getSlackInstallationByTeamId,
+    migrationsPath: slackMigrationsPath,
+    slackSecretsNamespace,
+    upsertSlackInstallation,
+  } = await import('@shipfox/api-integration-slack');
+
+  async function getExistingSlackConnection(input: {
+    teamId: string;
+  }): Promise<CoreIntegrationConnection<'slack'> | undefined> {
+    const installation = await getSlackInstallationByTeamId(input.teamId);
+    if (!installation) return undefined;
+    const connection = await getIntegrationConnectionById(installation.connectionId);
+    if (!connection) return undefined;
+    return connection as CoreIntegrationConnection<'slack'>;
+  }
+
+  async function connectSlackInstallation(
+    input: ConnectSlackInstallationInput,
+  ): Promise<CoreIntegrationConnection<'slack'>> {
+    return await retryConnectionSlugCollision(() =>
+      db().transaction(async (tx) => {
+        const baseSlug = slugifyConnectionSlug(`slack_${input.teamName || input.teamId}`, {
+          fallback: 'slack',
+        });
+        const slug = await resolveUniqueConnectionSlug(
+          {
+            workspaceId: input.workspaceId,
+            provider: 'slack',
+            externalAccountId: input.teamId,
+            baseSlug,
+          },
+          {tx},
+        );
+        const connection = await upsertIntegrationConnection(
+          {
+            workspaceId: input.workspaceId,
+            provider: 'slack',
+            externalAccountId: input.teamId,
+            slug,
+            displayName: input.displayName,
+            lifecycleStatus: 'active',
+          },
+          {tx},
+        );
+        await upsertSlackInstallation(
+          {
+            connectionId: connection.id,
+            teamId: input.teamId,
+            teamName: input.teamName,
+            appId: input.appId,
+            botUserId: input.botUserId,
+            scopes: input.scopes,
+            tokenExpiresAt: input.tokenExpiresAt,
+            status: 'installed',
+          },
+          {tx},
+        );
+        return connection as CoreIntegrationConnection<'slack'>;
+      }),
+    );
+  }
+
+  async function disconnectSlackInstallation(input: {connectionId: string}): Promise<void> {
+    await disconnectSlackInstallationRecords<IntegrationTx>({
+      connectionId: input.connectionId,
+      getConnection: getIntegrationConnectionById,
+      deleteSecrets: (params) =>
+        options.secrets?.slack?.deleteSecrets({
+          ...params,
+          namespace: slackNamespaceSuffix(params.namespace),
+        }) ?? Promise.resolve(0),
+      transaction: (fn) => db().transaction((tx) => fn(tx)),
+      deleteConnection: (params, options) =>
+        deleteIntegrationConnection({id: params.connectionId}, options),
+    });
+  }
+
+  const fallbackSecrets: SlackSecretsStore = {
+    getSecret: () => Promise.resolve(null),
+    setSecrets: () => Promise.reject(new Error('Slack token storage is not configured')),
+  };
+  const secrets: SlackSecretsStore = options.secrets?.slack
+    ? {
+        getSecret: (params: Parameters<SlackSecretsStore['getSecret']>[0]) =>
+          options.secrets?.slack?.getSecret({
+            ...params,
+            namespace: slackNamespaceSuffix(params.namespace),
+          }) ?? Promise.resolve(null),
+        setSecrets: (params: Parameters<SlackSecretsStore['setSecrets']>[0]) =>
+          options.secrets?.slack?.setSecrets({
+            ...params,
+            namespace: slackNamespaceSuffix(params.namespace),
+          }) ?? Promise.resolve(),
+      }
+    : fallbackSecrets;
+  const tokenStore = createSlackTokenStore({
+    resolveConnection: async (connectionId) => getIntegrationConnectionById(connectionId),
+    secrets,
+  });
+
+  return {
+    provider: createSlackIntegrationProvider({
+      agentTools: {tokenStore},
+      cleanup: {
+        deleteConnectionRecords: async (connection, {tx}) => {
+          await deleteSlackInstallationByConnectionId(connection.id, {tx});
+        },
+        deleteConnectionSecrets: async (connection) => {
+          // Scoped secrets accept the provider-local suffix, after this helper validates its prefix.
+          await (options.secrets?.slack?.deleteSecrets({
+            workspaceId: connection.workspaceId,
+            namespace: slackNamespaceSuffix(slackSecretsNamespace(connection.id)),
+          }) ?? Promise.resolve());
+        },
+      },
+      routes: {
+        tokenStore,
+        getExistingSlackConnection,
+        connectSlackInstallation,
+        disconnectSlackInstallation,
+        coreDb: db,
+        claimWebhookDelivery,
+        publishIntegrationEventReceived,
+        recordDeliveryOnly,
+        getIntegrationConnectionById,
+      },
+    }),
+    e2eRoutes: [
+      createSlackE2eRoutes({
+        tokenStore,
+        getExistingSlackConnection,
+        connectSlackInstallation,
+        disconnectSlackInstallation,
+        connectionCapabilities: ['agent_tools'],
+      }),
+    ],
+    database: {
+      db: slackDb,
+      migrationsPath: slackMigrationsPath,
+      migrationsTableName: SLACK_MIGRATIONS_TABLE,
+    },
+  };
+}
+
+export const slackProviderModule: IntegrationProviderModule = {
+  id: 'slack',
+  enabled: config.INTEGRATIONS_ENABLE_SLACK_PROVIDER,
+  load: loadSlackModuleParts,
+};
+
+function slackNamespaceSuffix(namespace: string): string {
+  if (!namespace.startsWith(SLACK_SECRETS_NAMESPACE_PREFIX)) {
+    throw new Error('Slack provider attempted to access an unscoped secret namespace');
+  }
+  return namespace.slice(SLACK_SECRETS_NAMESPACE_PREFIX.length);
+}

package/src/providers/types.ts

@@ -36,7 +36,9 @@ export interface IntegrationProviderModuleLoadOptions {
 
 export interface IntegrationProviderSecrets {
   github?: IntegrationProviderScopedSecrets | undefined;
+  jira?: IntegrationProviderScopedSecrets | undefined;
   linear?: IntegrationProviderScopedSecrets | undefined;
+  slack?: IntegrationProviderScopedSecrets | undefined;
   deleteSecrets(params: {workspaceId: string; namespace: string}): Promise<number>;
 }
 

package/test/env.ts

@@ -12,11 +12,23 @@ process.env.GITHUB_APP_CLIENT_SECRET = 'test-client-secret';
 process.env.GITHUB_APP_WEBHOOK_SECRET = 'test-webhook-secret';
 process.env.GITHUB_APP_SLUG = 'shipfox-test';
 process.env.GITHUB_INSTALL_STATE_SECRET = 'test-install-state-secret';
+process.env.JIRA_OAUTH_CLIENT_ID = 'test-client-id';
+process.env.JIRA_OAUTH_CLIENT_SECRET = 'test-client-secret';
+process.env.JIRA_OAUTH_REDIRECT_URL = 'https://shipfox.example.com/integrations/jira/callback';
+process.env.JIRA_WEBHOOK_SIGNING_SECRET = 'test-webhook-secret';
+process.env.JIRA_WEBHOOK_BASE_URL = 'https://shipfox.example.com';
+process.env.JIRA_API_BASE_URL = 'https://jira.example.com/api';
+process.env.JIRA_AUTH_BASE_URL = 'https://jira.example.com/auth';
 process.env.LINEAR_OAUTH_CLIENT_ID = 'test-client-id';
 process.env.LINEAR_OAUTH_CLIENT_SECRET = 'test-client-secret';
 process.env.LINEAR_WEBHOOK_SIGNING_SECRET = 'test-webhook-secret';
 process.env.LINEAR_OAUTH_REDIRECT_URL = 'https://shipfox.example.com/integrations/linear/callback';
 process.env.LINEAR_MCP_ENDPOINT = 'https://mcp.linear.app/mcp';
+process.env.SLACK_OAUTH_CLIENT_ID = 'test-client-id';
+process.env.SLACK_OAUTH_CLIENT_SECRET = 'test-client-secret';
+process.env.SLACK_SIGNING_SECRET = 'test-signing-secret';
+process.env.SLACK_OAUTH_REDIRECT_URL = 'https://shipfox.example.com/integrations/slack/callback';
+process.env.SLACK_API_BASE_URL = 'https://slack.example.com/api';
 process.env.GITEA_BASE_URL = 'https://gitea.example.com';
 process.env.GITEA_SERVICE_USERNAME = 'shipfox-bot';
 process.env.GITEA_SERVICE_TOKEN = 'test-service-token';