fullcourtdefense-cli 1.22.7 → 1.22.8

package/dist/commands/uninstallAll.js

@@ -33,10 +33,20 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFcdConfigBackups = listFcdConfigBackups;
+exports.removeFcdConfigBackups = removeFcdConfigBackups;
+exports.purgeLocalState = purgeLocalState;
+exports.parseMsiProductCodeFromRegOutput = parseMsiProductCodeFromRegOutput;
+exports.findMsiProductCode = findMsiProductCode;
+exports.detachCommand = detachCommand;
+exports.reportUninstallToFleet = reportUninstallToFleet;
 exports.uninstallAllCommand = uninstallAllCommand;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const machineIdentity_1 = require("../machineIdentity");
 const daemon_1 = require("./daemon");
 const autoProtect_1 = require("./autoProtect");
 const mcpGateway_1 = require("./mcpGateway");
@@ -46,25 +56,190 @@ const installClaudeHook_1 = require("./installClaudeHook");
 const shellGuard_1 = require("./shellGuard");
 const posixShellGuard_1 = require("./posixShellGuard");
 const cmdGuard_1 = require("./cmdGuard");
+const credentialStore_1 = require("../credentialStore");
+const machineKeyFile_1 = require("../machineKeyFile");
+const selfUpdate_1 = require("../selfUpdate");
+const backupManifest_1 = require("../backupManifest");
 const BOLD = '\x1b[1m';
 const GREEN = '\x1b[32m';
 const YELLOW = '\x1b[33m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 /**
- * `fullcourtdefense uninstall` — ONE command that reverses `onboard`/`install-all`:
- * daemon autostart, self-heal schedule, MCP gateway wraps, IDE hooks, terminal
- * guards, and the daily discovery schedule. Each step is best-effort so a
- * single failure never leaves the rest of the machine half-uninstalled.
- *
- * Machine credentials (~/.fullcourtdefense.yml) and local state are KEPT by
- * default so the machine can re-onboard without a new enrollment token; pass
- * `--purge true` to delete them too. The fleet record in the dashboard is not
- * touched — deprovision it from the console (Machines → machine → Deprovision).
+ * Directories where MCP-config edits leave `*.fcd-backup-*` safety copies
+ * (see backupFile() in mcpGateway.ts). Scanned non-recursively on purge so a
+ * full uninstall leaves no copies of configs — which can embed live
+ * credentials — behind. Project-local backups (e.g. repo .cursor/mcp.json)
+ * cannot be enumerated from here and are called out in the final message.
  */
-async function uninstallAllCommand(args, config) {
-    console.log(`\n${BOLD}\x1b[36mFullCourtDefense — uninstall local protection${RESET}`);
-    console.log(`${DIM}Daemon -> self-heal schedule -> MCP gateways -> IDE hooks -> terminal guards -> discovery schedule.${RESET}\n`);
+function fcdBackupSearchDirs() {
+    const home = os.homedir();
+    const dirs = [
+        home,
+        path.join(home, '.cursor'),
+        path.join(home, '.claude'),
+        path.join(home, '.codex'),
+        path.join(home, '.gemini'),
+        path.join(home, '.kiro', 'settings'),
+        path.join(home, '.codeium', 'windsurf'),
+    ];
+    if (process.platform === 'win32' && process.env.APPDATA) {
+        dirs.push(path.join(process.env.APPDATA, 'Claude'));
+        dirs.push(path.join(process.env.APPDATA, 'Code', 'User'));
+    }
+    else if (process.platform === 'darwin') {
+        dirs.push(path.join(home, 'Library', 'Application Support', 'Claude'));
+        dirs.push(path.join(home, 'Library', 'Application Support', 'Code', 'User'));
+    }
+    else {
+        dirs.push(path.join(home, '.config', 'Claude'));
+        dirs.push(path.join(home, '.config', 'Code', 'User'));
+    }
+    return dirs;
+}
+/**
+ * Every `*.fcd-backup-*` config safety copy: the known client dirs (scan)
+ * union-ed with the backup manifest, which records PROJECT-LOCAL backups
+ * (a repo's .cursor/mcp.json.fcd-backup-*) that no directory scan can find.
+ * The scan still covers backups created by pre-manifest CLI versions.
+ */
+function listFcdConfigBackups() {
+    const found = new Set();
+    for (const dir of fcdBackupSearchDirs()) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            continue; // dir absent — fine
+        }
+        for (const entry of entries) {
+            if (entry.includes('.fcd-backup-'))
+                found.add(path.join(dir, entry));
+        }
+    }
+    for (const entry of (0, backupManifest_1.readBackupManifest)()) {
+        try {
+            if (entry.includes('.fcd-backup-') && fs.existsSync(entry))
+                found.add(entry);
+        }
+        catch { /* unreadable path — skip */ }
+    }
+    return [...found];
+}
+/** Delete every known `*.fcd-backup-*` config safety copy (scan + manifest). */
+function removeFcdConfigBackups() {
+    const removed = [];
+    const failures = [];
+    for (const file of listFcdConfigBackups()) {
+        try {
+            fs.rmSync(file, { force: true });
+            removed.push(file);
+        }
+        catch {
+            failures.push(file);
+        }
+    }
+    (0, backupManifest_1.pruneBackupManifest)();
+    return { removed, failures };
+}
+/**
+ * Delete all local FullCourtDefense state: config + spool + logs, the
+ * ~/.fullcourtdefense dir (machine key file lives inside), the Credential
+ * Manager entry, %LOCALAPPDATA%\FullCourtDefense, and config backups.
+ */
+function purgeLocalState(config) {
+    const failures = [];
+    const home = os.homedir();
+    // Credential Manager entry first — needs the shieldId from config, which the
+    // file deletions below would erase.
+    if (process.platform === 'win32' && config.shieldId) {
+        (0, credentialStore_1.deleteShieldKeyNative)(config.shieldId);
+    }
+    (0, machineKeyFile_1.deleteMachineKeyFile)();
+    // Config backups BEFORE the state dirs: the backup manifest (which knows the
+    // project-local backup paths) lives inside ~/.fullcourtdefense — deleting
+    // that dir first would orphan every repo-local credential backup.
+    const backups = removeFcdConfigBackups();
+    for (const file of backups.removed)
+        console.log(`${DIM}  removed ${file}${RESET}`);
+    for (const file of backups.failures) {
+        failures.push(file);
+        console.log(`${YELLOW}  ⚠ could not remove ${file}${RESET}`);
+    }
+    const targets = [
+        path.join(home, '.fullcourtdefense.yml'),
+        path.join(home, '.fullcourtdefense-spool.jsonl'),
+        path.join(home, '.fullcourtdefense-runtime.json'),
+        path.join(home, '.fullcourtdefense-hook.log'),
+        path.join(home, '.fullcourtdefense'),
+    ];
+    if (process.platform === 'win32' && process.env.LOCALAPPDATA) {
+        targets.push(path.join(process.env.LOCALAPPDATA, 'FullCourtDefense'));
+    }
+    for (const target of targets) {
+        try {
+            if (!fs.existsSync(target))
+                continue;
+            fs.rmSync(target, { recursive: true, force: true });
+            console.log(`${DIM}  removed ${target}${RESET}`);
+        }
+        catch (error) {
+            failures.push(target);
+            console.log(`${YELLOW}  ⚠ could not remove ${target}: ${error instanceof Error ? error.message : String(error)}${RESET}`);
+        }
+    }
+    return { failures };
+}
+/**
+ * Product code of the installed FullCourtDefense MSI, from the registry
+ * uninstall hive (both 64-bit and WOW6432Node views). Undefined on npm
+ * installs or when the MSI entry is missing.
+ */
+function parseMsiProductCodeFromRegOutput(output) {
+    // `reg query … /s /f FullCourtDefense /d` prints the matching key path line
+    // followed by its matching values. We want the {GUID} keyed entry whose
+    // DisplayName is FullCourtDefense.
+    const lines = output.split(/\r?\n/);
+    let currentGuid;
+    for (const line of lines) {
+        const keyMatch = line.match(/\\Uninstall\\(\{[0-9A-Fa-f-]{36}\})\s*$/);
+        if (keyMatch) {
+            currentGuid = keyMatch[1];
+            continue;
+        }
+        if (currentGuid && /DisplayName\s+REG_SZ\s+FullCourtDefense\s*$/i.test(line.trim())) {
+            return currentGuid;
+        }
+    }
+    return undefined;
+}
+function findMsiProductCode() {
+    if (process.platform !== 'win32')
+        return undefined;
+    const hives = [
+        'HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
+        'HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall',
+    ];
+    for (const hive of hives) {
+        const query = (0, child_process_1.spawnSync)('reg', ['query', hive, '/s', '/f', 'FullCourtDefense', '/d'], {
+            encoding: 'utf8', windowsHide: true, timeout: 30_000,
+        });
+        if (query.status !== 0 || !query.stdout)
+            continue;
+        const code = parseMsiProductCodeFromRegOutput(query.stdout);
+        if (code)
+            return code;
+    }
+    return undefined;
+}
+/**
+ * The shared local teardown: daemon autostart, self-heal schedule, MCP gateway
+ * wraps, IDE hooks, terminal guards, and the daily discovery schedule. Each
+ * step is best-effort so a single failure never leaves the machine
+ * half-detached. Returns the labels of failed steps.
+ */
+async function runLocalDetach(args, config) {
     const steps = [
         { label: 'Resident daemon + autostart', run: () => (0, daemon_1.daemonCommand)({ ...args, uninstall: 'true', quiet: 'true' }, config) },
         { label: 'Self-healing protect schedule', run: () => (0, autoProtect_1.autoProtectCommand)({ ...args, uninstall: 'true' }, config) },
@@ -93,40 +268,187 @@ async function uninstallAllCommand(args, config) {
         }
         console.log('');
     }
+    return failures;
+}
+/**
+ * `fullcourtdefense detach` — reverse `onboard`/`install-all` protection but
+ * KEEP machine credentials and the installed application, so the machine can
+ * re-onboard without a new enrollment token. This is the old `uninstall`
+ * behavior, renamed to say what it actually does.
+ */
+async function detachCommand(args, config) {
+    console.log(`\n${BOLD}\x1b[36mFullCourtDefense — detach local protection${RESET}`);
+    console.log(`${DIM}Daemon -> self-heal schedule -> MCP gateways -> IDE hooks -> terminal guards -> discovery schedule.${RESET}\n`);
+    const failures = await runLocalDetach(args, config);
     if (args.purge === 'true') {
         console.log(`${BOLD}› Local state files${RESET}`);
-        const home = os.homedir();
-        const targets = [
-            path.join(home, '.fullcourtdefense.yml'),
-            path.join(home, '.fullcourtdefense-spool.jsonl'),
-            path.join(home, '.fullcourtdefense-runtime.json'),
-            path.join(home, '.fullcourtdefense-hook.log'),
-            path.join(home, '.fullcourtdefense'),
-        ];
-        for (const target of targets) {
-            try {
-                if (!fs.existsSync(target))
-                    continue;
-                fs.rmSync(target, { recursive: true, force: true });
-                console.log(`${DIM}  removed ${target}${RESET}`);
-            }
-            catch (error) {
-                failures.push(target);
-                console.log(`${YELLOW}  ⚠ could not remove ${target}: ${error instanceof Error ? error.message : String(error)}${RESET}`);
-            }
-        }
+        failures.push(...purgeLocalState(config).failures);
         console.log('');
     }
     if (failures.length === 0) {
-        console.log(`${GREEN}${BOLD}Local protection removed.${RESET}`);
-        if (args.purge !== 'true') {
-            console.log(`${DIM}Machine credentials were kept (re-run \`fullcourtdefense onboard\` to re-protect). Use --purge true to delete all local state.${RESET}`);
-        }
+        console.log(`${GREEN}${BOLD}Protection detached.${RESET}`);
+        console.log(`${DIM}The FullCourtDefense application itself is still installed${args.purge === 'true' ? '' : ' and machine credentials were kept (re-run `fullcourtdefense onboard` to re-protect)'}.${RESET}`);
+        console.log(`${DIM}For COMPLETE removal run \`fullcourtdefense uninstall\`${process.platform === 'win32' ? ' or use Windows Settings → Apps → FullCourtDefense → Uninstall' : ''}.${RESET}`);
         console.log(`${DIM}The machine still appears in the fleet console until an admin deprovisions it (Machines → machine → Deprovision).${RESET}`);
         console.log(`${DIM}Restart your AI clients (Cursor, Claude, VS Code, …) so they reload the restored configs.${RESET}`);
     }
     else {
-        console.log(`${YELLOW}${BOLD}Uninstall finished with ${failures.length} step(s) needing attention:${RESET} ${failures.join(', ')}`);
+        console.log(`${YELLOW}${BOLD}Detach finished with ${failures.length} step(s) needing attention:${RESET} ${failures.join(', ')}`);
         process.exitCode = 1;
     }
 }
+/**
+ * Tell the fleet console this machine is being uninstalled, BEFORE the local
+ * credential purge erases the shield key we need to authenticate the call.
+ * Best-effort with a short timeout: an offline uninstall must never hang or
+ * fail because the control plane is unreachable. On success the console shows
+ * the machine as "Uninstalled" instead of silently ghosting until an admin
+ * notices the missing heartbeats.
+ */
+async function reportUninstallToFleet(config, reason) {
+    try {
+        const creds = (0, config_1.resolveCliCredentials)(config);
+        if (!creds.shieldId || !creds.shieldKey || !creds.apiUrl)
+            return false;
+        const resp = await fetch(`${creds.apiUrl}/api/cli/machines/self-report-uninstall`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'x-shield-key': creds.shieldKey },
+            body: JSON.stringify({
+                shieldId: creds.shieldId,
+                machineId: (0, machineIdentity_1.getMachineIdentity)().machineId,
+                ...(reason ? { reason: reason.slice(0, 300) } : {}),
+            }),
+            signal: AbortSignal.timeout(8_000),
+        });
+        return resp.ok;
+    }
+    catch {
+        return false; // offline / old backend — uninstall proceeds regardless
+    }
+}
+/** Launch the complete Windows uninstall for an MSI install. */
+function launchMsiUninstall(productCode) {
+    try {
+        // /passive: progress bar only — the user already expressed intent by
+        // running `uninstall`, so no second confirmation dialog. UAC still prompts
+        // (per-machine MSI), which is exactly the elevation the SYSTEM task and
+        // HKLM policy cleanup need.
+        const child = (0, child_process_1.spawn)('msiexec.exe', ['/x', productCode, '/passive'], {
+            detached: true, stdio: 'ignore', windowsHide: false,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `fullcourtdefense uninstall` — COMPLETE removal.
+ *
+ * On MSI installs (Windows): runs the local teardown + credential purge, then
+ * hands off to the Windows uninstaller (`msiexec /x`) so the SYSTEM updater
+ * task, HKLM audit policies, and the installed application are all removed in
+ * the same flow — one command, one UAC prompt, machine back to its pre-FCD
+ * state. On npm installs: local teardown + purge, then tells the user the one
+ * remaining step (removing the npm package itself).
+ *
+ * To detach protection but keep credentials/the app, use `fullcourtdefense
+ * detach` instead.
+ */
+async function uninstallAllCommand(args, config) {
+    const isMsi = process.platform === 'win32' && (0, selfUpdate_1.detectInstallKind)() === 'msi';
+    const msiHandoff = isMsi && args.localOnly !== 'true';
+    console.log(`\n${BOLD}\x1b[36mFullCourtDefense — complete uninstall${RESET}`);
+    if (msiHandoff) {
+        console.log(`${DIM}This machine was installed with the Windows installer (MSI). After the local teardown, the Windows uninstaller will launch to remove the SYSTEM updater task, machine-wide audit policies, and the application itself.${RESET}\n`);
+    }
+    else {
+        console.log(`${DIM}Daemon -> self-heal schedule -> MCP gateways -> IDE hooks -> terminal guards -> discovery schedule -> local state.${RESET}\n`);
+    }
+    // Report to the fleet FIRST — the credential purge below erases the shield
+    // key this call authenticates with.
+    console.log(`${BOLD}› Reporting uninstall to the fleet console${RESET}`);
+    const fleetNotified = await reportUninstallToFleet(config, args.reason);
+    console.log(fleetNotified
+        ? `${DIM}  fleet console notified — the machine is now marked as uninstalled${RESET}`
+        : `${DIM}  could not reach the fleet console (offline or already detached) — continuing${RESET}`);
+    console.log('');
+    const failures = await runLocalDetach(args, config);
+    // Complete removal always purges: keeping credential files around after an
+    // uninstall is exactly the leftover users complain about. `detach` is the
+    // command that preserves them.
+    console.log(`${BOLD}› Local state files (credentials, caches, config backups)${RESET}`);
+    failures.push(...purgeLocalState(config).failures);
+    console.log('');
+    // PowerShell audit policies (HKLM ScriptBlockLogging + Transcription): the
+    // MSI uninstaller removes them itself, so only the non-MSI path cleans them
+    // here — otherwise a customer who enabled `--windows-audit` via an npm
+    // install keeps machine-wide policies after "uninstall" said it was done.
+    // Only FCD-attributed policies are touched (transcript dir is ours); a GPO
+    // pointing elsewhere is not ours to remove. One UAC prompt, fail-open.
+    if (process.platform === 'win32' && !msiHandoff) {
+        const { getWindowsAuditStatus, disableWindowsAudit } = await Promise.resolve().then(() => __importStar(require('./windowsAudit')));
+        const audit = getWindowsAuditStatus();
+        const fcdAttributed = /fullcourtdefense/i.test(audit.transcriptionPath || '');
+        if ((audit.scriptBlockLogging || audit.transcription) && fcdAttributed) {
+            console.log(`${BOLD}› PowerShell audit policies (HKLM) — approve the admin prompt to remove them${RESET}`);
+            const result = disableWindowsAudit();
+            console.log(result.ok ? `${DIM}  ${result.message}${RESET}` : `${YELLOW}  ⚠ ${result.message}${RESET}`);
+            if (!result.ok)
+                failures.push('PowerShell audit policies (HKLM)');
+            console.log('');
+        }
+    }
+    if (msiHandoff) {
+        const productCode = findMsiProductCode();
+        if (productCode && launchMsiUninstall(productCode)) {
+            console.log(`${GREEN}${BOLD}Local teardown done — Windows uninstaller launched.${RESET}`);
+            console.log(`${DIM}Approve the Windows elevation prompt (UAC) to finish. That step removes the "FullCourtDefense Updater" SYSTEM task, the HKLM PowerShell audit policies FCD enabled, and the application files under Program Files.${RESET}`);
+            console.log(`${YELLOW}If you decline the prompt, those privileged components STAY INSTALLED — re-run the uninstall from Windows Settings → Apps → FullCourtDefense.${RESET}`);
+            console.log(`${DIM}When the Windows uninstaller finishes, confirm a clean machine with: npx fullcourtdefense-cli verify-removed${RESET}`);
+        }
+        else {
+            console.log(`${YELLOW}${BOLD}Local teardown done, but the Windows uninstaller could not be launched automatically.${RESET}`);
+            console.log(`${YELLOW}IMPORTANT: this machine is NOT fully clean yet — the SYSTEM updater task, HKLM audit policies, and the application files are still installed.${RESET}`);
+            console.log(`${YELLOW}Finish removal from Windows Settings → Apps → FullCourtDefense → Uninstall.${RESET}`);
+            process.exitCode = 1;
+        }
+    }
+    else {
+        // Non-MSI path: nothing else runs after us, so verify the result instead
+        // of asserting it. "Removed" is only printed when the machine actually
+        // checks out clean — anything left prints with the exact fix.
+        const { collectRemnantChecks } = await Promise.resolve().then(() => __importStar(require('./verifyRemoved')));
+        let remnants = [];
+        try {
+            remnants = collectRemnantChecks().filter(check => check.present);
+        }
+        catch { /* verification is best-effort — fall back to step-failure reporting */ }
+        if (failures.length === 0 && remnants.length === 0) {
+            console.log(`${GREEN}${BOLD}Verified: local protection and state fully removed.${RESET}`);
+            if (!isMsi) {
+                console.log(`${DIM}One step remains — the CLI package itself: npm uninstall -g fullcourtdefense-cli${RESET}`);
+            }
+        }
+        else {
+            if (failures.length > 0) {
+                console.log(`${YELLOW}${BOLD}Uninstall finished with ${failures.length} step(s) needing attention:${RESET} ${failures.join(', ')}`);
+            }
+            if (remnants.length > 0) {
+                console.log(`${YELLOW}${BOLD}Post-uninstall verification found ${remnants.length} artifact(s) still on this machine:${RESET}`);
+                for (const remnant of remnants) {
+                    console.log(`  ${YELLOW}✗${RESET} ${remnant.label}`);
+                    if (remnant.fix)
+                        console.log(`    ${DIM}fix: ${remnant.fix}${RESET}`);
+                }
+            }
+            process.exitCode = 1;
+        }
+    }
+    console.log(`${DIM}Verify a clean machine any time with: npx fullcourtdefense-cli verify-removed${RESET}`);
+    console.log(`${DIM}Note: per-project config backups are tracked and deleted from CLI v1.22.8+; backups made by older versions inside repos (e.g. .cursor/mcp.json.fcd-backup-*) may need manual deletion.${RESET}`);
+    console.log(fleetNotified
+        ? `${DIM}The fleet console now shows this machine as Uninstalled; an admin can remove the record (Machines → machine → Remove).${RESET}`
+        : `${DIM}The machine still appears in the fleet console until an admin deprovisions it (Machines → machine → Deprovision).${RESET}`);
+}

package/dist/commands/verifyRemoved.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `fullcourtdefense verify-removed` — prove a machine is back to its pre-FCD
+ * state after an uninstall. Enumerates every artifact FCD is known to create
+ * (scheduled tasks, HKLM/HKCU registry entries, install/state directories,
+ * profile files, shell-guard wiring, config backups, wrapped client configs)
+ * and reports anything still present, with the command that removes it.
+ *
+ * Exit code 0 = clean, 1 = remnants found — usable as a CI release gate and
+ * runnable AFTER the CLI itself is gone via `npx fullcourtdefense-cli
+ * verify-removed`.
+ */
+export interface RemnantCheck {
+    id: string;
+    label: string;
+    present: boolean;
+    detail?: string;
+    fix?: string;
+}
+export interface VerifyRemovedArgs {
+    json?: string;
+}
+/** All known-artifact checks for this platform — reused by `uninstall` for its inline self-verification. */
+export declare function collectRemnantChecks(): RemnantCheck[];
+export declare function verifyRemovedCommand(args: VerifyRemovedArgs): Promise<void>;