@twentyhq/call-recorder 1.0.0

package/src/front-components/utils/get-speaker-name-match-keys.util.ts

@@ -0,0 +1,64 @@
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+const MINIMUM_FUZZY_MATCH_KEY_LENGTH = 5;
+
+export const getSpeakerNameMatchKeys = (speakerName: string): string[] => {
+  const normalizedSpeakerName = normalizeSpeakerName(speakerName);
+  const compactSpeakerName = getCompactSpeakerName(normalizedSpeakerName);
+  const compactSpeakerNameWithoutDigits = compactSpeakerName.replace(/\d/g, '');
+  const abbreviatedSpeakerNameMatchKey = getAbbreviatedSpeakerNameMatchKey(
+    normalizedSpeakerName,
+  );
+
+  return [
+    ...new Set(
+      [
+        normalizedSpeakerName,
+        compactSpeakerName,
+        compactSpeakerNameWithoutDigits,
+        abbreviatedSpeakerNameMatchKey,
+      ].filter(isSpeakerNameMatchKey),
+    ),
+  ];
+};
+
+const normalizeSpeakerName = (speakerName: string): string =>
+  speakerName
+    .trim()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLocaleLowerCase();
+
+const getCompactSpeakerName = (speakerName: string): string =>
+  normalizeSpeakerName(speakerName).replace(/[^a-z0-9]/g, '');
+
+const getAbbreviatedSpeakerNameMatchKey = (
+  speakerName: string,
+): string | undefined => {
+  const speakerNameParts = normalizeSpeakerName(speakerName)
+    .split(/\s+/)
+    .map(getCompactSpeakerName)
+    .filter(isNonEmptyString);
+
+  if (speakerNameParts.length < 2) {
+    return undefined;
+  }
+
+  const firstSpeakerNamePart = speakerNameParts[0];
+  const lastSpeakerNamePart = speakerNameParts[speakerNameParts.length - 1];
+  const abbreviatedSpeakerNameMatchKey = `${firstSpeakerNamePart.slice(
+    0,
+    4,
+  )}${lastSpeakerNamePart.slice(0, 4)}`;
+
+  return abbreviatedSpeakerNameMatchKey.length >= MINIMUM_FUZZY_MATCH_KEY_LENGTH
+    ? abbreviatedSpeakerNameMatchKey
+    : undefined;
+};
+
+const isSpeakerNameMatchKey = (
+  speakerNameMatchKey: string | undefined,
+): speakerNameMatchKey is string =>
+  isNonEmptyString(speakerNameMatchKey) &&
+  (speakerNameMatchKey.includes(' ') ||
+    speakerNameMatchKey.length >= MINIMUM_FUZZY_MATCH_KEY_LENGTH);

package/src/front-components/utils/get-video-file-extension.util.ts

@@ -0,0 +1,23 @@
+import { isUndefined } from '@sniptt/guards';
+
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+export const getVideoFileExtension = ({
+  extension,
+  label,
+}: {
+  extension: string | null;
+  label: string | null;
+}): string | undefined => {
+  const labelParts = label?.split('.');
+  const videoFileExtension =
+    extension ??
+    (isUndefined(labelParts) ? undefined : labelParts[labelParts.length - 1]);
+  const normalizedVideoFileExtension = videoFileExtension
+    ?.toLowerCase()
+    .replace(/^\./, '');
+
+  return isNonEmptyString(normalizedVideoFileExtension)
+    ? normalizedVideoFileExtension
+    : undefined;
+};

package/src/front-components/utils/parse-transcript-entries.util.ts

@@ -0,0 +1,85 @@
+import { isArray, isNumber, isUndefined } from '@sniptt/guards';
+
+import {
+  type TranscriptEntry,
+  type TranscriptWord,
+} from 'src/front-components/types/transcript-entry.type';
+import { asRecord } from 'src/logic-functions/utils/as-record.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+type TranscriptRecord = NonNullable<ReturnType<typeof asRecord>>;
+
+const isTranscriptRecord = (
+  candidate: TranscriptRecord | undefined,
+): candidate is TranscriptRecord => !isUndefined(candidate);
+
+const readRelativeTimestamp = (
+  timestamp: TranscriptRecord | undefined,
+): number | undefined => {
+  const relativeTimestamp = timestamp?.relative;
+
+  return isNumber(relativeTimestamp) && Number.isFinite(relativeTimestamp)
+    ? relativeTimestamp
+    : undefined;
+};
+
+const readTranscriptWord = (
+  candidate: TranscriptRecord,
+): TranscriptWord | undefined => {
+  if (!isNonEmptyString(candidate.text)) {
+    return undefined;
+  }
+
+  return {
+    text: candidate.text.trim(),
+    startSeconds: readRelativeTimestamp(asRecord(candidate.start_timestamp)),
+    endSeconds: readRelativeTimestamp(asRecord(candidate.end_timestamp)),
+  };
+};
+
+const readSpeakerName = (participant: TranscriptRecord | undefined): string => {
+  const name = participant?.name;
+
+  return isNonEmptyString(name) ? name.trim() : 'Unknown speaker';
+};
+
+const readTranscriptEntry = (
+  candidate: TranscriptRecord,
+): TranscriptEntry | undefined => {
+  if (!isArray(candidate.words)) {
+    return undefined;
+  }
+
+  const words = candidate.words
+    .map(asRecord)
+    .filter(isTranscriptRecord)
+    .map(readTranscriptWord)
+    .filter((word): word is TranscriptWord => !isUndefined(word));
+
+  if (words.length === 0) {
+    return undefined;
+  }
+
+  return {
+    speakerName: readSpeakerName(asRecord(candidate.participant)),
+    startSeconds: words[0].startSeconds,
+    endSeconds: words[words.length - 1].endSeconds,
+    text: words.map((word) => word.text).join(' '),
+    words,
+  };
+};
+
+// Undefined means the value is not a diarized transcript; malformed entries are skipped, not fatal.
+export const parseTranscriptEntries = (
+  transcript: unknown,
+): TranscriptEntry[] | undefined => {
+  if (!isArray(transcript)) {
+    return undefined;
+  }
+
+  return transcript
+    .map(asRecord)
+    .filter(isTranscriptRecord)
+    .map(readTranscriptEntry)
+    .filter((entry): entry is TranscriptEntry => !isUndefined(entry));
+};

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

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import processRecallWebhookLogicFunction, {
+  processRecallWebhookHandler,
+} from 'src/logic-functions/process-recall-webhook';
+
+const handleRecallWebhookMock = vi.hoisted(() => vi.fn());
+const coreApiClientMock = vi.hoisted(() => vi.fn());
+
+vi.mock('src/logic-functions/flows/handle-recall-webhook.util', () => ({
+  handleRecallWebhook: handleRecallWebhookMock,
+}));
+
+vi.mock('twenty-client-sdk/core', () => ({
+  CoreApiClient: coreApiClientMock,
+}));
+
+const buildRecordingDoneWebhookBody = () => ({
+  event: 'recording.done',
+  data: {
+    bot: {
+      id: 'recall-bot-1',
+      metadata: {
+        twentyWorkspaceId: '123e4567-e89b-12d3-a456-426614174000',
+        twentyCallRecordingId: 'call-recording-1',
+      },
+    },
+    recording: { id: 'recall-recording-1' },
+  },
+});
+
+describe('process-recall-webhook', () => {
+  beforeEach(() => {
+    handleRecallWebhookMock.mockReset();
+    handleRecallWebhookMock.mockResolvedValue({ status: 'updated' });
+    coreApiClientMock.mockReset();
+  });
+
+  it('declares no external trigger so it only runs when dispatched by the resolver', () => {
+    expect(processRecallWebhookLogicFunction.success).toBe(true);
+    expect(
+      'serverRouteTriggerSettings' in processRecallWebhookLogicFunction.config,
+    ).toBe(false);
+    expect(
+      processRecallWebhookLogicFunction.config.httpRouteTriggerSettings,
+    ).toBeUndefined();
+  });
+
+  it('forwards the resolved payload to handleRecallWebhook with a workspace-scoped client', async () => {
+    const body = buildRecordingDoneWebhookBody();
+
+    const result = await processRecallWebhookHandler(body);
+
+    expect(coreApiClientMock).toHaveBeenCalledTimes(1);
+    expect(handleRecallWebhookMock).toHaveBeenCalledTimes(1);
+    expect(handleRecallWebhookMock).toHaveBeenCalledWith({
+      client: coreApiClientMock.mock.instances[0],
+      body,
+    });
+    expect(result).toEqual({ status: 'updated' });
+  });
+});

package/src/logic-functions/__tests__/recall-webhook.test.ts

@@ -0,0 +1,180 @@
+import { createHmac } from 'crypto';
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/process-recall-webhook-logic-function-universal-identifier';
+import recallWebhookLogicFunction, {
+  recallWebhookRouteHandler,
+} from 'src/logic-functions/recall-webhook';
+
+const getApplicationVariableValueMock = vi.hoisted(() => vi.fn());
+
+vi.mock(
+  'src/logic-functions/utils/get-application-variable-value.util',
+  () => ({
+    getApplicationVariableValue: getApplicationVariableValueMock,
+  }),
+);
+
+const SECRET_BYTES = Buffer.from('entry-test-secret');
+const SECRET = `whsec_${SECRET_BYTES.toString('base64')}`;
+const WORKSPACE_ID = '123e4567-e89b-12d3-a456-426614174000';
+const CALL_RECORDING_ID = 'call-recording-1';
+
+type RecallWebhookRoutePayload = Parameters<
+  typeof recallWebhookRouteHandler
+>[0];
+
+const buildRoutePayload = (
+  overrides: Partial<RecallWebhookRoutePayload>,
+): RecallWebhookRoutePayload =>
+  ({
+    headers: {},
+    ...overrides,
+  }) as RecallWebhookRoutePayload;
+
+const buildSignedHeaders = (rawBody: string): Record<string, string> => {
+  const webhookId = 'msg_entry_test';
+  const webhookTimestamp = Math.floor(Date.now() / 1000).toString();
+  const signature = createHmac('sha256', SECRET_BYTES)
+    .update(`${webhookId}.${webhookTimestamp}.${rawBody}`)
+    .digest('base64');
+
+  return {
+    'webhook-id': webhookId,
+    'webhook-timestamp': webhookTimestamp,
+    'webhook-signature': `v1,${signature}`,
+  };
+};
+
+const buildRecordingDoneWebhookBody = () => ({
+  event: 'recording.done',
+  data: {
+    bot: {
+      id: 'recall-bot-1',
+      metadata: {
+        twentyWorkspaceId: WORKSPACE_ID,
+        twentyCallRecordingId: CALL_RECORDING_ID,
+      },
+    },
+    recording: {
+      id: 'recall-recording-1',
+    },
+  },
+});
+
+describe('recallWebhookRouteHandler', () => {
+  beforeEach(() => {
+    getApplicationVariableValueMock.mockReset();
+    getApplicationVariableValueMock.mockReturnValue(SECRET);
+  });
+
+  it('declares a server route trigger that forwards the webhook signature headers', () => {
+    expect(recallWebhookLogicFunction.success).toBe(true);
+    expect(
+      recallWebhookLogicFunction.config.httpRouteTriggerSettings,
+    ).toBeUndefined();
+    expect(
+      'serverRouteTriggerSettings' in recallWebhookLogicFunction.config,
+    ).toBe(true);
+
+    if (!('serverRouteTriggerSettings' in recallWebhookLogicFunction.config)) {
+      throw new Error('Expected a server route trigger');
+    }
+
+    expect(
+      recallWebhookLogicFunction.config.serverRouteTriggerSettings,
+    ).toEqual({
+      forwardedRequestHeaders: [
+        'webhook-id',
+        'webhook-timestamp',
+        'webhook-signature',
+        'svix-id',
+        'svix-timestamp',
+        'svix-signature',
+      ],
+    });
+  });
+
+  it('throws when the webhook secret is not configured', () => {
+    getApplicationVariableValueMock.mockReturnValue(undefined);
+
+    expect(() =>
+      recallWebhookRouteHandler(buildRoutePayload({ rawBody: '{}', body: {} })),
+    ).toThrow('RECALL_WEBHOOK_SECRET');
+  });
+
+  it('throws when the raw body is not forwarded', () => {
+    expect(() =>
+      recallWebhookRouteHandler(buildRoutePayload({ body: {} })),
+    ).toThrow('Raw request body');
+  });
+
+  it('throws when the signature is invalid', () => {
+    expect(() =>
+      recallWebhookRouteHandler(
+        buildRoutePayload({
+          rawBody: '{}',
+          body: {},
+          headers: {
+            'webhook-id': 'msg_entry_test',
+            'webhook-timestamp': Math.floor(Date.now() / 1000).toString(),
+            'webhook-signature': 'v1,not-a-real-signature',
+          },
+        }),
+      ),
+    ).toThrow('Invalid webhook signature');
+  });
+
+  it('throws when a correctly signed payload is empty', () => {
+    const rawBody = 'null';
+
+    expect(() =>
+      recallWebhookRouteHandler(
+        buildRoutePayload({
+          rawBody,
+          body: null,
+          headers: buildSignedHeaders(rawBody),
+        }),
+      ),
+    ).toThrow('Webhook payload was empty');
+  });
+
+  it('throws when the workspace id is missing from the bot metadata', () => {
+    const body = {
+      event: 'recording.done',
+      data: { bot: { id: 'recall-bot-1' } },
+    };
+    const rawBody = JSON.stringify(body);
+
+    expect(() =>
+      recallWebhookRouteHandler(
+        buildRoutePayload({
+          rawBody,
+          body,
+          headers: buildSignedHeaders(rawBody),
+        }),
+      ),
+    ).toThrow('workspace id');
+  });
+
+  it('resolves the target workspace for a correctly signed payload', () => {
+    const body = buildRecordingDoneWebhookBody();
+    const rawBody = JSON.stringify(body);
+
+    const result = recallWebhookRouteHandler(
+      buildRoutePayload({
+        rawBody,
+        body,
+        headers: buildSignedHeaders(rawBody),
+      }),
+    );
+
+    expect(result).toEqual({
+      workspaceId: WORKSPACE_ID,
+      targetLogicFunctionUniversalIdentifier:
+        PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+      payload: body,
+    });
+  });
+});

package/src/logic-functions/constants/call-recorder-everyone-left-timeout-seconds-env-var-name.ts

@@ -0,0 +1,2 @@
+export const CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS_ENV_VAR_NAME =
+  'CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS';

package/src/logic-functions/constants/call-recorder-everyone-left-timeout-seconds.ts

@@ -0,0 +1 @@
+export const CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS = 2;

package/src/logic-functions/constants/call-recorder-join-early-minutes-env-var-name.ts

@@ -0,0 +1,2 @@
+export const CALL_RECORDER_JOIN_EARLY_MINUTES_ENV_VAR_NAME =
+  'CALL_RECORDER_JOIN_EARLY_MINUTES';

package/src/logic-functions/constants/call-recorder-name-env-var-name.ts

@@ -0,0 +1 @@
+export const CALL_RECORDER_NAME_ENV_VAR_NAME = 'CALL_RECORDER_NAME';

package/src/logic-functions/constants/call-recorder-noone-joined-timeout-seconds-env-var-name.ts

@@ -0,0 +1,2 @@
+export const CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS_ENV_VAR_NAME =
+  'CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS';

package/src/logic-functions/constants/call-recorder-noone-joined-timeout-seconds.ts

@@ -0,0 +1 @@
+export const CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS = 20 * 60;

package/src/logic-functions/constants/call-recorder-recording-retention-hours-env-var-name.ts

@@ -0,0 +1,2 @@
+export const CALL_RECORDER_RECORDING_RETENTION_HOURS_ENV_VAR_NAME =
+  'CALL_RECORDER_RECORDING_RETENTION_HOURS';

package/src/logic-functions/constants/call-recorder-waiting-room-timeout-seconds-env-var-name.ts

@@ -0,0 +1,2 @@
+export const CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS_ENV_VAR_NAME =
+  'CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS';

package/src/logic-functions/constants/call-recorder-waiting-room-timeout-seconds.ts

@@ -0,0 +1 @@
+export const CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS = 1200;

package/src/logic-functions/constants/call-recording-micro-credits-per-hour.ts

@@ -0,0 +1 @@
+export const CALL_RECORDING_MICRO_CREDITS_PER_HOUR = 1_000_000;

package/src/logic-functions/constants/call-recording-request-status.ts

@@ -0,0 +1,5 @@
+// Mirrors the core select options; guarded by the schema integration test.
+export enum CallRecordingRequestStatus {
+  REQUESTED = 'REQUESTED',
+  CANCELED = 'CANCELED',
+}

package/src/logic-functions/constants/call-recording-status.ts

@@ -0,0 +1,9 @@
+// Mirrors the core select options; guarded by the schema integration test.
+export enum CallRecordingStatus {
+  SCHEDULED = 'SCHEDULED',
+  JOINING = 'JOINING',
+  RECORDING = 'RECORDING',
+  PROCESSING = 'PROCESSING',
+  COMPLETED = 'COMPLETED',
+  FAILED = 'FAILED',
+}

package/src/logic-functions/constants/default-call-recorder-join-early-minutes.ts

@@ -0,0 +1 @@
+export const DEFAULT_CALL_RECORDER_JOIN_EARLY_MINUTES = 1;

package/src/logic-functions/constants/default-call-recorder-name.ts

@@ -0,0 +1 @@
+export const DEFAULT_CALL_RECORDER_NAME = 'Twenty.com';

package/src/logic-functions/constants/default-call-recorder-recording-retention-hours.ts

@@ -0,0 +1,2 @@
+// Twenty stores ingested recording artifacts, so Recall.ai media is temporary. Keep the default below Recall.ai's 168-hour free storage window.
+export const DEFAULT_CALL_RECORDER_RECORDING_RETENTION_HOURS = 166;

package/src/logic-functions/constants/default-recall-region.ts

@@ -0,0 +1 @@
+export const DEFAULT_RECALL_REGION = 'eu-central-1';

package/src/logic-functions/constants/milliseconds-per-minute.ts

@@ -0,0 +1 @@
+export const MILLISECONDS_PER_MINUTE = 60_000;

package/src/logic-functions/constants/non-terminal-call-recording-statuses.ts

@@ -0,0 +1,8 @@
+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
+
+export const NON_TERMINAL_CALL_RECORDING_STATUSES = [
+  CallRecordingStatus.SCHEDULED,
+  CallRecordingStatus.JOINING,
+  CallRecordingStatus.RECORDING,
+  CallRecordingStatus.PROCESSING,
+] satisfies CallRecordingStatus[];

package/src/logic-functions/constants/recall-api-key-env-var-name.ts

@@ -0,0 +1 @@
+export const RECALL_API_KEY_ENV_VAR_NAME = 'RECALL_API_KEY';

package/src/logic-functions/constants/recall-api-max-attempts.ts

@@ -0,0 +1 @@
+export const RECALL_API_MAX_ATTEMPTS = 3;

package/src/logic-functions/constants/recall-api-retry-delay-ms.ts

@@ -0,0 +1 @@
+export const RECALL_API_RETRY_DELAY_MS = 500;

package/src/logic-functions/constants/recall-bot-automatic-leave.ts

@@ -0,0 +1,74 @@
+import { isUndefined } from '@sniptt/guards';
+
+import { CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS_ENV_VAR_NAME } from 'src/logic-functions/constants/call-recorder-everyone-left-timeout-seconds-env-var-name';
+import { CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS_ENV_VAR_NAME } from 'src/logic-functions/constants/call-recorder-noone-joined-timeout-seconds-env-var-name';
+import { CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS_ENV_VAR_NAME } from 'src/logic-functions/constants/call-recorder-waiting-room-timeout-seconds-env-var-name';
+import { RECALL_BOT_EVERYONE_LEFT_MIN_ACTIVATE_AFTER_SECONDS } from 'src/logic-functions/constants/recall-bot-everyone-left-min-activate-after-seconds';
+import { getApplicationVariableValue } from 'src/logic-functions/utils/get-application-variable-value.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+type RecallBotAutomaticLeave = {
+  waiting_room_timeout?: number;
+  noone_joined_timeout?: number;
+  everyone_left_timeout?: {
+    timeout: number;
+    activate_after: number;
+  };
+};
+
+export const getRecallBotAutomaticLeave = ():
+  | RecallBotAutomaticLeave
+  | undefined => {
+  const waitingRoomTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_WAITING_ROOM_TIMEOUT_SECONDS_ENV_VAR_NAME,
+  );
+  const nooneJoinedTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_NOONE_JOINED_TIMEOUT_SECONDS_ENV_VAR_NAME,
+  );
+  const everyoneLeftTimeoutSeconds = getOptionalPositiveIntegerVariable(
+    CALL_RECORDER_EVERYONE_LEFT_TIMEOUT_SECONDS_ENV_VAR_NAME,
+  );
+
+  const automaticLeave: RecallBotAutomaticLeave = {};
+
+  if (!isUndefined(waitingRoomTimeoutSeconds)) {
+    automaticLeave.waiting_room_timeout = waitingRoomTimeoutSeconds;
+  }
+
+  if (!isUndefined(nooneJoinedTimeoutSeconds)) {
+    automaticLeave.noone_joined_timeout = nooneJoinedTimeoutSeconds;
+  }
+
+  if (!isUndefined(everyoneLeftTimeoutSeconds)) {
+    automaticLeave.everyone_left_timeout = {
+      timeout: everyoneLeftTimeoutSeconds,
+      activate_after: RECALL_BOT_EVERYONE_LEFT_MIN_ACTIVATE_AFTER_SECONDS,
+    };
+  }
+
+  return Object.keys(automaticLeave).length === 0 ? undefined : automaticLeave;
+};
+
+const getOptionalPositiveIntegerVariable = (
+  variableName: string,
+): number | undefined => {
+  const rawValue = normalizeOptionalString(
+    getApplicationVariableValue(variableName),
+  );
+
+  if (isUndefined(rawValue)) {
+    return undefined;
+  }
+
+  const timeoutSeconds = Number(rawValue);
+
+  if (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0) {
+    return undefined;
+  }
+
+  return timeoutSeconds;
+};
+
+const normalizeOptionalString = (
+  value: string | undefined,
+): string | undefined => (isNonEmptyString(value) ? value.trim() : undefined);

package/src/logic-functions/constants/recall-bot-everyone-left-min-activate-after-seconds.ts

@@ -0,0 +1 @@
+export const RECALL_BOT_EVERYONE_LEFT_MIN_ACTIVATE_AFTER_SECONDS = 1;

package/src/logic-functions/constants/recall-bot-recording-config.ts

@@ -0,0 +1,34 @@
+import { CALL_RECORDER_RECORDING_RETENTION_HOURS_ENV_VAR_NAME } from 'src/logic-functions/constants/call-recorder-recording-retention-hours-env-var-name';
+import { DEFAULT_CALL_RECORDER_RECORDING_RETENTION_HOURS } from 'src/logic-functions/constants/default-call-recorder-recording-retention-hours';
+import { getApplicationVariableValue } from 'src/logic-functions/utils/get-application-variable-value.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+
+type RecallBotRecordingConfig = {
+  video_mixed_mp4: Record<string, never>;
+  audio_mixed_mp3: Record<string, never>;
+  retention: { type: 'timed'; hours: number };
+};
+
+// Recall only produces artifacts declared at bot creation; both gate COMPLETED.
+export const getRecallBotRecordingConfig = (): RecallBotRecordingConfig => {
+  const configuredRecordingRetentionHours = getApplicationVariableValue(
+    CALL_RECORDER_RECORDING_RETENTION_HOURS_ENV_VAR_NAME,
+  );
+
+  const recordingRetentionHours = isNonEmptyString(
+    configuredRecordingRetentionHours,
+  )
+    ? Number(configuredRecordingRetentionHours.trim())
+    : NaN;
+
+  const resolvedRecordingRetentionHours =
+    Number.isInteger(recordingRetentionHours) && recordingRetentionHours > 0
+      ? recordingRetentionHours
+      : DEFAULT_CALL_RECORDER_RECORDING_RETENTION_HOURS;
+
+  return {
+    video_mixed_mp4: {},
+    audio_mixed_mp3: {},
+    retention: { type: 'timed', hours: resolvedRecordingRetentionHours },
+  };
+};

package/src/logic-functions/constants/recall-region-env-var-name.ts

@@ -0,0 +1 @@
+export const RECALL_REGION_ENV_VAR_NAME = 'RECALL_REGION';

package/src/logic-functions/constants/recall-webhook-secret-env-var-name.ts

@@ -0,0 +1 @@
+export const RECALL_WEBHOOK_SECRET_ENV_VAR_NAME = 'RECALL_WEBHOOK_SECRET';

package/src/logic-functions/constants/restricted-field-placeholder.ts

@@ -0,0 +1,3 @@
+// Mirrors twenty-shared; calendar restrictions write it over title/description.
+export const RESTRICTED_FIELD_PLACEHOLDER =
+  'FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED';

package/src/logic-functions/constants/stale-bot-state-cron-pattern.ts

@@ -0,0 +1 @@
+export const STALE_BOT_STATE_CRON_PATTERN = '*/5 * * * *';

package/src/logic-functions/constants/twenty-page-size.ts

@@ -0,0 +1 @@
+export const TWENTY_PAGE_SIZE = 100;