1.3.1

changelog.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2025-02-07 - 1.3.1 - fix(core)
+Updated descriptions and keywords in package.json and npmextra.json. Improved README content for usage clarity.
+
+- Revised package.json description and keywords to better represent the project's features.
+- Enhanced npmextra.json with updated module attributes.
+- Improved README with clearer instructions and examples for using ClamAVManager and ClamAvService.
+- Fixed incorrect import path in test.clamav.manager.ts.
+
+## 2025-02-05 - 1.3.0 - feat(ClamAvService)
+Add support for enhanced streaming methods in ClamAvService
+
+- Add methods to ClamAvService: scanStream for NodeJS streams, scanWebStream for Web API streams, and scanFileFromWebAsStream for fetching and scanning files from URLs.
+- Update usage examples in readme for new streaming methods.
+
+## 2025-02-05 - 1.2.0 - feat(ClamAvService)
+Add stream scanning methods to ClamAvService
+
+- Added scanStream method to support scanning NodeJS streams directly.
+- Introduced scanWebStream method for scanning web resources as streams.
+- Integrated stream scanning into existing ClamAvService class.
+
+## 2025-02-03 - 1.1.2 - fix(documentation)
+Update readme with additional legal and trademark information
+
+- Added legal information related to licensing and trademarks
+- Provided company details of Task Venture Capital GmbH
+
+## 2025-02-03 - 1.1.1 - fix(clamav.manager)
+Improve log handling and add timeout for log reception in ClamAV manager tests
+
+- Refined the log receiving mechanism in ClamAV manager tests to use promises for better control over log receipt timing.
+- Introduced a timeout mechanism in the log receiving test case to avoid indefinite waiting.
+- Fixed the test case setup to accurately reflect log receipt and database information verification.
+
 ## 2025-02-03 - 1.1.0 - feat(ClamAvService)
 Add ClamAV Manager with Docker container management capabilities.
 

npmextra.json

@@ -5,21 +5,23 @@
       "githost": "code.foss.global",
       "gitscope": "push.rocks",
       "gitrepo": "smartantivirus",
-      "description": "A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.",
+      "description": "A Node.js package providing integration with ClamAV for anti-virus scanning, facilitating both Docker containerized management and direct connection to a ClamAV daemon.",
       "npmPackagename": "@push.rocks/smartantivirus",
       "license": "MIT",
       "projectDomain": "push.rocks",
       "keywords": [
         "antivirus",
-        "ClamAV",
         "Node.js",
+        "ClamAV",
         "virus scanning",
         "security",
-        "buffer scanning",
+        "Docker",
+        "in-memory scanning",
+        "file scanning",
+        "stream scanning",
         "data protection",
-        "HTTP requests",
+        "network security",
-        "file handling",
+        "buffer scanning",
-        "network communication",
         "software testing"
       ]
     }

package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartantivirus",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "private": false,
-  "description": "A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.",
+  "description": "A Node.js package providing integration with ClamAV for anti-virus scanning, facilitating both Docker containerized management and direct connection to a ClamAV daemon.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -19,11 +19,13 @@
     "@git.zone/tsrun": "^1.2.46",
     "@git.zone/tstest": "^1.0.44",
     "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^20.8.7"
+    "@types/node": "^20.8.7",
+    "typescript": "^5.7.3"
   },
   "dependencies": {
     "@push.rocks/smartfile": "^11.1.5",
     "@push.rocks/smartpath": "^5.0.18",
+    "@push.rocks/smartstream": "^3.2.5",
     "axios": "^1.7.9",
     "tar": "^7.4.3"
   },
@@ -49,15 +51,17 @@
   ],
   "keywords": [
     "antivirus",
-    "ClamAV",
     "Node.js",
+    "ClamAV",
     "virus scanning",
     "security",
-    "buffer scanning",
+    "Docker",
+    "in-memory scanning",
+    "file scanning",
+    "stream scanning",
     "data protection",
-    "HTTP requests",
+    "network security",
-    "file handling",
+    "buffer scanning",
-    "network communication",
     "software testing"
   ]
 }

pnpm-lock.yaml

@@ -14,6 +14,9 @@ importers:
       '@push.rocks/smartpath':
         specifier: ^5.0.18
         version: 5.0.18
+      '@push.rocks/smartstream':
+        specifier: ^3.2.5
+        version: 3.2.5
       axios:
         specifier: ^1.7.9
         version: 1.7.9
@@ -39,6 +42,9 @@ importers:
       '@types/node':
         specifier: ^20.8.7
         version: 20.17.12
+      typescript:
+        specifier: ^5.7.3
+        version: 5.7.3
 
 packages:
 
@@ -3935,6 +3941,11 @@ packages:
     engines: {node: '>=14.17'}
     hasBin: true
 
+  typescript@5.7.3:
+    resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
   uglify-js@3.19.3:
     resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==}
     engines: {node: '>=0.8.0'}
@@ -9602,6 +9613,8 @@ snapshots:
 
   typescript@5.6.3: {}
 
+  typescript@5.7.3: {}
+
   uglify-js@3.19.3: {}
 
   uint8array-extras@1.4.0: {}

readme.md

@@ -1,120 +1,233 @@
 # @push.rocks/smartantivirus
 
-A package for performing antivirus testing, especially suitable for use with ClamAV. 
+A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.
 
 ## Install
 
-Installing `@push.rocks/smartantivirus` is straightforward. You'll need Node.js and npm installed on your machine to get started. Once they are ready, you can add the `@push.rocks/smartantivirus` package to your project by running the following command:
+To install `@push.rocks/smartantivirus`, ensure that you have Node.js and npm installed on your system. You will also need Docker if you intend to use the containerized version of ClamAV. Once the prerequisites are sorted, you can install the package using the following command:
 
 ```bash
 npm install @push.rocks/smartantivirus
 ```
 
-This will add the package to your project's dependencies and allow you to integrate antivirus scanning capabilities directly into your application.
+### Prerequisites
+
+- Node.js and npm
+- Docker (for container-based usage)
+- ClamAV daemon (for direct daemon usage)
 
 ## Usage
 
-The `@push.rocks/smartantivirus` package provides tools to easily integrate antivirus scanning capabilities into your Node.js application by interfacing with the ClamAV daemon. Below is a comprehensive guide on how to use the features of this library.
+The `@push.rocks/smartantivirus` package provides intuitive tools for integrating ClamAV's virus scanning capabilities into your Node.js applications. It supports both Docker-based container management and direct communication with a running ClamAV daemon. Let’s dive into how you can effectively use this package.
 
-### Setting Up the ClamAV Daemon
+### Docker-based Usage with ClamAVManager
 
-Before using this package, make sure you have ClamAV installed and running on your system. You can find installation instructions for various operating systems on the [ClamAV official website](https://www.clamav.net/documents/installing-clamav).
+The `ClamAVManager` class simplifies the process of managing a ClamAV service running inside a Docker container. It ensures that the container is started, the virus database is updated, and logs are captured for monitoring.
 
-After installing ClamAV, start the ClamAV daemon (`clamd`). Make sure it is configured to listen on a port accessible to your Node.js application. You can configure this in the `clamd.conf` file, typically located in `/etc/clamav/clamd.conf`.
+#### Basic Setup
 
-### Basic Usage 
+Below demonstrates starting a ClamAV container, updating virus definitions, and reading logs:
-
-The primary interface provided by the package is the `ClamAvService` class. It allows you to scan data in memory or verify the connection to the ClamAV daemon.
 
 ```typescript
-import { ClamAvService } from '@push.rocks/smartantivirus';
+import { ClamAVManager } from '@push.rocks/smartantivirus';
 
 async function main() {
-  const clamService = new ClamAvService('127.0.0.1', 3310); // Replace with your ClamAV host and port
+  // Instantiate a ClamAVManager
+  const clamAvManager = new ClamAVManager();
 
-  // Verify connection to ClamAV
+  // Start ClamAV Docker container
-  const isConnected = await clamService.verifyConnection();
+  await clamAvManager.startContainer();
-  console.log(`Connection to ClamAV: ${isConnected ? 'successful' : 'failed'}`);
 
-  if (!isConnected) {
+  // Listen for log events
-    console.error('Could not connect to ClamAV daemon. Please check your configuration.');
+  clamAvManager.on('log', event => {
-    return;
+    console.log(`ClamAV log (${event.type}): ${event.message}`);
-  }
+  });
 
-  // Scan a text string
+  // Fetch and display database information
-  const testString = 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*';
+  const dbInfo = await clamAvManager.getDatabaseInfo();
-  const scanResult = await clamService.scanString(testString);
+  console.log('Database Information:', dbInfo);
-  console.log('Scan Result:', scanResult);
+
+  // Update the virus database
+  await clamAvManager.updateDatabase();
+
+  // Stop the container when done
+  await clamAvManager.stopContainer();
 }
 
 main().catch(console.error);
 ```
 
-**Breaking Down the Example:**
+### Direct Daemon Usage with ClamAvService
 
-1. **Initialization**: We start by creating an instance of the `ClamAvService` class. It takes two optional parameters: the host and port where your ClamAV daemon is running. By default, it assumes `127.0.0.1` and `3310`.
+If you prefer direct communication with an existing ClamAV daemon, use the `ClamAvService` class. This allows you to scan strings and streams directly in memory.
 
-2. **Verify Connection**: The `verifyConnection` method is called to ensure that our application can communicate with the ClamAV daemon. It returns a promise that resolves to `true` if the connection is successful, and `false` otherwise.
+#### Connection Verification and String Scanning
 
-3. **Scan Strings**: We utilize the `scanString` method to scan a text string (in this example, the EICAR test virus string is used). This method converts the string to a buffer and sends it to the ClamAV daemon for scanning.
+Below is an example of verifying connection to the ClamAV daemon and scanning a given string for virus signatures, using the EICAR test string:
-
-### Handling Buffers
-
-Below is an example demonstrating scanning raw binary data in the form of buffers:
 
 ```typescript
 import { ClamAvService } from '@push.rocks/smartantivirus';
 
-async function scanBufferExample() {
+async function main() {
-  const clamService = new ClamAvService();
+  const clamService = new ClamAvService('127.0.0.1', 3310);
 
-  // This buffer should represent the binary data you want to scan.
+  // Verify connection to ClamAV
-  const buffer = Buffer.from('Sample buffer contents', 'utf8');
+  const isConnected = await clamService.verifyConnection();
+  console.log(`Connection to ClamAV: ${isConnected ? 'successful' : 'failed'}`);
 
-  try {
+  // Scan a test string
-    const scanResult = await clamService.scanBuffer(buffer);
+  const eicarTest = 'X5O!P%@AP[4\PZX54(P^)7CC)7}$EICAR-STANDARD-ANTIVIRUS-TEST-FILE!$H+H*';
-    console.log('Buffer Scan Result:', scanResult);
+  const scanResult = await clamService.scanString(eicarTest);
-  } catch (error) {
+  console.log('EICAR Test Result:', scanResult);
-    console.error('Error scanning buffer:', error);
-  }
 }
 
-scanBufferExample();
+main().catch(console.error);
 ```
 
-**Explanation:**
+### Streaming Scanning
 
-- We create an instance of `ClamAvService`.
+`ClamAvService` provides methods to scan NodeJS and Web API streams. This is particularly useful for processing large files or data transferred over the network.
-- A buffer is created and passed to the `scanBuffer` method, which scans the in-memory data for potential viruses.
 
-### Error Handling and Debugging
+#### Example: NodeJS Streaming
-
-The methods of `ClamAvService` throw errors if there are issues with communication or processing data. Wrap your code in try-catch blocks and use appropriate logging to handle errors gracefully.
 
 ```typescript
-try {
+import { ClamAvService } from '@push.rocks/smartantivirus';
-  const scanResult = await clamService.scanString('Some suspicious string...');
+import { createReadStream } from 'fs';
-  console.log(`Infection Status: ${scanResult.isInfected ? 'Infected' : 'Clean'}`);
+
-  if (scanResult.isInfected) {
+async function main() {
-    console.log(`Reason: ${scanResult.reason}`);
+  const clamService = new ClamAvService();
-  }
+
-} catch (error) {
+  // Scan a local file stream
-  console.error('An error occurred during the scanning process:', error);
+  const fileStream = createReadStream('path/to/suspicious/file');
+  const fileScanResult = await clamService.scanStream(fileStream);
+  console.log('File Stream Scan Result:', fileScanResult);
+
+  // Scan a remote file by stream
+  const remoteFileScan = await clamService.scanFileFromWebAsStream('http://example.com/file');
+  console.log('Remote File Scan Result:', remoteFileScan);
 }
+
+main().catch(console.error);
+```
+
+#### Example: Web Stream (in Browser)
+
+```typescript
+import { ClamAvService } from '@push.rocks/smartantivirus';
+
+async function scanWebStream(url: string) {
+  const response = await fetch(url);
+  const webStream = response.body as ReadableStream<Uint8Array>;
+
+  const clamService = new ClamAvService();
+  if (webStream) {
+    const scanResult = await clamService.scanWebStream(webStream);
+    console.log('Web Stream Scan Result:', scanResult);
+  }
+}
+
+scanWebStream('http://example.com/streamed-file').catch(console.error);
+```
+
+### Handling Buffers
+
+Scan binary data directly using a buffer:
+
+```typescript
+import { ClamAvService } from '@push.rocks/smartantivirus';
+
+async function main() {
+  const clamService = new ClamAvService();
+  const buffer = Buffer.from('Potentially harmful binary data', 'utf8');
+
+  try {
+    const bufferScanResult = await clamService.scanBuffer(buffer);
+    console.log('Buffer Scan Result:', bufferScanResult);
+  } catch (err) {
+    console.error('Error scanning buffer:', err);
+  }
+}
+
+main().catch(console.error);
+```
+
+### Error Handling and Event Monitoring
+
+Both `ClamAVManager` and `ClamAvService` are designed with error handling features for robustness.
+
+```typescript
+import { ClamAVManager } from '@push.rocks/smartantivirus';
+
+async function errorHandlingExample() {
+  const clamAvManager = new ClamAVManager();
+
+  try {
+    await clamAvManager.startContainer();
+
+    // Listen for errors in logs
+    clamAvManager.on('log', event => {
+      if (event.type === 'error') {
+        console.error(`ClamAV Error: ${event.message}`);
+      }
+    });
+
+    console.log('ClamAV container started successfully.');
+  } catch (err) {
+    console.error('Error starting ClamAV container:', err);
+  }
+}
+
+errorHandlingExample().catch(console.error);
+```
+
+### Advanced Usage and Configuration
+
+#### Customize Container Settings
+
+Customizing the Docker container setup is possible through class methods and properties:
+
+```typescript
+const manager = new ClamAVManager();
+console.log(`Container Name: ${manager.containerName}`); // Access default name
+console.log(`Listening Port: ${manager.port}`); // Access default port
+```
+
+#### Managing Logs
+
+Capture and filter ClamAV logs for insights:
+
+```typescript
+const manager = new ClamAVManager();
+await manager.startContainer();
+
+const logs = manager.getLogs();
+const errorLogs = logs.filter(log => log.type === 'error');
+console.log('Error Logs:', errorLogs);
+```
+
+#### Health Checks
+
+Monitor and ensure ClamAV service readiness:
+
+```typescript
+const manager = new ClamAVManager();
+await manager.startContainer(); // Includes readiness checks
+
+const dbInfo = await manager.getDatabaseInfo();
+console.log('Database Version:', dbInfo);
 ```
 
 ### Testing your setup
 
-A preconfigured test script is provided, which demonstrates how to use the package with the Tap bundle testing framework. You can find the test script in `test/test.ts`. This is configured to run with the default `@push.rocks/tapbundle` setup:
+Utilize provided test scripts to validate your ClamAV setup:
 
 ```bash
 npm run test
 ```
 
-The tests include creating and utilizing a `ClamAvService` instance and attempts to scan the well-known EICAR test string. They ensure that the basic functionality of the package is working as intended.
+These tests use the `@push.rocks/tapbundle` framework to verify functionality, ensuring a reliable setup.
 
-### Advanced Usage and Integration
+### Conclusion
 
-Beyond scanning strings and buffers, you can implement additional advanced use cases based on your specific application needs, such as integrating into web services or automating file scans in cloud environments. Consider building upon provided functionalities and adapting them to meet the requirements of your application architecture.
+The `@push.rocks/smartantivirus` package offers a powerful suite of tools for incorporating ClamAV's scanning capabilities into Node.js applications. With Docker integration and direct daemon access, it covers a wide range of use-cases, from file scanning to real-time stream analysis. Designed with a focus on flexibility and ease of use, it allows developers to build secure, antivirus-enabled applications efficiently.
-
+undefined
-With the help of Node.js worker threads or external task queues like RabbitMQ, you can distribute scanning tasks efficiently within high-traffic environments.

test/test.clamav.manager.ts

@@ -1,7 +1,9 @@
-import { expect, tap } from '../ts/plugins.js';
+import { expect, tap } from '@push.rocks/tapbundle';
-import { type ClamAVLogEvent, ClamAVManager } from '../ts/classes.clamav.manager.js';
+import type { ClamAVLogEvent } from '../ts/classes.clamav.manager.js';
 import { setupClamAV, cleanupClamAV, getManager } from './helpers/clamav.helper.js';
 
+type ClamAVManager = Awaited<ReturnType<typeof setupClamAV>>;
+
 let manager: ClamAVManager;
 
 tap.test('setup', async () => {
@@ -10,31 +12,47 @@ tap.test('setup', async () => {
 });
 
 tap.test('should have initialized container and receive logs', async () => {
-  let logReceived = false;
+  // Create a promise that resolves when we receive a log
-  
+  const logPromise = new Promise<void>((resolve) => {
-  // Add event listener for logs
+    // First check if we already have logs
-  manager.on('log', (event: ClamAVLogEvent) => {
+    const existingLogs = manager.getLogs();
-    console.log(`[Test] Received log event: ${event.type} - ${event.message}`);
+    if (existingLogs.length > 0) {
-    logReceived = true;
+      console.log('[Test] Found existing logs:', existingLogs.map(log => `${log.type}: ${log.message}`).join('\n'));
+      resolve();
+      return;
+    }
+
+    // If no existing logs, wait for new ones
+    const handler = (event: ClamAVLogEvent) => {
+      console.log(`[Test] Received log event: ${event.type} - ${event.message}`);
+      manager.removeListener('log', handler);
+      resolve();
+    };
+    manager.on('log', handler);
   });
 
-  // Wait for logs
+  // Wait for logs with timeout
-  const maxWaitTime = 5000;
+  const timeoutPromise = new Promise<void>((_, reject) => {
-  const startTime = Date.now();
+    setTimeout(() => reject(new Error('Timeout waiting for logs')), 30000);
-  
+  });
-  while (!logReceived && Date.now() - startTime < maxWaitTime) {
+
-    await new Promise(resolve => setTimeout(resolve, 100));
+  try {
+    await Promise.race([logPromise, timeoutPromise]);
+  } catch (error) {
+    console.error('Error waiting for logs:', error);
+    throw error;
   }
   
-  expect(logReceived).toBeTruthy('No logs received within timeout period');
+  console.log('Log received check passed');
 
   // Verify container is running by checking if we can get database info
   try {
     const dbInfo = await manager.getDatabaseInfo();
-    expect(dbInfo).toBeTruthy('Container should be running and able to get database info');
+    expect(dbInfo).toBeTruthy();
+    console.log('Database info check passed');
   } catch (error) {
     console.error('Error getting database info:', error);
-    expect.fail('Failed to get database info - container may not be fully initialized');
+    throw new Error('Failed to get database info - container may not be fully initialized');
   }
 });
 

test/test.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '../ts/plugins.js';
+import { tap, expect } from '@push.rocks/tapbundle';
 import * as smartantivirus from '../ts/index.js';
 import { setupClamAV, cleanupClamAV } from './helpers/clamav.helper.js';
 

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartantivirus',
-  version: '1.1.0',
+  version: '1.3.1',
-  description: 'A Node.js package for integrating antivirus scanning capabilities using ClamAV, allowing in-memory file and data scanning.'
+  description: 'A Node.js package providing integration with ClamAV for anti-virus scanning, facilitating both Docker containerized management and direct connection to a ClamAV daemon.'
 }

ts/classes.clamav.manager.ts

@@ -11,11 +11,16 @@ export class ClamAVManager extends EventEmitter {
   private containerName = 'clamav-daemon';
   private imageTag = 'clamav/clamav:latest';
   private port = 3310;
+  private logs: ClamAVLogEvent[] = [];
 
   constructor() {
     super();
   }
 
+  public getLogs(): ClamAVLogEvent[] {
+    return this.logs;
+  }
+
   /**
    * Start the ClamAV container if it's not already running
    */
@@ -157,6 +162,7 @@ export class ClamAVManager extends EventEmitter {
           type: this.determineLogType(line)
         };
 
+        this.logs.push(event);
         this.emit('log', event);
         console.log(`[ClamAV ${event.type}] ${event.message}`);
       });
@@ -169,6 +175,7 @@ export class ClamAVManager extends EventEmitter {
         type: 'error'
       };
 
+      this.logs.push(event);
       this.emit('log', event);
       console.error(`[ClamAV error] ${event.message}`);
     });

ts/classes.clamavservice.ts

@@ -111,4 +111,77 @@ export class ClamAvService {
       });
     });
   }
+
+  /**
+   * Scans data from a NodeJS stream using ClamAV daemon's INSTREAM command.
+   */
+  public async scanStream(stream: NodeJS.ReadableStream): Promise<{ isInfected: boolean; reason?: string }> {
+    await this.ensureContainerStarted();
+    return new Promise((resolve, reject) => {
+      const client = new net.Socket();
+
+      client.connect(this.port, this.host, () => {
+        console.log('Connected to ClamAV daemon for stream scanning');
+        client.write('zINSTREAM\0');
+
+        stream.on('data', (chunk: Buffer) => {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          const sizeBuf = Buffer.alloc(4);
+          sizeBuf.writeUInt32BE(buf.length, 0);
+          client.write(sizeBuf);
+          client.write(buf);
+        });
+
+        stream.on('end', () => {
+          const endOfStream = Buffer.alloc(4);
+          endOfStream.writeUInt32BE(0, 0);
+          console.log('Stream ended, sending end-of-stream signal');
+          client.write(endOfStream);
+        });
+
+        stream.on('error', (err) => {
+          console.error('Error reading stream:', err);
+          reject(err);
+        });
+      });
+
+      client.on('data', (data) => {
+        const response = data.toString();
+        console.log('Raw Response from ClamAV (stream):', response);
+        const isInfected = response.includes('FOUND');
+        const reason = isInfected ? response.split('FOUND')[0].trim() : undefined;
+        resolve({ isInfected, reason });
+        client.end();
+      });
+
+      client.on('error', (err) => {
+        console.error('Error with ClamAV stream scanning:', err);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Scans a file from a web URL as a stream using ClamAV daemon's INSTREAM command.
+   */
+  public async scanFileFromWebAsStream(url: string): Promise<{ isInfected: boolean; reason?: string }> {
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith('https') ? plugins.https : plugins.http;
+      protocol.get(url, (response) => {
+        this.scanStream(response).then(resolve).catch(reject);
+      }).on('error', (err) => {
+        console.error('Error fetching URL:', err);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Scans a web resource by URL using ClamAV daemon's INSTREAM command.
+   */
+  public async scanWebStream(webstreamArg: ReadableStream): Promise<{ isInfected: boolean; reason?: string }> {
+    // Convert the web ReadableStream to a NodeJS ReadableStream
+    const nodeStream = plugins.smartstream.nodewebhelpers.convertWebReadableToNodeReadable(webstreamArg);
+    return this.scanStream(nodeStream);
+  }
 }

ts/index.ts

@@ -1,2 +1,2 @@
-export * from './classes.smartantivirus.js';
+export * from './classes.clamavservice.js';
 export * from './classes.clamav.manager.js';

ts/plugins.ts

@@ -5,6 +5,8 @@ import { exec, spawn } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 import net from 'net';
+import * as http from 'http';
+import * as https from 'https';
 
 export {
   fs,
@@ -13,19 +15,20 @@ export {
   spawn,
   promisify,
   EventEmitter,
-  net
+  net,
+  http,
+  https
 };
 
 // @push.rocks scope
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartfile from '@push.rocks/smartfile';
-import { expect, tap } from '@push.rocks/tapbundle';
+import * as smartstream from '@push.rocks/smartstream';
 
 export {
   smartpath,
   smartfile,
-  expect,
+  smartstream,
-  tap
 };
 
 // Third party scope