fullcourtdefense-cli 1.34.0 → 1.34.1

package/dist/codexHookStatus.d.ts

@@ -0,0 +1,19 @@
+export declare function resolveCodexExecutable(localAppData?: string): string;
+export interface CodexHook {
+    eventName: string;
+    command?: string;
+    enabled: boolean;
+    isManaged: boolean;
+    trustStatus: string;
+    sourcePath: string;
+}
+export interface CodexHookStatus {
+    state: 'unavailable' | 'not_configured' | 'approval_required' | 'disabled' | 'configured_unverified' | 'ready_for_probe';
+    managed: boolean;
+    message: string;
+}
+export declare function isFcdCodexHook(command: unknown): boolean;
+/** Configuration readiness is deliberately not a claim that the backend received an event. */
+export declare function summarizeCodexHooks(hooks: CodexHook[]): CodexHookStatus;
+/** Read-only app-server handshake. No thread, model turn, trust write, or hook execution. */
+export declare function getCodexHookStatus(cwd?: string, executable?: string, timeoutMs?: number): Promise<CodexHookStatus>;

package/dist/codexHookStatus.js

@@ -0,0 +1,156 @@
+"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.resolveCodexExecutable = resolveCodexExecutable;
+exports.isFcdCodexHook = isFcdCodexHook;
+exports.summarizeCodexHooks = summarizeCodexHooks;
+exports.getCodexHookStatus = getCodexHookStatus;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function resolveCodexExecutable(localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local')) {
+    if (process.platform !== 'win32')
+        return 'codex';
+    const bin = path.join(localAppData, 'OpenAI', 'Codex', 'bin');
+    try {
+        const candidates = fs.readdirSync(bin).map(version => path.join(bin, version, 'codex.exe'))
+            .filter(file => fs.existsSync(file) && fs.statSync(file).isFile());
+        candidates.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+        if (candidates.length)
+            return candidates[0];
+    }
+    catch { /* CLI-only or desktop absent: let spawn resolve PATH. */ }
+    return 'codex';
+}
+const EVENTS = ['preToolUse', 'postToolUse', 'userPromptSubmit'];
+function isFcdCodexHook(command) {
+    if (typeof command !== 'string')
+        return false;
+    const encoded = /-EncodedCommand ([A-Za-z0-9+/=]+)$/.exec(command)?.[1];
+    const decoded = encoded ? Buffer.from(encoded, 'base64').toString('utf16le') : command;
+    return decoded.includes('--fcd-native-managed true') && decoded.includes('--agent-client codex');
+}
+/** Configuration readiness is deliberately not a claim that the backend received an event. */
+function summarizeCodexHooks(hooks) {
+    const ours = hooks.filter(hook => isFcdCodexHook(hook.command));
+    const usable = (h) => h.enabled && (h.isManaged || h.trustStatus === 'trusted');
+    const complete = (items) => EVENTS.every(event => items.some(h => h.eventName === event));
+    const managed = complete(ours.filter(h => usable(h) && h.isManaged));
+    if (complete(ours.filter(usable)))
+        return { state: 'ready_for_probe', managed,
+            message: 'Codex hooks are trusted and enabled. Capture is not yet verified: run an action in the Codex app and confirm its event in Activity.' };
+    if (!complete(ours))
+        return { state: 'not_configured', managed: false,
+            message: 'Codex capture is incomplete: one or more FullCourtDefense hooks are missing.' };
+    if (ours.some(h => h.enabled && !h.isManaged && h.trustStatus !== 'trusted'))
+        return {
+            state: 'approval_required', managed: false,
+            message: 'Codex capture is inactive: hook approval is required. Company devices should use the administrator-managed installation.'
+        };
+    return { state: 'disabled', managed: false, message: 'Codex capture is inactive: required hooks are disabled.' };
+}
+/** Read-only app-server handshake. No thread, model turn, trust write, or hook execution. */
+function getCodexHookStatus(cwd = process.cwd(), executable = resolveCodexExecutable(), timeoutMs = 10_000) {
+    return new Promise(resolve => {
+        const child = (0, child_process_1.spawn)(executable, ['app-server', '--stdio'], { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true });
+        let finished = false;
+        let buffer = '';
+        let received = 0;
+        const finish = (status) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            child.kill();
+            resolve(status);
+        };
+        const unavailable = (message) => finish({ state: 'unavailable', managed: false, message });
+        const timer = setTimeout(() => unavailable('Codex hook status timed out; capture is not verified.'), timeoutMs);
+        const send = (value) => child.stdin.write(JSON.stringify(value) + '\n');
+        child.on('error', () => unavailable('Codex could not be started for hook diagnostics; capture is not verified.'));
+        child.stdin.on('error', () => unavailable('Codex hook diagnostics disconnected; capture is not verified.'));
+        child.on('exit', () => unavailable('Codex exited before reporting hook status; capture is not verified.'));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            received += Buffer.byteLength(chunk);
+            if (received > 2_000_000)
+                return unavailable('Codex hook diagnostics exceeded the response limit.');
+            buffer += chunk;
+            let newline;
+            while (!finished && (newline = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                let reply;
+                try {
+                    reply = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (![1, 2, 3].includes(reply.id))
+                    continue;
+                if (reply.error)
+                    return unavailable('Codex rejected hook diagnostics; update or repair the Codex installation.');
+                if (reply.id === 1) {
+                    send({ method: 'initialized' });
+                    send({ method: 'config/read', id: 3, params: { cwd, includeLayers: false } });
+                }
+                else if (reply.id === 3) {
+                    const features = reply.result?.config?.features;
+                    if (features?.hooks === false || (features?.hooks === undefined && features?.codex_hooks === false)) {
+                        return finish({ state: 'disabled', managed: false, message: 'Codex capture is inactive: hooks are disabled in the effective Codex configuration.' });
+                    }
+                    if (!reply.result?.config)
+                        return unavailable('Codex did not report its effective configuration; capture is not verified.');
+                    send({ method: 'hooks/list', id: 2, params: { cwds: [cwd] } });
+                }
+                else {
+                    const entry = reply.result?.data?.[0];
+                    if (!entry || !Array.isArray(entry.hooks) || entry.errors?.length)
+                        return unavailable('Codex reported invalid hook configuration; capture is not verified.');
+                    if (!entry.hooks.every((h) => h && typeof h.eventName === 'string' && typeof h.enabled === 'boolean'
+                        && typeof h.isManaged === 'boolean' && typeof h.trustStatus === 'string')) {
+                        return unavailable('Codex returned an unsupported hook status format; capture is not verified.');
+                    }
+                    finish(summarizeCodexHooks(entry.hooks));
+                }
+            }
+        });
+        send({ method: 'initialize', id: 1, params: {
+                clientInfo: { name: 'fullcourtdefense_hook_status', version: '1.0' }, capabilities: { experimentalApi: true },
+            } });
+    });
+}

package/dist/commands/installAll.js

@@ -1,4 +1,37 @@
 "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.installAllCommand = installAllCommand;
 const config_1 = require("../config");
@@ -6,6 +39,10 @@ const discover_1 = require("./discover");
 const installCursorHook_1 = require("./installCursorHook");
 const installClaudeHook_1 = require("./installClaudeHook");
 const installNativeHooks_1 = require("./installNativeHooks");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const installCodexManagedHooks_1 = require("./installCodexManagedHooks");
 const discoverSchedule_1 = require("./discoverSchedule");
 const mcpGateway_1 = require("./mcpGateway");
 const autoProtect_1 = require("./autoProtect");
@@ -40,11 +77,18 @@ async function installAllCommand(args, config) {
             const nativeFiles = (0, installNativeHooks_1.installNativeHooks)();
             for (const file of nativeFiles)
                 console.log(`Native action hooks configured: ${file}`);
-            if (nativeFiles.some(file => file.includes('.codex')))
-                console.log('Codex: review and trust the new hooks using /hooks before they can run.');
+            if (fs.existsSync(path.join(os.homedir(), '.codex'))) {
+                const status = await (0, installCodexManagedHooks_1.configureCodexForInstall)();
+                console.log(status.message);
+                if (status.state !== 'ready_for_probe')
+                    console.warn('Codex activation remains incomplete; other client setup can continue.');
+                else if (status.managed)
+                    (0, installNativeHooks_1.installNativeHooks)({ clients: ['codex'], remove: true });
+            }
         }
         catch (error) {
             console.error(`Native hooks incomplete: ${error instanceof Error ? error.message : String(error)}. Repair the settings and rerun install-native-hooks.`);
+            process.exitCode = 1;
         }
         console.log('\n\x1b[1mInstalling Cursor runtime hooks…\x1b[0m');
         const hookArgs = {
@@ -194,6 +238,7 @@ async function installAllCommand(args, config) {
             console.log('You can retry with: fullcourtdefense discover --schedule daily');
         }
     }
-    console.log('\n\x1b[32mDone.\x1b[0m Run \x1b[1mfullcourtdefense protect-all --dry-run true\x1b[0m to verify gateways.');
+    console.log(process.exitCode ? '\nSetup is incomplete; resolve the activation problem reported above.'
+        : '\nSetup configuration finished. Verify a fresh action from each IDE in Activity before treating its capture as active.');
     await (0, restartNotice_1.promptRestartNotice)();
 }

package/dist/commands/installCodexManagedHooks.d.ts

@@ -0,0 +1,17 @@
+export { isWindowsAdministrator } from '../windowsManagedAccess';
+import { CodexHookStatus } from '../codexHookStatus';
+export declare function codexSystemHookFile(): string;
+/** Install only from the MSI's stable, administrator-controlled runtime. */
+export declare function installedCodexRuntime(): {
+    executable: string;
+    entry: string;
+};
+/** npm-only administrators do not have an MSI runtime to deploy as managed code. */
+export declare function configureCodexForInstall(): Promise<CodexHookStatus>;
+/** Caller has checked administrator access and protected paths. Injectable read-only verification for tests. */
+export declare function writeVerifiedCodexHooks(file: string, command: string, verify?: () => Promise<CodexHookStatus>): Promise<CodexHookStatus>;
+export declare function codexTransactionJournal(directory: string, transaction: string): string;
+export declare function installCodexManagedHooks(transaction?: string): Promise<CodexHookStatus>;
+/** Fixed protected paths only; invoked by MSI rollback/commit in SYSTEM context. */
+export declare function finishCodexManagedTransaction(rollback: boolean, transaction: string): void;
+export declare function uninstallCodexManagedHooks(): void;

package/dist/commands/installCodexManagedHooks.js

@@ -0,0 +1,166 @@
+"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.isWindowsAdministrator = void 0;
+exports.codexSystemHookFile = codexSystemHookFile;
+exports.installedCodexRuntime = installedCodexRuntime;
+exports.configureCodexForInstall = configureCodexForInstall;
+exports.writeVerifiedCodexHooks = writeVerifiedCodexHooks;
+exports.codexTransactionJournal = codexTransactionJournal;
+exports.installCodexManagedHooks = installCodexManagedHooks;
+exports.finishCodexManagedTransaction = finishCodexManagedTransaction;
+exports.uninstallCodexManagedHooks = uninstallCodexManagedHooks;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const windowsManagedAccess_1 = require("../windowsManagedAccess");
+var windowsManagedAccess_2 = require("../windowsManagedAccess");
+Object.defineProperty(exports, "isWindowsAdministrator", { enumerable: true, get: function () { return windowsManagedAccess_2.isWindowsAdministrator; } });
+const crypto_1 = require("crypto");
+const installNativeHooks_1 = require("./installNativeHooks");
+const codexHookStatus_1 = require("../codexHookStatus");
+function codexSystemHookFile() {
+    return path.join(process.env.ProgramData || 'C:\\ProgramData', 'OpenAI', 'Codex', 'hooks.json');
+}
+/** Install only from the MSI's stable, administrator-controlled runtime. */
+function installedCodexRuntime() {
+    const root = path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'FullCourtDefense');
+    const runtime = { executable: path.join(root, 'runtime', 'node.exe'), entry: path.join(root, 'dist', 'nativeHook.js') };
+    for (const item of [root, path.dirname(runtime.entry), path.dirname(runtime.executable), runtime.executable, runtime.entry]) {
+        if (!fs.existsSync(item) || fs.lstatSync(item).isSymbolicLink())
+            throw new Error('Install or repair the FullCourtDefense MSI before activating managed Codex capture.');
+    }
+    return runtime;
+}
+/** npm-only administrators do not have an MSI runtime to deploy as managed code. */
+async function configureCodexForInstall() {
+    if (!(0, windowsManagedAccess_1.isWindowsAdministrator)())
+        return (0, codexHookStatus_1.getCodexHookStatus)();
+    const root = path.join(process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', 'FullCourtDefense');
+    if (!fs.existsSync(root))
+        return { state: 'configured_unverified', managed: false,
+            message: 'Codex user hooks are configured. Check hook trust from your normal Codex account; machine-managed deployment requires the MSI.' };
+    return installCodexManagedHooks();
+}
+/** Caller has checked administrator access and protected paths. Injectable read-only verification for tests. */
+async function writeVerifiedCodexHooks(file, command, verify = codexHookStatus_1.getCodexHookStatus) {
+    const before = fs.existsSync(file) ? fs.readFileSync(file) : undefined;
+    (0, installNativeHooks_1.installNativeHooks)({ clients: ['codex'], codexSystem: { file, command } });
+    try {
+        const status = await verify();
+        if (status.state !== 'ready_for_probe' || !status.managed)
+            throw new Error(status.message);
+        return status;
+    }
+    catch (error) {
+        if (before)
+            fs.writeFileSync(file, before);
+        else
+            fs.unlinkSync(file);
+        throw new Error(`Managed Codex activation could not be verified; previous configuration restored. ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function codexTransactionJournal(directory, transaction) {
+    if (!transaction || transaction.length > 256)
+        throw new Error('An MSI transaction identifier is required.');
+    return path.join(directory, `fullcourtdefense-rollback-${(0, crypto_1.createHash)('sha256').update(transaction).digest('hex')}.json`);
+}
+async function installCodexManagedHooks(transaction) {
+    if (!(0, windowsManagedAccess_1.isWindowsAdministrator)())
+        throw new Error('Managed Codex capture requires administrator deployment. Run setup elevated through your IT deployment tool. No employee /hooks approval is required for managed hooks.');
+    const runtime = installedCodexRuntime();
+    const file = codexSystemHookFile();
+    const directory = path.dirname(file);
+    for (const ancestor of [path.dirname(directory), directory]) {
+        if (fs.existsSync(ancestor) && fs.lstatSync(ancestor).isSymbolicLink())
+            throw new Error('Managed capture refuses redirected configuration paths.');
+    }
+    // Never promote a user-writable directory into a trusted execution source.
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+        (0, windowsManagedAccess_1.protectNewManagedDirectory)(directory);
+    }
+    const configFile = path.join(directory, 'config.toml');
+    for (const item of [path.dirname(directory), directory, ...[file, configFile].filter(p => fs.existsSync(p)),
+        path.dirname(path.dirname(runtime.entry)), path.dirname(runtime.entry), path.dirname(runtime.executable), runtime.executable, runtime.entry]) {
+        if (fs.lstatSync(item).isSymbolicLink())
+            throw new Error('Managed capture refuses redirected configuration or runtime paths.');
+        (0, windowsManagedAccess_1.verifyManagedPath)(item, item === path.dirname(directory));
+    }
+    // SYSTEM must never launch a user's Codex binary or alter the SYSTEM profile's
+    // user hooks. The impersonated onboarding step verifies the user's client.
+    if (transaction) {
+        const snapshot = [file, configFile].map(p => fs.existsSync(p) ? fs.readFileSync(p).toString('base64') : null);
+        fs.writeFileSync(codexTransactionJournal(directory, transaction), JSON.stringify(snapshot), { flag: 'wx' });
+    }
+    (0, installNativeHooks_1.installNativeHooks)({ clients: ['codex'], codexSystem: { file, command: (0, installNativeHooks_1.nativeHookCommand)('codex', runtime) } });
+    if (!fs.existsSync(configFile))
+        fs.writeFileSync(configFile, '# FullCourtDefense: activate the system hook configuration layer.\n', { flag: 'wx' });
+    return { state: 'configured_unverified', managed: false,
+        message: 'Managed Codex hooks installed. The customer Codex client must verify activation; Activity capture is not yet verified.' };
+}
+/** Fixed protected paths only; invoked by MSI rollback/commit in SYSTEM context. */
+function finishCodexManagedTransaction(rollback, transaction) {
+    if (!(0, windowsManagedAccess_1.isWindowsAdministrator)())
+        throw new Error('Administrator deployment is required.');
+    const directory = path.dirname(codexSystemHookFile());
+    const journal = codexTransactionJournal(directory, transaction);
+    if (!fs.existsSync(journal))
+        return;
+    if (fs.lstatSync(directory).isSymbolicLink() || fs.lstatSync(journal).isSymbolicLink())
+        throw new Error('Refusing redirected rollback configuration.');
+    if (rollback) {
+        const snapshot = JSON.parse(fs.readFileSync(journal, 'utf8'));
+        if (!Array.isArray(snapshot) || snapshot.length !== 2 || !snapshot.every(s => s === null || typeof s === 'string'))
+            throw new Error('Invalid managed hook rollback snapshot.');
+        [codexSystemHookFile(), path.join(directory, 'config.toml')].forEach((file, i) => {
+            if (fs.existsSync(file) && fs.lstatSync(file).isSymbolicLink())
+                throw new Error('Refusing redirected rollback target.');
+            if (snapshot[i] === null) {
+                if (fs.existsSync(file))
+                    fs.unlinkSync(file);
+            }
+            else
+                fs.writeFileSync(file, Buffer.from(snapshot[i], 'base64'));
+        });
+    }
+    fs.unlinkSync(journal);
+}
+function uninstallCodexManagedHooks() {
+    if (process.platform !== 'win32' || !fs.existsSync(codexSystemHookFile()))
+        return;
+    if (!(0, windowsManagedAccess_1.isWindowsAdministrator)())
+        throw new Error('Administrator access is required to remove machine-managed Codex hooks.');
+    (0, installNativeHooks_1.installNativeHooks)({ clients: ['codex'], remove: true, codexSystem: { file: codexSystemHookFile(), command: '' } });
+}

package/dist/commands/installNativeHooks.d.ts

@@ -1,9 +1,17 @@
 import type { NativeClient } from '../nativeHook';
-export declare function nativeHookCommand(client: NativeClient): string;
+export declare function nativeHookCommand(client: NativeClient, runtime?: {
+    executable: string;
+    entry: string;
+}): string;
 /** Preserve unrelated settings and hooks; refuse malformed files. */
 export declare function installNativeHooks(options?: {
     home?: string;
     project?: string;
     clients?: NativeClient[];
     remove?: boolean;
+    /** Internal target supplied by the administrator installer; never a CLI path override. */
+    codexSystem?: {
+        file: string;
+        command: string;
+    };
 }): string[];

package/dist/commands/installNativeHooks.js

@@ -48,18 +48,19 @@ const managed = (value) => {
     return Boolean(encoded && Buffer.from(encoded, 'base64').toString('utf16le').includes(marker));
 };
 const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
-function nativeHookCommand(client) {
+function nativeHookCommand(client, runtime) {
     if (!['codex', 'gemini_cli', 'windsurf', 'kiro'].includes(client))
         throw new Error('Unsupported native hook client');
-    const entry = path.resolve(__dirname, '..', 'nativeHook.js');
+    const entry = runtime?.entry || path.resolve(__dirname, '..', 'nativeHook.js');
+    const executable = runtime?.executable || process.execPath;
     const flags = `--agent-client ${client} ${marker} --fcd-managed true --local-only true`;
     if (process.platform !== 'win32')
-        return `${quote(process.execPath)} ${quote(entry)} ${flags}`;
+        return `${quote(executable)} ${quote(entry)} ${flags}`;
     // Windows vendors use different shells. An encoded PowerShell launcher is
     // valid in both cmd and PowerShell, preserves paths with spaces, and forwards
     // the JSON stdin explicitly. Paths are data, never interpolated expressions.
     const psQuote = (value) => `'${value.replace(/'/g, "''")}'`;
-    const script = `$ProgressPreference='SilentlyContinue'; $OutputEncoding=[Text.UTF8Encoding]::new($false); [Console]::InputEncoding=$OutputEncoding; [Console]::OutputEncoding=$OutputEncoding; $raw=[Console]::In.ReadToEnd(); $raw | & ${psQuote(process.execPath)} ${psQuote(entry)} ${flags}; exit $LASTEXITCODE`;
+    const script = `$ProgressPreference='SilentlyContinue'; $OutputEncoding=[Text.UTF8Encoding]::new($false); [Console]::InputEncoding=$OutputEncoding; [Console]::OutputEncoding=$OutputEncoding; $raw=[Console]::In.ReadToEnd(); $raw | & ${psQuote(executable)} ${psQuote(entry)} ${flags}; exit $LASTEXITCODE`;
     return `powershell.exe -NoProfile -NonInteractive -EncodedCommand ${Buffer.from(script, 'utf16le').toString('base64')}`;
 }
 /** Preserve unrelated settings and hooks; refuse malformed files. */
@@ -76,7 +77,8 @@ function installNativeHooks(options = {}) {
         // Install only detected clients. Explicit client selection also supports setup before first launch.
         if (!options.clients && !fs.existsSync(root))
             continue;
-        const file = path.join(root, client === 'kiro' ? 'hooks/fullcourtdefense.json' : client === 'gemini_cli' ? 'settings.json' : 'hooks.json');
+        const file = client === 'codex' && options.codexSystem ? options.codexSystem.file
+            : path.join(root, client === 'kiro' ? 'hooks/fullcourtdefense.json' : client === 'gemini_cli' ? 'settings.json' : 'hooks.json');
         if (options.remove && !fs.existsSync(file))
             continue;
         try {
@@ -84,7 +86,7 @@ function installNativeHooks(options = {}) {
             if (!data || typeof data !== 'object' || Array.isArray(data))
                 throw new Error(`Invalid hook settings: ${file}`);
             const before = JSON.stringify(data);
-            const command = nativeHookCommand(client);
+            const command = client === 'codex' && options.codexSystem ? options.codexSystem.command : nativeHookCommand(client);
             if (client === 'kiro') {
                 if (data.hooks !== undefined && !Array.isArray(data.hooks))
                     throw new Error(`Invalid Kiro hooks: ${file}`);

package/dist/commands/migrateCodexUserHooks.d.ts

@@ -0,0 +1,3 @@
+import { CodexHookStatus } from '../codexHookStatus';
+/** Run as the customer at daemon startup/repair, including silent MSI upgrades. */
+export declare function migrateCodexUserHooks(home?: string, verify?: () => Promise<CodexHookStatus>): Promise<boolean>;

package/dist/commands/migrateCodexUserHooks.js

@@ -0,0 +1,63 @@
+"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.migrateCodexUserHooks = migrateCodexUserHooks;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const codexHookStatus_1 = require("../codexHookStatus");
+const installNativeHooks_1 = require("./installNativeHooks");
+/** Run as the customer at daemon startup/repair, including silent MSI upgrades. */
+async function migrateCodexUserHooks(home = os.homedir(), verify = codexHookStatus_1.getCodexHookStatus) {
+    const file = path.join(home, '.codex', 'hooks.json');
+    try {
+        if (!fs.existsSync(file))
+            return false;
+        const config = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const ours = Object.values(config.hooks || {}).some((groups) => Array.isArray(groups)
+            && groups.some(group => Array.isArray(group?.hooks) && group.hooks.some((hook) => (0, codexHookStatus_1.isFcdCodexHook)(hook?.command))));
+        if (!ours)
+            return false;
+        const status = await verify();
+        if (status.state !== 'ready_for_probe' || !status.managed)
+            return false;
+        (0, installNativeHooks_1.installNativeHooks)({ home, clients: ['codex'], remove: true });
+        return true;
+    }
+    catch (error) {
+        console.warn(`Codex user-hook migration deferred: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}

package/dist/commands/protectionRepair.js

@@ -4,6 +4,7 @@ exports.repairProtection = repairProtection;
 const installClaudeHook_1 = require("./installClaudeHook");
 const installCursorHook_1 = require("./installCursorHook");
 const mcpGateway_1 = require("./mcpGateway");
+const migrateCodexUserHooks_1 = require("./migrateCodexUserHooks");
 /**
  * Single convergence pipeline for daemon startup, drift, and remote repair.
  * MCP wrapping repairs stale runtime paths; hook repair edits only managed
@@ -13,6 +14,7 @@ async function repairProtection(args, config) {
     await (0, mcpGateway_1.protectAllCommand)({ ...args, dryRun: undefined }, config);
     const cursor = (0, installCursorHook_1.repairCursorManagedHooks)();
     const claude = (0, installClaudeHook_1.repairClaudeManagedHooks)();
+    await (0, migrateCodexUserHooks_1.migrateCodexUserHooks)();
     const cursorAfter = (0, installCursorHook_1.inspectCursorManagedHooks)();
     const claudeAfter = (0, installClaudeHook_1.inspectClaudeManagedHooks)();
     return {

package/dist/commands/uninstallAll.js

@@ -54,6 +54,7 @@ const discoverSchedule_1 = require("./discoverSchedule");
 const installCursorHook_1 = require("./installCursorHook");
 const installClaudeHook_1 = require("./installClaudeHook");
 const installNativeHooks_1 = require("./installNativeHooks");
+const installCodexManagedHooks_1 = require("./installCodexManagedHooks");
 const shellGuard_1 = require("./shellGuard");
 const posixShellGuard_1 = require("./posixShellGuard");
 const cmdGuard_1 = require("./cmdGuard");
@@ -248,6 +249,7 @@ async function runLocalDetach(args, config) {
         { label: 'Cursor runtime hooks', run: () => (0, installCursorHook_1.uninstallCursorHookCommand)({}) },
         { label: 'Claude Code / VS Code / Copilot CLI hooks', run: () => (0, installClaudeHook_1.uninstallClaudeHookCommand)({}) },
         { label: 'Codex / Gemini / Windsurf / current Kiro project hooks', run: () => { (0, installNativeHooks_1.installNativeHooks)({ remove: true }); } },
+        { label: 'Machine-managed Codex hooks', run: () => (0, installCodexManagedHooks_1.uninstallCodexManagedHooks)() },
         ...(process.platform === 'win32'
             ? [
                 { label: 'PowerShell shell guard', run: () => (0, shellGuard_1.uninstallShellGuardCommand)() },

package/dist/index.js

@@ -204,6 +204,11 @@ function printHelp() {
                 Removes the FullCourtDefense Cursor hook entries.
     install-claude-hook
     install-native-hooks --clients codex,gemini_cli,windsurf,kiro
+    install-codex-managed-hooks
+                          Administrator deployment for Codex on Windows; no employee hook approval
+    codex-hook-status     Read Codex hook activation status (not proof of event delivery)
+    uninstall-codex-managed-hooks
+                          Remove only FullCourtDefense machine-managed Codex hooks (administrator)
                           Native tool hooks (Kiro: current project; Codex: trust via /hooks)
     uninstall-native-hooks
                 Installs Claude-format hooks in ~/.claude/settings.json — ONE file
@@ -735,6 +740,33 @@ async function main() {
             await (0, hook_1.hookCommand)(args, config);
             break;
         }
+        case 'codex-hook-status': {
+            const { getCodexHookStatus } = await Promise.resolve().then(() => __importStar(require('./codexHookStatus')));
+            const status = await getCodexHookStatus();
+            console.log(JSON.stringify(status, null, 2));
+            if (status.state !== 'ready_for_probe')
+                process.exitCode = 1;
+            break;
+        }
+        case 'install-codex-managed-hooks': {
+            const { installCodexManagedHooks } = await Promise.resolve().then(() => __importStar(require('./commands/installCodexManagedHooks')));
+            const status = await installCodexManagedHooks(flags['msi-transaction']);
+            console.log(status.message);
+            console.log('Restart Codex to load the machine-managed hooks, then verify a fresh Codex action in Activity.');
+            break;
+        }
+        case 'rollback-codex-managed-hooks':
+        case 'commit-codex-managed-hooks': {
+            const { finishCodexManagedTransaction } = await Promise.resolve().then(() => __importStar(require('./commands/installCodexManagedHooks')));
+            finishCodexManagedTransaction(command === 'rollback-codex-managed-hooks', flags['msi-transaction'] || '');
+            break;
+        }
+        case 'uninstall-codex-managed-hooks': {
+            const { uninstallCodexManagedHooks } = await Promise.resolve().then(() => __importStar(require('./commands/installCodexManagedHooks')));
+            uninstallCodexManagedHooks();
+            console.log('FullCourtDefense machine-managed Codex hooks removed. Restart Codex to reload its configuration.');
+            break;
+        }
         case 'install-native-hooks':
         case 'uninstall-native-hooks': {
             const clients = flags.clients?.split(',');
@@ -743,8 +775,16 @@ async function main() {
             const files = (0, installNativeHooks_1.installNativeHooks)({ clients, project: flags.project, remove: command === 'uninstall-native-hooks' });
             for (const file of files)
                 console.log(file);
-            if (command === 'install-native-hooks')
-                console.log('Restart the clients to load hooks. In Codex, review and trust the new definitions using /hooks. Kiro hooks apply to the selected project.');
+            if (command === 'install-native-hooks') {
+                console.log('Restart the clients to load hooks. Kiro hooks apply to the selected project.');
+                if (!clients || clients.includes('codex')) {
+                    const { getCodexHookStatus } = await Promise.resolve().then(() => __importStar(require('./codexHookStatus')));
+                    const status = await getCodexHookStatus();
+                    console.log(status.message);
+                    if (status.state !== 'ready_for_probe')
+                        process.exitCode = 1;
+                }
+            }
             break;
         }
         case 'install-copilot-hook': {

package/dist/version.json

@@ -1,3 +1,3 @@
 {
-  "version": "1.34.0"
+  "version": "1.34.1"
 }

package/dist/windowsManagedAccess.d.ts

@@ -0,0 +1,5 @@
+export declare function isWindowsAdministrator(): boolean;
+/** Parse icacls' language-independent SDDL; unknown ACL forms fail closed. */
+export declare function assertProtectedDacl(sddl: string, parent?: boolean): void;
+export declare function protectNewManagedDirectory(directory: string): void;
+export declare function verifyManagedPath(item: string, parent?: boolean): void;

package/dist/windowsManagedAccess.js

@@ -0,0 +1,132 @@
+"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.isWindowsAdministrator = isWindowsAdministrator;
+exports.assertProtectedDacl = assertProtectedDacl;
+exports.protectNewManagedDirectory = protectNewManagedDirectory;
+exports.verifyManagedPath = verifyManagedPath;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const windows = () => process.env.SystemRoot || 'C:\\Windows';
+function run(executable, args) {
+    return (0, child_process_1.execFileSync)(path.join(windows(), 'System32', executable), args, {
+        encoding: 'utf8', windowsHide: true, timeout: 15_000,
+    });
+}
+function isWindowsAdministrator() {
+    if (process.platform !== 'win32')
+        return false;
+    try {
+        return /"S-1-16-(12288|16384)"/.test(run('whoami.exe', ['/groups', '/fo', 'csv']));
+    }
+    catch {
+        return false;
+    }
+}
+const trusted = new Set(['SY', 'BA', 'S-1-5-18', 'S-1-5-32-544',
+    'S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464']);
+const rights = { FA: 0x1f01ff, FR: 0x120089, FW: 0x120116, FX: 0x1200a0,
+    GA: 0x1f01ff, GR: 0x120089, GW: 0x120116, GX: 0x1200a0,
+    SD: 0x10000, RC: 0x20000, WD: 0x40000, WO: 0x80000,
+    CC: 1, DC: 2, LC: 4, SW: 8, RP: 16, WP: 32, DT: 64, LO: 128, CR: 256 };
+/** Parse icacls' language-independent SDDL; unknown ACL forms fail closed. */
+function assertProtectedDacl(sddl, parent = false) {
+    sddl = sddl.split('S:')[0]; // A missing audit SACL does not remove the access DACL.
+    if (!sddl.startsWith('D:') || sddl.includes('NO_ACCESS_CONTROL'))
+        throw new Error('Missing managed-path DACL.');
+    const aces = sddl.match(/\([^()]*\)/g) || [];
+    if (!aces.length)
+        throw new Error('Empty or unsupported managed-path DACL.');
+    for (const ace of aces) {
+        const fields = ace.slice(1, -1).split(';');
+        if (fields.length !== 6)
+            throw new Error('Unsupported managed-path ACL.');
+        const [type, flags, mask, , , sid] = fields;
+        if (flags.includes('IO') || type === 'D')
+            continue;
+        if (type !== 'A')
+            throw new Error('Unsupported managed-path ACL entry.');
+        if (trusted.has(sid))
+            continue;
+        let value = 0;
+        if (/^0x[0-9a-f]+$/i.test(mask))
+            value = Number.parseInt(mask.slice(2), 16);
+        else {
+            if (!mask || mask.length % 2)
+                throw new Error('Unsupported managed-path access rights.');
+            for (let i = 0; i < mask.length; i += 2) {
+                const right = rights[mask.slice(i, i + 2)];
+                if (right === undefined)
+                    throw new Error('Unsupported managed-path access rights.');
+                value |= right;
+            }
+        }
+        if ((value & (parent ? 0xd0040 : 0xd0156)) || (value & 0x50000000)) {
+            throw new Error('Managed capture requires administrator-only write access to its configuration and runtime.');
+        }
+    }
+}
+function protectNewManagedDirectory(directory) {
+    run('icacls.exe', [directory, '/inheritance:r', '/grant:r',
+        '*S-1-5-18:(OI)(CI)F', '*S-1-5-32-544:(OI)(CI)F', '*S-1-5-32-545:(OI)(CI)RX', '/q']);
+}
+function verifyManagedPath(item, parent = false) {
+    if (fs.lstatSync(item).isSymbolicLink())
+        throw new Error('Managed capture refuses redirected paths.');
+    // Windows Temp permits users to create their own children, not replace an
+    // administrator's existing child. Never use a user's TEMP for SYSTEM input.
+    const scratch = fs.mkdtempSync(path.join(windows(), 'Temp', 'fcd-managed-acl-'));
+    const saved = path.join(scratch, 'acl.txt');
+    try {
+        run('icacls.exe', [item, '/save', saved, '/q']);
+        const lines = fs.readFileSync(saved).toString('utf16le').replace(/^\uFEFF/, '').split(/\r?\n/);
+        const dacl = lines.find(line => line.startsWith('D:'));
+        try {
+            assertProtectedDacl(dacl || '', parent);
+        }
+        catch (error) {
+            throw new Error(`${item}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Ownership grants implicit WRITE_DAC. Transfer only these managed config
+        // and FCD runtime paths to Administrators, preserving their existing DACL.
+        run('icacls.exe', [item, '/setowner', '*S-1-5-32-544', '/q']);
+    }
+    finally {
+        if (fs.existsSync(saved))
+            fs.unlinkSync(saved);
+        fs.rmdirSync(scratch);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fullcourtdefense-cli",
-  "version": "1.34.0",
+  "version": "1.34.1",
   "description": "Full Court Defense CLI — security scanning for AI agents from your terminal",
   "main": "dist/index.js",
   "bin": {
@@ -13,7 +13,7 @@
     "README.md"
   ],
   "scripts": {
-    "test:native-hooks": "npm run build && node scripts/test-native-hook-launch.js && node scripts/test-native-hook-edges.js && node scripts/test-client-telemetry.js && node scripts/test-native-hook-clients.js",
+    "test:native-hooks": "npm run build && node scripts/test-codex-activation.js && node scripts/test-native-hook-launch.js && node scripts/test-native-hook-edges.js && node scripts/test-client-telemetry.js && node scripts/test-native-hook-clients.js",
     "test:endpoint-approvals": "npm run build && node scripts/audit-endpoint-mcp-shell.js",
     "test:endpoint-clients": "npm run build && node scripts/test-endpoint-client-matrix.js && node scripts/test-copilot-hook-install.js",
     "build": "tsc && node scripts/copy-attack-corpus.js",