@quatrain/worker 1.1.45 → 1.1.47

package/dist/FileSystem.d.ts

@@ -0,0 +1,20 @@
+import { FileType } from '@quatrain/storage';
+export declare class FileSystem {
+    static prepare(folder: string): void;
+    static makeFolder(folder: string): void;
+    static removeFolder(folder: string, recursively?: boolean): void;
+    static downloadFile(url: string, filepath: string): Promise<unknown>;
+    static safeString(name: string): string;
+    /**
+     * Upload file to public URL and return meta data
+     * @param filename string
+     * @param meta
+     * @param mime
+     * @returns Promise
+     */
+    static uploadFile(filename: string, meta: FileType, mime?: string): Promise<FileType>;
+    /**
+     * Return meta data on given file
+     */
+    static getInfo: (file: string) => Promise<any>;
+}

package/dist/FileSystem.js

@@ -0,0 +1,182 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const axios_1 = __importDefault(require("axios"));
+const Worker_1 = require("./Worker");
+const node_fetch_native_1 = __importDefault(require("node-fetch-native"));
+const ffmpeg = __importStar(require("fluent-ffmpeg"));
+class FileSystem {
+    static prepare(folder) {
+        Worker_1.Worker.debug(`Setting up process folder ${folder}`);
+        this.removeFolder(folder);
+        node_fs_1.default.mkdirSync(folder);
+        node_fs_1.default.mkdirSync(folder + node_path_1.default.sep + 'images');
+        node_fs_1.default.mkdirSync(folder + node_path_1.default.sep + 'vecto');
+    }
+    static makeFolder(folder) {
+        node_fs_1.default.mkdirSync(folder);
+    }
+    static removeFolder(folder, recursively = true) {
+        if (node_fs_1.default.existsSync(folder)) {
+            node_fs_1.default.readdirSync(folder).forEach((element) => {
+                const item = node_path_1.default.join(folder, element);
+                if (node_fs_1.default.lstatSync(item).isDirectory()) {
+                    if (recursively !== true) {
+                        throw new Error(`Folder contains folder`);
+                    }
+                    this.removeFolder(item);
+                }
+                else {
+                    node_fs_1.default.unlinkSync(item);
+                }
+            });
+            node_fs_1.default.rmdirSync(folder);
+        }
+    }
+    static async downloadFile(url, filepath) {
+        try {
+            Worker_1.Worker.debug(`Downloading file at ${url} to ${filepath}`);
+            const writer = node_fs_1.default.createWriteStream(filepath);
+            const response = await axios_1.default.get(url, {
+                responseType: 'stream',
+            });
+            response.data.pipe(writer);
+            return new Promise((resolve, reject) => {
+                writer.on('finish', resolve);
+                writer.on('error', reject);
+            });
+        }
+        catch (err) {
+            Worker_1.Worker.error(`Download error: ${err.message}`);
+            throw err;
+        }
+    }
+    static safeString(name) {
+        return name.replace(/\s+/g, '_');
+    }
+    /**
+     * Upload file to public URL and return meta data
+     * @param filename string
+     * @param meta
+     * @param mime
+     * @returns Promise
+     */
+    static uploadFile(filename, meta, mime = 'video/mp4') {
+        // try to get more file metadata
+        meta = { ...meta, ...FileSystem.getInfo(filename) };
+        Worker_1.Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`);
+        const { size } = node_fs_1.default.statSync(filename);
+        if (size < 32 * 1024) {
+            return new Promise((resolve, reject) => {
+                (0, node_fetch_native_1.default)(meta.uploadUrl, {
+                    method: 'PUT',
+                    mode: 'cors',
+                    duplex: 'half',
+                    body: (0, node_fs_1.readFileSync)(filename),
+                    headers: {
+                        'Content-Type': meta.contentType || mime,
+                        'Content-length': String(size),
+                    },
+                })
+                    .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
+                    .catch((err) => {
+                    Worker_1.Worker.error(`An error occured while uploading ${filename}: ${err.message}`);
+                    reject(err);
+                });
+            });
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                let done = 0; // total bytes uploaded
+                let prev = 0; // latest value of done stored when % done was displayed
+                const { size } = node_fs_1.default.statSync(filename);
+                const readStream = node_fs_1.default.createReadStream(filename);
+                const sizeMB = (size / (1024 * 1024)).toFixed(2);
+                readStream.on('data', (data) => {
+                    done += data.length;
+                    if (done - prev >= size / 20) {
+                        // only display message when 5% more has been uploaded
+                        Worker_1.Worker.info(`${((done / size) * 100).toFixed(2)}% - ${(done /
+                            (1024 * 1024)).toFixed(2)}MB / ${sizeMB}MB`);
+                        prev = done;
+                    }
+                });
+                Worker_1.Worker.info(`Uploading file ${filename} with size ${size} bytes`);
+                (0, node_fetch_native_1.default)(meta.uploadUrl, {
+                    method: 'PUT',
+                    mode: 'cors',
+                    duplex: 'half',
+                    body: readStream,
+                    headers: {
+                        'Content-Type': meta.contentType || mime,
+                        'Content-length': String(size),
+                    },
+                })
+                    .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
+                    .catch((err) => {
+                    Worker_1.Worker.error(`An error occured while uploading ${filename}: ${err.message}`);
+                    reject(err);
+                });
+            }
+            catch (err) {
+                Worker_1.Worker.error(err);
+                reject(err);
+            }
+        });
+    }
+    /**
+     * Return meta data on given file
+     */
+    static getInfo = (file) => {
+        if (file.endsWith('.mp4') || file.endsWith('.insv')) {
+            return new Promise((resolve, reject) => ffmpeg.ffprobe(file, (err, metadata) => {
+                if (err) {
+                    Worker_1.Worker.error(err);
+                    reject(err);
+                }
+                //   Worker.debug(`ffprobe getInfo: ${JSON.stringify(metadata)}`)
+                const { width, height, duration, bit_rate: bitrate, nb_frames: nbFramees, } = metadata.streams[0];
+                const nb_frames = parseFloat(nbFramees);
+                const framerate = nb_frames / parseFloat(duration);
+                resolve({
+                    width,
+                    height,
+                    framerate: parseInt(framerate.toFixed(0)),
+                    duration: parseInt(duration),
+                    bitrate,
+                });
+            }));
+        }
+        // Handle other cases silently
+        return new Promise((resolve) => resolve({}));
+    };
+}
+exports.FileSystem = FileSystem;

package/dist/Handler.d.ts

@@ -0,0 +1 @@
+export declare const handler: (messageHandler: Function, config: any, adapters: any) => Promise<void>;

package/dist/Handler.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const Worker_1 = require("./Worker");
+const handler = async (messageHandler, config, adapters) => {
+    try {
+        Worker_1.Worker.info(`Worker version ${require('../package.json').version} started in ${config.MQ_MODE} mode`);
+        switch (config.MQ_MODE) {
+            case 'queue':
+                const { Queue } = require('@quatrain/queue');
+                Queue.addQueue(adapters.queue, 'default', true);
+                Queue.info(`Connecting to amqp://${config.MQ_HOST}:${config.MQ_PORT}`);
+                Queue.getQueue().listen(config.MQ_TOPIC, messageHandler, {
+                    concurrency: config.MQ_CONCURRENCY,
+                    gpu: config.MQ_GPU,
+                });
+                break;
+            case 'cli':
+            case 'test':
+                Worker_1.Worker.warn(`Message received from CLI.`);
+                const json = config.MQ_MODE === 'test'
+                    ? require('../test.json')
+                    : process.env.JSON;
+                if (!json) {
+                    throw new Error(`CLI call with missing environment variables`);
+                }
+                await messageHandler(json);
+                break;
+            default:
+                Worker_1.Worker.error(`Unknown mode option: '${config.MQ_MODE}'`);
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        Worker_1.Worker.error(error.message);
+        process.exit(1);
+    }
+};
+exports.handler = handler;

package/dist/Helpers.d.ts

@@ -0,0 +1,11 @@
+export declare class Helpers {
+    static FFMPEG: string;
+    /**
+     * Generate a thubnail from a video file at given frame position
+     * @param videoPath path to video file
+     * @param frame frame to extract thumbnail from
+     * @param width width of thumbnail (4/3 ratio)
+     * @returns
+     */
+    static generateVideoThumbnail: (videoPath: string, outputPath: string, frame?: number, width?: number) => Promise<any>;
+}

package/dist/Helpers.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Helpers = void 0;
+const Worker_1 = require("./Worker");
+class Helpers {
+    static FFMPEG = '/usr/bin/ffmpeg';
+    /**
+     * Generate a thubnail from a video file at given frame position
+     * @param videoPath path to video file
+     * @param frame frame to extract thumbnail from
+     * @param width width of thumbnail (4/3 ratio)
+     * @returns
+     */
+    static generateVideoThumbnail = async (videoPath, outputPath, frame = 0, width = 320) => {
+        const resolution = `${width}x${Math.ceil(width * 0.75)}`;
+        const ffmpegParams = [
+            '-i',
+            videoPath,
+            '-vframes',
+            '1',
+            '-vf',
+            String.raw `select=gte(n\,${frame})`,
+            '-s',
+            resolution,
+            '-ss',
+            '1',
+            outputPath,
+            '-y',
+        ];
+        Worker_1.Worker.info(`Generating Thumbnail : ${outputPath}`);
+        return await Worker_1.Worker.execPromise(Helpers.FFMPEG, ffmpegParams);
+    };
+}
+exports.Helpers = Helpers;

package/dist/Worker.d.ts

@@ -0,0 +1,37 @@
+import { Core } from '@quatrain/core';
+import { HandlerParameters } from './types/HandlerParameters';
+export declare class Worker extends Core {
+    static endpoint: string;
+    static readonly logger: any;
+    /**
+     * Execute an external command in a promise
+     * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
+     * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
+     * @param string command
+     * @param array args
+     * @return Promise
+     */
+    static readonly execPromise: (command: string, args?: any[], cwd?: string) => Promise<any>;
+    /**
+     * Push an event to the backend endpoint, if available
+     * @param event string
+     * @param data
+     * @param ts timestamp
+     * @returns boolean
+     */
+    static pushEvent(event: string, data?: {}, ts?: number): false | undefined;
+    /**
+     * Async Push an event to the backend endpoint, if available
+     * @param event string
+     * @param data
+     * @param ts timestamp
+     * @returns boolean
+     */
+    static pushEventAsync(event: string, data?: {}, ts?: number): Promise<boolean | undefined>;
+    /**
+     * Global handling function to process received messages
+     * @param messageHandler function
+     * @param config object
+     */
+    static readonly handler: (messageHandler: Function, config: HandlerParameters) => Promise<void>;
+}

package/dist/Worker.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const core_1 = require("@quatrain/core");
+const os_1 = __importDefault(require("os"));
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+class Worker extends core_1.Core {
+    static endpoint = '';
+    static logger = this.addLogger('Worker');
+    /**
+     * Execute an external command in a promise
+     * @see https://stackoverflow.com/questions/46289682/how-to-wait-for-child-process-spawn-execution-with-async-await
+     * @see https://dzone.com/articles/understanding-execfile-spawn-exec-and-fork-in-node
+     * @param string command
+     * @param array args
+     * @return Promise
+     */
+    static execPromise = (command, args = [], cwd = process.cwd()) => {
+        try {
+            Worker.info(`Executing command ${command} in ${cwd} with arguments:`);
+            args.forEach((arg) => console.log(`\t${arg}`));
+            return new Promise((resolve, reject) => {
+                const child = (0, child_process_1.spawn)(command, args, { cwd });
+                child.stdout.on('data', (data) => Worker.debug(data.toString()));
+                child.stderr.on('data', (data) => Worker.debug(data.toString()));
+                child.on('close', (code) => {
+                    if (code !== 0) {
+                        Worker.error(`Command execution failed with code: ${code}`);
+                        reject(new Error(`Process failed and returned code: ${code}`));
+                    }
+                    else {
+                        Worker.info(`Command execution completed with code: ${code}`);
+                        resolve(undefined);
+                    }
+                });
+            });
+        }
+        catch (err) {
+            Worker.error(err.message);
+            throw err;
+        }
+    };
+    /**
+     * Push an event to the backend endpoint, if available
+     * @param event string
+     * @param data
+     * @param ts timestamp
+     * @returns boolean
+     */
+    static pushEvent(event, data = {}, ts = 0) {
+        if (!this.endpoint) {
+            Worker.warn(`Events endpoint is not set, can't send update!`);
+            return false;
+        }
+        ts = ts === Date.now() ? Date.now() + 1 : Date.now();
+        const payload = {
+            event,
+            worker: `Container ${os_1.default.hostname}`,
+            os: `${os_1.default.type} ${os_1.default.release} (${os_1.default.platform} ${os_1.default.arch})`,
+            ...data,
+            ts,
+        };
+        Worker.debug('event payload', payload);
+        axios_1.default
+            .patch(Worker.endpoint, payload)
+            .then((res) => {
+            Worker.info(`Event pushed to backend: ${res.statusText}`);
+            Worker.info(res.data);
+            return true;
+        })
+            .catch((err) => {
+            Worker.error(`Failed to push event to backend: ${err}`);
+            return false;
+        });
+    }
+    /**
+     * Async Push an event to the backend endpoint, if available
+     * @param event string
+     * @param data
+     * @param ts timestamp
+     * @returns boolean
+     */
+    static async pushEventAsync(event, data = {}, ts = 0) {
+        if (!this.endpoint) {
+            Worker.warn(`Events endpoint is not set, can't send update!`);
+            return false;
+        }
+        try {
+            ts = ts === Date.now() ? Date.now() + 1 : Date.now();
+            const payload = {
+                event,
+                worker: `Container ${os_1.default.hostname}`,
+                os: `${os_1.default.type} ${os_1.default.release} (${os_1.default.platform} ${os_1.default.arch})`,
+                ...data,
+                ts,
+            };
+            const res = await axios_1.default.patch(Worker.endpoint, payload);
+            if (res.statusText === 'OK') {
+                Worker.info(`Event pushed to backend: ${res.statusText}`);
+                return true;
+            }
+        }
+        catch (err) {
+            Worker.error(`Failed to push event to backend: ${err}`);
+            return false;
+        }
+    }
+    /**
+     * Global handling function to process received messages
+     * @param messageHandler function
+     * @param config object
+     */
+    static handler = async (messageHandler, config) => {
+        try {
+            switch (config.mode) {
+                case 'queue':
+                    const { Queue } = require('@quatrain/queue');
+                    Queue.addQueue(config.queueAdapter, 'default', true);
+                    Queue.getQueue().listen(config.topic, messageHandler, {
+                        concurrency: config.concurrency,
+                        gpu: config.gpu,
+                    });
+                    Queue.info(`Connected and listening to ${config.topic}, ready to receive messages.`);
+                    break;
+                case 'cli':
+                case 'test':
+                    Worker.warn(`Message received from CLI.`);
+                    const json = config.mode === 'test'
+                        ? require('../test.json')
+                        : process.env.JSON;
+                    if (!json) {
+                        throw new Error(`CLI call with missing environment variables`);
+                    }
+                    await messageHandler(json);
+                    break;
+                default:
+                    Worker.error(`Unknown mode option: '${config.mode}'`);
+                    process.exit(1);
+            }
+        }
+        catch (error) {
+            Worker.error(error.message);
+            process.exit(1);
+        }
+    };
+}
+exports.Worker = Worker;

package/dist/Worker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Worker.test.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Worker_1 = require("./Worker");
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+// Mock dependencies
+jest.mock('axios');
+jest.mock('child_process');
+const mockedAxios = axios_1.default;
+const mockedSpawn = child_process_1.spawn;
+describe('Worker', () => {
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+        // Reset Worker.endpoint
+        Worker_1.Worker.endpoint = '';
+    });
+    describe('endpoint property', () => {
+        it('should have an empty endpoint by default', () => {
+            expect(Worker_1.Worker.endpoint).toBe('');
+        });
+        it('should allow setting the endpoint', () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            expect(Worker_1.Worker.endpoint).toBe('https://api.example.com/events');
+        });
+    });
+    describe('pushEvent', () => {
+        it('should return false when endpoint is not set', () => {
+            const result = Worker_1.Worker.pushEvent('test-event');
+            expect(result).toBe(false);
+            expect(mockedAxios.patch).not.toHaveBeenCalled();
+        });
+        it('should send event when endpoint is set', () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            Worker_1.Worker.pushEvent('test-event', { foo: 'bar' });
+            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
+                event: 'test-event',
+                foo: 'bar',
+            }));
+        });
+        it('should include custom timestamp in payload', () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            const customTs = 1234567890;
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            Worker_1.Worker.pushEvent('test-event', {}, customTs);
+            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
+                event: 'test-event',
+                ts: expect.any(Number),
+            }));
+        });
+        it('should include additional data in payload', () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            const additionalData = {
+                userId: '123',
+                action: 'upload',
+                metadata: { size: 1024 },
+            };
+            Worker_1.Worker.pushEvent('custom-event', additionalData);
+            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
+                event: 'custom-event',
+                userId: '123',
+                action: 'upload',
+                metadata: { size: 1024 },
+            }));
+        });
+    });
+    describe('pushEventAsync', () => {
+        it('should return false when endpoint is not set', async () => {
+            const result = await Worker_1.Worker.pushEventAsync('test-event');
+            expect(result).toBe(false);
+            expect(mockedAxios.patch).not.toHaveBeenCalled();
+        });
+        it('should send event and return true on success', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            const result = await Worker_1.Worker.pushEventAsync('test-event', {
+                foo: 'bar',
+            });
+            expect(result).toBe(true);
+            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
+                event: 'test-event',
+                foo: 'bar',
+            }));
+        });
+        it('should return false on axios error', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockRejectedValue(new Error('Network error'));
+            const result = await Worker_1.Worker.pushEventAsync('test-event');
+            expect(result).toBe(false);
+        });
+        it('should handle non-OK status response', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'Bad Request',
+                data: { error: 'Invalid payload' },
+            });
+            const result = await Worker_1.Worker.pushEventAsync('test-event');
+            expect(result).toBe(undefined);
+        });
+        it('should include custom timestamp', async () => {
+            Worker_1.Worker.endpoint = 'https://api.example.com/events';
+            const customTs = 9876543210;
+            mockedAxios.patch.mockResolvedValue({
+                statusText: 'OK',
+                data: { success: true },
+            });
+            await Worker_1.Worker.pushEventAsync('test-event', {}, customTs);
+            expect(mockedAxios.patch).toHaveBeenCalledWith('https://api.example.com/events', expect.objectContaining({
+                event: 'test-event',
+                ts: expect.any(Number),
+            }));
+        });
+    });
+    describe('execPromise', () => {
+        it('should execute command successfully', async () => {
+            const mockChild = {
+                stdout: {
+                    on: jest.fn((event, callback) => {
+                        if (event === 'data') {
+                            // Simulate stdout data
+                            setTimeout(() => callback(Buffer.from('Command output')), 10);
+                        }
+                    }),
+                },
+                stderr: {
+                    on: jest.fn(),
+                },
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        // Simulate successful completion
+                        setTimeout(() => callback(0), 20);
+                    }
+                }),
+            };
+            mockedSpawn.mockReturnValue(mockChild);
+            await expect(Worker_1.Worker.execPromise('ls', ['-la'], '/tmp')).resolves.toBeUndefined();
+            expect(mockedSpawn).toHaveBeenCalledWith('ls', ['-la'], {
+                cwd: '/tmp',
+            });
+        });
+        it('should reject on command failure', async () => {
+            const mockChild = {
+                stdout: {
+                    on: jest.fn(),
+                },
+                stderr: {
+                    on: jest.fn((event, callback) => {
+                        if (event === 'data') {
+                            setTimeout(() => callback(Buffer.from('Error output')), 10);
+                        }
+                    }),
+                },
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        // Simulate failure with exit code 1
+                        setTimeout(() => callback(1), 20);
+                    }
+                }),
+            };
+            mockedSpawn.mockReturnValue(mockChild);
+            await expect(Worker_1.Worker.execPromise('invalid-command', [])).rejects.toThrow('Process failed and returned code: 1');
+        });
+        it('should use current working directory by default', async () => {
+            const mockChild = {
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() },
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        setTimeout(() => callback(0), 10);
+                    }
+                }),
+            };
+            mockedSpawn.mockReturnValue(mockChild);
+            await Worker_1.Worker.execPromise('echo', ['test']);
+            expect(mockedSpawn).toHaveBeenCalledWith('echo', ['test'], {
+                cwd: process.cwd(),
+            });
+        });
+        it('should pass arguments to command', async () => {
+            const mockChild = {
+                stdout: { on: jest.fn() },
+                stderr: { on: jest.fn() },
+                on: jest.fn((event, callback) => {
+                    if (event === 'close') {
+                        setTimeout(() => callback(0), 10);
+                    }
+                }),
+            };
+            mockedSpawn.mockReturnValue(mockChild);
+            const args = ['arg1', 'arg2', '--flag'];
+            await Worker_1.Worker.execPromise('command', args, '/custom/path');
+            expect(mockedSpawn).toHaveBeenCalledWith('command', args, {
+                cwd: '/custom/path',
+            });
+        });
+    });
+    describe('logger', () => {
+        it('should have a logger instance', () => {
+            expect(Worker_1.Worker.logger).toBeDefined();
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { Worker } from './Worker';
+import { FileSystem } from './FileSystem';
+import { Helpers } from './Helpers';
+import { HandlerParameters } from './types/HandlerParameters';
+import { MessagehandlerParameters } from './types/MessagehandlerParameters';
+import { ModeEnum } from './types/ModeEnum';
+export { Worker, FileSystem, Helpers, ModeEnum, HandlerParameters, MessagehandlerParameters, };

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModeEnum = exports.Helpers = exports.FileSystem = exports.Worker = void 0;
+const Worker_1 = require("./Worker");
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return Worker_1.Worker; } });
+const FileSystem_1 = require("./FileSystem");
+Object.defineProperty(exports, "FileSystem", { enumerable: true, get: function () { return FileSystem_1.FileSystem; } });
+const Helpers_1 = require("./Helpers");
+Object.defineProperty(exports, "Helpers", { enumerable: true, get: function () { return Helpers_1.Helpers; } });
+const ModeEnum_1 = require("./types/ModeEnum");
+Object.defineProperty(exports, "ModeEnum", { enumerable: true, get: function () { return ModeEnum_1.ModeEnum; } });

package/dist/types/HandlerParameters.d.ts

@@ -0,0 +1,9 @@
+import { ModeEnum } from './ModeEnum';
+import { AbstractQueueAdapter } from '@quatrain/queue';
+export interface HandlerParameters {
+    mode: string | typeof ModeEnum;
+    topic?: string;
+    concurrency?: number;
+    queueAdapter?: AbstractQueueAdapter;
+    gpu?: boolean;
+}

package/dist/types/HandlerParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/MessagehandlerParameters.d.ts

@@ -0,0 +1,4 @@
+export interface MessagehandlerParameters {
+    concurrency?: number;
+    gpu?: boolean;
+}

package/dist/types/MessagehandlerParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ModeEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum ModeEnum {
+    MODE_CLI = "cli",
+    MODE_QUEUE = "queue",
+    MODE_TEST = "test"
+}

package/dist/types/ModeEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModeEnum = void 0;
+var ModeEnum;
+(function (ModeEnum) {
+    ModeEnum["MODE_CLI"] = "cli";
+    ModeEnum["MODE_QUEUE"] = "queue";
+    ModeEnum["MODE_TEST"] = "test";
+})(ModeEnum || (exports.ModeEnum = ModeEnum = {}));

package/package.json

@@ -1,45 +1,45 @@
 {
-   "name": "@quatrain/worker",
-   "version": "1.1.45",
-   "description": "Container Worker helpers",
-   "main": "lib/index.js",
-   "types": "lib/index.d.ts",
-   "bun": "src/index.ts",
-   "files": [
-      "LICENSE.md",
-      "src/",
-      "lib/",
-      "README.md"
-   ],
-   "author": "Quatrain Développement SAS <developers@quatrain.com>",
-   "license": "AGPL-3.0-only",
-   "devDependencies": {
-      "@tsconfig/recommended": "^1.0.1",
-      "@types/fluent-ffmpeg": "^2",
-      "@types/fs-extra": "^11.0.4",
-      "@types/jest": "^27.0.3",
-      "@types/node": "^22.9.0",
-      "@types/object-hash": "^3.0.6",
-      "jest": "^30.2.0",
-      "jest-node-exports-resolver": "^1.1.6",
-      "trace-unhandled": "^2.0.1",
-      "ts-jest": "^27.1.2",
-      "ts-node": "^10.4.0",
-      "typescript": "^5.1.5"
-   },
-   "dependencies": {
-      "@quatrain/core": "^1.1.43",
-      "@quatrain/queue": "^1.1.22",
-      "@quatrain/storage": "^1.1.24",
-      "axios": "^1.7.7",
-      "fluent-ffmpeg": "^2.1.2",
-      "fs-extra": "^11.2.0",
-      "node-fetch-native": "^1.6.4"
-   },
-   "scripts": {
-      "test-ci": "jest --runInBand",
-      "build": "tsc",
-      "wbuild": "tsc --watch",
-      "bump-to": "yarn version"
-   }
-}
+  "name": "@quatrain/worker",
+  "version": "1.1.47",
+  "description": "Container Worker helpers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "src/",
+    "dist/",
+    "README.md"
+  ],
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/fluent-ffmpeg": "^2",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^22.9.0",
+    "@types/object-hash": "^3.0.6",
+    "jest": "^30.2.0",
+    "jest-node-exports-resolver": "^1.1.6",
+    "trace-unhandled": "^2.0.1",
+    "ts-jest": "^27.1.2",
+    "ts-node": "^10.4.0",
+    "typescript": "^5.1.5"
+  },
+  "dependencies": {
+    "@quatrain/core": "^1.1.46",
+    "@quatrain/queue": "^1.1.24",
+    "@quatrain/storage": "^1.1.26",
+    "axios": "^1.7.7",
+    "fluent-ffmpeg": "^2.1.2",
+    "fs-extra": "^11.2.0",
+    "node-fetch-native": "^1.6.4"
+  },
+  "scripts": {
+    "test-ci": "jest --runInBand",
+    "build": "tsc",
+    "wbuild": "tsc --watch",
+    "bump-to": "yarn version"
+  }
+}