@push.rocks/smartmta 6.5.2 → 8.0.0

package/ts/paths.ts

@@ -1,48 +1,9 @@
 import * as plugins from './plugins.js';
 
-// Base directories
-export const baseDir = process.cwd();
+// Code and packaged executable paths only. SmartMTA data is supplied through
+// managed storage interfaces and never persisted directly to the filesystem.
 export const packageDir = plugins.path.join(
   plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
   '../'
 );
 export const distServe = plugins.path.join(packageDir, './dist_serve');
-
-// Configure data directory with environment variable or default to .nogit/data
-const DEFAULT_DATA_PATH = '.nogit/data';
-export const dataDir = process.env.DATA_DIR 
-  ? process.env.DATA_DIR 
-  : plugins.path.join(baseDir, DEFAULT_DATA_PATH);
-
-// MTA directories 
-export const keysDir = plugins.path.join(dataDir, 'keys');
-export const dnsRecordsDir = plugins.path.join(dataDir, 'dns');
-export const sentEmailsDir = plugins.path.join(dataDir, 'emails', 'sent');
-export const receivedEmailsDir = plugins.path.join(dataDir, 'emails', 'received');
-export const failedEmailsDir = plugins.path.join(dataDir, 'emails', 'failed'); // For failed emails
-export const logsDir = plugins.path.join(dataDir, 'logs'); // For logs
-
-// Email template directories
-export const emailTemplatesDir = plugins.path.join(dataDir, 'templates', 'email');
-export const MtaAttachmentsDir = plugins.path.join(dataDir, 'attachments'); // For email attachments
-
-// Configuration path
-export const configPath = process.env.CONFIG_PATH 
-  ? process.env.CONFIG_PATH 
-  : plugins.path.join(baseDir, 'config.json');
-
-// Create directories if they don't exist
-export async function ensureDirectories() {
-  // Ensure data directories
-  await plugins.smartfs.directory(dataDir).recursive().create();
-  await plugins.smartfs.directory(keysDir).recursive().create();
-  await plugins.smartfs.directory(dnsRecordsDir).recursive().create();
-  await plugins.smartfs.directory(sentEmailsDir).recursive().create();
-  await plugins.smartfs.directory(receivedEmailsDir).recursive().create();
-  await plugins.smartfs.directory(failedEmailsDir).recursive().create();
-  await plugins.smartfs.directory(logsDir).recursive().create();
-
-  // Ensure email template directories
-  await plugins.smartfs.directory(emailTemplatesDir).recursive().create();
-  await plugins.smartfs.directory(MtaAttachmentsDir).recursive().create();
-}

package/ts/plugins.ts

@@ -1,6 +1,5 @@
 // node native
 import * as dns from 'dns';
-import * as fs from 'fs';
 import * as crypto from 'crypto';
 import * as http from 'http';
 import * as net from 'net';
@@ -11,7 +10,6 @@ import * as util from 'util';
 
 export {
   dns,
-  fs,
   crypto,
   http,
   net,
@@ -23,15 +21,12 @@ export {
 
 // @push.rocks scope
 import * as smartfile from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartmail from '@push.rocks/smartmail';
 import * as smartpath from '@push.rocks/smartpath';
 import * as smartrust from '@push.rocks/smartrust';
 
-export const smartfs = new SmartFs(new SmartFsProviderNode());
-
-export { smartfile, SmartFs, smartlog, smartmail, smartpath, smartrust };
+export { smartfile, smartlog, smartmail, smartpath, smartrust };
 
 // Define SmartLog types for use in error handling
 export type TLogLevel = 'error' | 'warn' | 'info' | 'success' | 'debug';

package/ts/security/classes.contentscanner.ts

@@ -1,11 +1,12 @@
 import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
 import { logger } from '../logger.js';
 import { Email } from '../mail/core/classes.email.js';
 import type { IAttachment } from '../mail/core/classes.email.js';
 import { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
 import { RustSecurityBridge } from './classes.rustsecuritybridge.js';
 import { LRUCache } from 'lru-cache';
+import { getErrorMessage, getErrorStack } from '../functions.errors.js';
+import { callObserverSafely } from '../mail/delivery/functions.safe-observers.js';
 
 /**
  * Scan result information
@@ -180,9 +181,10 @@ export class ContentScanner {
 
       return result;
     } catch (error) {
-      logger.log('error', `Error scanning email: ${error.message}`, {
+      const errorMessage = getErrorMessage(error);
+      logger.log('error', `Error scanning email: ${errorMessage}`, {
         messageId: email.getMessageId(),
-        error: error.stack
+        error: getErrorStack(error)
       });
 
       // Return a safe default with error indication
@@ -192,7 +194,7 @@ export class ContentScanner {
         scannedElements: ['error'],
         timestamp: Date.now(),
         threatType: 'scan_error',
-        threatDetails: `Scan error: ${error.message}`
+        threatDetails: `Scan error: ${errorMessage}`
       };
     }
   }
@@ -301,7 +303,7 @@ export class ContentScanner {
         .replace(/[\x00-\x09\x0B-\x1F\x7F-\x9F]/g, '') // Remove control chars
         .replace(/\uFFFD/g, ''); // Remove replacement char
     } catch (error) {
-      logger.log('warn', `Error extracting text from buffer: ${error.message}`);
+      logger.log('warn', `Error extracting text from buffer: ${getErrorMessage(error)}`);
       return '';
     }
   }
@@ -341,7 +343,7 @@ export class ContentScanner {
    * @param result The scan result
    */
   private logHighThreatFound(email: Email, result: IScanResult): void {
-    SecurityLogger.getInstance().logEvent({
+    void callObserverSafely('content scan security log', () => SecurityLogger.getInstance().logEvent({
       level: SecurityLogLevel.ERROR,
       type: SecurityEventType.MALWARE,
       message: `High threat content detected in email from ${email.from} to ${email.to.join(', ')}`,
@@ -354,8 +356,8 @@ export class ContentScanner {
         subject: email.subject
       },
       success: false,
-      domain: email.getFromDomain()
-    });
+      domain: email.getFromDomain() || undefined
+    }));
   }
   
   /**
@@ -364,7 +366,7 @@ export class ContentScanner {
    * @param result The scan result
    */
   private logThreatFound(email: Email, result: IScanResult): void {
-    SecurityLogger.getInstance().logEvent({
+    void callObserverSafely('content scan security log', () => SecurityLogger.getInstance().logEvent({
       level: SecurityLogLevel.WARN,
       type: SecurityEventType.SPAM,
       message: `Suspicious content detected in email from ${email.from} to ${email.to.join(', ')}`,
@@ -377,8 +379,8 @@ export class ContentScanner {
         subject: email.subject
       },
       success: false,
-      domain: email.getFromDomain()
-    });
+      domain: email.getFromDomain() || undefined
+    }));
   }
   
   /**
@@ -397,4 +399,4 @@ export class ContentScanner {
       return 'high';
     }
   }
-}
+}

package/ts/security/classes.ipreputationchecker.ts

@@ -1,10 +1,10 @@
-import * as plugins from '../plugins.js';
-import * as paths from '../paths.js';
 import { logger } from '../logger.js';
-import { hasStorageManagerMethods, type IStorageManagerLike } from '../mail/interfaces.storage.js';
+import { getErrorMessage, getErrorStack } from '../functions.errors.js';
+import type { IStorageManager } from '../mail/interfaces.storage.js';
 import { SecurityLogger, SecurityLogLevel, SecurityEventType } from './classes.securitylogger.js';
 import { RustSecurityBridge } from './classes.rustsecuritybridge.js';
 import { LRUCache } from 'lru-cache';
+import { callObserverSafely } from '../mail/delivery/functions.safe-observers.js';
 
 /**
  * Reputation check result information
@@ -54,20 +54,21 @@ export interface IIPReputationOptions {
   highRiskThreshold?: number; // Score below this is high risk
   mediumRiskThreshold?: number; // Score below this is medium risk
   lowRiskThreshold?: number; // Score below this is low risk
-  enableLocalCache?: boolean; // Whether to persist cache to disk (default: true)
+  persistCache?: boolean; // Whether to persist cache through IStorageManager (default: true)
   enableDNSBL?: boolean; // Whether to use DNSBL checks (default: true)
   enableIPInfo?: boolean; // Whether to use IP info service (default: true)
 }
 
 /**
  * IP reputation checker — delegates DNSBL lookups to the Rust security bridge.
- * Retains LRU caching and disk persistence in TypeScript.
+ * Retains an in-memory LRU cache and optionally persists it through managed storage.
  */
 export class IPReputationChecker {
   private static instance: IPReputationChecker;
   private reputationCache: LRUCache<string, IReputationResult>;
   private options: Required<IIPReputationOptions>;
-  private storageManager?: IStorageManagerLike;
+  private storageManager?: IStorageManager;
+  private initializationPromise: Promise<void>;
 
   private static readonly DEFAULT_OPTIONS: Required<IIPReputationOptions> = {
     maxCacheSize: 10000,
@@ -76,12 +77,12 @@ export class IPReputationChecker {
     highRiskThreshold: ReputationThreshold.HIGH_RISK,
     mediumRiskThreshold: ReputationThreshold.MEDIUM_RISK,
     lowRiskThreshold: ReputationThreshold.LOW_RISK,
-    enableLocalCache: true,
+    persistCache: true,
     enableDNSBL: true,
     enableIPInfo: true
   };
 
-  constructor(options: IIPReputationOptions = {}, storageManager?: IStorageManagerLike) {
+  constructor(options: IIPReputationOptions = {}, storageManager?: IStorageManager) {
     this.options = {
       ...IPReputationChecker.DEFAULT_OPTIONS,
       ...options
@@ -94,14 +95,19 @@ export class IPReputationChecker {
       ttl: this.options.cacheTTL,
     });
 
-    if (this.options.enableLocalCache) {
-      this.loadCache().catch(error => {
-        logger.log('error', `Failed to load IP reputation cache during initialization: ${error.message}`);
-      });
-    }
+    const hydrationPromise = this.options.persistCache
+      ? this.loadCache()
+      : Promise.resolve();
+    hydrationPromise.catch(() => undefined);
+    this.initializationPromise = hydrationPromise;
+  }
+
+  /** Wait until the managed reputation cache has been hydrated. */
+  public async initialize(): Promise<void> {
+    await this.initializationPromise;
   }
 
-  public static getInstance(options: IIPReputationOptions = {}, storageManager?: IStorageManagerLike): IPReputationChecker {
+  public static getInstance(options: IIPReputationOptions = {}, storageManager?: IStorageManager): IPReputationChecker {
     if (!IPReputationChecker.instance) {
       IPReputationChecker.instance = new IPReputationChecker(options, storageManager);
     }
@@ -113,6 +119,8 @@ export class IPReputationChecker {
    */
   public async checkReputation(ip: string): Promise<IReputationResult> {
     try {
+      await this.initialize();
+
       if (!this.isValidIPAddress(ip)) {
         logger.log('warn', `Invalid IP address format: ${ip}`);
         return this.createErrorResult(ip, 'Invalid IP address format');
@@ -146,7 +154,7 @@ export class IPReputationChecker {
 
       this.reputationCache.set(ip, result);
 
-      if (this.options.enableLocalCache) {
+      if (this.options.persistCache) {
         this.saveCache().catch(error => {
           logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
         });
@@ -155,11 +163,12 @@ export class IPReputationChecker {
       this.logReputationCheck(ip, result);
       return result;
     } catch (error) {
-      logger.log('error', `Error checking IP reputation for ${ip}: ${error.message}`, {
+      const errorMessage = getErrorMessage(error);
+      logger.log('error', `Error checking IP reputation for ${ip}: ${errorMessage}`, {
         ip,
-        stack: error.stack
+        stack: getErrorStack(error)
       });
-      const errorResult = this.createErrorResult(ip, error.message);
+      const errorResult = this.createErrorResult(ip, errorMessage);
       // Cache error results to avoid repeated failing lookups
       this.reputationCache.set(ip, errorResult);
       return errorResult;
@@ -189,7 +198,7 @@ export class IPReputationChecker {
       logLevel = SecurityLogLevel.WARN;
     }
 
-    SecurityLogger.getInstance().logEvent({
+    void callObserverSafely('IP reputation security log', () => SecurityLogger.getInstance().logEvent({
       level: logLevel,
       type: SecurityEventType.IP_REPUTATION,
       message: `IP reputation check ${result.isSpam ? 'flagged spam' : 'completed'} for ${ip}`,
@@ -204,91 +213,29 @@ export class IPReputationChecker {
         blacklists: result.blacklists
       },
       success: !result.isSpam
-    });
+    }));
   }
 
   private async saveCache(): Promise<void> {
-    try {
-      const entries = Array.from(this.reputationCache.entries()).map(([ip, data]) => ({
-        ip,
-        data
-      }));
-
-      if (entries.length === 0) {
-        return;
-      }
-
-      const cacheData = JSON.stringify(entries);
-
-      if (hasStorageManagerMethods(this.storageManager, ['set'])) {
-        await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
-        logger.log('info', `Saved ${entries.length} IP reputation cache entries to StorageManager`);
-      } else {
-        const cacheDir = plugins.path.join(paths.dataDir, 'security');
-        await plugins.smartfs.directory(cacheDir).recursive().create();
-        const cacheFile = plugins.path.join(cacheDir, 'ip_reputation_cache.json');
-        await plugins.smartfs.file(cacheFile).write(cacheData);
-        logger.log('info', `Saved ${entries.length} IP reputation cache entries to disk`);
-      }
-    } catch (error) {
-      logger.log('error', `Failed to save IP reputation cache: ${error.message}`);
-    }
+    if (!this.storageManager) return;
+    const entries = Array.from(this.reputationCache.entries()).map(([ip, data]) => ({ ip, data }));
+    if (entries.length === 0) return;
+    await this.storageManager.set('/security/ip-reputation-cache.json', JSON.stringify(entries));
+    logger.log('info', `Saved ${entries.length} IP reputation cache entries`);
   }
 
   private async loadCache(): Promise<void> {
-    try {
-      let cacheData: string | null = null;
-      let fromFilesystem = false;
-
-      if (hasStorageManagerMethods(this.storageManager, ['get', 'set'])) {
-        try {
-          cacheData = await this.storageManager.get('/security/ip-reputation-cache.json');
-
-          if (!cacheData) {
-            const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
-            if (plugins.fs.existsSync(cacheFile)) {
-              logger.log('info', 'Migrating IP reputation cache from filesystem to StorageManager');
-              cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
-              fromFilesystem = true;
-              await this.storageManager.set('/security/ip-reputation-cache.json', cacheData);
-              logger.log('info', 'IP reputation cache migrated to StorageManager successfully');
-              try {
-                plugins.fs.unlinkSync(cacheFile);
-                logger.log('info', 'Old cache file removed after migration');
-              } catch (deleteError) {
-                logger.log('warn', `Could not delete old cache file: ${deleteError.message}`);
-              }
-            }
-          }
-        } catch (error) {
-          logger.log('error', `Error loading from StorageManager: ${error.message}`);
-        }
-      } else {
-        const cacheFile = plugins.path.join(paths.dataDir, 'security', 'ip_reputation_cache.json');
-        if (plugins.fs.existsSync(cacheFile)) {
-          cacheData = plugins.fs.readFileSync(cacheFile, 'utf8');
-          fromFilesystem = true;
-        }
-      }
-
-      if (cacheData) {
-        const entries = JSON.parse(cacheData);
-        const now = Date.now();
-        const validEntries = entries.filter(entry => {
-          const age = now - entry.data.timestamp;
-          return age < this.options.cacheTTL;
-        });
-
-        for (const entry of validEntries) {
-          this.reputationCache.set(entry.ip, entry.data);
-        }
-
-        const source = fromFilesystem ? 'disk' : 'StorageManager';
-        logger.log('info', `Loaded ${validEntries.length} IP reputation cache entries from ${source}`);
-      }
-    } catch (error) {
-      logger.log('error', `Failed to load IP reputation cache: ${error.message}`);
+    if (!this.storageManager) return;
+    const cacheData = await this.storageManager.get('/security/ip-reputation-cache.json');
+    if (!cacheData) return;
+
+    const entries = JSON.parse(cacheData);
+    const now = Date.now();
+    const validEntries = entries.filter((entry) => now - entry.data.timestamp < this.options.cacheTTL);
+    for (const entry of validEntries) {
+      this.reputationCache.set(entry.ip, entry.data);
     }
+    logger.log('info', `Loaded ${validEntries.length} IP reputation cache entries`);
   }
 
   public static getRiskLevel(score: number): 'high' | 'medium' | 'low' | 'trusted' {
@@ -303,11 +250,11 @@ export class IPReputationChecker {
     }
   }
 
-  public updateStorageManager(storageManager: IStorageManagerLike): void {
+  public updateStorageManager(storageManager: IStorageManager): void {
     this.storageManager = storageManager;
     logger.log('info', 'IPReputationChecker storage manager updated');
 
-    if (this.options.enableLocalCache && this.reputationCache.size > 0) {
+    if (this.options.persistCache && this.reputationCache.size > 0) {
       this.saveCache().catch(error => {
         logger.log('error', `Failed to save cache to new storage manager: ${error.message}`);
       });