fullcourtdefense-cli 1.10.0 → 1.11.0

package/dist/commands/cmdGuard.d.ts

@@ -0,0 +1,20 @@
+export interface CmdGuardStatus {
+    supported: boolean;
+    installed: boolean;
+    autorunValue?: string;
+    rulesPresent: boolean;
+    ruleCount?: number;
+    mode?: string;
+}
+export declare function isCmdGuardInstalled(): boolean;
+export declare function getCmdGuardStatus(): CmdGuardStatus;
+export interface InstallCmdGuardArgs {
+    /** Reserved for future use. */
+    profiles?: string;
+}
+/** `fullcourtdefense install-cmd-guard` — enable interactive cmd.exe blocking. */
+export declare function installCmdGuardCommand(_args?: InstallCmdGuardArgs): Promise<void>;
+/** `fullcourtdefense uninstall-cmd-guard` */
+export declare function uninstallCmdGuardCommand(): Promise<void>;
+/** Refresh shared rules JSON when cmd guard is installed. */
+export declare function refreshCmdGuardRules(): void;

package/dist/commands/cmdGuard.js

@@ -0,0 +1,245 @@
+"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.isCmdGuardInstalled = isCmdGuardInstalled;
+exports.getCmdGuardStatus = getCmdGuardStatus;
+exports.installCmdGuardCommand = installCmdGuardCommand;
+exports.uninstallCmdGuardCommand = uninstallCmdGuardCommand;
+exports.refreshCmdGuardRules = refreshCmdGuardRules;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const shellGuard_1 = require("./shellGuard");
+/**
+ * Interactive cmd.exe guard — blocks dangerous commands TYPED in Command Prompt.
+ *
+ * cmd.exe has no PSReadLine/preexec hook. We use the supported AutoRun registry
+ * value + doskey macros: every new cmd session registers macros for high-risk
+ * command names (del, erase, rd, curl, …) that delegate to a Node checker
+ * sharing the same rules JSON as the PowerShell guard.
+ *
+ * Allowed commands run via `cmd /d /c` so AutoRun is not re-triggered (no loop).
+ * Interactive cmd only — `cmd /c del ...` from scripts bypasses doskey by design.
+ */
+const GUARD_RULES_PATH = path.join(os.homedir(), '.fullcourtdefense-shell-guard.json');
+const GUARD_JS_PATH = path.join(os.homedir(), '.fullcourtdefense-cmd-guard.js');
+const AUTORUN_BAT_PATH = path.join(os.homedir(), '.fullcourtdefense-cmd-autorun.bat');
+const CMD_AUTORUN_KEY = 'HKCU\\Software\\Microsoft\\Command Processor';
+const AUTORUN_VALUE = 'AutoRun';
+const AUTORUN_MARKER = 'fullcourtdefense-cmd-autorun.bat';
+/** cmd builtins / exes we intercept via doskey (first token of the typed line). */
+const INTERCEPTED_COMMANDS = [
+    'del', 'erase', 'rd', 'rmdir', 'format',
+    'curl', 'wget', 'powershell', 'pwsh',
+    'terraform', 'kubectl', 'aws', 'gcloud', 'az',
+    'vssadmin', 'certutil', 'bitsadmin', 'reg', 'net', 'sc',
+];
+function regString(key, value) {
+    try {
+        const out = (0, child_process_1.execFileSync)('reg', ['query', key, '/v', value], {
+            encoding: 'utf8', windowsHide: true, timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const match = out.match(new RegExp(`${value}\\s+REG_(?:EXPAND_)?SZ\\s+(.+)`));
+        return match ? match[1].trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setRegString(key, valueName, data) {
+    (0, child_process_1.execFileSync)('reg', ['add', key, '/v', valueName, '/t', 'REG_SZ', '/d', data, '/f'], {
+        windowsHide: true, timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'],
+    });
+}
+function batQuote(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function buildGuardJs(nodePath, cliEntry) {
+    return [
+        `'use strict';`,
+        `const fs=require('fs');const os=require('os');const path=require('path');const{spawnSync}=require('child_process');const crypto=require('crypto');`,
+        `const RULES_PATH=${JSON.stringify(GUARD_RULES_PATH)};`,
+        `const SPOOL_PATH=${JSON.stringify(path.join(os.homedir(), '.fullcourtdefense-spool.jsonl'))};`,
+        `const NODE_PATH=${JSON.stringify(nodePath)};`,
+        `const CLI_ENTRY=${JSON.stringify(cliEntry)};`,
+        `function loadRules(){try{const raw=JSON.parse(fs.readFileSync(RULES_PATH,'utf8'));const rules=(raw.rules||[]).map(r=>{try{return{id:r.id,category:r.category,reason:r.reason,source:r.source,re:new RegExp(r.pattern,'i')};}catch{return null;}}).filter(Boolean);return{mode:raw.mode==='monitor'?'monitor':'block',rules};}catch{return{mode:'block',rules:[]};}}`,
+        `function matchLine(line,rules){const n=line.replace(/\\s+/g,' ').trim();for(const r of rules){try{if(r.re.test(n)||r.re.test(line))return r;}catch{}}return null;}`,
+        `function spoolEvent(rule,line,decision){try{const ev=line.trim();const evidence=ev.length>180?ev.slice(0,180)+'...':ev;const event={eventId:crypto.randomUUID(),type:'verdict',decision,toolName:'cmd_terminal',operation:'shell_command',reason:'Shell guard: '+rule.reason,ruleId:rule.id,category:rule.category,source:rule.source,evidence,occurredAt:new Date().toISOString()};fs.appendFileSync(SPOOL_PATH,JSON.stringify(event)+'\\n',{encoding:'utf8',mode:0o600});if(fs.existsSync(NODE_PATH)&&fs.existsSync(CLI_ENTRY)){spawnSync(NODE_PATH,[CLI_ENTRY,'flush-spool','--heartbeat','true'],{stdio:'ignore',windowsHide:true});}}catch{}}`,
+        `function delegate(args){const r=spawnSync(process.env.ComSpec||'cmd.exe',['/d','/c',...args],{stdio:'inherit',windowsHide:true});process.exit(typeof r.status==='number'?r.status:1);}`,
+        `const args=process.argv.slice(2);if(!args.length)process.exit(0);if(process.env.FCD_CMD_GUARD==='off')delegate(args);`,
+        `const line=args.join(' ');const{mode,rules}=loadRules();const hit=matchLine(line,rules);`,
+        `if(!hit)delegate(args);`,
+        `if(mode==='monitor'){console.error('[FullCourtDefense] monitor: would block - '+hit.reason+' (rule '+hit.id+')');spoolEvent(hit,line,'allow');delegate(args);}`,
+        `console.error('[FullCourtDefense] BLOCKED: '+hit.reason+' (rule '+hit.id+')');`,
+        `console.error('This command was not executed. Reported to your security dashboard.');`,
+        `spoolEvent(hit,line,'block');process.exit(1);`,
+        ``,
+    ].join('\n');
+}
+function buildAutorunBat(nodePath) {
+    const guardJs = batQuote(GUARD_JS_PATH);
+    const node = batQuote(nodePath);
+    const doskeyLines = INTERCEPTED_COMMANDS.map(cmd => `doskey ${cmd}=${node} ${guardJs} ${cmd} $*`);
+    return [
+        '@echo off',
+        'REM FullCourtDefense cmd.exe guard (installed by fullcourtdefense-cli).',
+        'REM Disable for one session: set FCD_CMD_GUARD=off',
+        'REM Remove permanently: fullcourtdefense uninstall-cmd-guard',
+        'if defined FCD_CMD_AUTORUN_DONE goto :eof',
+        'set FCD_CMD_AUTORUN_DONE=1',
+        ...doskeyLines,
+        '',
+    ].join('\r\n');
+}
+function readCurrentAutorun() {
+    return regString(CMD_AUTORUN_KEY, AUTORUN_VALUE) || '';
+}
+function mergeAutorunValue(current) {
+    const ours = batQuote(AUTORUN_BAT_PATH);
+    const cleaned = stripAutorunValue(current);
+    if (!cleaned.trim())
+        return ours;
+    if (cleaned.includes(AUTORUN_MARKER))
+        return ours;
+    return `${ours} & ${cleaned}`;
+}
+function stripAutorunValue(current) {
+    const ours = batQuote(AUTORUN_BAT_PATH);
+    let next = current
+        .replace(new RegExp(`${ours.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*&\\s*`, 'gi'), '')
+        .replace(new RegExp(`\\s*&\\s*${ours.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'gi'), '')
+        .replace(ours, '')
+        .replace(/^\s*&\s*|\s*&\s*$/g, '')
+        .trim();
+    return next;
+}
+function isCmdGuardInstalled() {
+    try {
+        if (process.platform !== 'win32')
+            return false;
+        if (!fs.existsSync(GUARD_JS_PATH) || !fs.existsSync(AUTORUN_BAT_PATH))
+            return false;
+        return readCurrentAutorun().includes(AUTORUN_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+function getCmdGuardStatus() {
+    if (process.platform !== 'win32') {
+        return { supported: false, installed: false, rulesPresent: false };
+    }
+    try {
+        let ruleCount;
+        let mode;
+        let rulesPresent = false;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(GUARD_RULES_PATH, 'utf8'));
+            rulesPresent = Array.isArray(parsed?.rules) && parsed.rules.length > 0;
+            ruleCount = Array.isArray(parsed?.rules) ? parsed.rules.length : undefined;
+            mode = typeof parsed?.mode === 'string' ? parsed.mode : undefined;
+        }
+        catch { /* not written yet */ }
+        const autorunValue = readCurrentAutorun();
+        return {
+            supported: true,
+            installed: isCmdGuardInstalled(),
+            autorunValue: autorunValue || undefined,
+            rulesPresent,
+            ruleCount,
+            mode,
+        };
+    }
+    catch {
+        return { supported: true, installed: false, rulesPresent: false };
+    }
+}
+/** `fullcourtdefense install-cmd-guard` — enable interactive cmd.exe blocking. */
+async function installCmdGuardCommand(_args = {}) {
+    if (process.platform !== 'win32') {
+        console.log('The cmd.exe guard currently supports Windows only.');
+        return;
+    }
+    const rules = (0, shellGuard_1.writeShellGuardRules)();
+    const nodePath = process.execPath;
+    const cliEntry = process.argv[1] || '';
+    fs.writeFileSync(GUARD_JS_PATH, buildGuardJs(nodePath, cliEntry), 'utf8');
+    fs.writeFileSync(AUTORUN_BAT_PATH, buildAutorunBat(nodePath), 'utf8');
+    console.log(`Guard rules written: ${rules.rules.length} rule(s), mode "${rules.mode}".`);
+    const current = readCurrentAutorun();
+    const merged = mergeAutorunValue(current);
+    setRegString(CMD_AUTORUN_KEY, AUTORUN_VALUE, merged);
+    console.log(`\x1b[32m✓ cmd.exe guard installed\x1b[0m \x1b[2m(AutoRun + doskey macros)\x1b[0m`);
+    console.log('\x1b[2mOpen a NEW Command Prompt window (prompt must be C:\\...> not PS C:\\...>). Dangerous commands like del /s /q C:\\ are blocked and reported.\x1b[0m');
+}
+/** `fullcourtdefense uninstall-cmd-guard` */
+async function uninstallCmdGuardCommand() {
+    if (process.platform !== 'win32') {
+        console.log('Nothing to remove on this OS.');
+        return;
+    }
+    const current = readCurrentAutorun();
+    const next = stripAutorunValue(current);
+    if (next) {
+        setRegString(CMD_AUTORUN_KEY, AUTORUN_VALUE, next);
+    }
+    else {
+        try {
+            (0, child_process_1.execFileSync)('reg', ['delete', CMD_AUTORUN_KEY, '/v', AUTORUN_VALUE, '/f'], {
+                windowsHide: true, timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'],
+            });
+        }
+        catch { /* value may already be absent */ }
+    }
+    try {
+        fs.unlinkSync(GUARD_JS_PATH);
+    }
+    catch { /* not present */ }
+    try {
+        fs.unlinkSync(AUTORUN_BAT_PATH);
+    }
+    catch { /* not present */ }
+    console.log('cmd.exe guard uninstalled. Open cmd windows keep doskey until closed.');
+}
+/** Refresh shared rules JSON when cmd guard is installed. */
+function refreshCmdGuardRules() {
+    try {
+        if (!isCmdGuardInstalled())
+            return;
+        (0, shellGuard_1.writeShellGuardRules)();
+    }
+    catch { /* best-effort */ }
+}

package/dist/commands/installAll.d.ts

@@ -12,6 +12,7 @@ export interface InstallAllArgs extends ProtectAllArgs {
     intervalMinutes?: string;
     windowsAudit?: string;
     shellGuard?: string;
+    cmdGuard?: string;
 }
 /**
  * One-click install: discover/wrap every existing MCP server, install Cursor

package/dist/commands/installAll.js

@@ -11,6 +11,7 @@ const autoProtect_1 = require("./autoProtect");
 const restartNotice_1 = require("./restartNotice");
 const windowsAudit_1 = require("./windowsAudit");
 const shellGuard_1 = require("./shellGuard");
+const cmdGuard_1 = require("./cmdGuard");
 /**
  * One-click install: discover/wrap every existing MCP server, install Cursor
  * hooks for built-in Cursor actions, optional self-heal and fleet upload.
@@ -106,6 +107,16 @@ async function installAllCommand(args, config) {
             console.log(`\x1b[33m⚠ Warning: shell guard install failed (${error instanceof Error ? error.message : String(error)}). Installation continues.\x1b[0m`);
         }
     }
+    // Interactive cmd.exe guard — same rules, doskey + AutoRun hook (no admin).
+    if (process.platform === 'win32' && args.cmdGuard !== 'false') {
+        console.log('\n\x1b[1mInstalling interactive cmd.exe shell guard…\x1b[0m');
+        try {
+            await (0, cmdGuard_1.installCmdGuardCommand)();
+        }
+        catch (error) {
+            console.log(`\x1b[33m⚠ Warning: cmd guard install failed (${error instanceof Error ? error.message : String(error)}). Installation continues.\x1b[0m`);
+        }
+    }
     if (args.autoProtect === 'true') {
         console.log('\n\x1b[1mScheduling self-healing MCP protection…\x1b[0m');
         await (0, autoProtect_1.autoProtectCommand)({

package/dist/commands/shellGuard.js

@@ -67,7 +67,7 @@ const path = __importStar(require("path"));
  *
  * Scope honesty: this covers INTERACTIVE PowerShell (PSReadLine hosts, incl.
  * IDE-integrated terminals). Non-interactive scripts are covered by ScriptBlock
- * Logging (windowsAudit.ts); native cmd.exe has no enforcement path yet.
+ * Logging (windowsAudit.ts). Native cmd.exe is covered separately (cmdGuard.ts).
  */
 const GUARD_RULES_PATH = path.join(os.homedir(), '.fullcourtdefense-shell-guard.json');
 const GUARD_PS1_PATH = path.join(os.homedir(), '.fullcourtdefense-shell-guard.ps1');
@@ -87,7 +87,9 @@ const BUILTIN_RULES = [
     { id: 'rm_rf_root', category: 'destructive_command', reason: 'recursive force delete of filesystem root', source: 'builtin',
         pattern: String.raw `\b(?:sudo\s+)?rm\s+-[a-z]*r[a-z]*f[a-z]*\s+(?:["']?/["']?|\*)(?:\s|$|[;&|])` },
     { id: 'windows_drive_delete', category: 'destructive_command', reason: 'recursive Windows drive delete', source: 'builtin',
-        pattern: String.raw `\b(?:del|erase)\s+/[a-z]*s[a-z]*\s+/[a-z]*q[a-z]*\s+[a-z]:\\` },
+        pattern: String.raw `\b(?:del|erase)\s+/[a-z]*s[a-z]*\s+/[a-z]*q[a-z]*\s+[a-z]:\\?(?:\s|$|[\\/])` },
+    { id: 'windows_drive_rmdir', category: 'destructive_command', reason: 'recursive Windows drive remove directory', source: 'builtin',
+        pattern: String.raw `\b(?:rd|rmdir)\s+/[a-z]*s[a-z]*\s+/[a-z]*q[a-z]*\s+[a-z]:\\?(?:\s|$|[\\/])` },
     { id: 'windows_drive_delete', category: 'destructive_command', reason: 'recursive Remove-Item on a drive root', source: 'builtin',
         pattern: String.raw `\bremove-item\b(?=.*-recurse)(?=.*-force)(?=.*\s[a-z]:[\\/]?(?:\s|$))` },
     { id: 'format_drive', category: 'destructive_command', reason: 'drive format command', source: 'builtin',

package/dist/index.js

@@ -52,6 +52,7 @@ const installAll_1 = require("./commands/installAll");
 const autoProtect_1 = require("./commands/autoProtect");
 const windowsAudit_1 = require("./commands/windowsAudit");
 const shellGuard_1 = require("./commands/shellGuard");
+const cmdGuard_1 = require("./commands/cmdGuard");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function readCliVersion() {
@@ -130,6 +131,8 @@ function printHelp() {
     install-shell-guard    Block dangerous commands typed in PowerShell terminals
                 (real-time, offline rule cache). uninstall-shell-guard removes it;
                 shell-guard-status shows coverage.
+    install-cmd-guard      Block dangerous commands typed in cmd.exe (Command Prompt).
+                uninstall-cmd-guard removes it; cmd-guard-status shows coverage.
     scan        Runs the scan. Use --local for inside-organization scans.
     discover    Finds MCP servers, local secrets, agent rules/skills, and machine
                 blast radius on this laptop. Use --surface all --upload for AI Fleet.
@@ -600,6 +603,8 @@ async function main() {
                 autoProtect: flags['auto-protect'],
                 intervalMinutes: flags['interval-minutes'],
                 windowsAudit: flags['windows-audit'],
+                shellGuard: flags['shell-guard'],
+                cmdGuard: flags['cmd-guard'],
             };
             await (0, installAll_1.installAllCommand)(args, config);
             break;
@@ -632,6 +637,28 @@ async function main() {
             console.log('');
             break;
         }
+        case 'install-cmd-guard': {
+            await (0, cmdGuard_1.installCmdGuardCommand)();
+            break;
+        }
+        case 'uninstall-cmd-guard': {
+            await (0, cmdGuard_1.uninstallCmdGuardCommand)();
+            break;
+        }
+        case 'cmd-guard-status': {
+            const status = (0, cmdGuard_1.getCmdGuardStatus)();
+            if (!status.supported) {
+                console.log('cmd guard supports Windows Command Prompt only.');
+                break;
+            }
+            console.log(`\nInteractive cmd.exe shell guard: ${status.installed ? '\x1b[32minstalled\x1b[0m' : '\x1b[31mnot installed\x1b[0m'}`);
+            if (status.autorunValue)
+                console.log(`  AutoRun: \x1b[2m${status.autorunValue}\x1b[0m`);
+            if (status.rulesPresent)
+                console.log(`  Rules: ${status.ruleCount} (mode: ${status.mode || 'block'})`);
+            console.log('');
+            break;
+        }
         case 'install-mcp-gateway': {
             await (0, mcpGateway_1.installMcpGatewayCommand)(buildInstallArgs(), config);
             break;

package/dist/telemetry.js

@@ -44,6 +44,7 @@ const path = __importStar(require("path"));
 const machineIdentity_1 = require("./machineIdentity");
 const windowsAudit_1 = require("./commands/windowsAudit");
 const shellGuard_1 = require("./commands/shellGuard");
+const cmdGuard_1 = require("./commands/cmdGuard");
 /**
  * Local-first telemetry: every enforcement decision is appended to an on-disk
  * spool (instant, offline-safe) and flushed to the backend in batches. Critical
@@ -110,9 +111,10 @@ function rewriteSpool(remaining) {
 }
 /** Drain the spool to the backend in one batch (+ optional heartbeat). Returns accepted count. */
 async function flushSpool(input) {
-    // Piggyback on the flush cycle to re-sync the interactive shell guard's rule
-    // cache (mode flips + new custom rules reach open-terminal machines in ~30s).
+    // Piggyback on the flush cycle to re-sync terminal guard rule caches (mode flips
+    // + new custom rules reach open shells within ~30s).
     (0, shellGuard_1.refreshShellGuardRules)();
+    (0, cmdGuard_1.refreshCmdGuardRules)();
     const all = readSpool();
     const batch = all.slice(0, MAX_BATCH);
     const overflow = all.slice(MAX_BATCH);

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.10.0"
+  "version": "1.11.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -18,6 +18,7 @@
     "test:taint-ledger": "npm run build && node scripts/test-taint-ledger.js",
     "test:shell-audit": "npm run build && node scripts/test-shell-audit.js",
     "test:shell-guard": "npm run build && node scripts/test-shell-guard.js",
+    "test:cmd-guard": "npm run build && node scripts/test-cmd-guard.js",
     "test:ping-e2e": "npm run build && node scripts/test-ping-e2e.js",
     "prepublishOnly": "npm run build"
   },