openclaw-plugin-vt-sentinel 0.4.0 → 0.6.0

package/dist/audit-log.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Simple rotating audit log.
+ * Format: ISO-8601 timestamp \t SHA-256 \t full file path
+ * Rotates by keeping the newest half when maxLines or maxBytes is exceeded.
+ */
+export declare class AuditLog {
+    private logPath;
+    private maxLines;
+    private maxBytes;
+    private lineCount;
+    private approxSize;
+    constructor(logPath: string, maxLines?: number, maxBytes?: number);
+    append(sha256: string, filePath: string): void;
+    private rotate;
+}
+/**
+ * Returns the directory for VT Sentinel logs (same as state dir).
+ */
+export declare function getLogDir(): string;

package/dist/audit-log.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuditLog = void 0;
+exports.getLogDir = getLogDir;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+/**
+ * Simple rotating audit log.
+ * Format: ISO-8601 timestamp \t SHA-256 \t full file path
+ * Rotates by keeping the newest half when maxLines or maxBytes is exceeded.
+ */
+class AuditLog {
+    constructor(logPath, maxLines = 1000, maxBytes = 1024 * 1024) {
+        this.lineCount = 0;
+        this.approxSize = 0;
+        this.logPath = logPath;
+        this.maxLines = maxLines;
+        this.maxBytes = maxBytes;
+        // Ensure parent directory exists
+        try {
+            const dir = path.dirname(logPath);
+            if (!fs.existsSync(dir))
+                fs.mkdirSync(dir, { recursive: true });
+        }
+        catch { /* best-effort */ }
+        // Seed counters from existing file
+        try {
+            const stat = fs.statSync(logPath);
+            this.approxSize = stat.size;
+            const content = fs.readFileSync(logPath, 'utf-8');
+            this.lineCount = content.split('\n').filter(l => l.length > 0).length;
+        }
+        catch {
+            this.lineCount = 0;
+            this.approxSize = 0;
+        }
+    }
+    append(sha256, filePath) {
+        const line = `${new Date().toISOString()}\t${sha256}\t${filePath}\n`;
+        try {
+            fs.appendFileSync(this.logPath, line);
+            this.lineCount++;
+            this.approxSize += Buffer.byteLength(line);
+            if (this.lineCount > this.maxLines || this.approxSize > this.maxBytes) {
+                this.rotate();
+            }
+        }
+        catch { /* best-effort — never crash the plugin for a log write failure */ }
+    }
+    rotate() {
+        try {
+            const content = fs.readFileSync(this.logPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.length > 0);
+            // Keep at most half of maxLines
+            let keep = lines.slice(-Math.floor(this.maxLines / 2));
+            // Also trim by size: drop oldest lines until under half of maxBytes
+            const halfBytes = Math.floor(this.maxBytes / 2);
+            while (keep.length > 1) {
+                const size = Buffer.byteLength(keep.join('\n') + '\n');
+                if (size <= halfBytes)
+                    break;
+                keep.shift();
+            }
+            const newContent = keep.join('\n') + '\n';
+            fs.writeFileSync(this.logPath, newContent);
+            this.lineCount = keep.length;
+            this.approxSize = Buffer.byteLength(newContent);
+        }
+        catch { /* best-effort */ }
+    }
+}
+exports.AuditLog = AuditLog;
+/**
+ * Returns the directory for VT Sentinel logs (same as state dir).
+ */
+function getLogDir() {
+    return process.env.OPENCLAW_STATE_DIR || path.join(os.homedir(), '.openclaw');
+}

package/dist/index.js

@@ -47,6 +47,7 @@ const path = __importStar(require("path"));
 const scanner_1 = require("./scanner");
 const path_extractor_1 = require("./path-extractor");
 const vt_api_1 = require("./vt-api");
+const audit_log_1 = require("./audit-log");
 // --- Helpers ---
 function formatResult(r) {
     const lines = [];
@@ -157,7 +158,8 @@ function vtSentinelPlugin(api) {
         if (scanner)
             return scanner;
         const cfg = getConfig();
-        const userApiKey = cfg?.apiKey || process.env.VIRUSTOTAL_API_KEY;
+        const envKey = process.env.VIRUSTOTAL_API_KEY;
+        const userApiKey = cfg?.apiKey || (envKey && envKey !== 'vtai-active' ? envKey : undefined);
         if (userApiKey) {
             // User-provided key → standard VT API
             if (!process.env.VIRUSTOTAL_API_KEY)
@@ -194,6 +196,21 @@ function vtSentinelPlugin(api) {
     // If file content changes (different hash), it gets rescanned.
     const READ_SCAN_REGISTRY_MAX = 5000;
     const readScanRegistry = new Map();
+    // --- Audit logs: rotating logs for uploads and detections ---
+    const logDir = (0, audit_log_1.getLogDir)();
+    const uploadLog = new audit_log_1.AuditLog(path.join(logDir, 'vt-sentinel-uploads.log'));
+    const detectionLog = new audit_log_1.AuditLog(path.join(logDir, 'vt-sentinel-detections.log'));
+    /** Log a scan result to the appropriate audit log(s). */
+    const auditResult = (result) => {
+        if (!result.sha256)
+            return;
+        if (result.verdict === 'pending') {
+            uploadLog.append(result.sha256, result.filePath);
+        }
+        if (result.verdict === 'malicious' || result.verdict === 'suspicious') {
+            detectionLog.append(result.sha256, result.filePath);
+        }
+    };
     // --- Blocklist: tracks files detected as malicious/suspicious ---
     const blocklist = new Map();
     // --- Context enrichment: derive interesting dirs from OpenClaw runtime ---
@@ -372,6 +389,7 @@ function vtSentinelPlugin(api) {
                 return;
             const force = isForceScannedDir(filePath);
             const result = await s.scanFile(filePath, force);
+            auditResult(result);
             if (result.verdict === 'malicious') {
                 api.logger.error(`[VT-Sentinel] ${result.message}`);
                 blockFile(filePath, result);
@@ -407,11 +425,14 @@ function vtSentinelPlugin(api) {
                 path.join(stateDir, 'hooks'),
             ];
             // Workspace: agent's working directory — downloads, ClawHub skills, etc.
-            // Force-scan entire workspace: files here are agent-created or plugin-installed,
-            // so even SAFE-classified files deserve VT analysis (catches disguised payloads).
+            // Watch but DON'T force-scan entire workspace — it contains user-private data
+            // (session memories, conversation context) that should never be uploaded to VT.
+            // Only force-scan code subdirs within workspace (skills/hooks/extensions).
             const workspaceDir = path.join(stateDir, 'workspace');
             candidates.push(workspaceDir);
-            forceScannedDirs.add(workspaceDir);
+            const wsCodeDirs = ['skills', 'hooks', 'extensions'].map(s => path.join(workspaceDir, s));
+            candidates.push(...wsCodeDirs);
+            wsCodeDirs.forEach(d => forceScannedDirs.add(d));
             // Set default workspace dir for resolving relative paths in hooks
             if (!resolvedWorkspaceDir) {
                 resolvedWorkspaceDir = workspaceDir;
@@ -478,14 +499,30 @@ function vtSentinelPlugin(api) {
                 api.logger.warn('[VT-Sentinel] No valid watch directories found');
                 return;
             }
+            // depth: 0 — only top-level files per directory. Prevents chokidar from
+            // recursively creating thousands of inotify watches on /tmp subdirectories,
+            // which in gateway environments blocks the 'ready' event and suppresses
+            // all high-level add/change events indefinitely.
+            // No awaitWriteFinish — it interacts badly with the gateway's event loop.
+            // We use a simple debounce map instead to avoid scanning files mid-write.
             watcher = chokidar.watch(validDirs, {
                 persistent: true,
                 ignoreInitial: true,
                 ignorePermissionErrors: true,
-                awaitWriteFinish: { stabilityThreshold: 2000, pollInterval: 100 },
+                depth: 0,
             });
-            watcher.on('add', handleWatcherFile);
-            watcher.on('change', handleWatcherFile);
+            const debounceTimers = new Map();
+            const debouncedHandler = (filePath) => {
+                const existing = debounceTimers.get(filePath);
+                if (existing)
+                    clearTimeout(existing);
+                debounceTimers.set(filePath, setTimeout(() => {
+                    debounceTimers.delete(filePath);
+                    handleWatcherFile(filePath);
+                }, 1500));
+            };
+            watcher.on('add', debouncedHandler);
+            watcher.on('change', debouncedHandler);
             watcher.on('error', (err) => {
                 api.logger.warn(`[VT-Sentinel] Watcher error (non-fatal): ${err.message}`);
             });
@@ -523,6 +560,7 @@ function vtSentinelPlugin(api) {
                 return textResponse('Error: VT-Sentinel not configured (API key missing and VTAI registration failed)');
             try {
                 const result = await s.scanFile(params.path, true);
+                auditResult(result);
                 return textResponse(formatResult(result));
             }
             catch (err) {
@@ -552,6 +590,7 @@ function vtSentinelPlugin(api) {
                 const result = await s.checkHash(params.hash);
                 if (!result)
                     return textResponse(`Hash ${params.hash} not found in VirusTotal database.`);
+                auditResult(result);
                 return textResponse(formatResult(result));
             }
             catch (err) {
@@ -589,6 +628,7 @@ function vtSentinelPlugin(api) {
             try {
                 s.recordConsent(true);
                 const result = await s.uploadWithConsent(params.path);
+                auditResult(result);
                 return textResponse(formatResult(result));
             }
             catch (err) {
@@ -633,6 +673,7 @@ function vtSentinelPlugin(api) {
                     }
                 }
                 const result = await s.scanFile(target.path, false, precomputedHash);
+                auditResult(result);
                 if (result.verdict === 'malicious') {
                     api.logger.error(`[VT-Sentinel] THREAT DETECTED — ${result.fileName} ` +
                         `(${result.detections?.malicious} detections) ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-plugin-vt-sentinel",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "VirusTotal Sentinel for OpenClaw - Malware detection and AI-powered code analysis",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,6 +25,7 @@
     "dist/classifier.*",
     "dist/cache.*",
     "dist/path-extractor.*",
+    "dist/audit-log.*",
     "skills/",
     "hooks/",
     "openclaw.plugin.json"