shieldcortex 4.1.0 → 4.2.0

package/dist/audit/dependency-scanner.d.ts

@@ -14,13 +14,42 @@
  *   shieldcortex audit --deps                      # scan ./node_modules
  *   shieldcortex audit --deps-global               # scan global npm prefix
  *   shieldcortex audit --deps-path /some/path      # scan specific path
+ *   shieldcortex audit --deps --quarantine         # scan + quarantine CRITICAL/HIGH
+ *   shieldcortex audit --deps --clean --force      # scan + permanently delete CRITICAL
+ *   shieldcortex audit --deps --auto-protect       # scan + auto-quarantine CRITICAL
  */
-import type { ScannerResult } from './types.js';
+import type { AuditFinding, ScannerResult } from './types.js';
 /**
  * Compute Levenshtein distance between two strings.
  * Standard dynamic-programming implementation, no external deps.
  */
 export declare function levenshtein(a: string, b: string): number;
+export interface QuarantineManifest {
+    packageName: string;
+    version: string;
+    reason: string;
+    originalPath: string;
+    quarantinedAt: string;
+    severity: string;
+}
+/**
+ * Quarantine a package by moving it from node_modules to
+ * ~/.shieldcortex/quarantine/deps/<pkg>-<timestamp>/.
+ *
+ * Creates a manifest.json alongside the quarantined files.
+ * Only acts on CRITICAL and HIGH findings.
+ *
+ * @returns The quarantine destination path, or null if not quarantined.
+ */
+export declare function quarantinePackage(finding: AuditFinding, nodeModulesPath: string): string | null;
+/**
+ * Permanently delete a malicious package from node_modules.
+ *
+ * Only acts on CRITICAL findings (known malicious packages from blocklist).
+ *
+ * @returns The package name that was deleted, or null if not deleted.
+ */
+export declare function cleanPackage(finding: AuditFinding, nodeModulesPath: string): string | null;
 export interface DependencyScanOptions {
     /** Absolute path to node_modules directory */
     nodeModulesPath: string;

package/dist/audit/dependency-scanner.js

@@ -14,10 +14,14 @@
  *   shieldcortex audit --deps                      # scan ./node_modules
  *   shieldcortex audit --deps-global               # scan global npm prefix
  *   shieldcortex audit --deps-path /some/path      # scan specific path
+ *   shieldcortex audit --deps --quarantine         # scan + quarantine CRITICAL/HIGH
+ *   shieldcortex audit --deps --clean --force      # scan + permanently delete CRITICAL
+ *   shieldcortex audit --deps --auto-protect       # scan + auto-quarantine CRITICAL
  */
-import { readdirSync, readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { readdirSync, readFileSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { join, resolve } from 'path';
 import { execSync } from 'child_process';
+import { homedir } from 'os';
 const LEARN_MORE_MALICIOUS = 'https://shieldcortex.ai/docs/threats/supply-chain';
 const LEARN_MORE_TYPOSQUAT = 'https://shieldcortex.ai/docs/threats/typosquatting';
 const LEARN_MORE_POSTINSTALL = 'https://shieldcortex.ai/docs/threats/malicious-scripts';
@@ -208,6 +212,84 @@ function checkPackageAge(pkg) {
     const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
     return ageMs < sevenDaysMs;
 }
+/**
+ * Quarantine a package by moving it from node_modules to
+ * ~/.shieldcortex/quarantine/deps/<pkg>-<timestamp>/.
+ *
+ * Creates a manifest.json alongside the quarantined files.
+ * Only acts on CRITICAL and HIGH findings.
+ *
+ * @returns The quarantine destination path, or null if not quarantined.
+ */
+export function quarantinePackage(finding, nodeModulesPath) {
+    // Only quarantine CRITICAL and HIGH
+    if (finding.severity !== 'critical' && finding.severity !== 'high') {
+        return null;
+    }
+    // Extract package name from the finding title heuristically
+    // Title examples:
+    //   "Known malicious package: plain-crypto-js"
+    //   "Possible typosquat: "axois" → "axios""
+    //   "Suspicious install script in "bad-pkg""
+    const nameMatch = finding.title.match(/^Known malicious package:\s+(.+)$/) ??
+        finding.title.match(/^Possible typosquat:\s+"([^"]+)"/) ??
+        finding.title.match(/^Suspicious install script in\s+"([^"]+)"/);
+    const pkgName = nameMatch?.[1]?.trim();
+    if (!pkgName)
+        return null;
+    // Resolve source path
+    const pkgParts = pkgName.split('/');
+    const srcPath = resolve(join(nodeModulesPath, ...pkgParts));
+    if (!existsSync(srcPath))
+        return null;
+    // Determine version from package.json
+    const pkg = readPackageJson(srcPath);
+    const version = pkg?.version ?? 'unknown';
+    // Build quarantine destination
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const safeName = pkgName.replace(/\//g, '__');
+    const quarantineBase = join(homedir(), '.shieldcortex', 'quarantine', 'deps');
+    const destDir = join(quarantineBase, `${safeName}-${timestamp}`);
+    const pkgDestDir = join(destDir, 'pkg');
+    mkdirSync(destDir, { recursive: true });
+    // Move the package directory
+    renameSync(srcPath, pkgDestDir);
+    // Write manifest
+    const manifest = {
+        packageName: pkgName,
+        version,
+        reason: finding.title,
+        originalPath: srcPath,
+        quarantinedAt: new Date().toISOString(),
+        severity: finding.severity,
+    };
+    writeFileSync(join(destDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    return destDir;
+}
+/**
+ * Permanently delete a malicious package from node_modules.
+ *
+ * Only acts on CRITICAL findings (known malicious packages from blocklist).
+ *
+ * @returns The package name that was deleted, or null if not deleted.
+ */
+export function cleanPackage(finding, nodeModulesPath) {
+    // Only clean CRITICAL findings
+    if (finding.severity !== 'critical') {
+        return null;
+    }
+    // Extract package name from the finding title
+    const nameMatch = finding.title.match(/^Known malicious package:\s+(.+)$/);
+    const pkgName = nameMatch?.[1]?.trim();
+    if (!pkgName)
+        return null;
+    const pkgParts = pkgName.split('/');
+    const srcPath = resolve(join(nodeModulesPath, ...pkgParts));
+    if (!existsSync(srcPath))
+        return null;
+    rmSync(srcPath, { recursive: true, force: true });
+    return pkgName;
+}
 export function scanDependencies(opts) {
     const start = Date.now();
     const { nodeModulesPath } = opts;

package/dist/audit/index.d.ts

@@ -8,7 +8,7 @@ export { scanMemories } from './memory-scanner.js';
 export { scanMcpConfigs } from './mcp-config-scanner.js';
 export { scanEnvFiles } from './env-scanner.js';
 export { scanRulesFiles } from './rules-file-scanner.js';
-export { scanDependencies, resolveNodeModulesPath } from './dependency-scanner.js';
+export { scanDependencies, resolveNodeModulesPath, quarantinePackage, cleanPackage } from './dependency-scanner.js';
 export { formatTerminalReport, formatMarkdownReport, formatJsonReport } from './report-formatter.js';
 export { calculateGrade } from './types.js';
 export type { AuditFinding, AuditReport, AuditGrade, AuditSeverity, ScannerResult, } from './types.js';

package/dist/audit/index.js

@@ -8,6 +8,6 @@ export { scanMemories } from './memory-scanner.js';
 export { scanMcpConfigs } from './mcp-config-scanner.js';
 export { scanEnvFiles } from './env-scanner.js';
 export { scanRulesFiles } from './rules-file-scanner.js';
-export { scanDependencies, resolveNodeModulesPath } from './dependency-scanner.js';
+export { scanDependencies, resolveNodeModulesPath, quarantinePackage, cleanPackage } from './dependency-scanner.js';
 export { formatTerminalReport, formatMarkdownReport, formatJsonReport } from './report-formatter.js';
 export { calculateGrade } from './types.js';

package/dist/cli/audit.d.ts

@@ -12,6 +12,9 @@
  *   npx shieldcortex audit --deps           # Also scan ./node_modules for malicious packages
  *   npx shieldcortex audit --deps-global    # Also scan global npm node_modules
  *   npx shieldcortex audit --deps-path /p   # Also scan specific node_modules path
+ *   npx shieldcortex audit --deps --quarantine         # Scan + quarantine CRITICAL/HIGH
+ *   npx shieldcortex audit --deps --clean --force      # Scan + permanently delete CRITICAL
+ *   npx shieldcortex audit --deps --auto-protect       # Scan + auto-quarantine CRITICAL
  */
 /**
  * Run the full audit.

package/dist/cli/audit.js

@@ -12,14 +12,22 @@
  *   npx shieldcortex audit --deps           # Also scan ./node_modules for malicious packages
  *   npx shieldcortex audit --deps-global    # Also scan global npm node_modules
  *   npx shieldcortex audit --deps-path /p   # Also scan specific node_modules path
+ *   npx shieldcortex audit --deps --quarantine         # Scan + quarantine CRITICAL/HIGH
+ *   npx shieldcortex audit --deps --clean --force      # Scan + permanently delete CRITICAL
+ *   npx shieldcortex audit --deps --auto-protect       # Scan + auto-quarantine CRITICAL
  */
-import { scanMemories, scanMcpConfigs, scanEnvFiles, scanRulesFiles, scanDependencies, resolveNodeModulesPath, formatTerminalReport, formatMarkdownReport, formatJsonReport, calculateGrade, } from '../audit/index.js';
+import { requireFeature, FeatureGatedError } from '../license/gate.js';
+import { scanMemories, scanMcpConfigs, scanEnvFiles, scanRulesFiles, scanDependencies, resolveNodeModulesPath, quarantinePackage, cleanPackage, formatTerminalReport, formatMarkdownReport, formatJsonReport, calculateGrade, } from '../audit/index.js';
 function parseAuditArgs(args) {
     const options = {
         format: 'terminal',
         ci: false,
         deps: false,
         depsMode: 'local',
+        quarantine: false,
+        clean: false,
+        autoProtect: false,
+        force: false,
     };
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -50,6 +58,21 @@ function parseAuditArgs(args) {
                 i++; // consume path argument
             }
         }
+        else if (arg === '--quarantine') {
+            options.quarantine = true;
+            options.deps = true;
+        }
+        else if (arg === '--clean') {
+            options.clean = true;
+            options.deps = true;
+        }
+        else if (arg === '--auto-protect') {
+            options.autoProtect = true;
+            options.deps = true;
+        }
+        else if (arg === '--force') {
+            options.force = true;
+        }
     }
     return options;
 }
@@ -59,6 +82,13 @@ function parseAuditArgs(args) {
 export async function handleAuditCommand(args) {
     const options = parseAuditArgs(args);
     const start = Date.now();
+    // --clean without --force: print warning and exit
+    if (options.clean && !options.force && !options.ci) {
+        console.error('\x1b[33m⚠  Are you sure? Use --force to confirm.\x1b[0m\n' +
+            '   --clean permanently deletes CRITICAL packages from node_modules.\n' +
+            '   Run: shieldcortex audit --deps --clean --force');
+        process.exit(1);
+    }
     // Get version from package.json
     let version = 'unknown';
     try {
@@ -110,8 +140,9 @@ export async function handleAuditCommand(args) {
     if (options.format === 'terminal')
         process.stdout.write(`\r  \x1b[32m[4/${totalSteps}]\x1b[0m Rules files      \x1b[2m${rulesResult.durationMs}ms\x1b[0m\n`);
     // Optional: dependency scan
+    let nodeModulesPath = '';
     if (options.deps) {
-        const nodeModulesPath = resolveNodeModulesPath(options.depsMode, options.depsPath);
+        nodeModulesPath = resolveNodeModulesPath(options.depsMode, options.depsPath);
         if (options.format === 'terminal') {
             process.stdout.write(`  \x1b[2m[5/${totalSteps}] Dependencies (${nodeModulesPath})...\x1b[0m`);
         }
@@ -160,6 +191,102 @@ export async function handleAuditCommand(args) {
             console.log(formatTerminalReport(report));
             break;
     }
+    // ── Post-scan actions ────────────────────────────────────────────────────
+    const depFindings = allFindings.filter(f => f.scanner === 'dependency');
+    if (options.quarantine && depFindings.length > 0) {
+        try {
+            requireFeature('deps_quarantine');
+        }
+        catch (e) {
+            if (e instanceof FeatureGatedError) {
+                console.error('\n' + e.message);
+                process.exit(1);
+            }
+            throw e;
+        }
+        const eligible = depFindings.filter(f => f.severity === 'critical' || f.severity === 'high');
+        if (eligible.length === 0) {
+            if (options.format === 'terminal') {
+                console.log('\n\x1b[32m✓  No CRITICAL or HIGH dependency findings to quarantine.\x1b[0m');
+            }
+        }
+        else {
+            if (options.format === 'terminal') {
+                console.log(`\n\x1b[33m⚠  Quarantining ${eligible.length} package(s)...\x1b[0m`);
+            }
+            for (const finding of eligible) {
+                const dest = quarantinePackage(finding, nodeModulesPath);
+                if (dest && options.format === 'terminal') {
+                    console.log(`  \x1b[31m✗\x1b[0m  Quarantined: ${finding.title}`);
+                    console.log(`       → ${dest}`);
+                }
+            }
+        }
+    }
+    if (options.clean && depFindings.length > 0) {
+        try {
+            requireFeature('deps_clean');
+        }
+        catch (e) {
+            if (e instanceof FeatureGatedError) {
+                console.error('\n' + e.message);
+                process.exit(1);
+            }
+            throw e;
+        }
+        const criticals = depFindings.filter(f => f.severity === 'critical');
+        if (criticals.length === 0) {
+            if (options.format === 'terminal') {
+                console.log('\n\x1b[32m✓  No CRITICAL dependency findings to clean.\x1b[0m');
+            }
+        }
+        else {
+            if (options.format === 'terminal') {
+                console.log(`\n\x1b[31m🗑  Cleaning ${criticals.length} CRITICAL package(s)...\x1b[0m`);
+            }
+            for (const finding of criticals) {
+                const deleted = cleanPackage(finding, nodeModulesPath);
+                if (deleted && options.format === 'terminal') {
+                    console.log(`  \x1b[31m✗\x1b[0m  Deleted: ${deleted}`);
+                }
+            }
+        }
+    }
+    if (options.autoProtect && depFindings.length > 0) {
+        try {
+            requireFeature('deps_auto_protect');
+        }
+        catch (e) {
+            if (e instanceof FeatureGatedError) {
+                console.error('\n' + e.message);
+                process.exit(1);
+            }
+            throw e;
+        }
+        const criticals = depFindings.filter(f => f.severity === 'critical');
+        const highs = depFindings.filter(f => f.severity === 'high');
+        if (criticals.length > 0) {
+            if (options.format === 'terminal') {
+                console.log(`\n\x1b[33m⚠  Auto-protect: quarantining ${criticals.length} CRITICAL package(s)...\x1b[0m`);
+            }
+            for (const finding of criticals) {
+                const dest = quarantinePackage(finding, nodeModulesPath);
+                if (dest && options.format === 'terminal') {
+                    console.log(`  \x1b[31m✗\x1b[0m  Quarantined: ${finding.title}`);
+                    console.log(`       → ${dest}`);
+                }
+            }
+        }
+        if (highs.length > 0 && options.format === 'terminal') {
+            console.log(`\n\x1b[33m⚠  Auto-protect: ${highs.length} HIGH finding(s) detected (manual review required):\x1b[0m`);
+            for (const finding of highs) {
+                console.log(`  \x1b[33m!\x1b[0m  ${finding.title}`);
+            }
+        }
+        if (criticals.length === 0 && highs.length === 0 && options.format === 'terminal') {
+            console.log('\n\x1b[32m✓  Auto-protect: no CRITICAL or HIGH dependency findings.\x1b[0m');
+        }
+    }
     // Exit code
     if (options.ci) {
         // In CI mode: fail on critical or high findings

package/dist/license/gate.d.ts

@@ -6,7 +6,7 @@
  *   isFeatureEnabled('cloud_sync');               // returns boolean (soft check)
  */
 import { type LicenseTier } from './keys.js';
-export type GatedFeature = 'custom_injection_patterns' | 'custom_iron_dome_policies' | 'custom_firewall_rules' | 'audit_export' | 'skill_scanner_deep' | 'cloud_sync' | 'team_management' | 'shared_patterns' | 'cortex_learning';
+export type GatedFeature = 'custom_injection_patterns' | 'custom_iron_dome_policies' | 'custom_firewall_rules' | 'audit_export' | 'skill_scanner_deep' | 'cloud_sync' | 'team_management' | 'shared_patterns' | 'cortex_learning' | 'deps_quarantine' | 'deps_clean' | 'deps_auto_protect' | 'deps_global_scan' | 'memory_types' | 'memory_scopes' | 'dream_mode' | 'llm_reranking' | 'positive_feedback';
 export declare class FeatureGatedError extends Error {
     feature: GatedFeature;
     requiredTier: LicenseTier;

package/dist/license/gate.js

@@ -17,6 +17,15 @@ const FEATURE_TIERS = {
     team_management: 'team',
     shared_patterns: 'team',
     cortex_learning: 'pro',
+    deps_quarantine: 'pro',
+    deps_clean: 'pro',
+    deps_auto_protect: 'pro',
+    deps_global_scan: 'pro',
+    memory_types: 'pro',
+    memory_scopes: 'team',
+    dream_mode: 'pro',
+    llm_reranking: 'pro',
+    positive_feedback: 'pro',
 };
 const FEATURE_DESCRIPTIONS = {
     custom_injection_patterns: 'Define up to 50 custom regex patterns for detecting domain-specific threats.',
@@ -28,6 +37,15 @@ const FEATURE_DESCRIPTIONS = {
     team_management: 'Manage team members, invites, and shared security policies.',
     shared_patterns: 'Share custom injection patterns and policies across your team.',
     cortex_learning: 'Systematic mistake learning with pre-flight checks, pattern detection, and rule graduation.',
+    deps_quarantine: 'Quarantine malicious packages — move threats to a safe holding area.',
+    deps_clean: 'Permanently remove known malicious packages from your project.',
+    deps_auto_protect: 'Automated scan + quarantine of critical threats on every install.',
+    deps_global_scan: 'Scan global npm installations for supply chain threats.',
+    memory_types: 'Typed memories (user/feedback/project/reference) for structured knowledge.',
+    memory_scopes: 'Private vs team memory scopes for multi-agent deployments.',
+    dream_mode: 'Background memory consolidation — merge duplicates, archive stale, detect contradictions.',
+    llm_reranking: 'LLM-powered memory reranking for precision recall.',
+    positive_feedback: 'Capture what worked, not just what failed — learn from success.',
 };
 // ── Error class ──────────────────────────────────────────
 export class FeatureGatedError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shieldcortex",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Trustworthy memory and security for AI agents. Recall debugging, review queue, OpenClaw session capture, and memory poisoning defence for Claude Code, Codex, OpenClaw, LangChain, and MCP agents.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",