fullcourtdefense-cli 1.8.0 → 1.9.0

package/dist/commands/discover.d.ts

@@ -1,4 +1,5 @@
 import { BotGuardConfig } from '../config';
+import { type ShellAuditReport } from './windowsAudit';
 export type DiscoverSurface = 'mcp' | 'secrets' | 'agent-files' | 'posture';
 export interface DiscoverArgs {
     type?: string;
@@ -57,6 +58,8 @@ export interface DesktopDiscoveryHost {
     user: string;
     scannedAt: string;
     probeMode: 'config' | 'deep';
+    /** Windows-only: PowerShell audit coverage (ScriptBlock Logging + Transcription). */
+    shellAudit?: ShellAuditReport;
 }
 export declare function discoverCommand(args: DiscoverArgs, config: BotGuardConfig): Promise<void>;
 /** Upload-only discover — used after install-mcp-gateway --upload. */

package/dist/commands/discover.js

@@ -47,6 +47,7 @@ const knownMcpServers_1 = require("./knownMcpServers");
 const discoverAgentFiles_1 = require("./discoverAgentFiles");
 const discoverBlastRadius_1 = require("./discoverBlastRadius");
 const discoverSecrets_1 = require("./discoverSecrets");
+const windowsAudit_1 = require("./windowsAudit");
 const DEFAULT_API_URL = 'https://api.fullcourtdefense.ai';
 function parseSurfaces(args) {
     const raw = (args.surface || args.type || 'mcp').toLowerCase().trim();
@@ -101,6 +102,7 @@ function buildHostMetadata(userEmail, probeMode = 'config') {
         user: userEmail || info.username,
         scannedAt: new Date().toISOString(),
         probeMode,
+        shellAudit: (0, windowsAudit_1.getShellAuditReport)(),
     };
 }
 /** Where MCP client configs live — see discoverPaths.ts for the canonical list. */

package/dist/commands/installAll.d.ts

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

package/dist/commands/installAll.js

@@ -9,6 +9,7 @@ const discoverSchedule_1 = require("./discoverSchedule");
 const mcpGateway_1 = require("./mcpGateway");
 const autoProtect_1 = require("./autoProtect");
 const restartNotice_1 = require("./restartNotice");
+const windowsAudit_1 = require("./windowsAudit");
 /**
  * One-click install: discover/wrap every existing MCP server, install Cursor
  * hooks for built-in Cursor actions, optional self-heal and fleet upload.
@@ -65,6 +66,33 @@ async function installAllCommand(args, config) {
             console.log(`Claude-format hooks skipped: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    // Windows-wide command auditing — PowerShell ScriptBlock Logging + Transcription.
+    // Covers commands typed in ANY PowerShell (inside or outside the IDE), not just
+    // agent-driven actions. Requires ONE admin (UAC) approval; failure is a warning,
+    // never an install blocker — missing coverage shows on the fleet dashboard.
+    if (process.platform === 'win32' && args.windowsAudit !== 'false') {
+        console.log('\n\x1b[1mEnabling Windows PowerShell audit logging (ScriptBlock Logging + Transcription)…\x1b[0m');
+        try {
+            const current = (0, windowsAudit_1.getWindowsAuditStatus)();
+            if (current.scriptBlockLogging && current.transcription) {
+                console.log('\x1b[32m✓ Already enabled — every PowerShell command on this machine is logged.\x1b[0m');
+            }
+            else {
+                console.log('\x1b[2mWindows will show an admin approval prompt (UAC). Approve it to enable machine-wide command auditing.\x1b[0m');
+                const result = (0, windowsAudit_1.enableWindowsAudit)();
+                if (result.ok) {
+                    console.log(`\x1b[32m✓ ${result.message}\x1b[0m`);
+                }
+                else {
+                    console.log(`\x1b[33m⚠ Warning: ${result.message}\x1b[0m`);
+                    console.log('\x1b[33m  Installation continues — this machine will show as "audit logging missing" in the fleet dashboard.\x1b[0m');
+                }
+            }
+        }
+        catch (error) {
+            console.log(`\x1b[33m⚠ Warning: PowerShell audit logging step 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/windowsAudit.d.ts

@@ -0,0 +1,47 @@
+export interface WindowsAuditStatus {
+    /** False on non-Windows platforms (audit logging is a Windows feature). */
+    supported: boolean;
+    scriptBlockLogging: boolean;
+    transcription: boolean;
+    transcriptionPath?: string;
+    checkedAt: string;
+}
+/** Shape reported to the backend (discovery host payload + heartbeat). */
+export interface ShellAuditReport {
+    platform: string;
+    scriptBlockLogging: boolean;
+    transcription: boolean;
+    transcriptionPath?: string;
+    checkedAt: string;
+}
+/** Probe current audit coverage. Read-only, no elevation needed, never throws. */
+export declare function getWindowsAuditStatus(): WindowsAuditStatus;
+/**
+ * Compact status for the discovery host payload and telemetry heartbeat.
+ * Returns undefined on non-Windows so the field is simply omitted.
+ * Never throws — telemetry/discovery must not break on a probe failure.
+ */
+export declare function getShellAuditReport(): ShellAuditReport | undefined;
+export interface EnableWindowsAuditResult {
+    ok: boolean;
+    status: WindowsAuditStatus;
+    /** Human-readable outcome, printable as-is. */
+    message: string;
+    /** True when the user saw (and answered) a UAC elevation prompt. */
+    promptShown: boolean;
+}
+/**
+ * Enable ScriptBlock Logging + Transcription via ONE UAC elevation prompt.
+ * Skips silently when already fully enabled. Never throws; on any failure
+ * (UAC declined, no admin, GPO conflict) returns ok=false with a warning
+ * message — callers must treat that as non-blocking.
+ */
+export declare function enableWindowsAudit(): EnableWindowsAuditResult;
+export interface WindowsAuditArgs {
+    enable?: string;
+}
+/**
+ * `fullcourtdefense windows-audit` — show (default) or enable (--enable)
+ * Windows PowerShell audit coverage on this machine.
+ */
+export declare function windowsAuditCommand(args: WindowsAuditArgs): Promise<void>;

package/dist/commands/windowsAudit.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.getWindowsAuditStatus = getWindowsAuditStatus;
+exports.getShellAuditReport = getShellAuditReport;
+exports.enableWindowsAudit = enableWindowsAudit;
+exports.windowsAuditCommand = windowsAuditCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Windows PowerShell audit coverage — ScriptBlock Logging + Transcription.
+ *
+ * Both are built-in Windows engine features (no agent, no driver): once the
+ * HKLM policy keys are set, PowerShell itself records every script block it
+ * executes (event 4104 — including decoded/obfuscated code, scripts run as
+ * files, and PowerShell spawned by other processes) and writes full session
+ * transcripts. That closes the biggest endpoint blind spot: dangerous commands
+ * that never pass through an IDE hook or interactive prompt.
+ *
+ * The keys live under HKLM\SOFTWARE\Policies so writing them requires
+ * elevation — `enableWindowsAudit()` triggers ONE UAC prompt via
+ * `Start-Process -Verb RunAs`. Reading them needs no elevation, so coverage
+ * status is probed freely by `install-all`, `discover --upload`, and every
+ * telemetry heartbeat (which is how the fleet dashboard knows which machines
+ * are covered).
+ *
+ * Fail-open by design: enable failures (UAC declined, no admin rights,
+ * GPO-managed) NEVER block an install — they surface as a warning locally and
+ * as missing coverage in the Devices & MCP fleet view.
+ */
+const SBL_KEY = 'HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\ScriptBlockLogging';
+const TRANSCRIPTION_KEY = 'HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\Transcription';
+/** Read a REG_DWORD value; returns undefined when the key/value is absent. */
+function regDword(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_DWORD\\s+0x([0-9a-fA-F]+)`));
+        return match ? parseInt(match[1], 16) : undefined;
+    }
+    catch {
+        return undefined; // key or value missing → not enabled
+    }
+}
+/** Read a REG_SZ value; returns undefined when the key/value is absent. */
+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;
+    }
+}
+/** Probe current audit coverage. Read-only, no elevation needed, never throws. */
+function getWindowsAuditStatus() {
+    const checkedAt = new Date().toISOString();
+    if (process.platform !== 'win32') {
+        return { supported: false, scriptBlockLogging: false, transcription: false, checkedAt };
+    }
+    return {
+        supported: true,
+        scriptBlockLogging: regDword(SBL_KEY, 'EnableScriptBlockLogging') === 1,
+        transcription: regDword(TRANSCRIPTION_KEY, 'EnableTranscripting') === 1,
+        transcriptionPath: regString(TRANSCRIPTION_KEY, 'OutputDirectory'),
+        checkedAt,
+    };
+}
+/**
+ * Compact status for the discovery host payload and telemetry heartbeat.
+ * Returns undefined on non-Windows so the field is simply omitted.
+ * Never throws — telemetry/discovery must not break on a probe failure.
+ */
+function getShellAuditReport() {
+    try {
+        if (process.platform !== 'win32')
+            return undefined;
+        const status = getWindowsAuditStatus();
+        return {
+            platform: 'win32',
+            scriptBlockLogging: status.scriptBlockLogging,
+            transcription: status.transcription,
+            transcriptionPath: status.transcriptionPath,
+            checkedAt: status.checkedAt,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultTranscriptDir() {
+    const programData = process.env.ProgramData || 'C:\\ProgramData';
+    return path.join(programData, 'FullCourtDefense', 'Transcripts');
+}
+/** The elevated payload: sets both policy keys + creates the transcript dir. */
+function buildEnableScript(transcriptDir) {
+    return [
+        `$ErrorActionPreference = 'Stop'`,
+        `$sbl = 'HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\ScriptBlockLogging'`,
+        `New-Item -Path $sbl -Force | Out-Null`,
+        `New-ItemProperty -Path $sbl -Name EnableScriptBlockLogging -Value 1 -PropertyType DWord -Force | Out-Null`,
+        `$tr = 'HKLM:\\SOFTWARE\\Policies\\Microsoft\\Windows\\PowerShell\\Transcription'`,
+        `New-Item -Path $tr -Force | Out-Null`,
+        `New-ItemProperty -Path $tr -Name EnableTranscripting -Value 1 -PropertyType DWord -Force | Out-Null`,
+        `New-ItemProperty -Path $tr -Name EnableInvocationHeader -Value 1 -PropertyType DWord -Force | Out-Null`,
+        `$dir = '${transcriptDir.replace(/'/g, "''")}'`,
+        `New-Item -ItemType Directory -Path $dir -Force | Out-Null`,
+        `New-ItemProperty -Path $tr -Name OutputDirectory -Value $dir -PropertyType String -Force | Out-Null`,
+    ].join('\r\n') + '\r\n';
+}
+/**
+ * Enable ScriptBlock Logging + Transcription via ONE UAC elevation prompt.
+ * Skips silently when already fully enabled. Never throws; on any failure
+ * (UAC declined, no admin, GPO conflict) returns ok=false with a warning
+ * message — callers must treat that as non-blocking.
+ */
+function enableWindowsAudit() {
+    const before = getWindowsAuditStatus();
+    if (!before.supported) {
+        return { ok: false, status: before, promptShown: false, message: 'PowerShell audit logging is a Windows feature — skipped on this OS.' };
+    }
+    if (before.scriptBlockLogging && before.transcription) {
+        return { ok: true, status: before, promptShown: false, message: 'PowerShell audit logging already enabled (ScriptBlock Logging + Transcription).' };
+    }
+    const transcriptDir = before.transcriptionPath || defaultTranscriptDir();
+    const scriptPath = path.join(os.tmpdir(), `fcd-enable-audit-${process.pid}.ps1`);
+    const elevatePath = path.join(os.tmpdir(), `fcd-elevate-audit-${process.pid}.ps1`);
+    let promptShown = false;
+    try {
+        fs.writeFileSync(scriptPath, buildEnableScript(transcriptDir), 'utf8');
+        // Outer (unelevated) launcher script asks Windows to run the payload
+        // elevated. Using -File for BOTH scripts avoids inline -Command quoting
+        // pitfalls (paths with spaces, nested quotes). -Wait blocks until the
+        // elevated child finishes so the recheck below is accurate; if the user
+        // clicks "No" on UAC, Start-Process throws and the launcher exits 1.
+        const quotedPayload = `"${scriptPath}"`.replace(/'/g, "''");
+        fs.writeFileSync(elevatePath, [
+            `$ErrorActionPreference = 'Stop'`,
+            `try {`,
+            `  $p = Start-Process -FilePath 'powershell.exe' -Verb RunAs -Wait -PassThru -WindowStyle Hidden -ArgumentList @('-NoProfile','-ExecutionPolicy','Bypass','-File','${quotedPayload}')`,
+            `  exit $p.ExitCode`,
+            `} catch {`,
+            `  exit 1`,
+            `}`,
+        ].join('\r\n') + '\r\n', 'utf8');
+        promptShown = true;
+        const result = (0, child_process_1.spawnSync)('powershell.exe', [
+            '-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', elevatePath,
+        ], { encoding: 'utf8', windowsHide: true, timeout: 120000 });
+        const after = getWindowsAuditStatus();
+        if (after.scriptBlockLogging && after.transcription) {
+            return {
+                ok: true, status: after, promptShown,
+                message: `PowerShell audit logging enabled — ScriptBlock Logging + Transcription (transcripts: ${after.transcriptionPath || transcriptDir}).`,
+            };
+        }
+        const declined = result.status !== 0;
+        return {
+            ok: false, status: after, promptShown,
+            message: declined
+                ? 'PowerShell audit logging NOT enabled — the admin prompt was declined or elevation failed. Re-run `fullcourtdefense install-all` (or `fullcourtdefense windows-audit --enable`) and approve the prompt, or ask IT to enable it via GPO/Intune.'
+                : 'PowerShell audit logging could not be verified after the elevated write — the keys may be managed by Group Policy. Ask IT to enable ScriptBlock Logging + Transcription via GPO/Intune.',
+        };
+    }
+    catch (error) {
+        return {
+            ok: false, status: getWindowsAuditStatus(), promptShown,
+            message: `PowerShell audit logging NOT enabled (${error instanceof Error ? error.message : String(error)}). Re-run elevated or ask IT to enable via GPO/Intune.`,
+        };
+    }
+    finally {
+        try {
+            fs.unlinkSync(scriptPath);
+        }
+        catch { /* best effort */ }
+        try {
+            fs.unlinkSync(elevatePath);
+        }
+        catch { /* best effort */ }
+    }
+}
+/**
+ * `fullcourtdefense windows-audit` — show (default) or enable (--enable)
+ * Windows PowerShell audit coverage on this machine.
+ */
+async function windowsAuditCommand(args) {
+    if (process.platform !== 'win32') {
+        console.log('PowerShell audit logging is a Windows feature — nothing to do on this OS.');
+        return;
+    }
+    if (args.enable === 'true') {
+        console.log('Enabling PowerShell audit logging (ScriptBlock Logging + Transcription)…');
+        console.log('\x1b[2mWindows will show an admin approval prompt (UAC). Approve it to enable machine-wide command auditing.\x1b[0m');
+        const result = enableWindowsAudit();
+        console.log(result.ok ? `\x1b[32m✓ ${result.message}\x1b[0m` : `\x1b[33m⚠ ${result.message}\x1b[0m`);
+        return;
+    }
+    const status = getWindowsAuditStatus();
+    const mark = (on) => (on ? '\x1b[32m✓ enabled\x1b[0m' : '\x1b[31m✗ disabled\x1b[0m');
+    console.log('\n\x1b[1mWindows PowerShell audit coverage\x1b[0m');
+    console.log(`  ScriptBlock Logging (event 4104):  ${mark(status.scriptBlockLogging)}`);
+    console.log(`  Transcription (session recording): ${mark(status.transcription)}${status.transcriptionPath ? ` \x1b[2m→ ${status.transcriptionPath}\x1b[0m` : ''}`);
+    if (!status.scriptBlockLogging || !status.transcription) {
+        console.log('\n  Enable with: \x1b[1mfullcourtdefense windows-audit --enable\x1b[0m (requires one admin approval)');
+    }
+    console.log('');
+}

package/dist/index.js

@@ -50,6 +50,7 @@ const installClaudeHook_1 = require("./commands/installClaudeHook");
 const mcpGateway_1 = require("./commands/mcpGateway");
 const installAll_1 = require("./commands/installAll");
 const autoProtect_1 = require("./commands/autoProtect");
+const windowsAudit_1 = require("./commands/windowsAudit");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function readCliVersion() {
@@ -123,6 +124,8 @@ function printHelp() {
                 install available runtime hooks for built-in actions. No folder path
                 or --mcp-command needed. Use --hooks false to skip runtime hooks.
     install     Alias for install-all.
+    windows-audit  Show Windows PowerShell audit coverage (ScriptBlock Logging +
+                Transcription). Use --enable to turn it on (one admin prompt).
     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.
@@ -592,10 +595,16 @@ async function main() {
                 discover: flags.discover,
                 autoProtect: flags['auto-protect'],
                 intervalMinutes: flags['interval-minutes'],
+                windowsAudit: flags['windows-audit'],
             };
             await (0, installAll_1.installAllCommand)(args, config);
             break;
         }
+        case 'windows-audit': {
+            const args = { enable: flags.enable };
+            await (0, windowsAudit_1.windowsAuditCommand)(args);
+            break;
+        }
         case 'install-mcp-gateway': {
             await (0, mcpGateway_1.installMcpGatewayCommand)(buildInstallArgs(), config);
             break;

package/dist/telemetry.js

@@ -42,6 +42,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const machineIdentity_1 = require("./machineIdentity");
+const windowsAudit_1 = require("./commands/windowsAudit");
 /**
  * Local-first telemetry: every enforcement decision is appended to an on-disk
  * spool (instant, offline-safe) and flushed to the backend in batches. Critical
@@ -125,7 +126,16 @@ async function flushSpool(input) {
                 shieldId: input.shieldId,
                 machineId: identity.machineId,
                 heartbeat: input.heartbeat
-                    ? { agentVersion: input.agentVersion, integrityOk: input.integrityOk, coverage: 'hooks' }
+                    ? {
+                        agentVersion: input.agentVersion,
+                        integrityOk: input.integrityOk,
+                        coverage: 'hooks',
+                        hostname: identity.hostname,
+                        // Windows-only: current PowerShell audit coverage (ScriptBlock
+                        // Logging + Transcription). Keeps the fleet dashboard's coverage
+                        // fresh on every ping — undefined (omitted) on other platforms.
+                        shellAudit: (0, windowsAudit_1.getShellAuditReport)(),
+                    }
                     : undefined,
                 events: batch,
             }),

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.8.0"
+  "version": "1.9.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -16,6 +16,8 @@
     "build": "tsc && node scripts/copy-attack-corpus.js",
     "test:deterministic-guard": "npm run build && node scripts/test-deterministic-guard.js",
     "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:ping-e2e": "npm run build && node scripts/test-ping-e2e.js",
     "prepublishOnly": "npm run build"
   },
   "keywords": [