@shipfox/client-integrations 13.0.0 → 14.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/client-integrations",
   "license": "MIT",
-  "version": "13.0.0",
+  "version": "14.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -28,18 +28,19 @@
     "@swc/helpers": "^0.5.17",
     "@tanstack/react-form": "^1.32.0",
     "@shipfox/api-integration-core-dto": "12.0.0",
+    "@shipfox/api-integration-gitea-dto": "12.0.0",
     "@shipfox/api-integration-github-dto": "12.0.0",
+    "@shipfox/api-integration-jira-dto": "12.0.0",
     "@shipfox/api-integration-linear-dto": "12.0.0",
-    "@shipfox/api-integration-gitea-dto": "12.0.0",
     "@shipfox/api-integration-slack-dto": "12.0.0",
+    "@shipfox/api-integration-sentry-dto": "12.0.0",
     "@shipfox/api-integration-webhook-dto": "12.0.0",
     "@shipfox/client-api": "6.0.1",
-    "@shipfox/client-shell": "13.0.0",
-    "@shipfox/integration-icons": "0.2.3",
-    "@shipfox/api-integration-sentry-dto": "12.0.0",
-    "@shipfox/client-ui": "13.0.0",
-    "@shipfox/client-auth": "13.0.0",
-    "@shipfox/react-ui": "0.4.0"
+    "@shipfox/client-auth": "14.0.0",
+    "@shipfox/client-shell": "14.0.0",
+    "@shipfox/client-ui": "14.0.0",
+    "@shipfox/integration-icons": "0.3.0",
+    "@shipfox/react-ui": "0.5.0"
   },
   "peerDependencies": {
     "@tanstack/react-query": "^5.101.0",

package/src/application/complete-integration-callback.test.ts

@@ -1,7 +1,10 @@
 import {QueryClient} from '@tanstack/react-query';
 import type {IntegrationConnection} from '#core/models.js';
 import {integrationsQueryKeys} from '#hooks/api/integrations.js';
-import {completeIntegrationCallback} from './complete-integration-callback.js';
+import {
+  completeIntegrationCallback,
+  completeIntegrationCallbackResult,
+} from './complete-integration-callback.js';
 
 const WORKSPACE_ID = '11111111-1111-4111-8111-111111111111';
 
@@ -38,4 +41,44 @@ describe('completeIntegrationCallback', () => {
       queryKey: integrationsQueryKeys.connectionsByWorkspace(WORKSPACE_ID),
     });
   });
+
+  test('does not invalidate a connection view for a result without a connection', async () => {
+    const queryClient = new QueryClient();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const refreshAuth = vi.fn().mockResolvedValue({accessToken: 'access-token'});
+    const complete = vi.fn().mockResolvedValue({sites: []});
+
+    const result = await completeIntegrationCallbackResult({
+      input: {code: 'grant-code'},
+      refreshAuth,
+      complete,
+      getConnection: () => undefined,
+      queryClient,
+    });
+
+    expect(result).toEqual({sites: []});
+    expect(complete).toHaveBeenCalledWith({code: 'grant-code'}, 'access-token');
+    expect(invalidateQueries).not.toHaveBeenCalled();
+  });
+
+  test('invalidates a connection view for a result with a connection', async () => {
+    const queryClient = new QueryClient();
+    const invalidateQueries = vi.spyOn(queryClient, 'invalidateQueries');
+    const refreshAuth = vi.fn().mockResolvedValue({accessToken: 'access-token'});
+    const complete = vi.fn(async () => connection);
+
+    const result = await completeIntegrationCallbackResult({
+      input: {code: 'grant-code'},
+      refreshAuth,
+      complete,
+      getConnection: (value) => value,
+      queryClient,
+    });
+
+    expect(result).toBe(connection);
+    expect(complete).toHaveBeenCalledWith({code: 'grant-code'}, 'access-token');
+    expect(invalidateQueries).toHaveBeenCalledWith({
+      queryKey: integrationsQueryKeys.connectionsByWorkspace(WORKSPACE_ID),
+    });
+  });
 });

package/src/application/complete-integration-callback.ts

@@ -10,22 +10,65 @@ export interface CompleteIntegrationCallbackOptions<TInput> {
   queryClient: QueryClient;
 }
 
+export interface CompleteIntegrationCallbackResultOptions<TInput, TResult> {
+  input: TInput;
+  refreshAuth: () => Promise<{accessToken: string}>;
+  complete: (input: TInput, accessToken: string) => Promise<TResult>;
+  getConnection: (result: TResult) => IntegrationConnection | undefined;
+  queryClient: QueryClient;
+}
+
 export async function completeIntegrationCallback<TInput>({
   input,
   refreshAuth,
   complete,
   queryClient,
 }: CompleteIntegrationCallbackOptions<TInput>): Promise<IntegrationConnection> {
+  return await completeIntegrationCallbackResultInternal({
+    input,
+    refreshAuth,
+    complete,
+    getConnection: (result) => result,
+    queryClient,
+  });
+}
+
+export async function completeIntegrationCallbackResult<TInput, TResult>({
+  input,
+  refreshAuth,
+  complete,
+  getConnection,
+  queryClient,
+}: CompleteIntegrationCallbackResultOptions<TInput, TResult>): Promise<TResult> {
+  return await completeIntegrationCallbackResultInternal({
+    input,
+    refreshAuth,
+    complete,
+    getConnection,
+    queryClient,
+  });
+}
+
+async function completeIntegrationCallbackResultInternal<TInput, TResult>({
+  input,
+  refreshAuth,
+  complete,
+  getConnection,
+  queryClient,
+}: CompleteIntegrationCallbackResultOptions<TInput, TResult>): Promise<TResult> {
   const session = await refreshAuth();
-  const connection = await complete(input, session.accessToken);
-  try {
-    await queryClient.invalidateQueries({
-      queryKey: integrationsQueryKeys.connectionsByWorkspace(connection.workspaceId),
-    });
-  } catch {
-    // Cache refresh is best effort: the successful callback is already committed server-side.
+  const result = await complete(input, session.accessToken);
+  const connection = getConnection(result);
+  if (connection) {
+    try {
+      await queryClient.invalidateQueries({
+        queryKey: integrationsQueryKeys.connectionsByWorkspace(connection.workspaceId),
+      });
+    } catch {
+      // Cache refresh is best effort: the callback is already committed server-side.
+    }
   }
-  return connection;
+  return result;
 }
 
 export function useCompleteIntegrationCallback() {
@@ -37,3 +80,13 @@ export function useCompleteIntegrationCallback() {
     [queryClient],
   );
 }
+
+export function useCompleteIntegrationCallbackResult() {
+  const queryClient = useQueryClient();
+  return useCallback(
+    async <TInput, TResult>(
+      options: Omit<CompleteIntegrationCallbackResultOptions<TInput, TResult>, 'queryClient'>,
+    ): Promise<TResult> => completeIntegrationCallbackResult({...options, queryClient}),
+    [queryClient],
+  );
+}

package/src/components/callback-status-shell.tsx

@@ -19,7 +19,10 @@ export function CallbackStatusShell({
   startOver?: boolean;
   switchAccount?: boolean;
   workspaceSlug?: string | undefined;
-  installPath: '/w/$workspaceSlug/integrations/linear' | '/w/$workspaceSlug/integrations/slack';
+  installPath:
+    | '/w/$workspaceSlug/integrations/linear'
+    | '/w/$workspaceSlug/integrations/slack'
+    | '/w/$workspaceSlug/integrations/jira';
 }) {
   const headingRef = useRef<HTMLHeadingElement>(null);
   useEffect(() => headingRef.current?.focus(), []);

package/src/components/integration-usage-events.test.ts

@@ -1,4 +1,5 @@
 import type {IntegrationConnectionDto} from '@shipfox/api-integration-core-dto';
+import {jiraWebhookEventNames} from '@shipfox/api-integration-jira-dto';
 import {linearWebhookEventNames} from '@shipfox/api-integration-linear-dto';
 import {WEBHOOK_RECEIVED_EVENT} from '@shipfox/api-integration-webhook-dto';
 import {usageEventsForConnection} from './integration-usage-events.js';
@@ -67,6 +68,18 @@ describe('usageEventsForConnection', () => {
     expect(events.map((event) => event.value)).toEqual(linearWebhookEventNames);
   });
 
+  it('uses Jira webhook names directly', () => {
+    const connection = {
+      ...baseConnection,
+      provider: 'jira',
+      capabilities: ['agent_tools'],
+    } satisfies IntegrationConnectionDto;
+
+    const events = usageEventsForConnection(connection);
+
+    expect(events.map((event) => event.value)).toEqual(jiraWebhookEventNames);
+  });
+
   it('falls back to a generic received event for uncataloged providers', () => {
     const connection = {
       ...baseConnection,

package/src/core/models.ts

@@ -7,6 +7,13 @@ export interface IntegrationProvider {
   capabilities: IntegrationCapability[];
 }
 
+export interface JiraSite {
+  cloudId: string;
+  name: string;
+  url: string;
+  scopes: string[];
+}
+
 export interface IntegrationConnection {
   id: string;
   workspaceId: string;
@@ -163,6 +170,15 @@ const linearUsageEvents = [
 
 const sentryIssueActions = ['created', 'resolved', 'assigned', 'archived', 'unresolved'] as const;
 
+const jiraUsageEvents = [
+  'jira:issue_created',
+  'jira:issue_updated',
+  'jira:issue_deleted',
+  'comment_created',
+  'comment_updated',
+  'comment_deleted',
+] as const;
+
 export function usageEventsForConnection(
   connection: Pick<IntegrationConnection, 'provider' | 'capabilities'>,
 ): IntegrationUsageEvent[] {
@@ -174,6 +190,8 @@ export function usageEventsForConnection(
       value: `issue.${action}`,
       label: `issue.${action}`,
     }));
+  if (connection.provider === 'jira')
+    return jiraUsageEvents.map((value) => ({value, label: value}));
   if (connection.provider === 'linear')
     return linearUsageEvents.map((value) => ({value, label: value}));
   if (connection.capabilities.includes('source_control')) return [{value: 'push', label: 'push'}];

package/src/feature.ts

@@ -23,6 +23,11 @@ export const integrationsFeature = defineClientFeature({
       parent: 'root',
       impl: '@shipfox/client-integrations/routes/linear-callback',
     },
+    {
+      path: '/integrations/jira/callback',
+      parent: 'root',
+      impl: '@shipfox/client-integrations/routes/jira-callback',
+    },
     {
       path: '/integrations/sentry/callback',
       parent: 'root',
@@ -53,6 +58,11 @@ export const integrationsFeature = defineClientFeature({
       parent: 'workspaceLayout',
       impl: '@shipfox/client-integrations/routes/linear',
     },
+    {
+      path: '/w/$workspaceSlug/integrations/jira',
+      parent: 'workspaceLayout',
+      impl: '@shipfox/client-integrations/routes/jira',
+    },
     {
       path: '/w/$workspaceSlug/integrations/sentry',
       parent: 'workspaceLayout',

package/src/hooks/api/integration-mapper.ts

@@ -3,11 +3,13 @@ import type {
   IntegrationProviderDto,
   RepositoryDto,
 } from '@shipfox/api-integration-core-dto';
+import type {JiraAccessibleResourceDto} from '@shipfox/api-integration-jira-dto';
 import type {WebhookConnectionDto} from '@shipfox/api-integration-webhook-dto';
 import type {
   InstallRedirect,
   IntegrationConnection,
   IntegrationProvider,
+  JiraSite,
   Repository,
   WebhookConnection,
 } from '#core/models.js';
@@ -20,6 +22,10 @@ export function toInstallRedirect(dto: {install_url: string}): InstallRedirect {
   return {installUrl: dto.install_url};
 }
 
+export function toJiraSite(dto: JiraAccessibleResourceDto): JiraSite {
+  return {cloudId: dto.cloud_id, name: dto.name, url: dto.url, scopes: dto.scopes};
+}
+
 export function toIntegrationConnection(dto: IntegrationConnectionDto): IntegrationConnection {
   return {
     id: dto.id,

package/src/hooks/api/integrations.test.ts

@@ -1,8 +1,11 @@
 import type {IntegrationConnectionDto} from '@shipfox/api-integration-core-dto';
 import {configureApiClient} from '@shipfox/client-api';
 import {
+  completeJiraCallback,
+  completeJiraSiteSelection,
   completeLinearCallback,
   completeSlackCallback,
+  createJiraInstall,
   createLinearInstall,
   createSlackInstall,
   listSourceConnections,
@@ -155,3 +158,92 @@ describe('Linear transport', () => {
     );
   });
 });
+
+describe('Jira transport', () => {
+  it('posts the install workspace, maps multi-site callbacks, and completes a site selection', async () => {
+    const requests: Request[] = [];
+    const connectionBody = {
+      id: '33333333-3333-4333-8333-333333333333',
+      workspace_id: '11111111-1111-4111-8111-111111111111',
+      provider: 'jira',
+      external_account_id: 'cloud-1',
+      slug: 'jira_acme',
+      display_name: 'Jira Acme',
+      lifecycle_status: 'active',
+      capabilities: ['agent_tools'],
+      created_at: '2026-01-01T00:00:00.000Z',
+      updated_at: '2026-01-01T00:00:00.000Z',
+    };
+    configureApiClient({
+      baseUrl: 'https://api.example.test',
+      fetchImpl: vi.fn((input, init) => {
+        const request = new Request(input, init);
+        requests.push(request);
+        if (request.url.endsWith('/install'))
+          return Promise.resolve(jsonResponse({install_url: 'https://jira.example.test/install'}));
+        if (request.url.endsWith('/callback/site'))
+          return Promise.resolve(jsonResponse(connectionBody));
+        return Promise.resolve(
+          jsonResponse({
+            sites: [
+              {
+                cloud_id: 'cloud-1',
+                name: 'Acme',
+                url: 'https://acme.atlassian.net',
+                scopes: ['read:jira-work'],
+              },
+              {
+                cloud_id: 'cloud-2',
+                name: 'Beta',
+                url: 'https://beta.atlassian.net',
+                scopes: ['read:jira-work'],
+              },
+            ],
+          }),
+        );
+      }),
+    });
+
+    const install = await createJiraInstall({
+      workspace_id: '11111111-1111-4111-8111-111111111111',
+    });
+    const sites = await completeJiraCallback({
+      query: {code: 'grant code', state: 'signed state'},
+      token: 'session-token',
+    });
+    const connection = await completeJiraSiteSelection({
+      body: {cloud_id: 'cloud-1', state: 'signed state'},
+      token: 'session-token',
+    });
+
+    expect(install).toEqual({installUrl: 'https://jira.example.test/install'});
+    expect(sites).toEqual({
+      sites: [
+        {
+          cloudId: 'cloud-1',
+          name: 'Acme',
+          url: 'https://acme.atlassian.net',
+          scopes: ['read:jira-work'],
+        },
+        {
+          cloudId: 'cloud-2',
+          name: 'Beta',
+          url: 'https://beta.atlassian.net',
+          scopes: ['read:jira-work'],
+        },
+      ],
+    });
+    expect(connection.provider).toBe('jira');
+    expect(requests[0]?.url).toBe('https://api.example.test/integrations/jira/install');
+    expect(await requests[0]?.json()).toEqual({
+      workspace_id: '11111111-1111-4111-8111-111111111111',
+    });
+    expect(requests[1]?.url).toBe(
+      'https://api.example.test/integrations/jira/callback/api?code=grant+code&state=signed+state',
+    );
+    expect(requests[1]?.headers.get('authorization')).toBe('Bearer session-token');
+    expect(requests[2]?.url).toBe('https://api.example.test/integrations/jira/callback/site');
+    expect(await requests[2]?.json()).toEqual({cloud_id: 'cloud-1', state: 'signed state'});
+    expect(requests[2]?.headers.get('authorization')).toBe('Bearer session-token');
+  });
+});

package/src/hooks/api/integrations.ts

@@ -15,6 +15,15 @@ import {
   createGithubInstallResponseSchema,
   githubCallbackResponseSchema,
 } from '@shipfox/api-integration-github-dto';
+import type {
+  CompleteJiraSiteSelectionBodyDto,
+  CreateJiraInstallBodyDto,
+  JiraCallbackQueryDto,
+} from '@shipfox/api-integration-jira-dto';
+import {
+  createJiraInstallResponseSchema,
+  jiraCallbackResponseSchema,
+} from '@shipfox/api-integration-jira-dto';
 import type {
   CreateLinearInstallBodyDto,
   LinearCallbackQueryDto,
@@ -56,14 +65,17 @@ import {
   type IntegrationConnection,
   type IntegrationProvider,
   isUsableConnection,
+  type JiraSite,
   type RepositoryPage,
 } from '#core/models.js';
+import {serializeJiraCallbackQuery} from '#jira-callback.js';
 import {serializeLinearCallbackQuery} from '#linear-callback.js';
 import {serializeSlackCallbackQuery} from '#slack-callback.js';
 import {
   toInstallRedirect,
   toIntegrationConnection,
   toIntegrationProvider,
+  toJiraSite,
   toRepository,
 } from './integration-mapper.js';
 
@@ -261,6 +273,15 @@ export async function createLinearInstall(
   );
 }
 
+export async function createJiraInstall(body: CreateJiraInstallBodyDto): Promise<InstallRedirect> {
+  return toInstallRedirect(
+    await checkedApiRequest(createJiraInstallResponseSchema, '/integrations/jira/install', {
+      method: 'POST',
+      body,
+    }),
+  );
+}
+
 export async function createSlackInstall(
   body: CreateSlackInstallBodyDto,
 ): Promise<InstallRedirect> {
@@ -302,6 +323,44 @@ export async function completeSlackCallback({
   return toIntegrationConnection(response);
 }
 
+export type JiraCallbackResult = IntegrationConnection | {sites: JiraSite[]};
+
+export async function completeJiraCallback({
+  query,
+  token,
+}: {
+  query: JiraCallbackQueryDto;
+  token: string;
+}): Promise<JiraCallbackResult> {
+  const response = await checkedApiRequest(
+    jiraCallbackResponseSchema,
+    `/integrations/jira/callback/api?${serializeJiraCallbackQuery(query)}`,
+    {headers: {authorization: `Bearer ${token}`}},
+  );
+  return 'sites' in response
+    ? {sites: response.sites.map(toJiraSite)}
+    : toIntegrationConnection(response);
+}
+
+export async function completeJiraSiteSelection({
+  body,
+  token,
+}: {
+  body: CompleteJiraSiteSelectionBodyDto;
+  token: string;
+}): Promise<IntegrationConnection> {
+  const response = await checkedApiRequest(
+    integrationConnectionDtoSchema,
+    '/integrations/jira/callback/site',
+    {
+      method: 'POST',
+      body,
+      headers: {authorization: `Bearer ${token}`},
+    },
+  );
+  return toIntegrationConnection(response);
+}
+
 // Called from the callback route with an explicit bearer (same as the GitHub
 // callback): the route refreshes auth itself before forwarding the grant code.
 export async function connectSentry({body, token}: {body: SentryConnectBodyDto; token: string}) {
@@ -452,6 +511,10 @@ export function useCreateSlackInstallMutation() {
   return useMutation({mutationFn: createSlackInstall});
 }
 
+export function useCreateJiraInstallMutation() {
+  return useMutation({mutationFn: createJiraInstall});
+}
+
 export function useCompleteLinearCallbackMutation() {
   return useMutation({mutationFn: completeLinearCallback});
 }
@@ -460,6 +523,14 @@ export function useCompleteSlackCallbackMutation() {
   return useMutation({mutationFn: completeSlackCallback});
 }
 
+export function useCompleteJiraCallbackMutation() {
+  return useMutation({mutationFn: completeJiraCallback});
+}
+
+export function useCompleteJiraSiteSelectionMutation() {
+  return useMutation({mutationFn: completeJiraSiteSelection});
+}
+
 export function useUpdateIntegrationConnectionMutation() {
   const queryClient = useQueryClient();
   return useMutation({

package/src/index.ts

@@ -6,8 +6,12 @@ export * from './components/redirect-install-page.js';
 export * from './components/repository-picker.js';
 export * from './connection-status-badge.js';
 export * from './hooks/api/integrations.js';
+export * from './jira-callback.js';
+export * from './jira-form-errors.js';
 export * from './pages/gitea-install-page.js';
 export * from './pages/github-install-page.js';
+export * from './pages/jira-callback-page.js';
+export * from './pages/jira-install-page.js';
 export * from './pages/linear-callback-page.js';
 export * from './pages/linear-install-page.js';
 export * from './pages/sentry-callback-page.js';

package/src/jira-callback-state.ts

@@ -0,0 +1,19 @@
+import {createSingleFlight} from '@shipfox/client-ui';
+import type {IntegrationConnection} from '#core/models.js';
+import type {JiraCallbackResult} from '#hooks/api/integrations.js';
+
+export const JIRA_CALLBACK_CACHE_SIZE = 32;
+
+export const jiraCallbackRequests = createSingleFlight<string, JiraCallbackResult>({
+  maxTerminalResults: JIRA_CALLBACK_CACHE_SIZE,
+});
+export const jiraSiteSelectionRequests = createSingleFlight<string, IntegrationConnection>();
+export const jiraCompletedConnections = new Map<string, IntegrationConnection>();
+export const jiraToastedCallbacks = new Set<string>();
+
+export function resetJiraCallbackState(): void {
+  jiraCallbackRequests.clear();
+  jiraSiteSelectionRequests.clear();
+  jiraCompletedConnections.clear();
+  jiraToastedCallbacks.clear();
+}

package/src/jira-callback.test.ts

@@ -0,0 +1,76 @@
+import {
+  clearJiraInstallWorkspace,
+  JIRA_INSTALL_WORKSPACE_KEY,
+  parseJiraCallbackQuery,
+  readJiraInstallWorkspace,
+  saveJiraInstallWorkspace,
+  serializeJiraCallbackQuery,
+} from './jira-callback.js';
+
+describe('Jira callback helpers', () => {
+  it('parses and serializes success and provider-error callback queries', () => {
+    const success = parseJiraCallbackQuery({code: 'grant code', state: 'signed state'});
+    const providerError = parseJiraCallbackQuery({
+      error: 'access_denied',
+      error_description: 'User denied access',
+      state: 'signed state',
+    });
+
+    expect(success).toEqual({code: 'grant code', state: 'signed state'});
+    expect(providerError).toEqual({
+      error: 'access_denied',
+      error_description: 'User denied access',
+      state: 'signed state',
+    });
+    expect(success && serializeJiraCallbackQuery(success)).toBe(
+      'code=grant+code&state=signed+state',
+    );
+    expect(providerError && serializeJiraCallbackQuery(providerError)).toBe(
+      'error=access_denied&error_description=User+denied+access&state=signed+state',
+    );
+  });
+
+  it('rejects malformed callback queries and prefers a grant code', () => {
+    expect(parseJiraCallbackQuery({code: 'grant'})).toBeUndefined();
+    expect(parseJiraCallbackQuery({state: 'signed'})).toBeUndefined();
+    expect(parseJiraCallbackQuery({error: 'access_denied'})).toBeUndefined();
+    expect(parseJiraCallbackQuery({state: ['a', 'b']})).toBeUndefined();
+    expect(
+      parseJiraCallbackQuery({
+        code: 'grant',
+        error: 'access_denied',
+        state: 'signed',
+      }),
+    ).toEqual({code: 'grant', state: 'signed'});
+  });
+
+  it('round-trips workspace navigation storage and swallows storage errors', () => {
+    const storage = new Map<string, string>();
+    const workspaceStorage = {
+      getItem: (key: string) => storage.get(key) ?? null,
+      setItem: (key: string, value: string) => storage.set(key, value),
+      removeItem: (key: string) => storage.delete(key),
+    };
+
+    saveJiraInstallWorkspace(workspaceStorage, 'workspace-1');
+    expect(storage.get(JIRA_INSTALL_WORKSPACE_KEY)).toBe('workspace-1');
+    expect(readJiraInstallWorkspace(workspaceStorage)).toBe('workspace-1');
+    clearJiraInstallWorkspace(workspaceStorage);
+    expect(readJiraInstallWorkspace(workspaceStorage)).toBeUndefined();
+
+    const unavailableStorage = {
+      getItem: () => {
+        throw new Error('unavailable');
+      },
+      setItem: () => {
+        throw new Error('unavailable');
+      },
+      removeItem: () => {
+        throw new Error('unavailable');
+      },
+    };
+    expect(() => saveJiraInstallWorkspace(unavailableStorage, 'workspace-1')).not.toThrow();
+    expect(() => readJiraInstallWorkspace(unavailableStorage)).not.toThrow();
+    expect(() => clearJiraInstallWorkspace(unavailableStorage)).not.toThrow();
+  });
+});