@twentyhq/call-recorder 1.0.0

package/src/logic-functions/flows/reschedule-call-recording-bot.util.ts

@@ -0,0 +1,69 @@
+import { isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { type MeetingRecording } from 'src/logic-functions/types/meeting-recording.type';
+import { buildRecallRoutingMetadata } from 'src/logic-functions/domain/build-recall-routing-metadata.util';
+import { computeRecallBotJoinAt } from 'src/logic-functions/domain/compute-recall-bot-join-at.util';
+import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';
+import { rescheduleRecallBot } from 'src/logic-functions/recall-api/reschedule-recall-bot.util';
+import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';
+
+const RECALL_BOT_NOT_FOUND_STATUS = 404;
+
+export const rescheduleCallRecordingBot = async (
+  client: CoreApiClient,
+  { callRecording, calendarEvent }: MeetingRecording,
+): Promise<void> => {
+  const externalBotId = callRecording.externalBotId;
+
+  if (isUndefined(externalBotId)) {
+    return;
+  }
+
+  const meetingUrl = calendarEvent.conferenceLinkUrl;
+  const meetingStartsAt = calendarEvent.startsAt;
+
+  if (isUndefined(meetingUrl) || isUndefined(meetingStartsAt)) {
+    return;
+  }
+
+  const joinAt = computeRecallBotJoinAt(meetingStartsAt);
+
+  const workspaceId = getCurrentWorkspaceId();
+
+  if (isUndefined(workspaceId)) {
+    console.warn(
+      `[call-recorder] cannot reschedule Recall bot for callRecording ${callRecording.id}: workspace id unavailable`,
+    );
+
+    return;
+  }
+
+  const rescheduleResult = await rescheduleRecallBot({
+    externalBotId,
+    meetingUrl,
+    joinAt,
+    metadata: buildRecallRoutingMetadata({
+      callRecordingId: callRecording.id,
+      workspaceId,
+    }),
+  });
+
+  if (rescheduleResult.ok) {
+    return;
+  }
+
+  // The bot vanished externally; drop the id so the stale-state cron re-creates it as the single writer.
+  if (rescheduleResult.status === RECALL_BOT_NOT_FOUND_STATUS) {
+    await updateCallRecording(client, {
+      id: callRecording.id,
+      data: { externalBotId: null },
+    });
+
+    return;
+  }
+
+  console.warn(
+    `[call-recorder] failed to update Recall bot for callRecording ${callRecording.id}: ${rescheduleResult.errorMessage}`,
+  );
+};

package/src/logic-functions/process-recall-webhook.ts

@@ -0,0 +1,23 @@
+import { CoreApiClient } from 'twenty-client-sdk/core';
+import { defineLogicFunction } from 'twenty-sdk/define';
+
+import { PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/process-recall-webhook-logic-function-universal-identifier';
+import { handleRecallWebhook } from 'src/logic-functions/flows/handle-recall-webhook.util';
+import { type RecallWebhookBody } from 'src/logic-functions/recall-api/parse-recall-webhook-event.util';
+
+// Dispatched by the recall-webhook resolver; runs in the resolved workspace so the client is workspace-scoped.
+export const processRecallWebhookHandler = (body: RecallWebhookBody) =>
+  handleRecallWebhook({
+    client: new CoreApiClient(),
+    body,
+  });
+
+export default defineLogicFunction({
+  universalIdentifier:
+    PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: 'process-recall-webhook',
+  description:
+    'Updates the matching CallRecording lifecycle status from a verified Recall.ai webhook event.',
+  timeoutSeconds: 30,
+  handler: processRecallWebhookHandler,
+});

package/src/logic-functions/recall-api/__tests__/extract-recall-bot-convergence.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it } from 'vitest';
+
+import { extractRecallBotConvergence } from 'src/logic-functions/recall-api/extract-recall-bot-convergence.util';
+
+describe('extractRecallBotConvergence', () => {
+  it('maps the latest status change code to a call recording status', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'joining_call', created_at: '2026-01-01T12:58:00.000Z' },
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:00.000Z' },
+        { code: 'call_ended', created_at: '2026-01-01T14:00:00.000Z' },
+        { code: 'done', created_at: '2026-01-01T14:05:00.000Z' },
+      ],
+    });
+
+    // COMPLETED is reserved for full artifact ingestion, never bot state.
+    expect(convergence.status).toBe('PROCESSING');
+    expect(convergence.isRecallRecordingDone).toBe(true);
+  });
+
+  it('uses created_at to find the latest status when Recall returns status changes out of order', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'done', created_at: '2026-01-01T14:05:00.000Z' },
+        { code: 'joining_call', created_at: '2026-01-01T12:58:00.000Z' },
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:00.000Z' },
+      ],
+    });
+
+    expect(convergence.status).toBe('PROCESSING');
+  });
+
+  it('prefers recording-object timestamps over status change entries', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:30.000Z' },
+        { code: 'call_ended', created_at: '2026-01-01T14:00:30.000Z' },
+      ],
+      recordings: [
+        {
+          id: 'recall-recording-1',
+          started_at: '2026-01-01T13:02:00.000Z',
+          completed_at: '2026-01-01T14:00:00.000Z',
+        },
+      ],
+    });
+
+    expect(convergence).toEqual({
+      status: 'PROCESSING',
+      failureReason: undefined,
+      startedAt: '2026-01-01T13:02:00.000Z',
+      endedAt: '2026-01-01T14:00:00.000Z',
+      externalRecordingId: 'recall-recording-1',
+      isRecallRecordingDone: true,
+    });
+  });
+
+  it('falls back to status change timestamps when recordings carry none', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:00.000Z' },
+        { code: 'call_ended', created_at: '2026-01-01T14:00:00.000Z' },
+      ],
+      recordings: [{ id: 'recall-recording-1' }],
+    });
+
+    expect(convergence).toEqual({
+      status: 'PROCESSING',
+      failureReason: undefined,
+      startedAt: '2026-01-01T13:02:00.000Z',
+      endedAt: '2026-01-01T14:00:00.000Z',
+      externalRecordingId: 'recall-recording-1',
+      isRecallRecordingDone: false,
+    });
+  });
+
+  it('normalizes microsecond-precision Recall timestamps to millisecond ISO', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'done', created_at: '2026-06-10T12:20:00.123456+00:00' },
+      ],
+      recordings: [
+        {
+          id: 'recall-recording-1',
+          started_at: '2026-06-10T11:02:28.281597+00:00',
+          completed_at: '2026-06-10T12:17:28.281597+00:00',
+        },
+      ],
+    });
+
+    expect(convergence.startedAt).toBe('2026-06-10T11:02:28.281Z');
+    expect(convergence.endedAt).toBe('2026-06-10T12:17:28.281Z');
+  });
+
+  it('returns nothing derivable from an empty bot response', () => {
+    expect(extractRecallBotConvergence({})).toEqual({
+      status: undefined,
+      failureReason: undefined,
+      startedAt: undefined,
+      endedAt: undefined,
+      externalRecordingId: undefined,
+      isRecallRecordingDone: false,
+    });
+  });
+
+  it('skips malformed status change entries', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        null,
+        'not-an-object',
+        { created_at: '2026-01-01T13:00:00.000Z' },
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:00.000Z' },
+      ],
+      recordings: 'not-an-array',
+    });
+
+    expect(convergence).toEqual({
+      status: 'RECORDING',
+      failureReason: undefined,
+      startedAt: '2026-01-01T13:02:00.000Z',
+      endedAt: undefined,
+      externalRecordingId: undefined,
+      isRecallRecordingDone: false,
+    });
+  });
+
+  it('carries the failing Recall status code as the failure reason', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'joining_call', created_at: '2026-01-01T12:58:00.000Z' },
+        {
+          code: 'recording_permission_denied',
+          created_at: '2026-01-01T13:02:00.000Z',
+        },
+      ],
+    });
+
+    expect(convergence.status).toBe('FAILED');
+    expect(convergence.failureReason).toBe('recording_permission_denied');
+  });
+
+  it('leaves the status undefined for unknown latest codes', () => {
+    const convergence = extractRecallBotConvergence({
+      status_changes: [
+        { code: 'in_call_recording', created_at: '2026-01-01T13:02:00.000Z' },
+        { code: 'some_future_code', created_at: '2026-01-01T13:30:00.000Z' },
+      ],
+    });
+
+    expect(convergence.status).toBeUndefined();
+    expect(convergence.startedAt).toBe('2026-01-01T13:02:00.000Z');
+  });
+});

package/src/logic-functions/recall-api/__tests__/extract-recall-media-urls.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+
+import { extractRecallMediaUrls } from 'src/logic-functions/recall-api/extract-recall-media-urls.util';
+
+describe('extractRecallMediaUrls', () => {
+  it('reads both download urls flat from the v1.11 media shortcuts', () => {
+    expect(
+      extractRecallMediaUrls({
+        id: 'recall-recording-1',
+        media_shortcuts: {
+          video_mixed: {
+            download_url: 'https://media.example.com/video.mp4',
+          },
+          audio_mixed: {
+            download_url: 'https://media.example.com/audio.mp3',
+          },
+        },
+      }),
+    ).toEqual({
+      videoUrl: 'https://media.example.com/video.mp4',
+      audioUrl: 'https://media.example.com/audio.mp3',
+    });
+  });
+
+  it('falls back to the nested data.download_url shape', () => {
+    expect(
+      extractRecallMediaUrls({
+        id: 'recall-recording-1',
+        media_shortcuts: {
+          video_mixed: {
+            data: { download_url: 'https://media.example.com/video.mp4' },
+          },
+          audio_mixed: {
+            data: { download_url: 'https://media.example.com/audio.mp3' },
+          },
+        },
+      }),
+    ).toEqual({
+      videoUrl: 'https://media.example.com/video.mp4',
+      audioUrl: 'https://media.example.com/audio.mp3',
+    });
+  });
+
+  it('returns undefined urls when artifacts are absent', () => {
+    expect(
+      extractRecallMediaUrls({
+        id: 'recall-recording-1',
+        media_shortcuts: {
+          video_mixed: {},
+        },
+      }),
+    ).toEqual({ videoUrl: undefined, audioUrl: undefined });
+  });
+
+  it('tolerates malformed recording payloads', () => {
+    expect(extractRecallMediaUrls({})).toEqual({
+      videoUrl: undefined,
+      audioUrl: undefined,
+    });
+    expect(extractRecallMediaUrls({ media_shortcuts: 'not-a-record' })).toEqual(
+      {
+        videoUrl: undefined,
+        audioUrl: undefined,
+      },
+    );
+  });
+});