@fonoster/autopilot 0.4.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Fonoster Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cerebro/cerebro.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EffectsManager } from "./effects";
+import { IntentsEngine } from "../intents/types";
+import { SGatherStream, VoiceRequest, VoiceResponse } from "@fonoster/voice";
+import { CerebroConfig, CerebroStatus } from "./types";
+import Events from "events";
+export declare class Cerebro {
+    voiceResponse: VoiceResponse;
+    cerebroEvents: Events;
+    voiceRequest: VoiceRequest;
+    status: CerebroStatus;
+    activationTimeout: number;
+    activeTimer: NodeJS.Timer;
+    intentsEngine: IntentsEngine;
+    stream: SGatherStream;
+    config: CerebroConfig;
+    lastIntent: any;
+    effects: EffectsManager;
+    constructor(config: CerebroConfig);
+    wake(): Promise<void>;
+    sleep(): Promise<void>;
+    startActiveTimer(): void;
+    resetActiveTimer(): void;
+    stopPlayback(): Promise<void>;
+}

package/dist/cerebro/cerebro.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cerebro = void 0;
+/* eslint-disable require-jsdoc */
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const effects_1 = require("./effects");
+const types_1 = require("./types");
+const util_1 = require("../util");
+const types_2 = require("../events/types");
+const logger_1 = require("@fonoster/logger");
+const events_1 = __importDefault(require("events"));
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class Cerebro {
+    voiceResponse;
+    cerebroEvents;
+    voiceRequest;
+    status;
+    activationTimeout;
+    activeTimer;
+    intentsEngine;
+    stream;
+    config;
+    lastIntent;
+    effects;
+    constructor(config) {
+        this.voiceResponse = config.voiceResponse;
+        this.voiceRequest = config.voiceRequest;
+        this.cerebroEvents = new events_1.default();
+        this.status = types_1.CerebroStatus.SLEEP;
+        this.activationTimeout = config.activationTimeout || 15000;
+        this.intentsEngine = config.intentsEngine;
+        this.effects = new effects_1.EffectsManager({
+            playbackId: config.voiceConfig.playbackId,
+            eventsClient: config.eventsClient,
+            voice: config.voiceResponse,
+            voiceConfig: config.voiceConfig,
+            activationIntentId: config.activationIntentId,
+            transfer: config.transfer
+        });
+        this.config = config;
+    }
+    // Subscribe to events
+    async wake() {
+        this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
+        this.voiceResponse.on("error", (error) => {
+            this.cerebroEvents.emit("error", error);
+            (0, logger_1.ulogger)({
+                accessKeyId: this.voiceRequest.accessKeyId,
+                eventType: logger_1.ULogType.APP,
+                level: "error",
+                message: error.message
+            });
+        });
+        const speechConfig = { source: "speech,dtmf" };
+        if (this.config.alternativeLanguageCode) {
+            speechConfig.model = "command_and_search";
+            speechConfig.alternativeLanguageCodes = [
+                this.config.alternativeLanguageCode
+            ];
+        }
+        this.stream = await this.voiceResponse.sgather(speechConfig);
+        this.stream.on("transcript", async (data) => {
+            if (data.isFinal) {
+                const intent = await this.intentsEngine.findIntent(data.transcript, {
+                    telephony: {
+                        caller_id: this.voiceRequest.callerNumber
+                    }
+                });
+                logger.verbose("cerebro received new transcription from user", {
+                    text: data.transcript,
+                    ref: intent.ref,
+                    confidence: intent.confidence
+                });
+                await this.effects.invokeEffects(intent, this.status, async () => {
+                    await this.stopPlayback();
+                    if (this.config.activationIntentId === intent.ref) {
+                        (0, util_1.sendClientEvent)(this.config.eventsClient, {
+                            eventName: types_2.CLIENT_EVENTS.RECOGNIZING
+                        });
+                        if (this.status === types_1.CerebroStatus.AWAKE_ACTIVE) {
+                            this.resetActiveTimer();
+                        }
+                        else {
+                            this.startActiveTimer();
+                        }
+                    }
+                });
+                // Need to save this to avoid duplicate intents
+                this.lastIntent = intent;
+            }
+        });
+    }
+    // Unsubscribe from events
+    async sleep() {
+        logger.verbose("cerebro timeout and is going to sleep");
+        await this.voiceResponse.closeMediaPipe();
+        this.stream.close();
+        this.status = types_1.CerebroStatus.SLEEP;
+    }
+    startActiveTimer() {
+        this.status = types_1.CerebroStatus.AWAKE_ACTIVE;
+        this.activeTimer = setTimeout(() => {
+            this.status = types_1.CerebroStatus.AWAKE_PASSIVE;
+            (0, util_1.sendClientEvent)(this.config.eventsClient, {
+                eventName: types_2.CLIENT_EVENTS.RECOGNIZING_FINISHED
+            });
+            logger.verbose("cerebro changed awake status", { status: this.status });
+        }, this.activationTimeout);
+        logger.verbose("cerebro changed awake status", { status: this.status });
+    }
+    resetActiveTimer() {
+        logger.verbose("cerebro is reseting awake status");
+        clearTimeout(this.activeTimer);
+        this.startActiveTimer();
+    }
+    async stopPlayback() {
+        const { playbackId } = this.config.voiceConfig;
+        if (playbackId) {
+            try {
+                const playbackControl = this.voiceResponse.playback(playbackId);
+                logger.verbose("cerebro is stoping playback", { playbackId });
+                await playbackControl.stop();
+            }
+            catch (e) {
+                (0, logger_1.ulogger)({
+                    accessKeyId: this.voiceRequest.accessKeyId,
+                    eventType: logger_1.ULogType.APP,
+                    level: "error",
+                    message: e.message
+                });
+            }
+        }
+    }
+}
+exports.Cerebro = Cerebro;

package/dist/cerebro/effects.d.ts

@@ -0,0 +1,11 @@
+import { VoiceResponse } from "@fonoster/voice";
+import { Intent } from "../intents/types";
+import { EffectsManagerConfig, CerebroStatus, Effect } from "./types";
+export declare class EffectsManager {
+    voice: VoiceResponse;
+    config: EffectsManagerConfig;
+    constructor(config: EffectsManagerConfig);
+    invokeEffects(intent: Intent, status: CerebroStatus, activateCallback: Function): Promise<void>;
+    run(effect: Effect): Promise<void>;
+    transferEffect(voice: VoiceResponse, effect: Effect): Promise<void>;
+}

package/dist/cerebro/effects.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectsManager = void 0;
+const nanoid_1 = require("nanoid");
+const helper_1 = require("./helper");
+const types_1 = require("./types");
+const util_1 = require("../util");
+const types_2 = require("../events/types");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+class EffectsManager {
+    voice;
+    config;
+    constructor(config) {
+        this.voice = config.voice;
+        this.config = config;
+    }
+    async invokeEffects(intent, status, activateCallback) {
+        activateCallback();
+        if (this.config.activationIntentId === intent.ref) {
+            logger.verbose("fired activation intent");
+            return;
+        }
+        else if (this.config.activationIntentId &&
+            status != types_1.CerebroStatus.AWAKE_ACTIVE) {
+            logger.verbose("received an intent but cerebro is not awake");
+            // If we have activation intent cerebro needs and active status
+            // before we can have any effects
+            return;
+        }
+        for (const e of intent.effects) {
+            logger.verbose("effects running effect", { type: e.type });
+            await this.run(e);
+        }
+    }
+    async run(effect) {
+        switch (effect.type) {
+            case "say":
+                await this.voice.say(effect.parameters["response"], this.config.voiceConfig);
+                break;
+            case "hangup":
+                await this.voice.hangup();
+                (0, util_1.sendClientEvent)(this.config.eventsClient, {
+                    eventName: types_2.CLIENT_EVENTS.HANGUP
+                });
+                break;
+            case "transfer":
+                // TODO: Add record effect
+                await this.transferEffect(this.voice, effect);
+                break;
+            case "send_data":
+                // Only send if client support events
+                (0, util_1.sendClientEvent)(this.config.eventsClient, {
+                    eventName: types_2.CLIENT_EVENTS.RECOGNIZING_FINISHED
+                });
+                (0, util_1.sendClientEvent)(this.config.eventsClient, {
+                    eventName: types_2.CLIENT_EVENTS.INTENT,
+                    intent: effect.parameters
+                });
+                break;
+            default:
+                throw new Error(`effects received unknown effect ${effect.type}`);
+        }
+    }
+    async transferEffect(voice, effect) {
+        await this.voice.closeMediaPipe();
+        const stream = await this.voice.dial(effect.parameters["destination"]);
+        const playbackId = (0, nanoid_1.nanoid)();
+        const control = this.voice.playback(playbackId);
+        let stay = true;
+        const moveForward = async () => {
+            stay = false;
+            await control.stop();
+        };
+        stream.on("answer", () => {
+            moveForward();
+        });
+        stream.on("busy", async () => {
+            await moveForward();
+            await (0, helper_1.playBusyAndHangup)(this.voice, playbackId, this.config);
+        });
+        stream.on("noanswer", async () => {
+            await moveForward();
+            await (0, helper_1.playNoAnswerAndHangup)(this.voice, playbackId, this.config);
+        });
+        while (stay) {
+            await (0, helper_1.playTransfering)(this.voice, playbackId, this.config);
+        }
+    }
+}
+exports.EffectsManager = EffectsManager;

package/dist/cerebro/helper.d.ts

@@ -0,0 +1,5 @@
+import { VoiceResponse } from "@fonoster/voice";
+import { EffectsManagerConfig } from "./types";
+export declare const playTransfering: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;
+export declare const playBusyAndHangup: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;
+export declare const playNoAnswerAndHangup: (voice: VoiceResponse, playbackId: string, config: EffectsManagerConfig) => Promise<void>;

package/dist/cerebro/helper.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playNoAnswerAndHangup = exports.playBusyAndHangup = exports.playTransfering = void 0;
+const playOrSay = async (param) => {
+    if (param.media) {
+        await param.voice.play("sound:" + param.media, {
+            playbackId: param.playbackId
+        });
+    }
+    if (param.message) {
+        if (param.voiceConfig) {
+            param.voiceConfig.playbackId = param.playbackId;
+        }
+        else {
+            param.voiceConfig = { playbackId: param.playbackId };
+        }
+        await param.voice.say(param.message, param.voiceConfig);
+    }
+};
+const playTransfering = async (voice, playbackId, config) => await playOrSay({
+    voice,
+    voiceConfig: config.voiceConfig,
+    playbackId,
+    media: config.transfer?.media,
+    message: config.transfer?.message
+});
+exports.playTransfering = playTransfering;
+const playBusyAndHangup = async (voice, playbackId, config) => await playOrSay({
+    voice,
+    voiceConfig: config.voiceConfig,
+    playbackId,
+    media: config.transfer?.mediaBusy,
+    message: config.transfer?.messageBusy
+});
+exports.playBusyAndHangup = playBusyAndHangup;
+const playNoAnswerAndHangup = async (voice, playbackId, config) => await playOrSay({
+    voice,
+    voiceConfig: config.voiceConfig,
+    playbackId,
+    media: config.transfer?.mediaNoAnswer,
+    message: config.transfer?.messageNoAnswer
+});
+exports.playNoAnswerAndHangup = playNoAnswerAndHangup;

package/dist/cerebro/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cerebro";
+export * from "./effects";

package/dist/cerebro/index.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./cerebro"), exports);
+__exportStar(require("./effects"), exports);

package/dist/cerebro/types.d.ts

@@ -0,0 +1,40 @@
+import { VoiceResponse } from "@fonoster/voice";
+import { VoiceRequest } from "@fonoster/voice/dist/types";
+import { EventsClient } from "../events/emitter";
+import { IntentsEngine } from "../intents/types";
+export declare enum CerebroStatus {
+    SLEEP = 0,
+    AWAKE_ACTIVE = 1,
+    AWAKE_PASSIVE = 2
+}
+export interface CerebroConfig {
+    voiceRequest: VoiceRequest;
+    voiceResponse: VoiceResponse;
+    activationTimeout?: number;
+    activationIntentId?: string;
+    intentsEngine: IntentsEngine;
+    voiceConfig: Record<string, string>;
+    eventsClient: EventsClient | null;
+    transfer?: Transfer;
+    alternativeLanguageCode?: string;
+}
+export interface Transfer {
+    media?: string;
+    mediaNoAnswer?: string;
+    mediaBusy?: string;
+    message?: string;
+    messageNoAnswer?: string;
+    messageBusy?: string;
+}
+export interface EffectsManagerConfig {
+    eventsClient: EventsClient | null;
+    voice: VoiceResponse;
+    voiceConfig: Record<string, unknown>;
+    activationIntentId?: string;
+    playbackId: string;
+    transfer?: Transfer;
+}
+export interface Effect {
+    type: "say" | "hangup" | "send_data" | "transfer";
+    parameters: Record<string, unknown>;
+}

package/dist/cerebro/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CerebroStatus = void 0;
+var CerebroStatus;
+(function (CerebroStatus) {
+    CerebroStatus[CerebroStatus["SLEEP"] = 0] = "SLEEP";
+    CerebroStatus[CerebroStatus["AWAKE_ACTIVE"] = 1] = "AWAKE_ACTIVE";
+    CerebroStatus[CerebroStatus["AWAKE_PASSIVE"] = 2] = "AWAKE_PASSIVE";
+})(CerebroStatus || (exports.CerebroStatus = CerebroStatus = {}));

package/dist/events/emitter.d.ts

@@ -0,0 +1,7 @@
+import { EventEmitter, ClientEvent } from "./types";
+import WebSocket = require("ws");
+export declare class EventsClient implements EventEmitter {
+    ws: WebSocket;
+    constructor(ws: WebSocket);
+    send(event: ClientEvent): void;
+}

package/dist/events/emitter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsClient = void 0;
+class EventsClient {
+    ws;
+    constructor(ws) {
+        this.ws = ws;
+    }
+    send(event) {
+        this.ws.send(JSON.stringify(event));
+    }
+}
+exports.EventsClient = EventsClient;

package/dist/events/server.d.ts

@@ -0,0 +1,12 @@
+import { EventsClient } from "./emitter";
+import WebSocket = require("ws");
+export declare class EventsServer {
+    clientConnections: Map<string, WebSocket>;
+    wss: WebSocket.Server;
+    port: number;
+    constructor(clientConnections: Map<string, WebSocket>, port?: number);
+    start(): void;
+    getConnection(clientId: string): EventsClient | null;
+    removeConnection(clientId: string): void;
+}
+export declare const eventsServer: EventsServer;

package/dist/events/server.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventsServer = exports.EventsServer = void 0;
+/* eslint-disable require-jsdoc */
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const emitter_1 = require("./emitter");
+const logger_1 = require("@fonoster/logger");
+const WebSocket = require("ws");
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+// Events server
+class EventsServer {
+    clientConnections;
+    wss;
+    port;
+    constructor(clientConnections, port = 3001) {
+        this.port = port;
+        this.wss = new WebSocket.Server({ port });
+        this.clientConnections = clientConnections;
+    }
+    start() {
+        this.wss.on("connection", (ws) => {
+            logger.verbose("received a new client connection");
+            ws.on("message", (data) => {
+                // Once we receive the first and only message from client we
+                // save the client in the clientConnections map
+                const clientId = JSON.parse(data.toString()).clientId;
+                this.clientConnections.set(clientId, ws);
+                logger.verbose("added clientId to list of connections", { clientId });
+            });
+            ws.send(JSON.stringify({
+                name: "connected",
+                payload: {}
+            }));
+        });
+        logger.verbose("starting events server", { port: this.port });
+    }
+    getConnection(clientId) {
+        const connection = this.clientConnections.get(clientId);
+        if (!connection) {
+            return null;
+        }
+        return new emitter_1.EventsClient(connection);
+    }
+    removeConnection(clientId) {
+        this.clientConnections.delete(clientId);
+    }
+}
+exports.EventsServer = EventsServer;
+// Starting events server
+exports.eventsServer = new EventsServer(new Map());

package/dist/events/types.d.ts

@@ -0,0 +1,20 @@
+export declare enum CLIENT_EVENTS {
+    RECOGNIZING = "RECOGNIZING",
+    ANSWERED = "ANSWERED",
+    RECOGNIZING_FINISHED = "RECOGNIZING_FINISHED",
+    INTENT = "INTENT",
+    HANGUP = "HANGUP"
+}
+export interface EventEmitter {
+    send(payload?: ClientEvent): void;
+}
+export interface Intent {
+    icon?: string;
+    title: string;
+    description: string;
+    transcript: string;
+}
+export interface ClientEvent {
+    eventName: CLIENT_EVENTS;
+    intent?: Intent;
+}

package/dist/events/types.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_EVENTS = void 0;
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/rox
+ *
+ * This file is part of Rox AI
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var CLIENT_EVENTS;
+(function (CLIENT_EVENTS) {
+    CLIENT_EVENTS["RECOGNIZING"] = "RECOGNIZING";
+    CLIENT_EVENTS["ANSWERED"] = "ANSWERED";
+    CLIENT_EVENTS["RECOGNIZING_FINISHED"] = "RECOGNIZING_FINISHED";
+    CLIENT_EVENTS["INTENT"] = "INTENT";
+    CLIENT_EVENTS["HANGUP"] = "HANGUP";
+})(CLIENT_EVENTS || (exports.CLIENT_EVENTS = CLIENT_EVENTS = {}));

package/dist/file-retention/cron.d.ts

@@ -0,0 +1,2 @@
+import { ServerConfig } from "../types";
+export declare const startFileRetentionPolicy: (config: ServerConfig) => void;

package/dist/file-retention/cron.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startFileRetentionPolicy = void 0;
+const task_1 = require("./task");
+const logger_1 = require("@fonoster/logger");
+const node_cron_1 = __importDefault(require("node-cron"));
+const logger = (0, logger_1.getLogger)({ service: "autopilot", filePath: __filename });
+const startFileRetentionPolicy = (config) => {
+    if (config.fileRetentionPolicyEnabled) {
+        logger.info("file retention policy enabled");
+        node_cron_1.default.schedule(config.fileRetentionPolicyCronExpression, () => (0, task_1.runFileRetentionPolicy)({
+            filesDirectory: config.fileRetentionPolicyDirectory,
+            maxFileAge: config.fileRetentionPolicyMaxAge,
+            fileExtension: config.fileRetentionPolicyExtension
+        }));
+        return;
+    }
+    logger.info("file retention policy is disabled, all files will be kept forever in the server");
+};
+exports.startFileRetentionPolicy = startFileRetentionPolicy;

package/dist/file-retention/index.d.ts

@@ -0,0 +1 @@
+export * from "./cron";