3.1.1

fix(source-interactive): Fix import path in receiver tests and rename progress bar property for clarity; update SmartlogSourceOra getter for improved backward compatibility.
3.1.0
2025-05-15 20:00:38 +00:00 · 2025-05-15 20:00:38 +00:00 · 2025-05-15 19:53:29 +00:00 · 2025-05-15 19:53:29 +00:00 · 2025-05-12 10:20:16 +00:00 · 2025-05-12 10:20:16 +00:00
51 changed files with 7855 additions and 1838 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true
--- a/.gitignore
+++ b/.gitignore
@ -3,7 +3,6 @@
 # artifacts
 coverage/
 public/
-pages/

 # installs
 node_modules/
@ -17,4 +16,5 @@ node_modules/
 dist/
 dist_*/

-# custom
+#------# custom
+**/.claude/settings.local.json
--- a/changelog.md
+++ b/changelog.md
@ -0,0 +1,335 @@
+# Changelog
+
+## 2025-05-15 - 3.1.1 - fix(source-interactive)
+Fix import path in receiver tests and rename progress bar property for clarity; update SmartlogSourceOra getter for improved backward compatibility.
+
+- Changed test file import from '../ts/index.js' to '../dist_ts/index.js' in test.receiver.node.ts to resolve module path issues
+- Renamed property 'complete' to 'completeChar' in SmartlogProgressBar and updated its usage accordingly
+- Modified SmartlogSourceOra getter to use public methods for starting and stopping the spinner, ensuring backward compatibility
+
+## 2025-05-15 - 3.1.0 - feat(interactive)
+Add interactive console features and refactor spinner module by renaming source-ora to source-interactive and removing ora dependency
+
+- Renamed source-ora module to source-interactive and updated package.json exports
+- Removed ora dependency in favor of a custom spinner implementation
+- Added new progress bar functionality with configurable options including ETA, percentage, and color
+- Updated tests and documentation (README and plan) to reflect the new interactive features
+- Bumped dependency versions in package.json and improved test script configuration
+
+## 2025-05-12 - 3.0.9 - fix(test/destination-devtools.browser)
+Simplify DevTools browser tests by removing redundant styled log assertions.
+
+- Removed detailed log styling tests to streamline the browser test suite.
+- Retained a basic test to verify DevTools destination instance creation.
+
+## 2025-05-11 - 3.0.8 - fix(ci)
+Update CI workflows, build scripts, and export configuration
+
+- Add separate Gitea workflows for tag and non-tag pushes to automate testing, auditing, and release steps
+- Revise package.json exports and update dependency versions and build scripts for improved module resolution
+- Enhance tsconfig settings with baseUrl and paths for consistency
+- Refine source code formatting and adjust test cases for better maintenance
+
+## 2024-06-06 - 3.0.7 - no notable changes
+This release contains no detailed changes.
+
+## 2024-06-06 - 3.0.6 - core
+A few fixes and updates were made in this release.
+
+- fix(core): update
+- update description
+
+## 2024-05-17 - 3.0.5 - core
+A minor core fix was applied.
+
+- fix(core): update
+
+## 2024-05-17 - 3.0.4 - core
+This release includes several updates to core files and configuration.
+
+- fix(core): update
+- update tsconfig
+- update npmextra.json: githost
+- update npmextra.json: githost
+- update npmextra.json: githost
+
+## 2023-08-08 - 3.0.3 - core
+A simple core update was performed.
+
+- fix(core): update
+
+## 2023-07-12 - 3.0.2 - core
+Core updates and a change of organizational scheme were introduced.
+
+- fix(core): update
+- switch to new org scheme (x2)
+
+## 2022-10-26 - 3.0.1 - core
+A core fix was applied.
+
+- fix(core): update
+
+## 2022-07-26 - 3.0.0 - core
+A minor core update was made.
+
+- fix(core): update
+
+## 2022-06-26 - 2.0.44 - core
+A breaking change switched the module system to esm.
+
+- BREAKING CHANGE(core): switch to esm
+
+## 2021-07-21 - 2.0.43 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2021-07-20 - 2.0.42 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2021-07-20 - 2.0.41 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2021-07-20 - 2.0.40 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2021-07-06 - 2.0.39 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-09-08 - 2.0.38 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-09-07 - 2.0.37 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-09-07 - 2.0.36 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-08-02 - 2.0.35 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.34 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.33 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.32 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.31 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.30 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.29 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-11 - 2.0.28 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-08 - 2.0.27 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-08 - 2.0.26 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-08 - 2.0.25 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-08 - 2.0.24 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-07 - 2.0.23 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-05 - 2.0.22 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2020-06-05 - 2.0.21 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-10-22 - 2.0.20 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-10-22 - 2.0.19 - core
+Dependencies were updated in the core.
+
+- fix(core): update dependencies
+
+## 2019-01-30 - 2.0.18 - license
+License files were updated.
+
+- fix(license): update license files
+
+## 2019-01-30 - 2.0.17 - readme
+A typo in the readme was fixed.
+
+- fix(readme): fix typo
+
+## 2019-01-30 - 2.0.16 - readme
+A typo in the readme was fixed.
+
+- fix(readme): fix typo
+
+## 2019-01-28 - 2.0.15 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-28 - 2.0.14 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-22 - 2.0.13 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-22 - 2.0.12 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-18 - 2.0.11 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-15 - 2.0.10 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2019-01-15 - 2.0.9 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-11-11 - 2.0.8 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-11-04 - 2.0.7 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-11-04 - 2.0.6 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-11-04 - 2.0.5 - api
+An API improvement was made.
+
+- fix(api): streamline api
+
+## 2018-11-04 - 2.0.4 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-11-03 - 2.0.3 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-10-31 - 2.0.2 - core
+A core update was applied.
+
+- fix(core): update
+
+## 2018-10-30 - 2.0.1 - core
+A new log router was implemented in core.
+
+- fix(core): implement log router
+
+## 2018-07-10 - 2.0.0 - core
+Console enabling was fixed.
+
+- fix(.enableConsole()): now works
+
+## 2018-07-10 - 1.0.6 - core
+A breaking change added a simple defaultLogger to core.
+
+- BREAKING CHANGE(core): now has simple defaultLogger
+
+## 2018-07-08 - 1.0.5 - npm
+Package distribution was fixed.
+
+- fix(npm): package distribution
+
+## 2018-06-05 - 1.0.4 - package
+The package name was updated.
+
+- fix(package): update package name
+
+## 2018-06-05 - 1.0.3 - core
+Several changes were made to update standards and system behavior.
+
+- fix(core): update to latest standards
+- system change
+
+## 2018-01-28 - 1.0.2 - docs
+Documentation was added to the readme.
+
+- docs(readme): add readme
+
+## 2018-01-28 - 1.0.1 - misc
+Initial cleanup and TypeScript support were introduced.
+
+- fix(cleanup):
+- feat(ts): initial
+
+## 2016-10-15 - 1.0.0 - no notable changes
+This initial release contains no detailed changes.
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "@push.rocks/smartlog",
-  "version": "3.0.6",
+  "version": "3.1.1",
  "private": false,
  "description": "A minimalistic, distributed, and extensible logging tool supporting centralized log management.",
  "keywords": [
@ -19,27 +19,47 @@
    "error tracking",
    "development tools"
  ],
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist_ts/index.js"
+    },
+    "./context": "./dist_ts_context/index.js",
+    "./interfaces": "./dist_ts_interfaces/index.js",
+    "./source-interactive": "./dist_ts_source_interactive/index.js",
+    "./destination-clickhouse": "./dist_ts_destination_clickhouse/index.js",
+    "./destination-devtools": "./dist_ts_destination_devtools/index.js",
+    "./destination-file": "./dist_ts_destination_file/index.js",
+    "./destination-local": "./dist_ts_destination_local/index.js",
+    "./destination-receiver": "./dist_ts_destination_receiver/index.js",
+    "./receiver": "./dist_ts_receiver/index.js"
+  },
  "author": "Lossless GmbH",
  "license": "MIT",
  "scripts": {
-    "test": "(tstest test/)",
-    "build": "(tsbuild --web && tsbundle npm)",
+    "test": "(tstest test/**/*.ts --verbose)",
+    "build": "(tsbuild tsfolders --allowimplicitany && tsbundle npm)",
    "format": "(gitzone format)",
    "buildDocs": "tsdoc"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.66",
-    "@git.zone/tsbundle": "^2.0.8",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.12.12"
+    "@git.zone/tsbuild": "^2.5.1",
+    "@git.zone/tsbundle": "^2.2.5",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.4.0",
+    "@push.rocks/tapbundle": "^6.0.3",
+    "@types/node": "^22.15.18"
  },
  "dependencies": {
+    "@api.global/typedrequest-interfaces": "^3.0.19",
+    "@push.rocks/consolecolor": "^2.0.2",
    "@push.rocks/isounique": "^1.0.4",
-    "@push.rocks/smartlog-interfaces": "^3.0.0"
+    "@push.rocks/smartclickhouse": "^2.0.17",
+    "@push.rocks/smartfile": "^11.2.0",
+    "@push.rocks/smarthash": "^3.0.4",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smarttime": "^4.1.1",
+    "@push.rocks/webrequest": "^3.0.37",
+    "@tsclass/tsclass": "^9.2.0"
  },
  "files": [
    "ts/**/*",
@ -56,5 +76,17 @@
  "browserslist": [
    "last 1 chrome versions"
  ],
-  "type": "module"
+  "type": "module",
+  "homepage": "https://code.foss.global/push.rocks/smartlog#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://code.foss.global/push.rocks/smartlog.git"
+  },
+  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39",
+  "bugs": {
+    "url": "https://code.foss.global/push.rocks/smartlog/issues"
+  },
+  "pnpm": {
+    "overrides": {}
+  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.md
+++ b/readme.md
@ -30,8 +30,8 @@ const logger = new Smartlog({
    containerName: 'awesome-container',
    environment: 'kubernetes-production',
    runtime: 'node',
-    zone: 'zone x'
-  }
+    zone: 'zone x',
+  },
 });
 ```

@ -60,6 +60,78 @@ defaultLogger.log('warn', 'This is a warning message using the default logger');

 This is particularly helpful for simple applications or for initial project setup.

+### Interactive Console Features
+
+Smartlog provides interactive console features through the `@push.rocks/smartlog/source-interactive` module:
+
+#### Spinners
+
+Use spinners to show progress for operations:
+
+```typescript
+import { SmartlogSourceInteractive } from '@push.rocks/smartlog/source-interactive';
+
+const spinner = new SmartlogSourceInteractive();
+spinner.text('Loading data...');
+
+// Later, when the operation completes:
+spinner.finishSuccess('Data loaded successfully!');
+// Or if it fails:
+spinner.finishFail('Failed to load data');
+
+// You can chain operations:
+spinner.text('Connecting to server');
+spinner.successAndNext('Fetching records');
+spinner.successAndNext('Processing data');
+spinner.finishSuccess('All done!');
+
+// Customize appearance:
+spinner.setSpinnerStyle('line'); // 'dots', 'line', 'star', or 'simple'
+spinner.setColor('green');       // 'red', 'green', 'yellow', 'blue', etc.
+spinner.setSpeed(100);           // Animation speed in milliseconds
+```
+
+#### Progress Bars
+
+Create progress bars for tracking operation progress:
+
+```typescript
+import { SmartlogProgressBar } from '@push.rocks/smartlog/source-interactive';
+
+const progressBar = new SmartlogProgressBar({
+  total: 100,                // Total number of items
+  width: 40,                 // Width of the progress bar
+  complete: '█',             // Character for completed section
+  incomplete: '░',           // Character for incomplete section
+  showEta: true,             // Show estimated time remaining
+  showPercent: true,         // Show percentage
+  showCount: true            // Show count (e.g., "50/100")
+});
+
+// Update progress
+progressBar.update(50);      // Set to 50% progress
+
+// Or increment
+progressBar.increment(10);   // Increase by 10 units
+
+// Change color
+progressBar.setColor('blue');
+
+// Complete the progress bar
+progressBar.update(100);     // or progressBar.complete();
+```
+
+#### Non-Interactive Environments
+
+Both spinners and progress bars automatically detect non-interactive environments (CI/CD, piped output, non-TTY) and provide fallback text-based output:
+
+```
+[Loading] Loading data...
+Progress: 50% (50/100)
+Progress: 100% (100/100)
+[Success] Data loaded successfully!
+```
+
 ### Extending With Log Destinations

 One of the core strengths of `@push.rocks/smartlog` is its ability to work with multiple log destinations, enabling you to log messages not just to the console but also to external logging services or custom destinations.
@ -76,7 +148,11 @@ class MyCustomLogDestination implements ILogDestination {
  }
 }

-const logger = new Smartlog({ logContext: { /* your context */ } });
+const logger = new Smartlog({
+  logContext: {
+    /* your context */
+  },
+});
 logger.addLogDestination(new MyCustomLogDestination());
 ```

--- a/readme.plan.md
+++ b/readme.plan.md
@ -0,0 +1,101 @@
+# Smartlog Interactive Console Features Plan
+
+## Overview
+
+This document outlines the plan for enhancing the console output capabilities of `@push.rocks/smartlog` by creating a comprehensive interactive console module. This involves renaming the current `ts_source_ora` module to `ts_source_interactive`, implementing our own spinner functionality (removing the ora dependency), and adding new features like progress bars and other interactive elements.
+
+## Implementation Steps
+
+### 1. Rename and Restructure
+
+- Rename directory from `ts_source_ora` to `ts_source_interactive`
+- Update all imports, exports, and references
+- Update package.json exports to reflect new module name
+- Maintain backward compatibility through proper export paths
+
+### 2. Custom Spinner Implementation
+
+- Create a native spinner implementation to replace ora dependency
+- Implement spinner frames and animation timing
+- Maintain API compatibility with current spinner methods:
+  - `text(textArg)` - Set text and start spinner
+  - `stop()` - Stop the spinner
+  - `finishSuccess(textArg?)` - Mark as succeeded
+  - `finishFail(textArg?)` - Mark as failed
+  - `successAndNext(textArg)` - Success and start new spinner
+  - `failAndNext(textArg)` - Fail and start new spinner
+- Add spinner customization options (speed, frames, colors)
+
+### 3. Progress Bar Implementation
+
+- Create a progress bar component with the following features:
+  - Configurable width and style
+  - Percentage display
+  - ETA calculation
+  - Current/total value display
+  - Custom formatting
+  - Theming support
+  - Methods for incrementing and updating
+
+### 4. Additional Interactive Features
+
+- Add indeterminate progress indicator
+- Add multi-line status display
+- Add table formatting for structured data
+- Add interactive prompts/confirmations
+
+### 5. Testing
+
+- Update existing tests to work with new implementation
+- Add tests for new progress bar functionality
+- Add tests for additional interactive features
+- Ensure consistent behavior across platforms
+
+### 6. Documentation
+
+- Update README with examples of new features
+- Add API documentation for all new methods
+- Include usage examples
+
+## Implementation Details
+
+### Progress Bar API
+
+```typescript
+// Creating a progress bar
+const progressBar = new SmartlogProgressBar({
+  total: 100,
+  width: 40,
+  complete: '=',
+  incomplete: ' ',
+  renderThrottle: 100, // ms
+  clearOnComplete: false,
+  showEta: true
+});
+
+// Updating a progress bar
+progressBar.update(50); // Update to 50%
+progressBar.increment(10); // Increment by 10
+progressBar.complete(); // Mark as complete
+```
+
+### Spinner API (maintains compatibility)
+
+```typescript
+// Current API (to be maintained)
+const spinner = new SmartlogSourceInteractive();
+spinner.text('Loading data');
+spinner.finishSuccess('Data loaded successfully');
+
+// New additions
+spinner.setSpinnerStyle('dots'); // Change spinner style
+spinner.setColor('green'); // Change color
+```
+
+## Benefits
+
+- Remove external dependency (ora) for better control and smaller bundle size
+- Provide more interactive console features for improved user experience
+- Maintain consistent API styling across all smartlog modules
+- Improve testability with custom implementation
+- Enable more advanced terminal interactions
--- a/test/test.context.ts
+++ b/test/test.context.ts
@ -0,0 +1,9 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as smartlogContext from '../ts_context/index.js';
+
+tap.test('should correctly export strings from context module', async () => {
+  expect(typeof smartlogContext.standardExport).toEqual('string');
+  expect(smartlogContext.standardExport).toEqual('Hi there! :) This is an exported string');
+});
+
+export default tap.start();
--- a/test/test.destination-clickhouse.node.ts
+++ b/test/test.destination-clickhouse.node.ts
@ -0,0 +1,19 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogDestinationClickhouse } from '../ts_destination_clickhouse/index.js';
+import * as smartclickhouse from '@push.rocks/smartclickhouse';
+
+// Test we can create a destination instance
+tap.test('should create a ClickHouse destination instance', async () => {
+  // Use mock configuration
+  const clickhouseOptions: smartclickhouse.IClickhouseConstructorOptions = {
+    url: 'defult:@localhost:8123',
+    database: 'test_logs'
+  };
+  
+  // Verify we can create an instance
+  // We won't start it to avoid making real connections
+  const clickhouseDestination = new SmartlogDestinationClickhouse(clickhouseOptions);
+  expect(clickhouseDestination).toBeTruthy();
+});
+
+export default tap.start();
--- a/test/test.destination-devtools.browser.ts
+++ b/test/test.destination-devtools.browser.ts
@ -0,0 +1,13 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogDestinationDevtools } from '../ts_destination_devtools/index.js';
+
+export const run = async function() {
+  tap.test('should create a DevTools destination instance in browser', async () => {
+    const devtoolsDestination = new SmartlogDestinationDevtools();
+    expect(devtoolsDestination).toBeTruthy();
+  });
+  
+  return await tap.start();
+};
+
+export default run();
--- a/test/test.destination-devtools.node.ts
+++ b/test/test.destination-devtools.node.ts
@ -0,0 +1,10 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogDestinationDevtools } from '../ts_destination_devtools/index.js';
+
+// Test we can create a destination instance
+tap.test('should create a DevTools destination instance', async () => {
+  const devtoolsDestination = new SmartlogDestinationDevtools();
+  expect(devtoolsDestination).toBeTruthy();
+});
+
+export default tap.start();
--- a/test/test.destination-file.node.ts
+++ b/test/test.destination-file.node.ts
@ -0,0 +1,87 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogDestinationFile } from '../ts_destination_file/index.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+let testLogDir: string;
+let testLogFile: string;
+let testDestination: SmartlogDestinationFile;
+
+// Setup and teardown helpers
+const createTempLogDir = () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'smartlog-test-'));
+  return tempDir;
+};
+
+const removeTempDir = (dirPath: string) => {
+  if (fs.existsSync(dirPath)) {
+    const files = fs.readdirSync(dirPath);
+    for (const file of files) {
+      fs.unlinkSync(path.join(dirPath, file));
+    }
+    fs.rmdirSync(dirPath);
+  }
+};
+
+// Tests
+tap.test('should prepare test environment', async () => {
+  testLogDir = createTempLogDir();
+  testLogFile = path.join(testLogDir, 'test.log');
+  expect(fs.existsSync(testLogDir)).toBeTrue();
+});
+
+tap.test('should create a file destination instance with a valid path', async () => {
+  testDestination = new SmartlogDestinationFile(testLogFile);
+  expect(testDestination).toBeTruthy();
+  expect(fs.existsSync(testLogFile)).toBeTrue();
+});
+
+tap.test('should throw error when file path is not absolute', async () => {
+  let errorThrown = false;
+  try {
+    new SmartlogDestinationFile('relative/path/file.log');
+  } catch (error) {
+    errorThrown = true;
+    expect(error.message).toContain('filePath needs to be absolute');
+  }
+  expect(errorThrown).toBeTrue();
+});
+
+tap.test('should write log messages to file', async () => {
+  const testMessage = 'Test log message';
+
+  await testDestination.handleLog({
+    timestamp: Date.now(),
+    type: 'log',
+    level: 'info',
+    message: testMessage,
+    context: {
+      environment: 'test',
+      runtime: 'node'
+    },
+    correlation: {
+      id: '123',
+      type: 'none'
+    }
+  });
+
+  // Give file system a moment to write
+  await new Promise(resolve => setTimeout(resolve, 50));
+
+  const fileContent = fs.readFileSync(testLogFile, 'utf8');
+  expect(fileContent).toContain(testMessage);
+});
+
+tap.test('should clean up test resources', async () => {
+  // Close file handle before cleanup
+  testDestination.fileWriteStream.end();
+
+  // Small delay to ensure file is properly closed
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  removeTempDir(testLogDir);
+  expect(fs.existsSync(testLogDir)).toBeFalse();
+});
+
+export default tap.start();
--- a/test/test.destination-local.node.ts
+++ b/test/test.destination-local.node.ts
@ -0,0 +1,96 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { DestinationLocal } from '../ts_destination_local/index.js';
+import * as smartlogInterfaces from '../ts_interfaces/index.js';
+
+let testDestination: DestinationLocal;
+
+// Mock log package
+const createMockLogPackage = (level: smartlogInterfaces.TLogLevel, message: string): smartlogInterfaces.ILogPackage => {
+  return {
+    timestamp: Date.now(),
+    type: 'log',
+    level,
+    message,
+    context: {
+      environment: 'test',
+      runtime: 'node'
+    },
+    correlation: {
+      id: '123',
+      type: 'none'
+    }
+  };
+};
+
+// Tests
+tap.test('should create a local destination instance', async () => {
+  testDestination = new DestinationLocal();
+  expect(testDestination).toBeTruthy();
+});
+
+tap.test('should handle logs with different levels', async () => {
+  // Testing with a spy would be ideal, but since we don't have a mocking framework,
+  // we'll just verify the method runs without errors for different log levels
+
+  // Test info level
+  const logPackageInfo = createMockLogPackage('info', 'Info message');
+  await testDestination.handleLog(logPackageInfo);
+
+  // Test error level
+  const logPackageError = createMockLogPackage('error', 'Error message');
+  await testDestination.handleLog(logPackageError);
+
+  // Test warn level
+  const logPackageWarn = createMockLogPackage('warn', 'Warning message');
+  await testDestination.handleLog(logPackageWarn);
+
+  // Test silly level
+  const logPackageSilly = createMockLogPackage('silly', 'Silly message');
+  await testDestination.handleLog(logPackageSilly);
+});
+
+tap.test('should handle reduced logging', async () => {
+  testDestination = new DestinationLocal();
+
+  // Note: In a real test environment with a mocking framework,
+  // we would capture console output and verify it's only written
+  // according to the expected behavior. Here we just ensure
+  // the methods execute without errors.
+
+  // First call with message
+  testDestination.logReduced('Test message');
+
+  // Same message immediately after
+  testDestination.logReduced('Test message');
+
+  // Different message
+  testDestination.logReduced('Different message');
+});
+
+tap.test('should handle repeated logging with repeatEveryTimesArg', async () => {
+  testDestination = new DestinationLocal();
+
+  // First call with message
+  testDestination.logReduced('Repeated with count', 3);
+
+  // Second call
+  testDestination.logReduced('Repeated with count', 3);
+
+  // Third call
+  testDestination.logReduced('Repeated with count', 3);
+
+  // Fourth call (3rd repetition)
+  testDestination.logReduced('Repeated with count', 3);
+});
+
+tap.test('should create new line(s)', async () => {
+  testDestination = new DestinationLocal();
+
+  // Default 1 line
+  testDestination.newLine();
+
+  // Multiple lines
+  testDestination.newLine(3);
+});
+
+export default tap.start();
--- a/test/test.destination-receiver.node.ts
+++ b/test/test.destination-receiver.node.ts
@ -0,0 +1,72 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogDestinationReceiver } from '../ts_destination_receiver/index.js';
+import { Smartlog } from '../ts/index.js';
+import * as smartlogInterfaces from '../ts_interfaces/index.js';
+
+let testDestination: SmartlogDestinationReceiver;
+let testSmartlog: Smartlog;
+
+// Mock log package
+const createMockLogPackage = (level: smartlogInterfaces.TLogLevel, message: string): smartlogInterfaces.ILogPackage => {
+  return {
+    timestamp: Date.now(),
+    type: 'log',
+    level,
+    message,
+    context: {
+      environment: 'test',
+      runtime: 'node'
+    },
+    correlation: {
+      id: '123',
+      type: 'none'
+    }
+  };
+};
+
+// Tests
+tap.test('should create a Smartlog instance', async () => {
+  testSmartlog = new Smartlog({
+    logContext: {
+      environment: 'test',
+      runtime: 'node',
+      zone: 'test-zone',
+      company: 'Test Company',
+      companyunit: 'Test Unit',
+      containerName: 'test-container',
+    },
+  });
+  
+  expect(testSmartlog).toBeTruthy();
+});
+
+tap.test('should create a destination receiver instance with valid options', async () => {
+  testDestination = new SmartlogDestinationReceiver({
+    passphrase: 'test-passphrase',
+    receiverEndpoint: 'https://example.com/logs',
+  });
+  
+  expect(testDestination).toBeTruthy();
+});
+
+tap.test('should attempt to send logs to the receiver endpoint', async () => {
+  // Create a mock version of the webrequest.postJson method to avoid actual HTTP calls
+  const originalPostJson = testDestination['webrequest'].postJson;
+  testDestination['webrequest'].postJson = async () => {
+    return {
+      body: { status: 'ok' },
+      statusCode: 200
+    };
+  };
+
+  try {
+    const logPackage = createMockLogPackage('info', 'Test receiver message');
+    const result = await testDestination.handleLog(logPackage);
+    expect(result).toEqual({ status: 'ok' });
+  } finally {
+    // Restore the original method
+    testDestination['webrequest'].postJson = originalPostJson;
+  }
+});
+
+export default tap.start();
--- a/test/test.noninteractive.node.ts
+++ b/test/test.noninteractive.node.ts
@ -0,0 +1,64 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogSourceInteractive, SmartlogProgressBar } from '../ts_source_interactive/index.js';
+
+// Test instances
+let testSpinner: SmartlogSourceInteractive;
+let testProgressBar: SmartlogProgressBar;
+
+// Original state for restoration
+const originalState = {
+  stdoutTTY: process.stdout.isTTY,
+  consoleLog: console.log
+};
+
+// Log tracking
+const logs: string[] = [];
+
+tap.test('should handle non-interactive mode correctly', async (toolsArg) => {
+  // Setup non-interactive mode
+  process.stdout.isTTY = false;
+  console.log = (...args: any[]) => {
+    logs.push(args.join(' '));
+  };
+
+  // Test spinner creation
+  testSpinner = new SmartlogSourceInteractive();
+  expect(testSpinner).toBeTruthy();
+
+  // Test spinner text
+  logs.length = 0;
+  testSpinner.text('Loading data');
+  expect(logs.length).toBeGreaterThan(0);
+  expect(logs[0]).toContain('[Loading]');
+  expect(logs[0]).toContain('Loading data');
+
+  // Test spinner success
+  logs.length = 0;
+  testSpinner.finishSuccess('Task completed');
+  expect(logs.length).toBeGreaterThan(0);
+  expect(logs[0]).toContain('[Success]');
+  expect(logs[0]).toContain('Task completed');
+
+  // Test progress bar
+  testProgressBar = new SmartlogProgressBar({ total: 100 });
+  expect(testProgressBar).toBeTruthy();
+
+  // Test progress updates
+  logs.length = 0;
+  testProgressBar.update(10);
+  testProgressBar.update(50);
+  testProgressBar.update(100);
+  
+  expect(logs.length).toBeGreaterThan(0);
+  const progressLogs = logs.join(' ');
+  expect(progressLogs).toContain('10%');
+  expect(progressLogs).toContain('50%');
+  expect(progressLogs).toContain('100%');
+
+  // Cleanup
+  testSpinner.stop();
+  console.log = originalState.consoleLog;
+  process.stdout.isTTY = originalState.stdoutTTY;
+});
+
+export default tap.start();
--- a/test/test.receiver.node.ts
+++ b/test/test.receiver.node.ts
@ -0,0 +1,115 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogReceiver } from '../ts_receiver/index.js';
+import { Smartlog } from '../dist_ts/index.js';
+import * as smartlogInterfaces from '../ts_interfaces/index.js';
+import * as smarthash from '@push.rocks/smarthash';
+
+let testSmartlog: Smartlog;
+let testReceiver: SmartlogReceiver;
+const testPassphrase = 'test-secret-passphrase';
+
+// Helper to create authenticated log package
+const createAuthenticatedLogPackage = (
+  level: smartlogInterfaces.TLogLevel,
+  message: string
+): smartlogInterfaces.ILogPackageAuthenticated => {
+  const logPackage: smartlogInterfaces.ILogPackage = {
+    timestamp: Date.now(),
+    type: 'log',
+    level,
+    message,
+    context: {
+      environment: 'test',
+      runtime: 'node'
+    },
+    correlation: {
+      id: '123',
+      type: 'none'
+    }
+  };
+  
+  return {
+    auth: smarthash.sha256FromStringSync(testPassphrase),
+    logPackage
+  };
+};
+
+// Tests
+tap.test('should create a Smartlog instance for receiver', async () => {
+  testSmartlog = new Smartlog({
+    logContext: {
+      environment: 'test',
+      runtime: 'node',
+      zone: 'test-zone',
+      company: 'Test Company',
+      companyunit: 'Test Unit',
+      containerName: 'test-container',
+    },
+  });
+  
+  expect(testSmartlog).toBeTruthy();
+});
+
+tap.test('should create a SmartlogReceiver instance', async () => {
+  // Create a validator function that always returns true
+  const validatorFunction = async () => true;
+  
+  testReceiver = new SmartlogReceiver({
+    smartlogInstance: testSmartlog,
+    passphrase: testPassphrase,
+    validatorFunction
+  });
+  
+  expect(testReceiver).toBeTruthy();
+  expect(testReceiver.passphrase).toEqual(testPassphrase);
+});
+
+tap.test('should handle authenticated log with correct passphrase', async () => {
+  const authLogPackage = createAuthenticatedLogPackage('info', 'Test authenticated message');
+  
+  const result = await testReceiver.handleAuthenticatedLog(authLogPackage);
+  
+  expect(result).toBeTruthy();
+  expect(result.status).toEqual('ok');
+});
+
+tap.test('should reject authenticated log with incorrect passphrase', async () => {
+  const logPackage: smartlogInterfaces.ILogPackage = {
+    timestamp: Date.now(),
+    type: 'log',
+    level: 'info',
+    message: 'Test unauthorized message',
+    context: {
+      environment: 'test',
+      runtime: 'node'
+    },
+    correlation: {
+      id: '123',
+      type: 'none'
+    }
+  };
+  
+  const badAuthPackage = {
+    auth: 'incorrect-hash',
+    logPackage
+  };
+  
+  const result = await testReceiver.handleAuthenticatedLog(badAuthPackage);
+  
+  expect(result).toBeTruthy();
+  expect(result.status).toEqual('error');
+});
+
+tap.test('should handle many authenticated logs', async () => {
+  const authLogPackage1 = createAuthenticatedLogPackage('info', 'Test batch message 1');
+  const authLogPackage2 = createAuthenticatedLogPackage('warn', 'Test batch message 2');
+  const authLogPackage3 = createAuthenticatedLogPackage('error', 'Test batch message 3');
+  
+  const authLogPackages = [authLogPackage1, authLogPackage2, authLogPackage3];
+  
+  await testReceiver.handleManyAuthenticatedLogs(authLogPackages);
+  
+  // No assertions needed as we're just testing it doesn't throw errors
+});
+
+export default tap.start();
--- a/test/test.source-interactive.node.ts
+++ b/test/test.source-interactive.node.ts
@ -0,0 +1,190 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import { SmartlogSourceInteractive, SmartlogProgressBar, SmartlogSourceOra } from '../ts_source_interactive/index.js';
+
+// Test spinner functionality
+let testSpinner: SmartlogSourceInteractive;
+
+// Helper function to clean up spinners after each test
+const cleanupSpinner = (spinner: SmartlogSourceInteractive) => {
+  if (spinner.isStarted()) {
+    spinner.stop();
+  }
+};
+
+tap.test('should create a SmartlogSourceInteractive instance', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Set fast animation speed for tests
+  expect(testSpinner).toBeTruthy();
+  expect(testSpinner.isStarted()).toBeFalse();
+});
+
+tap.test('should set text and start spinner', async () => {
+  const testText = 'Testing spinner';
+  testSpinner.text(testText);
+  
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should update text', async () => {
+  const newText = 'Updated text';
+  testSpinner.text(newText);
+  
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should stop spinner', async () => {
+  testSpinner.stop();
+  // We can't easily test the visual state, but we can verify it doesn't throw errors
+});
+
+tap.test('should finish with success', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.text('Starting again');
+  
+  const successText = 'Operation successful';
+  testSpinner.finishSuccess(successText);
+  
+  expect(testSpinner.isStarted()).toBeFalse();
+});
+
+tap.test('should finish with failure', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.text('Starting again');
+  
+  const failText = 'Operation failed';
+  testSpinner.finishFail(failText);
+  
+  expect(testSpinner.isStarted()).toBeFalse();
+});
+
+tap.test('should handle success and next', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Fast animation
+  testSpinner.text('Starting again');
+  
+  const nextText = 'Next operation';
+  testSpinner.successAndNext(nextText);
+  
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should handle fail and next', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Fast animation
+  testSpinner.text('Starting again');
+  
+  const nextText = 'Next operation after failure';
+  testSpinner.failAndNext(nextText);
+  
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should set spinner style', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Fast animation
+  testSpinner.setSpinnerStyle('line');
+  testSpinner.text('Custom style spinner');
+  
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should set spinner color', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Fast animation
+  testSpinner.setColor('green');
+  testSpinner.text('Green spinner');
+  
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+tap.test('should set animation speed', async () => {
+  testSpinner = new SmartlogSourceInteractive();
+  testSpinner.setSpeed(10); // Actually set fast for testing
+  testSpinner.text('Slow spinner');
+  
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+  expect(testSpinner.isStarted()).toBeTrue();
+  cleanupSpinner(testSpinner);
+});
+
+// Test progress bar functionality
+let testProgressBar: SmartlogProgressBar;
+
+tap.test('should create a progress bar instance', async () => {
+  testProgressBar = new SmartlogProgressBar({
+    total: 100
+  });
+  
+  expect(testProgressBar).toBeTruthy();
+});
+
+tap.test('should update progress bar value', async () => {
+  testProgressBar.update(50);
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+});
+
+tap.test('should increment progress bar', async () => {
+  const initialValue = 50;
+  const increment = 10;
+  testProgressBar = new SmartlogProgressBar({ total: 100 });
+  testProgressBar.update(initialValue);
+  testProgressBar.increment(increment);
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+});
+
+tap.test('should complete progress bar', async () => {
+  testProgressBar = new SmartlogProgressBar({ total: 100 });
+  testProgressBar.update(50);
+  testProgressBar.update(100); // Update to 100% to simulate completion
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+});
+
+tap.test('should set progress bar color', async () => {
+  testProgressBar = new SmartlogProgressBar({ total: 100 });
+  testProgressBar.setColor('blue');
+  testProgressBar.update(50);
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+});
+
+tap.test('should handle custom progress bar options', async () => {
+  testProgressBar = new SmartlogProgressBar({
+    total: 100,
+    width: 40,
+    complete: '=',
+    incomplete: '-',
+    showEta: false,
+    showPercent: true,
+    showCount: true
+  });
+  
+  testProgressBar.update(30);
+  // Visual effect can't be easily tested, but we can verify it doesn't throw errors
+});
+
+// Test backward compatibility with SmartlogSourceOra
+let testSourceOra: SmartlogSourceOra;
+
+tap.test('should create a SmartlogSourceOra instance for backward compatibility', async () => {
+  testSourceOra = new SmartlogSourceOra();
+  expect(testSourceOra).toBeTruthy();
+  expect(testSourceOra.isStarted()).toBeFalse();
+});
+
+tap.test('should maintain compatibility with old API', async () => {
+  testSourceOra.setSpeed(10); // Fast animation
+  testSourceOra.text('Testing backward compatibility');
+  expect(testSourceOra.isStarted()).toBeTrue();
+  
+  testSourceOra.finishSuccess('Success');
+  expect(testSourceOra.isStarted()).toBeFalse();
+});
+
+export default tap.start();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
 */
 export const commitinfo = {
  name: '@push.rocks/smartlog',
-  version: '3.0.6',
+  version: '3.1.1',
  description: 'A minimalistic, distributed, and extensible logging tool supporting centralized log management.'
 }
--- a/ts/smartlog.classes.consolelog.ts
+++ b/ts/smartlog.classes.consolelog.ts
@ -8,7 +8,7 @@ export class ConsoleLog {
    logLevelArg: plugins.smartlogInterfaces.TLogLevel,
    logMessageArg: string,
    dataArg?: any,
-    correlationArg?: plugins.smartlogInterfaces.ILogCorrelation
+    correlationArg?: plugins.smartlogInterfaces.ILogCorrelation,
  ) {
    console.log(`__# ${logLevelArg}: ${logMessageArg}`);
  }
--- a/ts/smartlog.classes.loggroup.ts
+++ b/ts/smartlog.classes.loggroup.ts
@ -14,7 +14,7 @@ export class LogGroup {
  public log(
    logLevelArg: plugins.smartlogInterfaces.TLogLevel,
    logMessageArg: string,
-    logDataArg?: any
+    logDataArg?: any,
  ) {
    this.smartlogRef.log(logLevelArg, logMessageArg, logDataArg, {
      id: plugins.isounique.uni(),
--- a/ts/smartlog.classes.smartlog.ts
+++ b/ts/smartlog.classes.smartlog.ts
@ -9,6 +9,18 @@ export interface ISmartlogContructorOptions {
 }

 export class Smartlog implements plugins.smartlogInterfaces.ILogDestination {
+  // STATIC
+  public static createForCommitinfo(
+    commitinfo: plugins.smartlogInterfaces.ILogContext['commitinfo'],
+  ) {
+    return new Smartlog({
+      logContext: {
+        commitinfo,
+      },
+    });
+  }
+
+  // INSTANCE
  public logContext: plugins.smartlogInterfaces.ILogContext;
  public minimumLogLevel: plugins.smartlogInterfaces.TLogLevel;

@ -85,7 +97,7 @@ export class Smartlog implements plugins.smartlogInterfaces.ILogDestination {
    logLevelArg: plugins.smartlogInterfaces.TLogLevel,
    logMessageArg: string,
    logDataArg?: any,
-    correlationArg?: plugins.smartlogInterfaces.ILogCorrelation
+    correlationArg?: plugins.smartlogInterfaces.ILogCorrelation,
  ) {
    correlationArg = {
      ...{
@ -121,7 +133,7 @@ export class Smartlog implements plugins.smartlogInterfaces.ILogDestination {
    correlationArg: plugins.smartlogInterfaces.ILogCorrelation = {
      id: plugins.isounique.uni(),
      type: 'none',
-    }
+    },
  ) {
    if (this.consoleEnabled) {
      this.safeConsoleLog(`INCREMENT: ${logLevelArg}: ${logMessageArg}`);
@ -142,7 +154,7 @@ export class Smartlog implements plugins.smartlogInterfaces.ILogDestination {

  private safeConsoleLog(logLine: string) {
    console.log(
-      `LOG => ${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()} => ${logLine}`
+      `LOG => ${new Date().getHours()}:${new Date().getMinutes()}:${new Date().getSeconds()} => ${logLine}`,
    );
  }

--- a/ts/smartlog.plugins.ts
+++ b/ts/smartlog.plugins.ts
@ -1,4 +1,4 @@
 import * as isounique from '@push.rocks/isounique';
-import * as smartlogInterfaces from '@push.rocks/smartlog-interfaces';
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';

 export { isounique, smartlogInterfaces };
--- a/ts_context/index.ts
+++ b/ts_context/index.ts
@ -0,0 +1,3 @@
+import * as plugins from './smartlog-context.plugins.js';
+
+export let standardExport = 'Hi there! :) This is an exported string';
--- a/ts_context/smartlog-context.plugins.ts
+++ b/ts_context/smartlog-context.plugins.ts
@ -0,0 +1,6 @@
+// node native scope
+import * as path from 'path';
+
+export {
+  path
+}
--- a/ts_destination_clickhouse/00_commitinfo_data.ts
+++ b/ts_destination_clickhouse/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-destination-clickhouse',
+  version: '1.0.14',
+  description: 'A library to integrate Smartlog logging with ClickHouse database for efficient log storage and querying.'
+}
--- a/ts_destination_clickhouse/index.ts
+++ b/ts_destination_clickhouse/index.ts
@ -0,0 +1,30 @@
+import * as plugins from './slclick.plugins.js';
+
+export class SmartlogDestinationClickhouse implements plugins.smartlogInterfaces.ILogDestination {
+  // STATIC
+  public static async createAndStart(
+    optionsArg: plugins.smartclickhouse.IClickhouseConstructorOptions
+  ) {
+    const destinationClickhouse = new SmartlogDestinationClickhouse(optionsArg);
+    await destinationClickhouse.start();
+    return destinationClickhouse;
+  }
+
+  // INSTANCE
+  private smartclickhouseDb: plugins.smartclickhouse.SmartClickHouseDb;
+  private logTable: plugins.smartclickhouse.TimeDataTable;
+  constructor(options: plugins.smartclickhouse.IClickhouseConstructorOptions) {
+    this.smartclickhouseDb = new plugins.smartclickhouse.SmartClickHouseDb(options);
+  }
+
+  public async start() {
+    await this.smartclickhouseDb.start();
+    this.logTable = await this.smartclickhouseDb.getTable('logs');
+  }
+
+  public async handleLog(
+    logPackage: plugins.smartlogInterfaces.ILogPackage<unknown>
+  ): Promise<void> {
+    await this.logTable.addData(logPackage);
+  }
+}
--- a/ts_destination_clickhouse/slclick.plugins.ts
+++ b/ts_destination_clickhouse/slclick.plugins.ts
@ -0,0 +1,5 @@
+// pushrocks scope
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as smartclickhouse from '@push.rocks/smartclickhouse';
+
+export { smartlogInterfaces, smartclickhouse };
--- a/ts_destination_devtools/00_commitinfo_data.ts
+++ b/ts_destination_devtools/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-destination-devtools',
+  version: '1.0.12',
+  description: 'A library enabling enhanced logging in browser development tools.'
+}
--- a/ts_destination_devtools/index.ts
+++ b/ts_destination_devtools/index.ts
@ -0,0 +1,58 @@
+import * as plugins from './plugins.js';
+import type { ILogDestination, ILogPackage } from '../dist_ts_interfaces/index.js';
+
+export class SmartlogDestinationDevtools implements ILogDestination {
+  public async handleLog(logPackageArg: ILogPackage) {
+    await this.logInBrowser(logPackageArg);
+  }
+
+  private async logInBrowser(logPackage: ILogPackage) {
+    switch (logPackage.level) {
+      case 'error':
+        console.log(
+          `%c Error: %c ${logPackage.message}`,
+          'background:#000000;color:#800000;',
+          'color:#000000;'
+        );
+        break;
+      case 'info':
+        console.log(
+          `%c Info: %c ${logPackage.message}`,
+          'background:#EC407A;color:#ffffff;',
+          'color:#EC407A;'
+        );
+        break;
+      case 'ok':
+        console.log(
+          `%c OK: %c ${logPackage.message}`,
+          'background:#000000;color:#8BC34A;',
+          'color:#000000;'
+        );
+        break;
+      case 'success':
+        console.log(
+          `%c Success: %c ${logPackage.message}`,
+          'background:#8BC34A;color:#ffffff;',
+          'color:#8BC34A;'
+        );
+        break;
+      case 'warn':
+        console.log(
+          `%c Warn: %c ${logPackage.message}`,
+          'background:#000000;color:#FB8C00;',
+          'color:#000000;'
+        );
+        break;
+      case 'note':
+        console.log(
+          `%c Note: %c ${logPackage.message}`,
+          'background:#42A5F5;color:#ffffff',
+          'color:#42A5F5;'
+        );
+        break;
+      default:
+        console.log(`unknown logType for "${logPackage.message}"`);
+        break;
+    }
+  }
+}
--- a/ts_destination_devtools/plugins.ts
+++ b/ts_destination_devtools/plugins.ts
@ -0,0 +1,2 @@
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+export { smartlogInterfaces };
--- a/ts_destination_file/index.ts
+++ b/ts_destination_file/index.ts
@ -0,0 +1,23 @@
+import * as plugins from './smartfile-destination-file.plugins.js';
+
+export class SmartlogDestinationFile implements plugins.smartlogInterfaces.ILogDestination {
+  public fileWriteStream: plugins.fs.WriteStream;
+
+  public async handleLog(logPackageArg: plugins.smartlogInterfaces.ILogPackage) {
+    this.fileWriteStream.write(`${new plugins.smarttime.ExtendedDate(Date.now()).toISOString()}: ${logPackageArg.message} \n`);
+  }
+
+  constructor(filePathArg: string) {
+    const extendedDate = new plugins.smarttime.ExtendedDate(Date.now());
+    if (!plugins.path.isAbsolute(filePathArg)) {
+      throw new Error(`filePath needs to be absolute but is not: "${filePathArg}"`);
+    }
+    plugins.smartfile.fs.ensureFileSync(filePathArg, `# Smartlogfile. Created at ${extendedDate.toISOString()}\n`);
+    this.fileWriteStream = plugins.fs.createWriteStream(
+      filePathArg,
+      {
+        flags: 'a+',
+      }
+    );
+  }
+}
--- a/ts_destination_file/smartfile-destination-file.plugins.ts
+++ b/ts_destination_file/smartfile-destination-file.plugins.ts
@ -0,0 +1,19 @@
+// node native scope
+import * as fs from 'fs';
+import * as path from 'path';
+
+export {
+  fs,
+  path
+};
+
+// pushrocks scope
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as smarttime from '@push.rocks/smarttime';
+
+export {
+  smartfile,
+  smartlogInterfaces,
+  smarttime
+};
--- a/ts_destination_local/00_commitinfo_data.ts
+++ b/ts_destination_local/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-destination-local',
+  version: '9.0.2',
+  description: 'a smartlog destination targeting the local console'
+}
--- a/ts_destination_local/classes.destinationlocal.ts
+++ b/ts_destination_local/classes.destinationlocal.ts
@ -0,0 +1,135 @@
+import * as plugins from './plugins.js';
+import type { ILogDestination, ILogPackage, TLogLevel } from '../dist_ts_interfaces/index.js';
+
+// other beautylog classes
+import { type TColorName } from '@push.rocks/consolecolor';
+
+export class DestinationLocal implements ILogDestination {
+  /**
+   * handles a log according to the smartlog standard
+   * @param logPackage
+   */
+  public async handleLog(logPackage: ILogPackage) {
+    this.logToConsole(logPackage);
+  }
+
+  /**
+   * creates a new empty line
+   * @param linesArg
+   * @returns void
+   */
+  public newLine(linesArg: number = 1) {
+    for (let i = 0; i < linesArg; i++) {
+      console.log('\n');
+    }
+  }
+
+  /**
+   * logs a reduced log that only logs changes of consequential log messages
+   */
+  public logReduced(logTextArg: string, repeatEveryTimesArg: number = 0) {
+    if (
+      logTextArg === this.previousMessage &&
+      (repeatEveryTimesArg === 0 || this.sameMessageCounter !== repeatEveryTimesArg)
+    ) {
+      this.sameMessageCounter++;
+    } else {
+      this.sameMessageCounter = 0;
+      this.previousMessage = logTextArg;
+      this.logToConsole({
+        timestamp: Date.now(),
+        type: 'log',
+        level: 'info',
+        context: {
+          company: 'undefined',
+          companyunit: 'undefined',
+          containerName: 'undefined',
+          environment: 'test',
+          runtime: 'node',
+          zone: 'undefined',
+        },
+        message: logTextArg,
+        correlation: {
+          id: 'none',
+          type: 'none',
+        },
+      });
+    }
+  }
+  private previousMessage: string = '';
+  private sameMessageCounter: number = 0;
+
+  // default logging
+  private logToConsole(logPackageArg: ILogPackage) {
+    let logString: string;
+    try {
+      logString =
+        this.localBl[logPackageArg.level].prefix +
+        plugins.consolecolor.coloredString(
+          logPackageArg.message,
+          this.localBl[logPackageArg.level].textColor
+        );
+      console.log(logString);
+      return true;
+    } catch (error) {
+      console.log(
+        this.localBl.errorPrefix + 'You seem to have tried logging something strange' + error
+      );
+      return false;
+    }
+  }
+
+  private localBl: {
+    [key: string]: {
+      prefix: string;
+      textColor: TColorName;
+    };
+  } = {
+    silly: {
+      prefix: plugins.consolecolor.coloredString(' silly ', 'white', 'blue') + ' ',
+      textColor: 'blue',
+    },
+    error: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'red', 'red') +
+        plugins.consolecolor.coloredString(' ERROR!  ', 'red', 'black') +
+        ' ',
+      textColor: 'red',
+    },
+    info: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'blue', 'blue') +
+        plugins.consolecolor.coloredString(' info: ', 'blue', 'black') +
+        ' ',
+      textColor: 'white',
+    },
+    note: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'pink', 'pink') +
+        plugins.consolecolor.coloredString(' note -> ', 'pink', 'black') +
+        ' ',
+      textColor: 'pink',
+    },
+    ok: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'green', 'green') +
+        plugins.consolecolor.coloredString(' ok ', 'green', 'black') +
+        ' ',
+      textColor: 'green',
+    },
+    success: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'green', 'green') +
+        plugins.consolecolor.coloredString(' SUCCESS! ', 'green', 'black') +
+        ' ',
+      textColor: 'green',
+    },
+    warn: {
+      prefix:
+        plugins.consolecolor.coloredString(' ', 'orange', 'orange') +
+        plugins.consolecolor.coloredString(' WARN -> ', 'orange', 'black') +
+        ' ',
+      textColor: 'orange',
+    },
+  };
+}
--- a/ts_destination_local/index.ts
+++ b/ts_destination_local/index.ts
@ -0,0 +1,2 @@
+// export classes
+export { DestinationLocal } from './classes.destinationlocal.js';
--- a/ts_destination_local/plugins.ts
+++ b/ts_destination_local/plugins.ts
@ -0,0 +1,5 @@
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+export { consolecolor, smartlogInterfaces, smartpromise };
--- a/ts_destination_receiver/00_commitinfo_data.ts
+++ b/ts_destination_receiver/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-destination-receiver',
+  version: '2.0.6',
+  description: 'A package providing a destination handler for smartlog logging packages'
+}
--- a/ts_destination_receiver/index.ts
+++ b/ts_destination_receiver/index.ts
@ -0,0 +1,35 @@
+import * as plugins from './smartlog-destination-receiver.plugins.js';
+import {
+  type ILogDestination,
+  type ILogPackageAuthenticated,
+  type ILogPackage,
+} from '../dist_ts_interfaces/index.js';
+
+export interface ISmartlogDestinationReceiverConstructorOptions {
+  passphrase: string;
+  receiverEndpoint: string;
+}
+
+export class SmartlogDestinationReceiver implements ILogDestination {
+  private options: ISmartlogDestinationReceiverConstructorOptions;
+  private webrequest = new plugins.webrequest.WebRequest();
+
+  constructor(optionsArg: ISmartlogDestinationReceiverConstructorOptions) {
+    this.options = optionsArg;
+  }
+
+  private errorCounter = 0;
+  public async handleLog(logPackageArg: ILogPackage) {
+    const response = await this.webrequest.postJson(this.options.receiverEndpoint, {
+      auth: plugins.smarthash.sha256FromStringSync(this.options.passphrase),
+      logPackage: logPackageArg,
+    }).catch(err => {
+      if (this.errorCounter % 100 === 0) {
+        console.error(`There seems to be an error with logging.`);
+        console.error(`Accumulated ${this.errorCounter} errors so far`)
+      }
+      this.errorCounter++;
+    });
+    return response.body;
+  }
+}
--- a/ts_destination_receiver/smartlog-destination-receiver.plugins.ts
+++ b/ts_destination_receiver/smartlog-destination-receiver.plugins.ts
@ -0,0 +1,5 @@
+import * as smarthash from '@push.rocks/smarthash';
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as webrequest from '@push.rocks/webrequest';
+
+export { smarthash, smartlogInterfaces, webrequest };
--- a/ts_interfaces/00_commitinfo_data.ts
+++ b/ts_interfaces/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-interfaces',
+  version: '3.0.2',
+  description: 'Defines interfaces for the smartlog ecosystem.'
+}
--- a/ts_interfaces/index.ts
+++ b/ts_interfaces/index.ts
@ -0,0 +1,126 @@
+import * as plugins from './smartlog-interfaces.plugins.js';
+
+import * as requestInterfaces from './smartlog-interfaces.requests.js';
+
+export { requestInterfaces as request };
+
+/**
+ * the different available log types
+ */
+export type TLogType =
+  | 'log'
+  | 'increment'
+  | 'gauge'
+  | 'error'
+  | 'success'
+  | 'value'
+  | 'finance'
+  | 'compliance';
+
+/**
+ * the available log levels
+ */
+export type TLogLevel =
+  | 'silly'
+  | 'info'
+  | 'debug'
+  | 'note'
+  | 'ok'
+  | 'success'
+  | 'warn'
+  | 'error'
+  | 'lifecycle';
+
+/**
+ * the available environments
+ */
+export type TEnvironment = 'local' | 'test' | 'staging' | 'production';
+
+/**
+ * the available runtimes
+ */
+export type TRuntime = 'node' | 'chrome' | 'rust' | 'deno' | 'cloudflare_workers';
+
+/**
+ * the log context e.g. what app in what version on what server
+ */
+export interface ILogContext {
+  commitinfo?: plugins.tsclass.code.ICommitInfo;
+  company?: string;
+  companyunit?: string;
+  containerName?: string;
+  environment?: TEnvironment;
+  runtime?: TRuntime;
+  zone?: string;
+}
+
+export interface ILogCorrelation {
+  /**
+   * a unique id for this log
+   */
+  id: string;
+  /**
+   * the type of this log
+   */
+  type: 'none' | 'service' | 'build' | 'infrastructure' | 'cdn';
+  /**
+   * the instance on which the log is created
+   * use it for pinning logs to a certain instance in a cluster
+   */
+  instance?: string;
+  /**
+   * a series of logs
+   */
+  group?: string;
+  /**
+   * a log that belongs to a transaction. E.g. a Payment or a request traveling through multiple backend instances
+   */
+  transaction?: string;
+}
+
+/**
+ * the main logpackage
+ */
+export interface ILogPackage<T = unknown> {
+  /**
+   * a unix timestamp in milliseconds
+   */
+  timestamp: number;
+  type: TLogType;
+  context: ILogContext;
+  level: TLogLevel;
+  /**
+   * allows grouping of log messages
+   */
+  correlation: ILogCorrelation;
+  /**
+   * the message to log
+   */
+  message: string;
+  data?: T;
+}
+
+export interface ILogPackageDataRequest {
+  requestCorrelationId: string;
+  url: string;
+  pathname: string;
+  method: string;
+  status: string;
+}
+
+export interface ILogPackageAuthenticated {
+  auth: string;
+  logPackage: ILogPackage;
+}
+
+export interface ILogPackageArrayAuthenticated {
+  auth: string;
+  logPackages: ILogPackage[];
+}
+
+/**
+ * a destination interface for extending smartlog modules
+ */
+export interface ILogDestination {
+  handleLog: (logPackage: ILogPackage) => Promise<void>;
+}
--- a/ts_interfaces/smartlog-interfaces.plugins.ts
+++ b/ts_interfaces/smartlog-interfaces.plugins.ts
@ -0,0 +1,10 @@
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export {
+  tsclass
+}
--- a/ts_interfaces/smartlog-interfaces.requests.ts
+++ b/ts_interfaces/smartlog-interfaces.requests.ts
@ -0,0 +1,9 @@
+import { type ILogPackageAuthenticated } from './index.js';
+
+export interface IRequest_SmartlogDestinationReceiver_Any_PostLogPackages {
+  method: 'postLogPackages';
+  request: {
+    logPackages: ILogPackageAuthenticated[];
+  };
+  response: {};
+}
--- a/ts_receiver/00_commitinfo_data.ts
+++ b/ts_receiver/00_commitinfo_data.ts
@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartlog-receiver',
+  version: '2.0.0',
+  description: 'a receiver for smartlog-destination-receiver'
+}
--- a/ts_receiver/index.ts
+++ b/ts_receiver/index.ts
@ -0,0 +1 @@
+export * from './sl.classes.smartlogreceiver.js';
--- a/ts_receiver/sl.classes.smartlogreceiver.ts
+++ b/ts_receiver/sl.classes.smartlogreceiver.ts
@ -0,0 +1,73 @@
+import * as plugins from './sl.receiver.plugins.js';
+
+import type {
+  ILogPackage,
+  ILogPackageAuthenticated,
+  ILogDestination,
+} from '../dist_ts_interfaces/index.js';
+
+export type TValidatorFunction = (logPackage: ILogPackage) => Promise<boolean>;
+
+export interface ISmartlogReceiverOptions {
+  smartlogInstance: plugins.smartlog.Smartlog;
+  passphrase: string;
+  validatorFunction: TValidatorFunction;
+}
+
+/**
+ * a class that receives smartlog packages
+ */
+export class SmartlogReceiver {
+  public passphrase: string;
+  public validatorFunction: TValidatorFunction;
+  public smartlogInstance: plugins.smartlog.Smartlog;
+
+  constructor(smartlogReceiverOptions: ISmartlogReceiverOptions) {
+    this.passphrase = smartlogReceiverOptions.passphrase;
+    this.validatorFunction =
+      smartlogReceiverOptions.validatorFunction ||
+      (async (logpackageArg) => {
+        return true;
+      });
+    this.smartlogInstance = smartlogReceiverOptions.smartlogInstance;
+  }
+
+  /**
+   * handles a authenticated log
+   */
+  public async handleAuthenticatedLog(authenticatedLogPackageArg: ILogPackageAuthenticated) {
+    const authString = authenticatedLogPackageArg.auth;
+    const logPackage = authenticatedLogPackageArg.logPackage;
+
+    if (
+      authString === plugins.smarthash.sha256FromStringSync(this.passphrase) &&
+      (await this.validatorFunction(logPackage))
+    ) {
+      // Message authenticated lets clean up.
+      logPackage.correlation ? null : (logPackage.correlation = { id: '123', type: 'none' });
+      logPackage.correlation.id ? null : (logPackage.correlation.id = '123');
+      logPackage.correlation.type ? null : (logPackage.correlation.type = 'none');
+
+      this.smartlogInstance.handleLog(logPackage);
+      return { status: 'ok' };
+    } else {
+      this.smartlogInstance.log('error', 'Message rejected because of bad passphrase');
+      return { status: 'error' };
+      // console.log(plugins.smarthash.sha256FromStringSync(this.passphrase));
+    }
+  }
+
+  /**
+   * handles an array of authenticated logs
+   * @param authenticatedLogsPackageArrayArg
+   */
+  public async handleManyAuthenticatedLogs(
+    authenticatedLogsPackageArrayArg: ILogPackageAuthenticated[]
+  ) {
+    const promiseArray: Array<Promise<any>> = [];
+    for (const logPackage of authenticatedLogsPackageArrayArg) {
+      promiseArray.push(this.handleAuthenticatedLog(logPackage));
+    }
+    await Promise.all(promiseArray);
+  }
+}
--- a/ts_receiver/sl.receiver.plugins.ts
+++ b/ts_receiver/sl.receiver.plugins.ts
@ -0,0 +1,4 @@
+import * as smarthash from '@push.rocks/smarthash';
+import * as smartlog from '../dist_ts/index.js';
+
+export { smartlog, smarthash };
--- a/ts_source_interactive/index.ts
+++ b/ts_source_interactive/index.ts
@ -0,0 +1,417 @@
+import * as plugins from './smartlog-source-interactive.plugins.js';
+
+/**
+ * Utility to detect if the environment is interactive
+ * Checks for TTY capability and common CI environment variables
+ */
+const isInteractive = () => {
+  try {
+    return Boolean(
+      // Check TTY capability
+      process.stdout && process.stdout.isTTY && 
+      
+      // Additional checks for non-interactive environments
+      !('CI' in process.env) &&
+      !process.env.GITHUB_ACTIONS &&
+      !process.env.JENKINS_URL &&
+      !process.env.GITLAB_CI &&
+      !process.env.TRAVIS &&
+      !process.env.CIRCLECI &&
+      process.env.TERM !== 'dumb'
+    );
+  } catch (e) {
+    // If any error occurs (e.g., in browser environments without process),
+    // assume a non-interactive environment to be safe
+    return false;
+  }
+};
+
+// Helper to log messages in non-interactive mode
+const logMessage = (message: string, prefix = '') => {
+  if (prefix) {
+    console.log(`${prefix} ${message}`);
+  } else {
+    console.log(message);
+  }
+};
+
+// Spinner frames and styles
+const spinnerFrames = {
+  dots: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+  line: ['|', '/', '-', '\\'],
+  star: ['✶', '✸', '✹', '✺', '✹', '✷'],
+  simple: ['-', '\\', '|', '/']
+};
+
+// Color names mapping to ANSI color codes
+const colors = {
+  black: '\u001b[30m',
+  red: '\u001b[31m',
+  green: '\u001b[32m',
+  yellow: '\u001b[33m',
+  blue: '\u001b[34m',
+  magenta: '\u001b[35m',
+  cyan: '\u001b[36m',
+  white: '\u001b[37m',
+  gray: '\u001b[90m',
+  reset: '\u001b[0m'
+};
+
+/**
+ * A class for creating interactive spinners
+ * Automatically handles non-interactive environments
+ */
+export class SmartlogSourceInteractive {
+  private textContent: string = 'loading';
+  private currentFrame: number = 0;
+  private interval: NodeJS.Timeout | null = null;
+  private started: boolean = false;
+  private spinnerStyle: keyof typeof spinnerFrames = 'dots';
+  private color: keyof typeof colors = 'cyan';
+  private frames: string[];
+  private frameInterval: number = 80;
+  private interactive: boolean;
+
+  constructor() {
+    this.frames = spinnerFrames[this.spinnerStyle];
+    this.interactive = isInteractive();
+  }
+
+  /**
+   * Sets the text for the spinner and starts it if not already started
+   */
+  public text(textArg: string) {
+    this.textContent = textArg;
+    
+    if (!this.interactive) {
+      // In non-interactive mode, just log the message with a loading indicator
+      logMessage(textArg, '[Loading]');
+      this.started = true;
+      return;
+    }
+    
+    if (!this.started) {
+      this.started = true;
+      this.start();
+    } else {
+      this.renderFrame();
+    }
+  }
+
+  /**
+   * Starts the spinner animation
+   */
+  private start() {
+    if (!this.interactive) {
+      return; // No animation in non-interactive mode
+    }
+    
+    if (this.interval) {
+      clearInterval(this.interval);
+    }
+    
+    this.renderFrame();
+    this.interval = setInterval(() => {
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+      this.renderFrame();
+    }, this.frameInterval);
+  }
+
+  /**
+   * Renders the current frame of the spinner
+   */
+  private renderFrame() {
+    if (!this.started || !this.interactive) return;
+    
+    const frame = this.frames[this.currentFrame];
+    const colorCode = colors[this.color];
+    const resetCode = colors.reset;
+    
+    // Only use ANSI escape codes in interactive mode
+    process.stdout.write('\r\x1b[2K'); // Clear the current line
+    process.stdout.write(`${colorCode}${frame}${resetCode} ${this.textContent}`);
+  }
+
+  /**
+   * Stops the spinner
+   */
+  public stop() {
+    // Always clear the interval even in non-interactive mode
+    // This prevents memory leaks in tests and long-running applications
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    
+    if (!this.interactive) {
+      return; // No need to clear the line in non-interactive mode
+    }
+    
+    process.stdout.write('\r\x1b[2K'); // Clear the current line
+  }
+
+  /**
+   * Marks the spinner as successful and optionally displays a success message
+   */
+  public finishSuccess(textArg?: string) {
+    const message = textArg || this.textContent;
+    
+    // Always stop the spinner first to clean up intervals
+    this.stop();
+    
+    if (!this.interactive) {
+      logMessage(message, '[Success]');
+    } else {
+      const successSymbol = colors.green + '✓' + colors.reset;
+      process.stdout.write(`${successSymbol} ${message}\n`);
+    }
+    
+    this.started = false;
+  }
+
+  /**
+   * Marks the spinner as failed and optionally displays a failure message
+   */
+  public finishFail(textArg?: string) {
+    const message = textArg || this.textContent;
+    
+    // Always stop the spinner first to clean up intervals
+    this.stop();
+    
+    if (!this.interactive) {
+      logMessage(message, '[Failed]');
+    } else {
+      const failSymbol = colors.red + '✗' + colors.reset;
+      process.stdout.write(`${failSymbol} ${message}\n`);
+    }
+    
+    this.started = false;
+  }
+
+  /**
+   * Marks the current spinner as successful and starts a new one
+   */
+  public successAndNext(textArg: string) {
+    this.finishSuccess();
+    this.text(textArg);
+  }
+
+  /**
+   * Marks the current spinner as failed and starts a new one
+   */
+  public failAndNext(textArg: string) {
+    this.finishFail();
+    this.text(textArg);
+  }
+
+  /**
+   * Sets the spinner style
+   */
+  public setSpinnerStyle(style: keyof typeof spinnerFrames) {
+    this.spinnerStyle = style;
+    this.frames = spinnerFrames[style];
+    return this;
+  }
+
+  /**
+   * Sets the spinner color
+   */
+  public setColor(colorName: keyof typeof colors) {
+    if (colorName in colors) {
+      this.color = colorName;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the animation speed in milliseconds
+   */
+  public setSpeed(ms: number) {
+    this.frameInterval = ms;
+    if (this.started) {
+      this.stop();
+      this.start();
+    }
+    return this;
+  }
+
+  /**
+   * Gets the current started state
+   */
+  public isStarted() {
+    return this.started;
+  }
+}
+
+export interface IProgressBarOptions {
+  total: number;
+  width?: number;
+  complete?: string;
+  incomplete?: string;
+  renderThrottle?: number;
+  clear?: boolean;
+  showEta?: boolean;
+  showPercent?: boolean;
+  showCount?: boolean;
+}
+
+export class SmartlogProgressBar {
+  private total: number;
+  private current: number = 0;
+  private width: number;
+  private completeChar: string;
+  private incomplete: string;
+  private renderThrottle: number;
+  private clear: boolean;
+  private showEta: boolean;
+  private showPercent: boolean;
+  private showCount: boolean;
+  private color: keyof typeof colors = 'green';
+  private startTime: number | null = null;
+  private lastRenderTime: number = 0;
+  private interactive: boolean;
+  private lastLoggedPercent: number = 0;
+  private logThreshold: number = 10; // Log every 10% in non-interactive mode
+
+  constructor(options: IProgressBarOptions) {
+    this.total = options.total;
+    this.width = options.width || 30;
+    this.completeChar = options.complete || '█';
+    this.incomplete = options.incomplete || '░';
+    this.renderThrottle = options.renderThrottle || 16;
+    this.clear = options.clear !== undefined ? options.clear : false;
+    this.showEta = options.showEta !== undefined ? options.showEta : true;
+    this.showPercent = options.showPercent !== undefined ? options.showPercent : true;
+    this.showCount = options.showCount !== undefined ? options.showCount : true;
+    this.interactive = isInteractive();
+  }
+
+  /**
+   * Update the progress bar to a specific value
+   */
+  public update(value: number): this {
+    if (this.startTime === null) {
+      this.startTime = Date.now();
+    }
+
+    this.current = Math.min(value, this.total);
+    
+    if (!this.interactive) {
+      // In non-interactive mode, log progress at certain thresholds
+      const percent = Math.floor((this.current / this.total) * 100);
+      const currentThreshold = Math.floor(percent / this.logThreshold) * this.logThreshold;
+      
+      if (currentThreshold > this.lastLoggedPercent || percent === 100) {
+        this.lastLoggedPercent = currentThreshold;
+        logMessage(`Progress: ${percent}% (${this.current}/${this.total})`);
+      }
+      return this;
+    }
+    
+    // Throttle rendering to avoid excessive updates in interactive mode
+    const now = Date.now();
+    if (now - this.lastRenderTime < this.renderThrottle) {
+      return this;
+    }
+    
+    this.lastRenderTime = now;
+    this.render();
+    return this;
+  }
+
+  /**
+   * Increment the progress bar by a value
+   */
+  public increment(value: number = 1): this {
+    return this.update(this.current + value);
+  }
+
+  /**
+   * Mark the progress bar as complete
+   */
+  public complete(): this {
+    this.update(this.total);
+    
+    if (!this.interactive) {
+      logMessage(`Completed: 100% (${this.total}/${this.total})`);
+      return this;
+    }
+    
+    if (this.clear) {
+      process.stdout.write('\r\x1b[2K');
+    } else {
+      process.stdout.write('\n');
+    }
+    return this;
+  }
+
+  /**
+   * Set the color of the progress bar
+   */
+  public setColor(colorName: keyof typeof colors): this {
+    if (colorName in colors) {
+      this.color = colorName;
+    }
+    return this;
+  }
+
+  /**
+   * Render the progress bar
+   */
+  private render(): void {
+    if (!this.interactive) {
+      return; // Don't render in non-interactive mode
+    }
+    
+    // Calculate percent complete
+    const percent = Math.floor((this.current / this.total) * 100);
+    const completeLength = Math.round((this.current / this.total) * this.width);
+    const incompleteLength = this.width - completeLength;
+
+    // Build the progress bar
+    const completePart = colors[this.color] + this.completeChar.repeat(completeLength) + colors.reset;
+    const incompletePart = this.incomplete.repeat(incompleteLength);
+    const progressBar = `[${completePart}${incompletePart}]`;
+
+    // Calculate ETA if needed
+    let etaStr = '';
+    if (this.showEta && this.startTime !== null && this.current > 0) {
+      const elapsed = (Date.now() - this.startTime) / 1000;
+      const rate = this.current / elapsed;
+      const remaining = Math.max(0, this.total - this.current);
+      const eta = Math.round(remaining / rate);
+      
+      const mins = Math.floor(eta / 60);
+      const secs = eta % 60;
+      etaStr = ` eta: ${mins}m${secs}s`;
+    }
+
+    // Build additional information
+    const percentStr = this.showPercent ? ` ${percent}%` : '';
+    const countStr = this.showCount ? ` ${this.current}/${this.total}` : '';
+
+    // Clear the line and render
+    process.stdout.write('\r\x1b[2K');
+    process.stdout.write(`${progressBar}${percentStr}${countStr}${etaStr}`);
+  }
+}
+
+// For backward compatibility with 'source-ora' module
+export class SmartlogSourceOra extends SmartlogSourceInteractive {
+  // Add a stub for the oraInstance property for backward compatibility
+  public get oraInstance() {
+    // Use public methods instead of accessing private properties
+    const instance = this;
+    return {
+      get text() { return ''; }, // We can't access private textContent directly
+      start: () => instance.text(''), // This starts the spinner
+      stop: () => instance.stop(),
+      succeed: (text?: string) => instance.finishSuccess(text),
+      fail: (text?: string) => instance.finishFail(text)
+    };
+  }
+  
+  public set oraInstance(value: any) {
+    // No-op, just for compatibility
+  }
+}
--- a/ts_source_interactive/smartlog-source-interactive.plugins.ts
+++ b/ts_source_interactive/smartlog-source-interactive.plugins.ts
@ -0,0 +1,10 @@
+// pushrocks scope
+import * as smartlogInterfaces from '../dist_ts_interfaces/index.js';
+import * as consolecolor from '@push.rocks/consolecolor';
+
+export { smartlogInterfaces, consolecolor };
+
+// node.js internal
+import { stdout, stderr } from 'process';
+
+export { stdout, stderr };
--- a/tsconfig.json
+++ b/tsconfig.json
@ -6,7 +6,9 @@
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "esModuleInterop": true,
-    "verbatimModuleSyntax": true
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
  },
  "exclude": [
    "dist_*/**/*.d.ts"
Author	SHA1	Message	Date
Philipp Kunz	75783b0e87	3.1.1 Some checks failed Default (tags) / security (push) Successful in 45s Details Default (tags) / test (push) Failing after 1m6s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-05-15 20:00:38 +00:00
Philipp Kunz	13e1582732	fix(source-interactive): Fix import path in receiver tests and rename progress bar property for clarity; update SmartlogSourceOra getter for improved backward compatibility.	2025-05-15 20:00:38 +00:00
Philipp Kunz	7e2f076b35	3.1.0 Some checks failed Default (tags) / security (push) Successful in 38s Details Default (tags) / test (push) Failing after 1m6s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-05-15 19:53:29 +00:00
Philipp Kunz	7e8a404fcf	feat(interactive): Add interactive console features and refactor spinner module by renaming source-ora to source-interactive and removing ora dependency	2025-05-15 19:53:29 +00:00
Philipp Kunz	09da3a1e2d	3.0.9 Some checks failed Default (tags) / security (push) Successful in 31s Details Default (tags) / test (push) Failing after 1m0s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-05-12 10:20:16 +00:00
Philipp Kunz	f542596eae	fix(test/destination-devtools.browser): Simplify DevTools browser tests by removing redundant styled log assertions.	2025-05-12 10:20:16 +00:00
Philipp Kunz	1ca8cf89de	3.0.8 Some checks failed Default (tags) / security (push) Successful in 39s Details Default (tags) / test (push) Failing after 1m1s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-05-12 10:03:22 +00:00
Philipp Kunz	9b63777a76	fix(ci): Update CI workflows, build scripts, and export configuration	2025-05-12 10:03:22 +00:00
Philipp Kunz	e853b2d5e4	3.0.7	2024-06-06 17:05:55 +02:00
Philipp Kunz	a88b614e80	fix(core): update	2024-06-06 17:05:55 +02:00
Philipp Kunz	92a48c415d	update description	2024-05-29 14:14:04 +02:00
				`@ -0,0 +1 @@`
				`export * from './sl.classes.smartlogreceiver.js';`