Skip to content

The open alternative to Salesforce, designed for AI.

Fan out Fireflies backfill into batched jobs (#23622)

nitin6e1c710a7d08
diff --git a/packages/twenty-apps/public/fireflies/package.json b/packages/twenty-apps/public/fireflies/package.json
index 8d20b08d112..8610637941b 100644
--- a/packages/twenty-apps/public/fireflies/package.json
+++ b/packages/twenty-apps/public/fireflies/package.json
@@ -7,7 +7,7 @@
"node": "^24.5.0",
"npm": "please-use-yarn",
"yarn": ">=4.0.2",
- "twenty": ">=2.23.0"
+ "twenty": ">=2.26.0"
},
"keywords": [
"twenty-app"
@@ -35,8 +35,8 @@
"oxlint": "^0.16.0",
"react": "^18.2.0",
"react-dom": "^18.2.0",
- "twenty-client-sdk": "2.23.0-alpha.2",
- "twenty-sdk": "2.23.0-alpha.2",
+ "twenty-client-sdk": "2.26.0",
+ "twenty-sdk": "2.26.0",
"twenty-ui": "^1.0.0-alpha.1",
"typescript": "^5.9.3",
"vite-tsconfig-paths": "^4.2.1",
diff --git a/packages/twenty-apps/public/fireflies/src/application.config.ts b/packages/twenty-apps/public/fireflies/src/application.config.ts
index af0342f3458..1c62e32a6c1 100644
--- a/packages/twenty-apps/public/fireflies/src/application.config.ts
+++ b/packages/twenty-apps/public/fireflies/src/application.config.ts
@@ -8,7 +8,7 @@ import {
export default defineApplication({
universalIdentifier: APPLICATION_UNIVERSAL_IDENTIFIER,
- displayName: 'Twenty Fireflies',
+ displayName: 'Fireflies',
description:
'Sync Fireflies call transcripts and AI summaries into CallRecording records linked to matching CalendarEvents in Twenty, and trigger sync / list / search of Fireflies calls from workflows and the AI chat.',
logoUrl: 'public/twenty-fireflies.svg',
@@ -30,7 +30,8 @@ export default defineApplication({
isSecret: true,
},
FIREFLIES_WEBHOOK_SECRET: {
- universalIdentifier: FIREFLIES_WEBHOOK_SECRET_VARIABLE_UNIVERSAL_IDENTIFIER,
+ universalIdentifier:
+ FIREFLIES_WEBHOOK_SECRET_VARIABLE_UNIVERSAL_IDENTIFIER,
description:
'Signing secret for verifying Fireflies Webhooks V2 payloads (sent in the X-Hub-Signature header as sha256=<hex-hmac-sha256-of-body>). Configure the same value on the Fireflies V2 webhook setup page.',
isSecret: true,
diff --git a/packages/twenty-apps/public/fireflies/src/constants/fireflies-backfill-route-path.constant.ts b/packages/twenty-apps/public/fireflies/src/constants/fireflies-backfill-route-path.constant.ts
new file mode 100644
index 00000000000..b00a1dfc7f5
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/constants/fireflies-backfill-route-path.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_ROUTE_PATH = '/fireflies/backfill';
diff --git a/packages/twenty-apps/public/fireflies/src/constants/universal-identifiers.ts b/packages/twenty-apps/public/fireflies/src/constants/universal-identifiers.ts
index d94354baa63..30fc19d570e 100644
--- a/packages/twenty-apps/public/fireflies/src/constants/universal-identifiers.ts
+++ b/packages/twenty-apps/public/fireflies/src/constants/universal-identifiers.ts
@@ -13,6 +13,18 @@ export const FIREFLIES_WEBHOOK_SECRET_VARIABLE_UNIVERSAL_IDENTIFIER =
export const FIREFLIES_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =
'e0c2d033-0ef4-4b92-9e64-2d8f2e4c497e';
+export const FIREFLIES_BACKFILL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =
+ '4b138241-0059-485b-8b7f-31f2d1ae645a';
+
+export const FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =
+ 'd9477b08-0abb-479e-b944-41cbfec72e2b';
+
+export const FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =
+ '0f5c21b6-a58c-4170-abe1-4631e0e0e28d';
+
+export const FIREFLIES_DAILY_HEALER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =
+ 'abe764da-3eeb-42d7-921c-7b967328e053';
+
export const FIREFLIES_SYNC_CALL_UNIVERSAL_IDENTIFIER =
'c715a476-929e-4e5b-b692-6350fc0adb73';
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-batch.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-batch.test.ts
new file mode 100644
index 00000000000..6336c11e1d3
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-batch.test.ts
@@ -0,0 +1,167 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ answerTwentyQueries,
+ serveFirefliesApi,
+ setUpImportMissingFirefliesCallsTest,
+} from 'src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support';
+import firefliesBackfillBatchLogicFunction from 'src/logic-functions/fireflies-backfill-batch';
+import { FIREFLIES_BACKFILL_BATCH_SIZE } from 'src/logic-functions/constants/fireflies-backfill-batch-size.constant';
+import { computeCallRecordingIdForFirefliesMeeting } from 'src/logic-functions/utils/compute-call-recording-id-for-fireflies-meeting';
+
+const queryMock = vi.hoisted(() => vi.fn());
+const mutationMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: class {
+ query = queryMock;
+ mutation = mutationMock;
+ },
+}));
+
+const fetchMock = vi.fn();
+
+describe('firefliesBackfillBatchLogicFunction', () => {
+ beforeEach(() => {
+ setUpImportMissingFirefliesCallsTest({
+ fetchMock,
+ queryMock,
+ mutationMock,
+ });
+ vi.stubEnv('FIREFLIES_API_KEY', 'fireflies-api-key');
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ vi.unstubAllGlobals();
+ vi.unstubAllEnvs();
+ });
+
+ it('is configured as an enqueue-only batch importer', () => {
+ expect(firefliesBackfillBatchLogicFunction.config).toEqual(
+ expect.objectContaining({
+ name: 'fireflies-backfill-batch',
+ timeoutSeconds: 900,
+ }),
+ );
+ expect(firefliesBackfillBatchLogicFunction.config).not.toHaveProperty(
+ 'httpRouteTriggerSettings',
+ );
+ expect(firefliesBackfillBatchLogicFunction.config).not.toHaveProperty(
+ 'cronTriggerSettings',
+ );
+ });
+
+ it('imports the calls listed in the raw job payload', async () => {
+ serveFirefliesApi([], fetchMock);
+ vi.useFakeTimers();
+
+ const resultPromise = firefliesBackfillBatchLogicFunction.config.handler({
+ transcriptIds: ['call-1', 'call-2'],
+ });
+
+ await vi.runAllTimersAsync();
+
+ const result = await resultPromise;
+
+ expect(result).toEqual({
+ status: 'completed',
+ importedCallCount: 2,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ expect(mutationMock).toHaveBeenCalledTimes(2);
+ expect(
+ mutationMock.mock.calls.map(
+ ([mutation]) =>
+ mutation.createCallRecording.__args.data.externalRecordingId,
+ ),
+ ).toEqual(['call-1', 'call-2']);
+ });
+
+ it('skips already synced calls without calling Fireflies', async () => {
+ serveFirefliesApi([], fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: [
+ {
+ id: computeCallRecordingIdForFirefliesMeeting('call-1'),
+ transcript: [{ text: 'already imported' }],
+ summary: { markdown: 'Already imported' },
+ },
+ ],
+ });
+
+ const result = await firefliesBackfillBatchLogicFunction.config.handler({
+ transcriptIds: ['call-1'],
+ });
+
+ expect(result).toEqual(
+ expect.objectContaining({ status: 'completed', skippedCallCount: 1 }),
+ );
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ it('throws on a Fireflies rate limit so the queue retries the job', async () => {
+ const consoleLogSpy = vi
+ .spyOn(console, 'log')
+ .mockImplementation(() => undefined);
+
+ vi.useFakeTimers();
+ fetchMock.mockImplementation(
+ async () =>
+ new Response(
+ JSON.stringify({ errors: [{ message: 'too many requests' }] }),
+ { status: 429 },
+ ),
+ );
+ vi.stubGlobal('fetch', fetchMock);
+
+ const resultPromise = firefliesBackfillBatchLogicFunction.config.handler({
+ transcriptIds: ['call-1'],
+ });
+ const resultExpectation = expect(resultPromise).rejects.toThrow(
+ 'transient Fireflies API error',
+ );
+
+ await vi.runAllTimersAsync();
+ await resultExpectation;
+
+ expect(consoleLogSpy).toHaveBeenCalledWith(
+ '[fireflies] Backfill batch processed',
+ {
+ importedCallCount: 0,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ },
+ );
+ });
+
+ it('throws on an invalid job payload', async () => {
+ await expect(
+ firefliesBackfillBatchLogicFunction.config.handler({ transcriptIds: [] }),
+ ).rejects.toThrow('requires 1 to 20 non-empty transcript ids');
+ });
+
+ it('throws when a job payload exceeds the configured batch size', async () => {
+ await expect(
+ firefliesBackfillBatchLogicFunction.config.handler({
+ transcriptIds: Array.from(
+ { length: FIREFLIES_BACKFILL_BATCH_SIZE + 1 },
+ (_, transcriptIndex) => `call-${transcriptIndex}`,
+ ),
+ }),
+ ).rejects.toThrow('requires 1 to 20 non-empty transcript ids');
+ });
+
+ it('throws when the Fireflies api key is missing', async () => {
+ vi.stubEnv('FIREFLIES_API_KEY', '');
+
+ await expect(
+ firefliesBackfillBatchLogicFunction.config.handler({
+ transcriptIds: ['call-1'],
+ }),
+ ).rejects.toThrow('Fireflies is not configured');
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-worker.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-worker.test.ts
new file mode 100644
index 00000000000..f4e9b07f8f8
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill-worker.test.ts
@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ buildListedTranscript,
+ serveFirefliesApi,
+} from 'src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support';
+import firefliesBackfillWorkerLogicFunction from 'src/logic-functions/fireflies-backfill-worker';
+
+const fetchMock = vi.fn();
+const enqueueJobMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ enqueueJob: enqueueJobMock,
+}));
+
+describe('firefliesBackfillWorkerLogicFunction', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.stubGlobal('fetch', fetchMock);
+ vi.stubEnv('FIREFLIES_API_KEY', 'fireflies-api-key');
+ vi.spyOn(console, 'log').mockImplementation(() => undefined);
+ fetchMock.mockImplementation(
+ async () => new Response('invalid request', { status: 400 }),
+ );
+ enqueueJobMock.mockResolvedValue({ enqueued: true });
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+ vi.unstubAllEnvs();
+ });
+
+ it('is configured as an enqueue-only discovery worker', () => {
+ expect(firefliesBackfillWorkerLogicFunction.config).toEqual(
+ expect.objectContaining({
+ name: 'fireflies-backfill-worker',
+ timeoutSeconds: 900,
+ }),
+ );
+ expect(firefliesBackfillWorkerLogicFunction.config).not.toHaveProperty(
+ 'httpRouteTriggerSettings',
+ );
+ expect(firefliesBackfillWorkerLogicFunction.config).not.toHaveProperty(
+ 'cronTriggerSettings',
+ );
+ });
+
+ it('rejects an invalid worker payload', async () => {
+ await expect(
+ firefliesBackfillWorkerLogicFunction.config.handler({ days: 0 }),
+ ).rejects.toThrow('requires a valid days window');
+ });
+
+ it('lists the requested window and enqueues every transcript batch', async () => {
+ const transcripts = Array.from({ length: 25 }, (_, callIndex) =>
+ buildListedTranscript(
+ `call-${callIndex}`,
+ Date.parse('2026-06-02T10:00:00.000Z'),
+ ),
+ );
+
+ serveFirefliesApi([transcripts], fetchMock);
+
+ const result = await firefliesBackfillWorkerLogicFunction.config.handler({
+ days: 30,
+ });
+
+ expect(result).toEqual(
+ expect.objectContaining({
+ outcome: 'completed',
+ transcriptCount: 25,
+ batchCount: 2,
+ enqueuedBatchCount: 2,
+ }),
+ );
+ expect(enqueueJobMock).toHaveBeenCalledTimes(2);
+ expect(enqueueJobMock.mock.calls[0][0].payload.transcriptIds).toHaveLength(
+ 20,
+ );
+ expect(enqueueJobMock.mock.calls[1][0].payload.transcriptIds).toHaveLength(
+ 5,
+ );
+
+ const [, request] = fetchMock.mock.calls[0];
+ const { variables } = JSON.parse(String((request as RequestInit).body)) as {
+ variables: { fromDate: string; toDate: string };
+ };
+
+ expect(Date.parse(variables.toDate) - Date.parse(variables.fromDate)).toBe(
+ 30 * 24 * 60 * 60 * 1_000,
+ );
+ });
+
+ it('fails discovery with partial enqueue progress so the queue retries it', async () => {
+ const transcripts = Array.from({ length: 25 }, (_, callIndex) =>
+ buildListedTranscript(
+ `call-${callIndex}`,
+ Date.parse('2026-06-02T10:00:00.000Z'),
+ ),
+ );
+
+ serveFirefliesApi([transcripts], fetchMock);
+ enqueueJobMock
+ .mockResolvedValueOnce({ enqueued: true })
+ .mockRejectedValueOnce(new Error('Network failed'));
+
+ await expect(
+ firefliesBackfillWorkerLogicFunction.config.handler({ days: 30 }),
+ ).rejects.toThrow(
+ 'Fireflies backfill enqueued 1 of 2 batches before enqueue failed: Network failed',
+ );
+ expect(enqueueJobMock).toHaveBeenCalledTimes(2);
+ });
+
+ it('fails discovery when Fireflies listing fails', async () => {
+ await expect(
+ firefliesBackfillWorkerLogicFunction.config.handler({ days: 30 }),
+ ).rejects.toThrow('Fireflies backfill listing failed');
+ expect(enqueueJobMock).not.toHaveBeenCalled();
+ });
+
+ it('skips discovery when the Fireflies api key is missing', async () => {
+ vi.stubEnv('FIREFLIES_API_KEY', '');
+
+ const result = await firefliesBackfillWorkerLogicFunction.config.handler({
+ days: 30,
+ });
+
+ expect(result).toEqual(
+ expect.objectContaining({ outcome: 'not-configured' }),
+ );
+ expect(fetchMock).not.toHaveBeenCalled();
+ expect(console.log).toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill.test.ts
new file mode 100644
index 00000000000..02f9061c855
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-backfill.test.ts
@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { type RoutePayload } from 'twenty-sdk/define';
+
+import { FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import firefliesBackfillLogicFunction from 'src/logic-functions/fireflies-backfill';
+
+const enqueueJobMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ enqueueJob: enqueueJobMock,
+}));
+
+const buildRoutePayload = (body: object | null): RoutePayload<unknown> => ({
+ body,
+ headers: {},
+ queryStringParameters: {},
+ pathParameters: {},
+ isBase64Encoded: false,
+ rawBody: undefined,
+ requestContext: { http: { method: 'POST', path: '/' } },
+ userWorkspaceId: null,
+});
+
+describe('firefliesBackfillLogicFunction', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ enqueueJobMock.mockResolvedValue({ enqueued: true });
+ });
+
+ it('is configured as an authenticated backfill route', () => {
+ expect(firefliesBackfillLogicFunction.config).toEqual(
+ expect.objectContaining({
+ name: 'fireflies-backfill',
+ timeoutSeconds: 900,
+ httpRouteTriggerSettings: {
+ path: '/fireflies/backfill',
+ httpMethod: 'POST',
+ isAuthRequired: true,
+ },
+ }),
+ );
+ });
+
+ it('rejects an empty route body', async () => {
+ const result = await firefliesBackfillLogicFunction.config.handler(
+ buildRoutePayload(null),
+ );
+
+ expect(result).toEqual({
+ outcome: 'invalid-request',
+ error: 'Fireflies backfill requires a days window between 1 and 3650',
+ });
+ expect(enqueueJobMock).not.toHaveBeenCalled();
+ });
+
+ it('enqueues discovery instead of listing transcripts in the route', async () => {
+ const result = await firefliesBackfillLogicFunction.config.handler(
+ buildRoutePayload({ days: 30 }),
+ );
+
+ expect(result).toEqual({ outcome: 'started' });
+ expect(enqueueJobMock).toHaveBeenCalledWith({
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { days: 30 },
+ });
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-daily-healer.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-daily-healer.test.ts
new file mode 100644
index 00000000000..c21f01eb70a
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/__tests__/fireflies-daily-healer.test.ts
@@ -0,0 +1,69 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import firefliesDailyHealerLogicFunction from 'src/logic-functions/fireflies-daily-healer';
+
+const fetchMock = vi.fn();
+const enqueueJobMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: class {},
+}));
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ enqueueJob: enqueueJobMock,
+}));
+
+describe('firefliesDailyHealerLogicFunction', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.stubGlobal('fetch', fetchMock);
+ vi.stubEnv('FIREFLIES_API_KEY', 'fireflies-api-key');
+ fetchMock.mockImplementation(
+ async () => new Response('invalid request', { status: 400 }),
+ );
+ enqueueJobMock.mockResolvedValue({ enqueued: true });
+ vi.spyOn(console, 'log').mockImplementation(() => undefined);
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.unstubAllGlobals();
+ vi.unstubAllEnvs();
+ });
+
+ it('is configured as the daily healing trigger', () => {
+ expect(firefliesDailyHealerLogicFunction.config).toEqual(
+ expect.objectContaining({
+ name: 'fireflies-daily-healer',
+ timeoutSeconds: 900,
+ cronTriggerSettings: {
+ pattern: '0 3 * * *',
+ },
+ }),
+ );
+ });
+
+ it('lists a fixed seven-day healing window', async () => {
+ fetchMock.mockResolvedValue(
+ new Response(JSON.stringify({ data: { transcripts: [] } }), {
+ status: 200,
+ }),
+ );
+
+ const result = await firefliesDailyHealerLogicFunction.config.handler();
+
+ const [, request] = fetchMock.mock.calls[0];
+ const { variables } = JSON.parse(String((request as RequestInit).body)) as {
+ variables: { fromDate: string; toDate: string; skip: number };
+ };
+
+ expect(Date.parse(variables.toDate) - Date.parse(variables.fromDate)).toBe(
+ 7 * 24 * 60 * 60 * 1_000,
+ );
+ expect(variables.skip).toBe(0);
+ expect(console.log).toHaveBeenCalledWith(
+ '[fireflies] Daily healing discovery finished',
+ result,
+ );
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-retry-limit.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-retry-limit.constant.ts
new file mode 100644
index 00000000000..1047ddf3ff9
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-retry-limit.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT = 2;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-size.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-size.constant.ts
new file mode 100644
index 00000000000..cd2d1aa9696
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-size.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_BATCH_SIZE = 20;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-stagger-milliseconds.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-stagger-milliseconds.constant.ts
new file mode 100644
index 00000000000..dc3acbde33c
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-batch-stagger-milliseconds.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS = 60_000;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-batch-delay-milliseconds.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-batch-delay-milliseconds.constant.ts
new file mode 100644
index 00000000000..cd270528bea
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-batch-delay-milliseconds.constant.ts
@@ -0,0 +1,2 @@
+export const FIREFLIES_BACKFILL_MAX_BATCH_DELAY_MILLISECONDS =
+ 7 * 24 * 60 * 60 * 1_000;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-page-count.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-page-count.constant.ts
new file mode 100644
index 00000000000..cb95852a0c3
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-page-count.constant.ts
@@ -0,0 +1,2 @@
+// Prevent an unbounded loop if Fireflies keeps returning full pages.
+export const FIREFLIES_BACKFILL_MAX_PAGE_COUNT = 2_000;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-window-days.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-window-days.constant.ts
new file mode 100644
index 00000000000..71631511ddd
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-max-window-days.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_MAX_WINDOW_DAYS = 3_650;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-outcome.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-outcome.constant.ts
new file mode 100644
index 00000000000..31a37c429cc
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-outcome.constant.ts
@@ -0,0 +1,6 @@
+export const FIREFLIES_BACKFILL_OUTCOME = {
+ INVALID_REQUEST: 'invalid-request',
+ NOT_CONFIGURED: 'not-configured',
+ COMPLETED: 'completed',
+ STARTED: 'started',
+} as const;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-pacing-milliseconds.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-pacing-milliseconds.constant.ts
new file mode 100644
index 00000000000..93aa2f6b503
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-pacing-milliseconds.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_PACING_MILLISECONDS = 1_000;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-page-size.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-page-size.constant.ts
new file mode 100644
index 00000000000..17a8dbab565
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-page-size.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_PAGE_SIZE = 50;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant.ts
new file mode 100644
index 00000000000..eeb11fd22dc
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_BACKFILL_TIMEOUT_SECONDS = 900;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-call-recording-fields.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-call-recording-fields.constant.ts
new file mode 100644
index 00000000000..5b279ab71bd
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-call-recording-fields.constant.ts
@@ -0,0 +1,6 @@
+import { type FirefliesSyncableField } from 'src/logic-functions/types/fireflies-syncable-field.type';
+
+export const FIREFLIES_CALL_RECORDING_FIELDS: FirefliesSyncableField[] = [
+ 'transcript',
+ 'summary',
+];
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-daily-healer-cron-pattern.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-daily-healer-cron-pattern.constant.ts
new file mode 100644
index 00000000000..13a8ad6fb6e
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-daily-healer-cron-pattern.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_DAILY_HEALER_CRON_PATTERN = '0 3 * * *';
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-healing-window-days.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-healing-window-days.constant.ts
new file mode 100644
index 00000000000..aff96b925b1
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/fireflies-healing-window-days.constant.ts
@@ -0,0 +1 @@
+export const FIREFLIES_HEALING_WINDOW_DAYS = 7;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/constants/milliseconds-per-day.constant.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/milliseconds-per-day.constant.ts
new file mode 100644
index 00000000000..676b82d25cb
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/constants/milliseconds-per-day.constant.ts
@@ -0,0 +1 @@
+export const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1_000;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/data/__tests__/enqueue-fireflies-backfill-batches.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/data/__tests__/enqueue-fireflies-backfill-batches.test.ts
new file mode 100644
index 00000000000..752ea1f8a44
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/data/__tests__/enqueue-fireflies-backfill-batches.test.ts
@@ -0,0 +1,93 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT } from 'src/logic-functions/constants/fireflies-backfill-batch-retry-limit.constant';
+import { FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS } from 'src/logic-functions/constants/fireflies-backfill-batch-stagger-milliseconds.constant';
+import { enqueueFirefliesBackfillBatches } from 'src/logic-functions/data/enqueue-fireflies-backfill-batches.util';
+
+const enqueueJobMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-sdk/logic-function', () => ({
+ enqueueJob: enqueueJobMock,
+}));
+
+vi.mock(
+ 'src/logic-functions/constants/fireflies-backfill-max-batch-delay-milliseconds.constant',
+ () => ({
+ FIREFLIES_BACKFILL_MAX_BATCH_DELAY_MILLISECONDS: 120_000,
+ }),
+);
+
+describe('enqueueFirefliesBackfillBatches', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ enqueueJobMock.mockResolvedValue({
+ enqueued: true,
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ });
+ });
+
+ it('enqueues one staggered job per batch', async () => {
+ await enqueueFirefliesBackfillBatches({
+ transcriptIdBatches: [
+ ['call-1', 'call-2'],
+ ['call-3'],
+ ['call-4'],
+ ['call-5'],
+ ],
+ });
+
+ expect(enqueueJobMock).toHaveBeenNthCalledWith(1, {
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { transcriptIds: ['call-1', 'call-2'] },
+ retryLimit: FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT,
+ delayMs: 0,
+ });
+ expect(enqueueJobMock).toHaveBeenNthCalledWith(2, {
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { transcriptIds: ['call-3'] },
+ retryLimit: FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT,
+ delayMs: FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS,
+ });
+ expect(enqueueJobMock).toHaveBeenNthCalledWith(3, {
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { transcriptIds: ['call-4'] },
+ retryLimit: FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT,
+ delayMs: 2 * FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS,
+ });
+ expect(enqueueJobMock).toHaveBeenNthCalledWith(4, {
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { transcriptIds: ['call-5'] },
+ retryLimit: FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT,
+ delayMs: 2 * FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS,
+ });
+ });
+
+ it('throws partial progress without enqueueing later batches', async () => {
+ const enqueueError = new Error('Network failed');
+
+ enqueueJobMock
+ .mockResolvedValueOnce({
+ enqueued: true,
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ })
+ .mockRejectedValueOnce(enqueueError);
+
+ await expect(
+ enqueueFirefliesBackfillBatches({
+ transcriptIdBatches: [['call-1'], ['call-2'], ['call-3']],
+ }),
+ ).rejects.toMatchObject({
+ message:
+ 'Fireflies backfill enqueued 1 of 3 batches before enqueue failed: Network failed',
+ cause: enqueueError,
+ });
+ expect(enqueueJobMock).toHaveBeenCalledTimes(2);
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/data/enqueue-fireflies-backfill-batches.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/data/enqueue-fireflies-backfill-batches.util.ts
new file mode 100644
index 00000000000..661517453bf
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/data/enqueue-fireflies-backfill-batches.util.ts
@@ -0,0 +1,36 @@
+import { enqueueJob } from 'twenty-sdk/logic-function';
+
+import { FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT } from 'src/logic-functions/constants/fireflies-backfill-batch-retry-limit.constant';
+import { FIREFLIES_BACKFILL_MAX_BATCH_DELAY_MILLISECONDS } from 'src/logic-functions/constants/fireflies-backfill-max-batch-delay-milliseconds.constant';
+import { FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS } from 'src/logic-functions/constants/fireflies-backfill-batch-stagger-milliseconds.constant';
+
+export const enqueueFirefliesBackfillBatches = async ({
+ transcriptIdBatches,
+}: {
+ transcriptIdBatches: string[][];
+}): Promise<void> => {
+ for (const [batchIndex, transcriptIds] of transcriptIdBatches.entries()) {
+ try {
+ await enqueueJob({
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { transcriptIds },
+ retryLimit: FIREFLIES_BACKFILL_BATCH_RETRY_LIMIT,
+ delayMs: Math.min(
+ batchIndex * FIREFLIES_BACKFILL_BATCH_STAGGER_MILLISECONDS,
+ FIREFLIES_BACKFILL_MAX_BATCH_DELAY_MILLISECONDS,
+ ),
+ });
+ } catch (error) {
+ throw Object.assign(
+ new Error(
+ `Fireflies backfill enqueued ${batchIndex} of ${transcriptIdBatches.length} batches before enqueue failed: ${
+ error instanceof Error ? error.message : String(error)
+ }`,
+ ),
+ { cause: error },
+ );
+ }
+ }
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-batch.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-batch.ts
new file mode 100644
index 00000000000..6ab15d2d5ad
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-batch.ts
@@ -0,0 +1,15 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_TIMEOUT_SECONDS } from 'src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant';
+import { firefliesBackfillBatchHandler } from 'src/logic-functions/handlers/fireflies-backfill-batch-handler';
+
+export default defineLogicFunction({
+ universalIdentifier:
+ FIREFLIES_BACKFILL_BATCH_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ name: 'fireflies-backfill-batch',
+ description:
+ 'Imports one enqueued batch of Fireflies calls into CallRecording records by transcript id.',
+ timeoutSeconds: FIREFLIES_BACKFILL_TIMEOUT_SECONDS,
+ handler: firefliesBackfillBatchHandler,
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-worker.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-worker.ts
new file mode 100644
index 00000000000..e3c6d0c3c5d
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill-worker.ts
@@ -0,0 +1,39 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_TIMEOUT_SECONDS } from 'src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant';
+import { firefliesBackfillHandler } from 'src/logic-functions/handlers/fireflies-backfill-handler';
+import { firefliesBackfillRequestBodySchema } from 'src/logic-functions/schemas/fireflies-backfill-request-body.schema';
+import { type FirefliesBackfillResult } from 'src/logic-functions/types/fireflies-backfill-result.type';
+
+const firefliesBackfillWorkerHandler = async (
+ payload: unknown,
+): Promise<FirefliesBackfillResult> => {
+ const payloadParseResult =
+ firefliesBackfillRequestBodySchema.safeParse(payload);
+
+ if (!payloadParseResult.success) {
+ throw new Error('Fireflies backfill worker requires a valid days window');
+ }
+
+ const firefliesBackfillResult = await firefliesBackfillHandler({
+ windowDays: payloadParseResult.data.days,
+ });
+
+ console.log(
+ '[fireflies] Backfill discovery finished',
+ firefliesBackfillResult,
+ );
+
+ return firefliesBackfillResult;
+};
+
+export default defineLogicFunction({
+ universalIdentifier:
+ FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ name: 'fireflies-backfill-worker',
+ description:
+ 'Lists Fireflies transcript ids for a requested window and enqueues one import job per batch.',
+ timeoutSeconds: FIREFLIES_BACKFILL_TIMEOUT_SECONDS,
+ handler: firefliesBackfillWorkerHandler,
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill.ts
new file mode 100644
index 00000000000..0df28f35679
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-backfill.ts
@@ -0,0 +1,49 @@
+import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';
+import { enqueueJob } from 'twenty-sdk/logic-function';
+
+import {
+ FIREFLIES_BACKFILL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+} from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_ROUTE_PATH } from 'src/constants/fireflies-backfill-route-path.constant';
+import { FIREFLIES_BACKFILL_MAX_WINDOW_DAYS } from 'src/logic-functions/constants/fireflies-backfill-max-window-days.constant';
+import { FIREFLIES_BACKFILL_OUTCOME } from 'src/logic-functions/constants/fireflies-backfill-outcome.constant';
+import { FIREFLIES_BACKFILL_TIMEOUT_SECONDS } from 'src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant';
+import { firefliesBackfillRequestBodySchema } from 'src/logic-functions/schemas/fireflies-backfill-request-body.schema';
+
+const firefliesBackfillRequestHandler = async (
+ payload: RoutePayload<unknown>,
+) => {
+ const requestBodyParseResult = firefliesBackfillRequestBodySchema.safeParse(
+ payload.body,
+ );
+
+ if (!requestBodyParseResult.success) {
+ return {
+ outcome: FIREFLIES_BACKFILL_OUTCOME.INVALID_REQUEST,
+ error: `Fireflies backfill requires a days window between 1 and ${FIREFLIES_BACKFILL_MAX_WINDOW_DAYS}`,
+ };
+ }
+
+ await enqueueJob({
+ logicFunctionUniversalIdentifier:
+ FIREFLIES_BACKFILL_WORKER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ payload: { days: requestBodyParseResult.data.days },
+ });
+
+ return { outcome: FIREFLIES_BACKFILL_OUTCOME.STARTED };
+};
+
+export default defineLogicFunction({
+ universalIdentifier: FIREFLIES_BACKFILL_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ name: 'fireflies-backfill',
+ description:
+ 'Enqueues a background worker that discovers and imports missing Fireflies calls for the requested days window.',
+ timeoutSeconds: FIREFLIES_BACKFILL_TIMEOUT_SECONDS,
+ handler: firefliesBackfillRequestHandler,
+ httpRouteTriggerSettings: {
+ path: FIREFLIES_BACKFILL_ROUTE_PATH,
+ httpMethod: 'POST',
+ isAuthRequired: true,
+ },
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-daily-healer.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-daily-healer.ts
new file mode 100644
index 00000000000..a8a118e5ff2
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/fireflies-daily-healer.ts
@@ -0,0 +1,35 @@
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { FIREFLIES_DAILY_HEALER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-identifiers';
+import { FIREFLIES_BACKFILL_TIMEOUT_SECONDS } from 'src/logic-functions/constants/fireflies-backfill-timeout-seconds.constant';
+import { FIREFLIES_DAILY_HEALER_CRON_PATTERN } from 'src/logic-functions/constants/fireflies-daily-healer-cron-pattern.constant';
+import { FIREFLIES_HEALING_WINDOW_DAYS } from 'src/logic-functions/constants/fireflies-healing-window-days.constant';
+import { firefliesBackfillHandler } from 'src/logic-functions/handlers/fireflies-backfill-handler';
+import { type FirefliesBackfillResult } from 'src/logic-functions/types/fireflies-backfill-result.type';
+
+const firefliesDailyHealerCronHandler =
+ async (): Promise<FirefliesBackfillResult> => {
+ const firefliesBackfillResult = await firefliesBackfillHandler({
+ windowDays: FIREFLIES_HEALING_WINDOW_DAYS,
+ });
+
+ console.log(
+ '[fireflies] Daily healing discovery finished',
+ firefliesBackfillResult,
+ );
+
+ return firefliesBackfillResult;
+ };
+
+export default defineLogicFunction({
+ universalIdentifier:
+ FIREFLIES_DAILY_HEALER_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+ name: 'fireflies-daily-healer',
+ description:
+ 'Daily sweep that enqueues import batches for Fireflies calls missed by webhooks over the last seven days.',
+ timeoutSeconds: FIREFLIES_BACKFILL_TIMEOUT_SECONDS,
+ handler: firefliesDailyHealerCronHandler,
+ cronTriggerSettings: {
+ pattern: FIREFLIES_DAILY_HEALER_CRON_PATTERN,
+ },
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls-retry.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls-retry.test.ts
new file mode 100644
index 00000000000..91c8e5e795c
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls-retry.test.ts
@@ -0,0 +1,160 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CALL_RECORDING_STATUS } from 'src/logic-functions/constants/call-recording-status.constant';
+import {
+ answerTwentyQueries,
+ buildGraphqlResponse,
+ FIREFLIES_API_KEY,
+ FIREFLIES_BACKFILL_FROM_DATE,
+ setUpImportMissingFirefliesCallsTest,
+ skipSleep,
+} from 'src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support';
+import { importMissingFirefliesCalls } from 'src/logic-functions/flows/import-missing-fireflies-calls.util';
+import { computeCallRecordingIdForFirefliesMeeting } from 'src/logic-functions/utils/compute-call-recording-id-for-fireflies-meeting';
+
+const queryMock = vi.hoisted(() => vi.fn());
+const mutationMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: class {
+ query = queryMock;
+ mutation = mutationMock;
+ },
+}));
+
+const fetchMock = vi.fn();
+
+describe('importMissingFirefliesCalls retries', () => {
+ beforeEach(() => {
+ setUpImportMissingFirefliesCallsTest({
+ fetchMock,
+ queryMock,
+ mutationMock,
+ });
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ it('aborts the batch on a Fireflies rate limit', async () => {
+ fetchMock.mockImplementation(
+ async () =>
+ new Response(
+ JSON.stringify({ errors: [{ message: 'too many requests' }] }),
+ { status: 429 },
+ ),
+ );
+ vi.stubGlobal('fetch', fetchMock);
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-newer', 'call-older'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'retryable-error',
+ importedCallCount: 0,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ });
+
+ it('keeps the counts of calls synced before a rate limit aborts the batch', async () => {
+ let isFirstCall = true;
+
+ fetchMock.mockImplementation(async () => {
+ if (isFirstCall) {
+ isFirstCall = false;
+
+ return buildGraphqlResponse({
+ transcript: {
+ id: 'call-1',
+ title: 'Call 1',
+ date: Date.parse(FIREFLIES_BACKFILL_FROM_DATE),
+ duration: 30,
+ meeting_link: null,
+ participants: ['[email protected]'],
+ organizer_email: '[email protected]',
+ calendar_id: null,
+ cal_id: null,
+ calendar_type: null,
+ sentences: [
+ { speaker_name: 'A', text: 'hello', start_time: 0, end_time: 1 },
+ ],
+ summary: { overview: 'Summary' },
+ },
+ });
+ }
+
+ return new Response(
+ JSON.stringify({ errors: [{ message: 'too many requests' }] }),
+ { status: 429 },
+ );
+ });
+ vi.stubGlobal('fetch', fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: [
+ {
+ id: computeCallRecordingIdForFirefliesMeeting('call-1'),
+ status: CALL_RECORDING_STATUS.PROCESSING,
+ transcript: null,
+ summary: { markdown: 'Already imported' },
+ },
+ ],
+ });
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-1', 'call-2'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'retryable-error',
+ importedCallCount: 1,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ });
+
+ it('aborts the batch on a persistent Fireflies server error', async () => {
+ fetchMock.mockImplementation(
+ async () =>
+ new Response(
+ JSON.stringify({
+ errors: [
+ {
+ message: 'Temporary Fireflies failure',
+ extensions: { code: 'invariant_violation' },
+ },
+ ],
+ }),
+ { status: 200 },
+ ),
+ );
+ vi.stubGlobal('fetch', fetchMock);
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-with-server-error'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'retryable-error',
+ importedCallCount: 0,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ expect(fetchMock).toHaveBeenCalledTimes(3);
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support.ts
index 4ef5dd17b8f..877fc87fe0d 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support.ts
@@ -2,12 +2,7 @@ import { type Mock, vi } from 'vitest';
export const FIREFLIES_API_KEY = 'fireflies-api-key';
export const FIREFLIES_BACKFILL_FROM_DATE = '2026-05-01T00:00:00.000Z';
-export const FAR_DEADLINE_MILLISECONDS = Number.MAX_SAFE_INTEGER;
-export const INITIAL_FIREFLIES_BACKFILL_CURSOR = {
- fromDate: FIREFLIES_BACKFILL_FROM_DATE,
- toDate: '2026-07-30T00:00:00.000Z',
- skip: 0,
-};
+export const FIREFLIES_BACKFILL_TO_DATE = '2026-07-30T00:00:00.000Z';
export const skipSleep = async (): Promise<void> => {};
@@ -46,7 +41,10 @@ export const serveFirefliesApi = (
let listRequestIndex = 0;
fetchMock.mockImplementation(async (_url: string, init: RequestInit) => {
- const body = JSON.parse(String(init.body)) as { query: string };
+ const body = JSON.parse(String(init.body)) as {
+ query: string;
+ variables?: { transcriptId?: string };
+ };
if (body.query.includes('query Transcripts(')) {
const page = pages[listRequestIndex] ?? [];
@@ -58,7 +56,7 @@ export const serveFirefliesApi = (
return buildGraphqlResponse({
transcript: {
- id: 'detail',
+ id: body.variables?.transcriptId ?? 'detail',
title: 'Call detail',
date: Date.parse(FIREFLIES_BACKFILL_FROM_DATE),
duration: 30,
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test.ts
new file mode 100644
index 00000000000..ee24c9dd1bb
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test.ts
@@ -0,0 +1,321 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { CALL_RECORDING_STATUS } from 'src/logic-functions/constants/call-recording-status.constant';
+import {
+ answerTwentyQueries,
+ buildGraphqlResponse,
+ FIREFLIES_API_KEY,
+ serveFirefliesApi,
+ setUpImportMissingFirefliesCallsTest,
+ skipSleep,
+} from 'src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support';
+import { importMissingFirefliesCalls } from 'src/logic-functions/flows/import-missing-fireflies-calls.util';
+import { computeCallRecordingIdForFirefliesMeeting } from 'src/logic-functions/utils/compute-call-recording-id-for-fireflies-meeting';
+
+const queryMock = vi.hoisted(() => vi.fn());
+const mutationMock = vi.hoisted(() => vi.fn());
+
+vi.mock('twenty-client-sdk/core', () => ({
+ CoreApiClient: class {
+ query = queryMock;
+ mutation = mutationMock;
+ },
+}));
+
+const fetchMock = vi.fn();
+
+describe('importMissingFirefliesCalls synchronization', () => {
+ beforeEach(() => {
+ setUpImportMissingFirefliesCallsTest({
+ fetchMock,
+ queryMock,
+ mutationMock,
+ });
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ it('imports every call in the batch', async () => {
+ serveFirefliesApi([], fetchMock);
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-1', 'call-2'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'completed',
+ importedCallCount: 2,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ expect(mutationMock).toHaveBeenCalledTimes(2);
+ expect(
+ mutationMock.mock.calls.map(
+ ([mutation]) =>
+ mutation.createCallRecording.__args.data.externalRecordingId,
+ ),
+ ).toEqual(['call-1', 'call-2']);
+ });
+
+ it('imports duplicate transcript ids only once', async () => {
+ serveFirefliesApi([], fetchMock);
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-1', 'call-1'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'completed',
+ importedCallCount: 1,
+ erroredCallCount: 0,
+ skippedCallCount: 0,
+ });
+ expect(fetchMock).toHaveBeenCalledTimes(2);
+ expect(mutationMock).toHaveBeenCalledTimes(1);
+ });
+
+ it('keeps a call recording processing while its Fireflies summary is pending', async () => {
+ serveFirefliesApi([], fetchMock);
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+
+ await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-with-pending-summary'],
+ sleep: skipSleep,
+ });
+
+ expect(mutationMock).toHaveBeenCalledWith({
+ createCallRecording: {
+ __args: {
+ data: expect.objectContaining({
+ status: CALL_RECORDING_STATUS.PROCESSING,
+ transcript: expect.any(Array),
+ }),
+ },
+ id: true,
+ },
+ });
+ });
+
+ it('skips complete calls without calling Fireflies', async () => {
+ serveFirefliesApi([], fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: ['call-1', 'call-2'].map((callId) => ({
+ id: computeCallRecordingIdForFirefliesMeeting(callId),
+ transcript: [{ text: 'already imported' }],
+ summary: { markdown: 'Already imported' },
+ })),
+ });
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: ['call-1', 'call-2'],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual({
+ status: 'completed',
+ importedCallCount: 0,
+ erroredCallCount: 0,
+ skippedCallCount: 2,
+ });
+ expect(mutationMock).not.toHaveBeenCalled();
+ expect(fetchMock).not.toHaveBeenCalled();
+ });
+
+ it('syncs only the missing field of a partial call recording', async () => {
+ const callId = 'partially-imported-call';
+ const callRecordingId = computeCallRecordingIdForFirefliesMeeting(callId);
+ const callDateMilliseconds = Date.parse('2026-06-02T10:00:00.000Z');
+ let summaryRequestCount = 0;
+ let transcriptRequestCount = 0;
+
+ fetchMock.mockImplementation(async (_url: string, init: RequestInit) => {
+ const body = JSON.parse(String(init.body)) as { query: string };
+
+ if (body.query.includes('sentences {')) {
+ transcriptRequestCount += 1;
+ }
+
+ summaryRequestCount += 1;
+
+ return buildGraphqlResponse({
+ transcript: {
+ id: callId,
+ title: 'Partially imported call',
+ date: callDateMilliseconds,
+ duration: 30,
+ meeting_link: null,
+ participants: ['[email protected]'],
+ organizer_email: '[email protected]',
+ calendar_id: null,
+ cal_id: null,
+ calendar_type: null,
+ summary: { overview: 'Recovered summary' },
+ },
+ });
+ });
+ vi.stubGlobal('fetch', fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: [
+ {
+ id: callRecordingId,
+ status: 'COMPLETED',
+ transcript: [{ text: 'Already imported' }],
+ summary: null,
+ },
+ ],
+ });
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+ const result = await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: [callId],
+ sleep: skipSleep,
+ });
+
+ expect(result).toEqual(
+ expect.objectContaining({
+ status: 'completed',
+ importedCallCount: 1,
+ }),
+ );
+ expect(transcriptRequestCount).toBe(0);
+ expect(summaryRequestCount).toBe(1);
+ expect(mutationMock).toHaveBeenCalledWith({
+ updateCallRecording: {
+ __args: {
+ id: callRecordingId,
+ data: expect.objectContaining({
+ status: CALL_RECORDING_STATUS.COMPLETED,
+ summary: expect.objectContaining({
+ markdown: expect.stringContaining('Recovered summary'),
+ }),
+ }),
+ },
+ id: true,
+ },
+ });
+ });
+
+ it('moves a completed legacy recording back to processing while its summary is unavailable', async () => {
+ const callId = 'legacy-transcript-only-call';
+ const callRecordingId = computeCallRecordingIdForFirefliesMeeting(callId);
+ const callDateMilliseconds = Date.parse('2026-06-02T10:00:00.000Z');
+
+ fetchMock.mockResolvedValue(
+ buildGraphqlResponse({
+ transcript: {
+ id: callId,
+ title: 'Legacy transcript-only call',
+ date: callDateMilliseconds,
+ duration: 30,
+ meeting_link: null,
+ participants: ['[email protected]'],
+ organizer_email: '[email protected]',
+ calendar_id: null,
+ cal_id: null,
+ calendar_type: null,
+ summary: null,
+ },
+ }),
+ );
+ vi.stubGlobal('fetch', fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: [
+ {
+ id: callRecordingId,
+ status: CALL_RECORDING_STATUS.COMPLETED,
+ transcript: [{ text: 'Already imported' }],
+ summary: null,
+ },
+ ],
+ });
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+
+ await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: [callId],
+ sleep: skipSleep,
+ });
+
+ expect(mutationMock).toHaveBeenCalledWith({
+ updateCallRecording: {
+ __args: {
+ id: callRecordingId,
+ data: expect.objectContaining({
+ status: CALL_RECORDING_STATUS.PROCESSING,
+ }),
+ },
+ id: true,
+ },
+ });
+ });
+
+ it('keeps a transcript processing when its summary remains unavailable', async () => {
+ const callId = 'call-with-skipped-summary';
+ const callRecordingId = computeCallRecordingIdForFirefliesMeeting(callId);
+ const callDateMilliseconds = Date.parse('2026-06-02T10:00:00.000Z');
+
+ fetchMock.mockResolvedValue(
+ buildGraphqlResponse({
+ transcript: {
+ id: callId,
+ title: 'Call with skipped summary',
+ date: callDateMilliseconds,
+ duration: 30,
+ meeting_link: null,
+ participants: ['[email protected]'],
+ organizer_email: '[email protected]',
+ calendar_id: null,
+ cal_id: null,
+ calendar_type: null,
+ summary: null,
+ },
+ }),
+ );
+ vi.stubGlobal('fetch', fetchMock);
+ answerTwentyQueries({
+ queryMock,
+ callRecordings: [
+ {
+ id: callRecordingId,
+ status: CALL_RECORDING_STATUS.PROCESSING,
+ transcript: [{ text: 'Already imported' }],
+ summary: null,
+ },
+ ],
+ });
+
+ const { CoreApiClient } = await import('twenty-client-sdk/core');
+
+ await importMissingFirefliesCalls({
+ apiKey: FIREFLIES_API_KEY,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: [callId],
+ sleep: skipSleep,
+ });
+
+ expect(mutationMock).not.toHaveBeenCalled();
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/import-missing-fireflies-calls.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/import-missing-fireflies-calls.util.ts
new file mode 100644
index 00000000000..6b0c02d60e4
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/import-missing-fireflies-calls.util.ts
@@ -0,0 +1,38 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { sleepForMilliseconds } from 'src/utils/sleep-for-milliseconds.util';
+
+import { findCallRecordingFieldStatesOrThrow } from 'src/logic-functions/data/find-call-recording-field-states-or-throw.util';
+import { syncFirefliesTranscriptBatch } from 'src/logic-functions/flows/sync-fireflies-transcript-batch.util';
+import { type ImportMissingFirefliesCallsResult } from 'src/logic-functions/types/import-missing-fireflies-calls-result.type';
+import { computeCallRecordingIdForFirefliesMeeting } from 'src/logic-functions/utils/compute-call-recording-id-for-fireflies-meeting';
+
+type ImportMissingFirefliesCallsParams = {
+ apiKey: string;
+ coreApiClient: CoreApiClient;
+ transcriptIds: string[];
+ sleep?: (milliseconds: number) => Promise<void>;
+};
+
+export const importMissingFirefliesCalls = async ({
+ apiKey,
+ coreApiClient,
+ transcriptIds,
+ sleep = sleepForMilliseconds,
+}: ImportMissingFirefliesCallsParams): Promise<ImportMissingFirefliesCallsResult> => {
+ const uniqueTranscriptIds = [...new Set(transcriptIds)];
+ const callRecordingFieldStates = await findCallRecordingFieldStatesOrThrow({
+ coreApiClient,
+ callRecordingIds: uniqueTranscriptIds.map(
+ computeCallRecordingIdForFirefliesMeeting,
+ ),
+ });
+
+ return syncFirefliesTranscriptBatch({
+ apiKey,
+ coreApiClient,
+ transcriptIds: uniqueTranscriptIds,
+ callRecordingFieldStates,
+ sleep,
+ });
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/flows/sync-fireflies-transcript-batch.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/sync-fireflies-transcript-batch.util.ts
new file mode 100644
index 00000000000..4fbe8eed425
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/flows/sync-fireflies-transcript-batch.util.ts
@@ -0,0 +1,215 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+import { isDefined } from 'src/utils/is-defined';
+
+import { CALL_RECORDING_STATUS } from 'src/logic-functions/constants/call-recording-status.constant';
+import { FIREFLIES_BACKFILL_PACING_MILLISECONDS } from 'src/logic-functions/constants/fireflies-backfill-pacing-milliseconds.constant';
+import { FIREFLIES_CALL_RECORDING_FIELDS } from 'src/logic-functions/constants/fireflies-call-recording-fields.constant';
+import { type CallRecordingFieldState } from 'src/logic-functions/types/call-recording-field-state.type';
+import { type FirefliesSyncableField } from 'src/logic-functions/types/fireflies-syncable-field.type';
+import { type ImportMissingFirefliesCallsResult } from 'src/logic-functions/types/import-missing-fireflies-calls-result.type';
+import { type SyncFirefliesCallResult } from 'src/logic-functions/types/sync-fireflies-call-result.type';
+import { computeCallRecordingIdForFirefliesMeeting } from 'src/logic-functions/utils/compute-call-recording-id-for-fireflies-meeting';
+import { isRetryableFirefliesApiStatus } from 'src/logic-functions/utils/is-retryable-fireflies-api-status.util';
+import { syncFirefliesCallToCallRecording } from 'src/logic-functions/utils/sync-fireflies-call-to-call-recording.util';
+
+type FirefliesCallSyncOutcome = 'imported' | 'errored' | 'skipped';
+
+type SyncMissingFirefliesCallRecordingFieldsParams = {
+ apiKey: string;
+ coreApiClient: CoreApiClient;
+ transcriptId: string;
+ firefliesCallRecordingFields: FirefliesSyncableField[];
+ callRecordingFieldState: CallRecordingFieldState | undefined;
+ sleep: (milliseconds: number) => Promise<void>;
+};
+
+type SyncFirefliesTranscriptBatchParams = {
+ apiKey: string;
+ coreApiClient: CoreApiClient;
+ transcriptIds: string[];
+ callRecordingFieldStates: Map<string, CallRecordingFieldState>;
+ sleep: (milliseconds: number) => Promise<void>;
+};
+
+const getMissingFirefliesCallRecordingFields = (
+ callRecordingFieldState: CallRecordingFieldState | undefined,
+): FirefliesSyncableField[] => {
+ if (!isDefined(callRecordingFieldState)) {
+ return FIREFLIES_CALL_RECORDING_FIELDS;
+ }
+
+ return FIREFLIES_CALL_RECORDING_FIELDS.filter(
+ (firefliesCallRecordingField) =>
+ (firefliesCallRecordingField === 'transcript' &&
+ !callRecordingFieldState.isTranscriptFilled) ||
+ (firefliesCallRecordingField === 'summary' &&
+ !callRecordingFieldState.isSummaryFilled),
+ );
+};
+
+const getFirefliesCallSyncOutcome = (
+ firefliesFieldSyncResults: SyncFirefliesCallResult[],
+): FirefliesCallSyncOutcome => {
+ if (
+ firefliesFieldSyncResults.some(
+ (firefliesFieldSyncResult) => firefliesFieldSyncResult.status === 'error',
+ )
+ ) {
+ return 'errored';
+ }
+
+ if (
+ firefliesFieldSyncResults.some(
+ (firefliesFieldSyncResult) =>
+ firefliesFieldSyncResult.status === 'updated',
+ )
+ ) {
+ return 'imported';
+ }
+
+ return 'skipped';
+};
+
+const buildCurrentCallRecordingFieldState = ({
+ callRecordingFieldState,
+ firefliesFieldSyncResults,
+}: {
+ callRecordingFieldState: CallRecordingFieldState | undefined;
+ firefliesFieldSyncResults: SyncFirefliesCallResult[];
+}): CallRecordingFieldState => {
+ const isTranscriptFilled =
+ (callRecordingFieldState?.isTranscriptFilled ?? false) ||
+ firefliesFieldSyncResults.some(
+ (firefliesFieldSyncResult) =>
+ firefliesFieldSyncResult.status === 'updated' &&
+ firefliesFieldSyncResult.field === 'transcript',
+ );
+ const isSummaryFilled =
+ (callRecordingFieldState?.isSummaryFilled ?? false) ||
+ firefliesFieldSyncResults.some(
+ (firefliesFieldSyncResult) =>
+ firefliesFieldSyncResult.status === 'updated' &&
+ firefliesFieldSyncResult.field === 'summary',
+ );
+
+ if (firefliesFieldSyncResults.length === 0) {
+ return {
+ isTranscriptFilled,
+ isSummaryFilled,
+ status: callRecordingFieldState?.status,
+ };
+ }
+
+ return {
+ isTranscriptFilled,
+ isSummaryFilled,
+ status:
+ isTranscriptFilled && isSummaryFilled
+ ? CALL_RECORDING_STATUS.COMPLETED
+ : CALL_RECORDING_STATUS.PROCESSING,
+ };
+};
+
+const syncMissingFirefliesCallRecordingFields = async ({
+ apiKey,
+ coreApiClient,
+ transcriptId,
+ firefliesCallRecordingFields,
+ callRecordingFieldState,
+ sleep,
+}: SyncMissingFirefliesCallRecordingFieldsParams): Promise<
+ FirefliesCallSyncOutcome | 'retryable-error'
+> => {
+ const firefliesFieldSyncResults: SyncFirefliesCallResult[] = [];
+
+ for (const firefliesCallRecordingField of firefliesCallRecordingFields) {
+ const currentCallRecordingFieldState = buildCurrentCallRecordingFieldState({
+ callRecordingFieldState,
+ firefliesFieldSyncResults,
+ });
+ const firefliesFieldSyncResult = await syncFirefliesCallToCallRecording({
+ apiKey,
+ coreApiClient,
+ transcriptId,
+ field: firefliesCallRecordingField,
+ callRecordingFieldState: currentCallRecordingFieldState,
+ });
+
+ if (
+ firefliesFieldSyncResult.status === 'error' &&
+ isDefined(firefliesFieldSyncResult.httpStatus) &&
+ isRetryableFirefliesApiStatus(firefliesFieldSyncResult.httpStatus)
+ ) {
+ return 'retryable-error';
+ }
+
+ firefliesFieldSyncResults.push(firefliesFieldSyncResult);
+
+ await sleep(FIREFLIES_BACKFILL_PACING_MILLISECONDS);
+ }
+
+ return getFirefliesCallSyncOutcome(firefliesFieldSyncResults);
+};
+
+const countFirefliesCallSyncOutcomes = (
+ firefliesCallSyncOutcomes: FirefliesCallSyncOutcome[],
+) => ({
+ importedCallCount: firefliesCallSyncOutcomes.filter(
+ (firefliesCallSyncOutcome) => firefliesCallSyncOutcome === 'imported',
+ ).length,
+ erroredCallCount: firefliesCallSyncOutcomes.filter(
+ (firefliesCallSyncOutcome) => firefliesCallSyncOutcome === 'errored',
+ ).length,
+ skippedCallCount: firefliesCallSyncOutcomes.filter(
+ (firefliesCallSyncOutcome) => firefliesCallSyncOutcome === 'skipped',
+ ).length,
+});
+
+export const syncFirefliesTranscriptBatch = async ({
+ apiKey,
+ coreApiClient,
+ transcriptIds,
+ callRecordingFieldStates,
+ sleep,
+}: SyncFirefliesTranscriptBatchParams): Promise<ImportMissingFirefliesCallsResult> => {
+ const firefliesCallSyncOutcomes: FirefliesCallSyncOutcome[] = [];
+
+ for (const transcriptId of transcriptIds) {
+ const callRecordingId =
+ computeCallRecordingIdForFirefliesMeeting(transcriptId);
+ const callRecordingFieldState =
+ callRecordingFieldStates.get(callRecordingId);
+ const firefliesCallRecordingFields = getMissingFirefliesCallRecordingFields(
+ callRecordingFieldState,
+ );
+
+ if (firefliesCallRecordingFields.length === 0) {
+ firefliesCallSyncOutcomes.push('skipped');
+ continue;
+ }
+
+ const firefliesCallSyncOutcome =
+ await syncMissingFirefliesCallRecordingFields({
+ apiKey,
+ coreApiClient,
+ transcriptId,
+ firefliesCallRecordingFields,
+ callRecordingFieldState,
+ sleep,
+ });
+
+ if (firefliesCallSyncOutcome === 'retryable-error') {
+ return {
+ status: 'retryable-error',
+ ...countFirefliesCallSyncOutcomes(firefliesCallSyncOutcomes),
+ };
+ }
+
+ firefliesCallSyncOutcomes.push(firefliesCallSyncOutcome);
+ }
+
+ return {
+ status: 'completed',
+ ...countFirefliesCallSyncOutcomes(firefliesCallSyncOutcomes),
+ };
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-batch-handler.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-batch-handler.ts
new file mode 100644
index 00000000000..c02670c3c90
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-batch-handler.ts
@@ -0,0 +1,46 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+
+import { FIREFLIES_BACKFILL_BATCH_SIZE } from 'src/logic-functions/constants/fireflies-backfill-batch-size.constant';
+import { importMissingFirefliesCalls } from 'src/logic-functions/flows/import-missing-fireflies-calls.util';
+import { firefliesBackfillBatchPayloadSchema } from 'src/logic-functions/schemas/fireflies-backfill-batch-payload.schema';
+import { type ImportMissingFirefliesCallsResult } from 'src/logic-functions/types/import-missing-fireflies-calls-result.type';
+import { getFirefliesApiKey } from 'src/logic-functions/utils/get-fireflies-api-key';
+
+export const firefliesBackfillBatchHandler = async (
+ payload: unknown,
+): Promise<ImportMissingFirefliesCallsResult> => {
+ const payloadParseResult =
+ firefliesBackfillBatchPayloadSchema.safeParse(payload);
+
+ if (!payloadParseResult.success) {
+ throw new Error(
+ `Fireflies backfill batch requires 1 to ${FIREFLIES_BACKFILL_BATCH_SIZE} non-empty transcript ids`,
+ );
+ }
+
+ const apiKeyResult = getFirefliesApiKey();
+
+ if (!apiKeyResult.success) {
+ throw new Error(apiKeyResult.error);
+ }
+
+ const importMissingFirefliesCallsResult = await importMissingFirefliesCalls({
+ apiKey: apiKeyResult.apiKey,
+ coreApiClient: new CoreApiClient(),
+ transcriptIds: payloadParseResult.data.transcriptIds,
+ });
+
+ console.log('[fireflies] Backfill batch processed', {
+ importedCallCount: importMissingFirefliesCallsResult.importedCallCount,
+ erroredCallCount: importMissingFirefliesCallsResult.erroredCallCount,
+ skippedCallCount: importMissingFirefliesCallsResult.skippedCallCount,
+ });
+
+ if (importMissingFirefliesCallsResult.status === 'retryable-error') {
+ throw new Error(
+ 'Fireflies backfill batch hit a transient Fireflies API error; failing the job so the queue retries it',
+ );
+ }
+
+ return importMissingFirefliesCallsResult;
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-handler.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-handler.ts
new file mode 100644
index 00000000000..74bbbad3fa3
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-backfill-handler.ts
@@ -0,0 +1,55 @@
+import { FIREFLIES_BACKFILL_BATCH_SIZE } from 'src/logic-functions/constants/fireflies-backfill-batch-size.constant';
+import { FIREFLIES_BACKFILL_OUTCOME } from 'src/logic-functions/constants/fireflies-backfill-outcome.constant';
+import { enqueueFirefliesBackfillBatches } from 'src/logic-functions/data/enqueue-fireflies-backfill-batches.util';
+import { type FirefliesBackfillResult } from 'src/logic-functions/types/fireflies-backfill-result.type';
+import { buildFirefliesBackfillWindow } from 'src/logic-functions/utils/build-fireflies-backfill-window.util';
+import { getFirefliesApiKey } from 'src/logic-functions/utils/get-fireflies-api-key';
+import { listFirefliesTranscriptIds } from 'src/logic-functions/utils/list-fireflies-transcript-ids.util';
+import { chunkIntoBatches } from 'src/utils/chunk-into-batches.util';
+
+export const firefliesBackfillHandler = async ({
+ windowDays,
+}: {
+ windowDays: number;
+}): Promise<FirefliesBackfillResult> => {
+ const apiKeyResult = getFirefliesApiKey();
+
+ if (!apiKeyResult.success) {
+ return {
+ outcome: FIREFLIES_BACKFILL_OUTCOME.NOT_CONFIGURED,
+ error: apiKeyResult.error,
+ };
+ }
+
+ const { fromDate, toDate } = buildFirefliesBackfillWindow({
+ windowDays,
+ nowMilliseconds: Date.now(),
+ });
+
+ const listFirefliesTranscriptIdsResult = await listFirefliesTranscriptIds({
+ apiKey: apiKeyResult.apiKey,
+ fromDate,
+ toDate,
+ });
+
+ if (!listFirefliesTranscriptIdsResult.ok) {
+ throw new Error(
+ `Fireflies backfill listing failed: ${listFirefliesTranscriptIdsResult.errorMessage}`,
+ );
+ }
+
+ const transcriptIdBatches = chunkIntoBatches(
+ listFirefliesTranscriptIdsResult.transcriptIds,
+ FIREFLIES_BACKFILL_BATCH_SIZE,
+ );
+ await enqueueFirefliesBackfillBatches({ transcriptIdBatches });
+
+ return {
+ outcome: FIREFLIES_BACKFILL_OUTCOME.COMPLETED,
+ fromDate,
+ toDate,
+ transcriptCount: listFirefliesTranscriptIdsResult.transcriptIds.length,
+ batchCount: transcriptIdBatches.length,
+ enqueuedBatchCount: transcriptIdBatches.length,
+ };
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-list-calls-by-participant-handler.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-list-calls-by-participant-handler.ts
index 7a84fd2b2d0..afb52f483b6 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-list-calls-by-participant-handler.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-list-calls-by-participant-handler.ts
@@ -3,7 +3,7 @@ import { isNonEmptyString } from '@sniptt/guards';
import { type FirefliesCallListResult } from 'src/logic-functions/types/fireflies-call-list-result.type';
import { type FirefliesListCallsByParticipantInput } from 'src/logic-functions/types/fireflies-list-calls-by-participant-input.type';
import { getFirefliesApiKey } from 'src/logic-functions/utils/get-fireflies-api-key';
-import { listFirefliesTranscripts } from 'src/logic-functions/utils/list-fireflies-transcripts';
+import { listFirefliesTranscripts } from 'src/logic-functions/utils/list-fireflies-transcripts.util';
const DEFAULT_LIMIT = 20;
const MAX_LIMIT = 50;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-search-calls-handler.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-search-calls-handler.ts
index 3ff3910aed5..f571f665013 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-search-calls-handler.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/handlers/fireflies-search-calls-handler.ts
@@ -3,7 +3,7 @@ import { isNonEmptyString } from '@sniptt/guards';
import { type FirefliesCallListResult } from 'src/logic-functions/types/fireflies-call-list-result.type';
import { type FirefliesSearchCallsInput } from 'src/logic-functions/types/fireflies-search-calls-input.type';
import { getFirefliesApiKey } from 'src/logic-functions/utils/get-fireflies-api-key';
-import { listFirefliesTranscripts } from 'src/logic-functions/utils/list-fireflies-transcripts';
+import { listFirefliesTranscripts } from 'src/logic-functions/utils/list-fireflies-transcripts.util';
const DEFAULT_LIMIT = 20;
const MAX_LIMIT = 50;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/__tests__/fireflies-backfill-request-body.schema.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/__tests__/fireflies-backfill-request-body.schema.test.ts
new file mode 100644
index 00000000000..7b27297e273
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/__tests__/fireflies-backfill-request-body.schema.test.ts
@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+
+import { FIREFLIES_BACKFILL_MAX_WINDOW_DAYS } from 'src/logic-functions/constants/fireflies-backfill-max-window-days.constant';
+import { firefliesBackfillRequestBodySchema } from 'src/logic-functions/schemas/fireflies-backfill-request-body.schema';
+
+describe('firefliesBackfillRequestBodySchema', () => {
+ it('accepts a days window', () => {
+ expect(
+ firefliesBackfillRequestBodySchema.safeParse({ days: 30 }).success,
+ ).toBe(true);
+ });
+
+ it('rejects an empty request body', () => {
+ expect(firefliesBackfillRequestBodySchema.safeParse(null).success).toBe(
+ false,
+ );
+ });
+
+ it('rejects a non-positive days window', () => {
+ expect(
+ firefliesBackfillRequestBodySchema.safeParse({ days: 0 }).success,
+ ).toBe(false);
+ });
+
+ it('rejects a fractional days window', () => {
+ expect(
+ firefliesBackfillRequestBodySchema.safeParse({ days: 1.5 }).success,
+ ).toBe(false);
+ });
+
+ it('rejects a days window beyond the supported maximum', () => {
+ expect(
+ firefliesBackfillRequestBodySchema.safeParse({
+ days: FIREFLIES_BACKFILL_MAX_WINDOW_DAYS + 1,
+ }).success,
+ ).toBe(false);
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-batch-payload.schema.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-batch-payload.schema.ts
new file mode 100644
index 00000000000..71163ed7939
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-batch-payload.schema.ts
@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+import { FIREFLIES_BACKFILL_BATCH_SIZE } from 'src/logic-functions/constants/fireflies-backfill-batch-size.constant';
+
+export const firefliesBackfillBatchPayloadSchema = z.object({
+ transcriptIds: z
+ .array(z.string().min(1))
+ .min(1)
+ .max(FIREFLIES_BACKFILL_BATCH_SIZE),
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-request-body.schema.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-request-body.schema.ts
new file mode 100644
index 00000000000..a3f61f1e7f7
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/schemas/fireflies-backfill-request-body.schema.ts
@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+import { FIREFLIES_BACKFILL_MAX_WINDOW_DAYS } from 'src/logic-functions/constants/fireflies-backfill-max-window-days.constant';
+
+export const firefliesBackfillRequestBodySchema = z.object({
+ days: z.number().int().positive().max(FIREFLIES_BACKFILL_MAX_WINDOW_DAYS),
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-result.type.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-result.type.ts
new file mode 100644
index 00000000000..ca28379f18f
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-result.type.ts
@@ -0,0 +1,15 @@
+import type { FIREFLIES_BACKFILL_OUTCOME } from 'src/logic-functions/constants/fireflies-backfill-outcome.constant';
+
+export type FirefliesBackfillResult =
+ | {
+ outcome: typeof FIREFLIES_BACKFILL_OUTCOME.NOT_CONFIGURED;
+ error: string;
+ }
+ | {
+ outcome: typeof FIREFLIES_BACKFILL_OUTCOME.COMPLETED;
+ fromDate: string;
+ toDate: string;
+ transcriptCount: number;
+ batchCount: number;
+ enqueuedBatchCount: number;
+ };
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-window.type.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-window.type.ts
new file mode 100644
index 00000000000..7439a6be220
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/types/fireflies-backfill-window.type.ts
@@ -0,0 +1,4 @@
+export type FirefliesBackfillWindow = {
+ fromDate: string;
+ toDate: string;
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/types/import-missing-fireflies-calls-result.type.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/types/import-missing-fireflies-calls-result.type.ts
new file mode 100644
index 00000000000..ee9b4a0386a
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/types/import-missing-fireflies-calls-result.type.ts
@@ -0,0 +1,13 @@
+type ImportMissingFirefliesCallsCounts = {
+ importedCallCount: number;
+ erroredCallCount: number;
+ skippedCallCount: number;
+};
+
+export type ImportMissingFirefliesCallsResult =
+ | (ImportMissingFirefliesCallsCounts & {
+ status: 'completed';
+ })
+ | (ImportMissingFirefliesCallsCounts & {
+ status: 'retryable-error';
+ });
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/types/list-fireflies-transcript-ids-result.type.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/types/list-fireflies-transcript-ids-result.type.ts
new file mode 100644
index 00000000000..d6c990b1b94
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/types/list-fireflies-transcript-ids-result.type.ts
@@ -0,0 +1,10 @@
+export type ListFirefliesTranscriptIdsResult =
+ | {
+ ok: true;
+ transcriptIds: string[];
+ }
+ | {
+ ok: false;
+ status: number;
+ errorMessage: string;
+ };
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/build-fireflies-backfill-window.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/build-fireflies-backfill-window.test.ts
new file mode 100644
index 00000000000..3b98e4e2e6b
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/build-fireflies-backfill-window.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildFirefliesBackfillWindow } from 'src/logic-functions/utils/build-fireflies-backfill-window.util';
+
+describe('buildFirefliesBackfillWindow', () => {
+ it('creates a date window ending now for the requested days', () => {
+ const nowMilliseconds = Date.parse('2026-07-30T00:00:00.000Z');
+
+ expect(
+ buildFirefliesBackfillWindow({ windowDays: 30, nowMilliseconds }),
+ ).toEqual({
+ fromDate: '2026-06-30T00:00:00.000Z',
+ toDate: '2026-07-30T00:00:00.000Z',
+ });
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/fireflies-api-request.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/fireflies-api-request.test.ts
index 1d0a60bfd14..1231ede3710 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/fireflies-api-request.test.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/fireflies-api-request.test.ts
@@ -4,6 +4,7 @@ import { firefliesApiRequest } from 'src/logic-functions/utils/fireflies-api-req
describe('firefliesApiRequest', () => {
afterEach(() => {
+ vi.useRealTimers();
vi.unstubAllGlobals();
});
@@ -85,19 +86,23 @@ describe('firefliesApiRequest', () => {
expect(fetchMock).toHaveBeenCalledTimes(3);
});
- it('does not retry rate limiting so the sweep can pause and continue', async () => {
+ it('retries rate limiting using the shared retry policy', async () => {
+ vi.useFakeTimers();
const fetchMock = vi
.fn()
.mockResolvedValue(new Response('rate limited', { status: 429 }));
vi.stubGlobal('fetch', fetchMock);
- const result = await firefliesApiRequest({
+ const resultPromise = firefliesApiRequest({
apiKey: 'api-key',
query: 'query Test { user { user_id } }',
});
+ await vi.runAllTimersAsync();
+ const result = await resultPromise;
+
expect(result).toEqual(expect.objectContaining({ ok: false, status: 429 }));
- expect(fetchMock).toHaveBeenCalledTimes(1);
+ expect(fetchMock).toHaveBeenCalledTimes(3);
});
});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/list-fireflies-transcript-ids.test.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/list-fireflies-transcript-ids.test.ts
new file mode 100644
index 00000000000..9fad7733209
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/__tests__/list-fireflies-transcript-ids.test.ts
@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+ buildListedTranscript,
+ FIREFLIES_API_KEY,
+ FIREFLIES_BACKFILL_FROM_DATE,
+ FIREFLIES_BACKFILL_TO_DATE,
+ getListRequestVariables,
+ serveFirefliesApi,
+} from 'src/logic-functions/flows/__tests__/import-missing-fireflies-calls.test-support';
+import { FIREFLIES_BACKFILL_PAGE_SIZE } from 'src/logic-functions/constants/fireflies-backfill-page-size.constant';
+import { listFirefliesTranscriptIds } from 'src/logic-functions/utils/list-fireflies-transcript-ids.util';
+
+vi.mock(
+ 'src/logic-functions/constants/fireflies-backfill-max-page-count.constant',
+ () => ({ FIREFLIES_BACKFILL_MAX_PAGE_COUNT: 2 }),
+);
+
+const fetchMock = vi.fn();
+
+const buildFullPage = (pageIndex: number) =>
+ Array.from({ length: FIREFLIES_BACKFILL_PAGE_SIZE }, (_, callIndex) =>
+ buildListedTranscript(
+ `call-${pageIndex}-${callIndex}`,
+ Date.parse('2026-06-02T10:00:00.000Z'),
+ ),
+ );
+
+describe('listFirefliesTranscriptIds', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.stubGlobal('fetch', fetchMock);
+ });
+
+ afterEach(() => {
+ vi.unstubAllGlobals();
+ });
+
+ it('collects every transcript id across pages', async () => {
+ const shortPage = [
+ buildListedTranscript(
+ 'call-last',
+ Date.parse('2026-06-01T10:00:00.000Z'),
+ ),
+ ];
+
+ serveFirefliesApi([buildFullPage(0), shortPage], fetchMock);
+
+ const result = await listFirefliesTranscriptIds({
+ apiKey: FIREFLIES_API_KEY,
+ fromDate: FIREFLIES_BACKFILL_FROM_DATE,
+ toDate: FIREFLIES_BACKFILL_TO_DATE,
+ });
+
+ expect(result).toEqual({
+ ok: true,
+ transcriptIds: [...buildFullPage(0).map(({ id }) => id), 'call-last'],
+ });
+ expect(getListRequestVariables(fetchMock)).toEqual([
+ expect.objectContaining({ skip: 0 }),
+ expect.objectContaining({ skip: FIREFLIES_BACKFILL_PAGE_SIZE }),
+ ]);
+ });
+
+ it('stops at an empty first page', async () => {
+ serveFirefliesApi([[]], fetchMock);
+
+ const result = await listFirefliesTranscriptIds({
+ apiKey: FIREFLIES_API_KEY,
+ fromDate: FIREFLIES_BACKFILL_FROM_DATE,
+ toDate: FIREFLIES_BACKFILL_TO_DATE,
+ });
+
+ expect(result).toEqual({ ok: true, transcriptIds: [] });
+ expect(getListRequestVariables(fetchMock)).toHaveLength(1);
+ });
+
+ it('propagates a Fireflies listing failure', async () => {
+ fetchMock.mockResolvedValue(
+ new Response('invalid request', { status: 400 }),
+ );
+
+ const result = await listFirefliesTranscriptIds({
+ apiKey: FIREFLIES_API_KEY,
+ fromDate: FIREFLIES_BACKFILL_FROM_DATE,
+ toDate: FIREFLIES_BACKFILL_TO_DATE,
+ });
+
+ expect(result).toEqual(expect.objectContaining({ ok: false, status: 400 }));
+ });
+
+ it('fails after the bounded number of full pages', async () => {
+ serveFirefliesApi([buildFullPage(0), buildFullPage(1)], fetchMock);
+
+ const result = await listFirefliesTranscriptIds({
+ apiKey: FIREFLIES_API_KEY,
+ fromDate: FIREFLIES_BACKFILL_FROM_DATE,
+ toDate: FIREFLIES_BACKFILL_TO_DATE,
+ });
+
+ expect(result).toEqual({
+ ok: false,
+ status: 0,
+ errorMessage: 'Fireflies backfill listing exceeded 2 pages',
+ });
+ expect(getListRequestVariables(fetchMock)).toHaveLength(2);
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/build-fireflies-backfill-window.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/build-fireflies-backfill-window.util.ts
new file mode 100644
index 00000000000..51822d0c89c
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/build-fireflies-backfill-window.util.ts
@@ -0,0 +1,15 @@
+import { MILLISECONDS_PER_DAY } from 'src/logic-functions/constants/milliseconds-per-day.constant';
+import { type FirefliesBackfillWindow } from 'src/logic-functions/types/fireflies-backfill-window.type';
+
+export const buildFirefliesBackfillWindow = ({
+ windowDays,
+ nowMilliseconds,
+}: {
+ windowDays: number;
+ nowMilliseconds: number;
+}): FirefliesBackfillWindow => ({
+ fromDate: new Date(
+ nowMilliseconds - windowDays * MILLISECONDS_PER_DAY,
+ ).toISOString(),
+ toDate: new Date(nowMilliseconds).toISOString(),
+});
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-api-key.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-api-key.ts
index b1db0dc6acd..1ab2b741558 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-api-key.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-api-key.ts
@@ -11,7 +11,7 @@ export const getFirefliesApiKey = ():
return {
success: false,
error:
- 'Fireflies is not configured. Open the Twenty Fireflies app settings and set the FIREFLIES_API_KEY application variable (Fireflies → Integrations → Fireflies API → Generate API key).',
+ 'Fireflies is not configured. Open the Fireflies app settings and set the FIREFLIES_API_KEY application variable (Fireflies → Integrations → Fireflies API → Generate API key).',
};
}
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-webhook-secret.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-webhook-secret.ts
index c3d2d165678..2826a9b73d3 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-webhook-secret.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/get-fireflies-webhook-secret.ts
@@ -11,7 +11,7 @@ export const getFirefliesWebhookSecret = ():
return {
success: false,
error:
- 'FIREFLIES_WEBHOOK_SECRET application variable is not set. Set it in Twenty Fireflies app settings, then configure the same value on the Fireflies side when registering the webhook URL.',
+ 'FIREFLIES_WEBHOOK_SECRET application variable is not set. Set it in Fireflies app settings, then configure the same value on the Fireflies side when registering the webhook URL.',
};
}
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/is-retryable-fireflies-api-status.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/is-retryable-fireflies-api-status.util.ts
index da3ded9bb95..3e94eb8fcd9 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/is-retryable-fireflies-api-status.util.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/is-retryable-fireflies-api-status.util.ts
@@ -1,3 +1,2 @@
-// 429 is excluded: rate limits pause the sweep and continue via cursor instead.
export const isRetryableFirefliesApiStatus = (status: number): boolean =>
- status === 0 || status === 408 || status >= 500;
+ status === 0 || status === 408 || status === 429 || status >= 500;
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcript-ids.util.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcript-ids.util.ts
new file mode 100644
index 00000000000..c3155bb6988
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcript-ids.util.ts
@@ -0,0 +1,59 @@
+import { FIREFLIES_BACKFILL_MAX_PAGE_COUNT } from 'src/logic-functions/constants/fireflies-backfill-max-page-count.constant';
+import { FIREFLIES_BACKFILL_PAGE_SIZE } from 'src/logic-functions/constants/fireflies-backfill-page-size.constant';
+import { type ListFirefliesTranscriptIdsResult } from 'src/logic-functions/types/list-fireflies-transcript-ids-result.type';
+import { listFirefliesTranscripts } from 'src/logic-functions/utils/list-fireflies-transcripts.util';
+
+export const listFirefliesTranscriptIds = async ({
+ apiKey,
+ fromDate,
+ toDate,
+}: {
+ apiKey: string;
+ fromDate: string;
+ toDate: string;
+}): Promise<ListFirefliesTranscriptIdsResult> => {
+ const transcriptIds: string[] = [];
+ let skip = 0;
+
+ for (
+ let pageIndex = 0;
+ pageIndex < FIREFLIES_BACKFILL_MAX_PAGE_COUNT;
+ pageIndex++
+ ) {
+ const listFirefliesTranscriptsResult = await listFirefliesTranscripts({
+ apiKey,
+ fromDate,
+ toDate,
+ limit: FIREFLIES_BACKFILL_PAGE_SIZE,
+ skip,
+ });
+
+ if (!listFirefliesTranscriptsResult.ok) {
+ return {
+ ok: false,
+ status: listFirefliesTranscriptsResult.status,
+ errorMessage: listFirefliesTranscriptsResult.errorMessage,
+ };
+ }
+
+ transcriptIds.push(
+ ...listFirefliesTranscriptsResult.data.map(
+ (firefliesCallSummary) => firefliesCallSummary.id,
+ ),
+ );
+
+ if (
+ listFirefliesTranscriptsResult.data.length < FIREFLIES_BACKFILL_PAGE_SIZE
+ ) {
+ return { ok: true, transcriptIds };
+ }
+
+ skip += listFirefliesTranscriptsResult.data.length;
+ }
+
+ return {
+ ok: false,
+ status: 0,
+ errorMessage: `Fireflies backfill listing exceeded ${FIREFLIES_BACKFILL_MAX_PAGE_COUNT} pages`,
+ };
+};
diff --git a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.ts b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.util.ts
similarity index 85%
rename from packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.ts
rename to packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.util.ts
index 5f3e44abcd8..4f8da68ae6d 100644
--- a/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.ts
+++ b/packages/twenty-apps/public/fireflies/src/logic-functions/utils/list-fireflies-transcripts.util.ts
@@ -15,6 +15,7 @@ const TRANSCRIPTS_QUERY = `
$fromDate: DateTime
$toDate: DateTime
$limit: Int
+ $skip: Int
) {
transcripts(
keyword: $keyword
@@ -23,6 +24,7 @@ const TRANSCRIPTS_QUERY = `
fromDate: $fromDate
toDate: $toDate
limit: $limit
+ skip: $skip
) {
id
title
@@ -40,9 +42,9 @@ type TranscriptsResponse = {
transcripts: FirefliesTranscript[] | null;
};
-export type FirefliesKeywordScope = 'title' | 'sentences' | 'all';
+type FirefliesKeywordScope = 'title' | 'sentences' | 'all';
-export type ListFirefliesTranscriptsArgs = {
+type ListFirefliesTranscriptsArgs = {
apiKey: string;
keyword?: string;
keywordScope?: FirefliesKeywordScope;
@@ -50,12 +52,17 @@ export type ListFirefliesTranscriptsArgs = {
fromDate?: string;
toDate?: string;
limit?: number;
+ skip?: number;
};
-const toCallSummary = (transcript: FirefliesTranscript): FirefliesCallSummary => ({
+const toCallSummary = (
+ transcript: FirefliesTranscript,
+): FirefliesCallSummary => ({
id: transcript.id,
title: transcript.title,
- date: isDefined(transcript.date) ? new Date(transcript.date).toISOString() : null,
+ date: isDefined(transcript.date)
+ ? new Date(transcript.date).toISOString()
+ : null,
durationMinutes: transcript.duration,
participants: transcript.participants,
hostEmail: transcript.host_email ?? transcript.organizer_email ?? null,
@@ -71,6 +78,7 @@ export const listFirefliesTranscripts = async ({
fromDate,
toDate,
limit,
+ skip,
}: ListFirefliesTranscriptsArgs): Promise<
FirefliesApiResult<FirefliesCallSummary[]>
> => {
@@ -84,6 +92,7 @@ export const listFirefliesTranscripts = async ({
fromDate,
toDate,
limit,
+ skip,
},
});
diff --git a/packages/twenty-apps/public/fireflies/src/roles/default-function.role.ts b/packages/twenty-apps/public/fireflies/src/roles/default-function.role.ts
index f8d07c136aa..05654509734 100644
--- a/packages/twenty-apps/public/fireflies/src/roles/default-function.role.ts
+++ b/packages/twenty-apps/public/fireflies/src/roles/default-function.role.ts
@@ -7,7 +7,7 @@ import { DEFAULT_ROLE_UNIVERSAL_IDENTIFIER } from 'src/constants/universal-ident
export default defineApplicationRole({
universalIdentifier: DEFAULT_ROLE_UNIVERSAL_IDENTIFIER,
- label: 'Twenty Fireflies sync role',
+ label: 'Fireflies sync role',
description:
'Reads CalendarEvent and CalendarChannelEventAssociation to locate the meeting matching a Fireflies call (from an incoming webhook or from the on-demand Sync Fireflies Call workflow tool), and writes the synced transcript and summary into a CallRecording record linked to that meeting. The list / search workflow tools only call the Fireflies API and do not require any Twenty object permissions.',
canReadAllObjectRecords: false,
diff --git a/packages/twenty-apps/public/fireflies/src/utils/__tests__/chunk-into-batches.test.ts b/packages/twenty-apps/public/fireflies/src/utils/__tests__/chunk-into-batches.test.ts
new file mode 100644
index 00000000000..04da0363caa
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/utils/__tests__/chunk-into-batches.test.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest';
+
+import { chunkIntoBatches } from 'src/utils/chunk-into-batches.util';
+
+describe('chunkIntoBatches', () => {
+ it('splits items into batches of the requested size', () => {
+ expect(chunkIntoBatches(['a', 'b', 'c', 'd', 'e'], 2)).toEqual([
+ ['a', 'b'],
+ ['c', 'd'],
+ ['e'],
+ ]);
+ });
+
+ it('returns no batches for an empty list', () => {
+ expect(chunkIntoBatches([], 2)).toEqual([]);
+ });
+
+ it('returns a single batch when the list fits the batch size', () => {
+ expect(chunkIntoBatches(['a', 'b'], 20)).toEqual([['a', 'b']]);
+ });
+
+ it.each([0, -1, 1.5])('rejects an invalid batch size of %s', (batchSize) => {
+ expect(() => chunkIntoBatches(['a'], batchSize)).toThrow(
+ 'Batch size must be a positive integer',
+ );
+ });
+});
diff --git a/packages/twenty-apps/public/fireflies/src/utils/chunk-into-batches.util.ts b/packages/twenty-apps/public/fireflies/src/utils/chunk-into-batches.util.ts
new file mode 100644
index 00000000000..8c9f5f87be1
--- /dev/null
+++ b/packages/twenty-apps/public/fireflies/src/utils/chunk-into-batches.util.ts
@@ -0,0 +1,14 @@
+export const chunkIntoBatches = <TItem>(
+ items: TItem[],
+ batchSize: number,
+): TItem[][] => {
+ if (!Number.isInteger(batchSize) || batchSize <= 0) {
+ throw new Error('Batch size must be a positive integer');
+ }
+
+ return Array.from(
+ { length: Math.ceil(items.length / batchSize) },
+ (_, batchIndex) =>
+ items.slice(batchIndex * batchSize, (batchIndex + 1) * batchSize),
+ );
+};
diff --git a/packages/twenty-apps/public/fireflies/yarn.lock b/packages/twenty-apps/public/fireflies/yarn.lock
index 9674b419ad0..138cbda4fb1 100644
--- a/packages/twenty-apps/public/fireflies/yarn.lock
+++ b/packages/twenty-apps/public/fireflies/yarn.lock
@@ -1375,8 +1375,8 @@ __metadata:
oxlint: "npm:^0.16.0"
react: "npm:^18.2.0"
react-dom: "npm:^18.2.0"
- twenty-client-sdk: "npm:2.23.0-alpha.2"
- twenty-sdk: "npm:2.23.0-alpha.2"
+ twenty-client-sdk: "npm:2.26.0"
+ twenty-sdk: "npm:2.26.0"
twenty-ui: "npm:^1.0.0-alpha.1"
typescript: "npm:^5.9.3"
vite-tsconfig-paths: "npm:^4.2.1"
@@ -3643,22 +3643,22 @@ __metadata:
languageName: node
linkType: hard
-"twenty-client-sdk@npm:2.23.0-alpha.2":
- version: 2.23.0-alpha.2
- resolution: "twenty-client-sdk@npm:2.23.0-alpha.2"
+"twenty-client-sdk@npm:2.26.0":
+ version: 2.26.0
+ resolution: "twenty-client-sdk@npm:2.26.0"
dependencies:
"@genql/runtime": "npm:^2.10.0"
esbuild: "npm:^0.28.1"
graphql: "npm:^16.8.1"
lodash: "npm:^4.17.21"
prettier: "npm:^3.8.3"
- checksum: 10c0/9bdee21c07c3a3369199289e16860213c9dde995e62bbdbce20ad0aa4490d8a664cd3c9a1c654bc6291189c8941616dda38df359828472330b15efdf9f4c089f
+ checksum: 10c0/f5d184567877d10175f887e5ee81510d43c8c5c4d98ad73fbc757a28547da8299ccbe3072d9de33f8c9e9a41eafe06f335b3706196f4a92fd33b0cdcc5d47acf
languageName: node
linkType: hard
-"twenty-sdk@npm:2.23.0-alpha.2":
- version: 2.23.0-alpha.2
- resolution: "twenty-sdk@npm:2.23.0-alpha.2"
+"twenty-sdk@npm:2.26.0":
+ version: 2.26.0
+ resolution: "twenty-sdk@npm:2.26.0"
dependencies:
"@sniptt/guards": "npm:^0.2.0"
axios: "npm:^1.16.0"
@@ -3677,12 +3677,12 @@ __metadata:
semver: "npm:7.6.3"
sharp: "npm:^0.34.5"
tinyglobby: "npm:^0.2.15"
- twenty-client-sdk: "npm:2.23.0-alpha.2"
+ twenty-client-sdk: "npm:2.26.0"
typescript: "npm:^5.9.3"
uuid: "npm:^13.0.2"
bin:
twenty: dist/cli.cjs
- checksum: 10c0/82f820a23bc84fb45b6ca06e237b02d71cb9c5fddc98bcdaa4838e1268a7c687242ff89f429ae7c5b30c211325de8f8d349d57f18acdb8130c1d2f677c1db913
+ checksum: 10c0/e3edaced59a93bfa3579dc863f799693c9361fc4993eec6942f711a394a678dff21a9c790a3ad6b1683f71ed3f80ec7e6bcc4172d123f538912f88ff7ca32cfa
languageName: node
linkType: hard