@quatrain/worker 1.1.42 → 1.1.43

package/LICENSE.md

@@ -0,0 +1,15 @@
+# LICENSE UPDATE NOTICE
+
+As of 01/01/2026, Quatrain Core is licensed under the **GNU Affero General Public License v3.0 (AGPL v3)**.
+Previous versions remain under the MIT License.
+
+## Why AGPL?
+
+We believe in open collaboration for the development ecosystem. The AGPL ensures that any modification or deployment of this BaaS stack, including over a network, benefits the entire community.
+
+## Commercial Services & Enterprise Usage
+
+We provide official deployment services, technical training, and certification for Quatrain Core.
+For organizations requiring a non-copyleft license (commercial license) or custom proprietary integrations, please contact the copyright holder: **Quatrain Technologies**.
+
+Copyright © 2024-2026 Quatrain Technologies. All Rights Reserved.

package/lib/Worker.test.d.ts

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

package/lib/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/package.json

@@ -1,46 +1,45 @@
 {
-  "name": "@quatrain/worker",
-  "version": "1.1.42",
-  "description": "Container Worker helpers",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib/",
-    "README.md"
-  ],
-  "author": "Quatrain Développement SAS <developers@quatrain.com>",
-  "license": "MIT",
-  "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": "^27.4.7",
-    "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.23",
-    "@quatrain/queue": "^1.1.19",
-    "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",
-    "hash": "node ../../bin/hashFolder.js",
-    "hash:persist": "yarn hash  > .hash_latest.txt",
-    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
-    "publish": "yarn hash:compare || yarn publish:process",
-    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
-  }
-}
+   "name": "@quatrain/worker",
+   "version": "1.1.43",
+   "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.20",
+      "@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"
+   }
+}

package/src/FileSystem.ts

@@ -0,0 +1,186 @@
+import fs, { readFileSync } from 'node:fs'
+import path from 'node:path'
+import axios from 'axios'
+import { Worker } from './Worker'
+import fetch from 'node-fetch-native'
+import * as ffmpeg from 'fluent-ffmpeg'
+import { FileType } from '@quatrain/storage'
+
+export class FileSystem {
+   static prepare(folder: string) {
+      Worker.debug(`Setting up process folder ${folder}`)
+      this.removeFolder(folder)
+
+      fs.mkdirSync(folder)
+      fs.mkdirSync(folder + path.sep + 'images')
+      fs.mkdirSync(folder + path.sep + 'vecto')
+   }
+
+   static makeFolder(folder: string) {
+      fs.mkdirSync(folder)
+   }
+
+   static removeFolder(folder: string, recursively = true) {
+      if (fs.existsSync(folder)) {
+         fs.readdirSync(folder).forEach((element) => {
+            const item = path.join(folder, element)
+            if (fs.lstatSync(item).isDirectory()) {
+               if (recursively !== true) {
+                  throw new Error(`Folder contains folder`)
+               }
+               this.removeFolder(item)
+            } else {
+               fs.unlinkSync(item)
+            }
+         })
+
+         fs.rmdirSync(folder)
+      }
+   }
+
+   static async downloadFile(url: string, filepath: string) {
+      try {
+         Worker.debug(`Downloading file at ${url} to ${filepath}`)
+         const writer = fs.createWriteStream(filepath)
+         const response = await axios.get(url, {
+            responseType: 'stream',
+         })
+
+         response.data.pipe(writer)
+
+         return new Promise((resolve, reject) => {
+            writer.on('finish', resolve)
+            writer.on('error', reject)
+         })
+      } catch (err) {
+         Worker.error(`Download error: ${(err as Error).message}`)
+         throw err
+      }
+   }
+
+   static safeString(name: string) {
+      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: string,
+      meta: FileType,
+      mime = 'video/mp4'
+   ): Promise<FileType> {
+      // try to get more file metadata
+      meta = { ...meta, ...FileSystem.getInfo(filename) }
+      Worker.info(`Uploading file ${filename} to ${meta.uploadUrl}`)
+      const { size } = fs.statSync(filename)
+
+      if (size < 32 * 1024) {
+         return new Promise((resolve, reject) => {
+            fetch(meta.uploadUrl, {
+               method: 'PUT',
+               mode: 'cors',
+               duplex: 'half',
+               body: readFileSync(filename),
+               headers: {
+                  'Content-Type': meta.contentType || mime,
+                  'Content-length': String(size),
+               },
+            })
+               .then(() => resolve({ ...meta, size, uploadUrl: undefined }))
+               .catch((err) => {
+                  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 } = fs.statSync(filename)
+            const readStream = fs.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.info(
+                     `${((done / size) * 100).toFixed(2)}% - ${(
+                        done /
+                        (1024 * 1024)
+                     ).toFixed(2)}MB / ${sizeMB}MB`
+                  )
+                  prev = done
+               }
+            })
+
+            Worker.info(`Uploading file ${filename} with size ${size} bytes`)
+            fetch(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.error(
+                     `An error occured while uploading ${filename}: ${err.message}`
+                  )
+                  reject(err)
+               })
+         } catch (err) {
+            Worker.error(err)
+            reject(err)
+         }
+      })
+   }
+
+   /**
+    * Return meta data on given file
+    */
+   static getInfo = (file: string): Promise<any> => {
+      if (file.endsWith('.mp4') || file.endsWith('.insv')) {
+         return new Promise((resolve, reject) =>
+            ffmpeg.ffprobe(file, (err: any, metadata: any) => {
+               if (err) {
+                  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: number = parseFloat(nbFramees as string)
+               const framerate = nb_frames / parseFloat(duration as string)
+               resolve({
+                  width,
+                  height,
+                  framerate: parseInt(framerate.toFixed(0)),
+                  duration: parseInt(duration as string),
+                  bitrate,
+               })
+            })
+         )
+      }
+      // Handle other cases silently
+      return new Promise((resolve) => resolve({}))
+   }
+}

package/src/Handler.ts

@@ -0,0 +1,50 @@
+import { Worker } from './Worker'
+
+export const handler = async (
+   messageHandler: Function,
+   config: any,
+   adapters: any
+) => {
+   try {
+      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.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.error(`Unknown mode option: '${config.MQ_MODE}'`)
+            process.exit(1)
+      }
+   } catch (error) {
+      Worker.error((error as Error).message)
+      process.exit(1)
+   }
+}

package/src/Helpers.ts

@@ -0,0 +1,40 @@
+import { Worker } from './Worker'
+import path from 'path'
+
+export 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: string,
+      outputPath: string,
+      frame: number = 0,
+      width: number = 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.info(`Generating Thumbnail : ${outputPath}`)
+
+      return await Worker.execPromise(Helpers.FFMPEG, ffmpegParams)
+   }
+}

package/src/Worker.test.ts

@@ -0,0 +1,289 @@
+import { Worker } from './Worker'
+import axios from 'axios'
+import { spawn } from 'child_process'
+
+// Mock dependencies
+jest.mock('axios')
+jest.mock('child_process')
+
+const mockedAxios = axios as jest.Mocked<typeof axios>
+const mockedSpawn = spawn as jest.MockedFunction<typeof spawn>
+
+describe('Worker', () => {
+   beforeEach(() => {
+      // Clear all mocks before each test
+      jest.clearAllMocks()
+
+      // Reset Worker.endpoint
+      Worker.endpoint = ''
+   })
+
+   describe('endpoint property', () => {
+      it('should have an empty endpoint by default', () => {
+         expect(Worker.endpoint).toBe('')
+      })
+
+      it('should allow setting the endpoint', () => {
+         Worker.endpoint = 'https://api.example.com/events'
+         expect(Worker.endpoint).toBe('https://api.example.com/events')
+      })
+   })
+
+   describe('pushEvent', () => {
+      it('should return false when endpoint is not set', () => {
+         const result = Worker.pushEvent('test-event')
+         expect(result).toBe(false)
+         expect(mockedAxios.patch).not.toHaveBeenCalled()
+      })
+
+      it('should send event when endpoint is set', () => {
+         Worker.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         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.endpoint = 'https://api.example.com/events'
+         const customTs = 1234567890
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         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.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         const additionalData = {
+            userId: '123',
+            action: 'upload',
+            metadata: { size: 1024 },
+         }
+
+         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.pushEventAsync('test-event')
+         expect(result).toBe(false)
+         expect(mockedAxios.patch).not.toHaveBeenCalled()
+      })
+
+      it('should send event and return true on success', async () => {
+         Worker.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         const result = await 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.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockRejectedValue(new Error('Network error'))
+
+         const result = await Worker.pushEventAsync('test-event')
+
+         expect(result).toBe(false)
+      })
+
+      it('should handle non-OK status response', async () => {
+         Worker.endpoint = 'https://api.example.com/events'
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'Bad Request',
+            data: { error: 'Invalid payload' },
+         })
+
+         const result = await Worker.pushEventAsync('test-event')
+
+         expect(result).toBe(undefined)
+      })
+
+      it('should include custom timestamp', async () => {
+         Worker.endpoint = 'https://api.example.com/events'
+         const customTs = 9876543210
+
+         mockedAxios.patch.mockResolvedValue({
+            statusText: 'OK',
+            data: { success: true },
+         })
+
+         await 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 as any)
+
+         await expect(
+            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 as any)
+
+         await expect(
+            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 as any)
+
+         await 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 as any)
+
+         const args = ['arg1', 'arg2', '--flag']
+         await Worker.execPromise('command', args, '/custom/path')
+
+         expect(mockedSpawn).toHaveBeenCalledWith('command', args, {
+            cwd: '/custom/path',
+         })
+      })
+   })
+
+   describe('logger', () => {
+      it('should have a logger instance', () => {
+         expect(Worker.logger).toBeDefined()
+      })
+   })
+})

package/src/Worker.ts

@@ -0,0 +1,173 @@
+import { Core } from '@quatrain/core'
+import os from 'os'
+import axios from 'axios'
+import { spawn } from 'child_process'
+import { HandlerParameters } from './types/HandlerParameters'
+
+export class Worker extends Core {
+   static endpoint: string = ''
+   static readonly 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 readonly execPromise = (
+      command: string,
+      args: any[] = [],
+      cwd = process.cwd()
+   ): Promise<any> => {
+      try {
+         Worker.info(`Executing command ${command} in ${cwd} with arguments:`)
+         args.forEach((arg) => console.log(`\t${arg}`))
+         return new Promise((resolve, reject) => {
+            const child = spawn(command, args, { cwd })
+
+            child.stdout.on('data', (data: Buffer) =>
+               Worker.debug(data.toString())
+            )
+
+            child.stderr.on('data', (data: Buffer) =>
+               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 as Error).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: string, 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.hostname}`,
+         os: `${os.type} ${os.release} (${os.platform} ${os.arch})`,
+         ...data,
+         ts,
+      }
+
+      Worker.debug('event payload', payload)
+
+      axios
+         .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: string, 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.hostname}`,
+            os: `${os.type} ${os.release} (${os.platform} ${os.arch})`,
+            ...data,
+            ts,
+         }
+
+         const res = await axios.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 readonly handler = async (
+      messageHandler: Function,
+      config: HandlerParameters
+   ) => {
+      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 as Error).message)
+         process.exit(1)
+      }
+   }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+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/src/types/HandlerParameters.ts

@@ -0,0 +1,10 @@
+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/src/types/MessagehandlerParameters.ts

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

package/src/types/ModeEnum.ts

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

package/lib/types/HandlerParameters copy.d.ts

@@ -1,9 +0,0 @@
-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/lib/types/HandlerParameters copy.js

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

package/lib/types/ModeTypes.d.ts

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

package/lib/types/ModeTypes.js

@@ -1,9 +0,0 @@
-"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 = {}));