fullcourtdefense-cli 1.33.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/discoverPaths.js

@@ -215,6 +215,8 @@ function candidateConfigPaths(cwd, extra) {
         { path: path.join(xdg, 'Code', 'User', 'settings.json'), source: 'VS Code (user, linux)', clientKey: 'vscode' },
         { path: path.join(home, '.codeium', 'windsurf', 'mcp_config.json'), source: 'Windsurf', clientKey: 'windsurf' },
         { path: path.join(home, '.kiro', 'mcp.json'), source: 'Kiro', clientKey: 'kiro' },
+        { path: path.join(home, '.kiro', 'settings', 'mcp.json'), source: 'Kiro (settings)', clientKey: 'kiro' },
+        { path: path.join(cwd, '.kiro', 'settings', 'mcp.json'), source: 'Kiro (project settings)', clientKey: 'kiro' },
         { path: path.join(cwd, '.mcp.json'), source: 'Repo (.mcp.json)', clientKey: 'other' },
         { path: path.join(cwd, 'mcp.json'), source: 'Repo (mcp.json)', clientKey: 'other' },
     ];

package/dist/commands/hook.d.ts

@@ -20,6 +20,7 @@ import { BotGuardConfig } from '../config';
  * human approves/rejects in the FullCourtDefense console (same as the gateway).
  */
 export interface HookArgs {
+    agentClient?: string;
     event?: string;
     apiUrl?: string;
     shieldId?: string;

package/dist/commands/hook.js

@@ -191,10 +191,10 @@ function mapClaudeToolPayload(payload) {
 // a file read is `read_file { path }`. Built-ins with no enforcement surface
 // (search, task, web) are ignored. Nothing here decides anything.
 // ---------------------------------------------------------------------------
-const BUILTIN_SHELL_TOOLS = new Set(['bash', 'shell', 'runterminalcommand', 'runinterminal', 'powershell', 'terminal']);
-const BUILTIN_READ_TOOLS = new Set(['read', 'readfile', 'view']);
+const BUILTIN_SHELL_TOOLS = new Set(['bash', 'shell', 'runterminalcommand', 'runinterminal', 'powershell', 'terminal', 'runshellcommand', 'executebash', 'execcommand']);
+const BUILTIN_READ_TOOLS = new Set(['read', 'readfile', 'view', 'fsread']);
 const BUILTIN_WRITE_TOOLS = new Set([
-    'write', 'edit', 'multiedit', 'notebookedit', 'createfile', 'editfiles',
+    'write', 'edit', 'multiedit', 'notebookedit', 'createfile', 'editfiles', 'writefile', 'fswrite', 'replace',
     'replacestringinfile', 'editfile', 'applypatch', 'strreplaceeditor', 'insertedittofile', 'strreplace', 'editnotebook',
 ]);
 /**
@@ -221,11 +221,11 @@ function mapBuiltinToolPayload(toolName, input, payload) {
     if (BUILTIN_SHELL_TOOLS.has(canon)) {
         return {
             event: 'shell',
-            payload: { ...payload, command: str(input.command), cwd: str(input.cwd) || str(input.working_directory) || str(payload.cwd) || undefined },
+            payload: { ...payload, command: str(input.command) || str(input.cmd), cwd: str(input.cwd) || str(input.workdir) || str(input.working_directory) || str(payload.cwd) || undefined },
         };
     }
     if (BUILTIN_READ_TOOLS.has(canon)) {
-        return { event: 'read', payload: { ...payload, file_path: str(input.file_path) || str(input.path) || str(input.target_file) } };
+        return { event: 'read', payload: { ...payload, file_path: str(input.file_path) || str(input.filePath) || str(input.absolute_path) || str(input.path) || str(input.target_file) } };
     }
     if (BUILTIN_WRITE_TOOLS.has(canon)) {
         const filePath = str(input.file_path) || str(input.notebook_path) || str(input.path) || str(input.filePath) || str(input.target_file)
@@ -235,7 +235,7 @@ function mapBuiltinToolPayload(toolName, input, payload) {
         // `new_source`) are reduced to the lines they add. Both then drop the
         // credential-shaped words the file on disk already contains — re-stating a
         // value that is already in the file is not putting a secret into it.
-        const delta = str(input.new_string) || str(input.new_str) || str(input.new_text)
+        const delta = str(input.new_string) || str(input.newString) || str(input.newText) || str(input.new_str) || str(input.new_text)
             || (Array.isArray(input.edits)
                 ? input.edits.map((e) => str(e?.new_string) || str(e?.new_text) || str(e?.newText) || str(e?.content)).filter(Boolean).join('\n')
                 : '');
@@ -1345,7 +1345,8 @@ async function hookCommandInner(args, config, io) {
     // client that reads ~/.claude/settings.json.
     const claudeNormalized = normalizeClaudePayload(payload);
     const hookFormat = claudeNormalized ? 'claude' : 'cursor';
-    const client = claudeNormalized ? claudeFormatClient() : 'cursor';
+    const client = args.agentClient || (claudeNormalized ? claudeFormatClient() : 'cursor');
+    (0, telemetry_1.setVerdictClient)(client);
     let event;
     let ignoreEvent = false;
     if (claudeNormalized) {

package/dist/commands/installAll.js

@@ -1,10 +1,48 @@
 "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");
 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");
@@ -35,6 +73,23 @@ async function installAllCommand(args, config) {
     console.log('\x1b[2mAuto-protect MCP servers across AI clients + Cursor built-in action hooks. No --mcp-command or folder path needed.\x1b[0m\n');
     await (0, mcpGateway_1.protectAllCommand)(gatewayArgs, config);
     if (args.hooks !== 'false') {
+        try {
+            const nativeFiles = (0, installNativeHooks_1.installNativeHooks)();
+            for (const file of nativeFiles)
+                console.log(`Native action hooks configured: ${file}`);
+            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 = {
             shieldId: creds.shieldId,
@@ -183,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/installClaudeHook.d.ts

@@ -35,5 +35,11 @@ export interface ClaudeManagedHookRepairResult {
 export declare function inspectClaudeManagedHooks(): ClaudeManagedHookRepairResult;
 /** Repair managed commands without changing matcher/event/fail-open behavior. */
 export declare function repairClaudeManagedHooks(): ClaudeManagedHookRepairResult;
+/** Copilot CLI user settings are separate from Claude's global settings.
+ * Use inline settings, not ~/.copilot/hooks, which VS Code also loads and
+ * would therefore execute twice alongside its Claude hook.
+ */
+export declare function syncCopilotToolHooks(command?: string): boolean;
+export declare function installCopilotHookCommand(): void;
 export declare function installClaudeHookCommand(args: InstallClaudeHookArgs, config: BotGuardConfig): Promise<void>;
 export declare function uninstallClaudeHookCommand(args: InstallClaudeHookArgs): Promise<void>;

package/dist/commands/installClaudeHook.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inspectClaudeManagedHooks = inspectClaudeManagedHooks;
 exports.repairClaudeManagedHooks = repairClaudeManagedHooks;
+exports.syncCopilotToolHooks = syncCopilotToolHooks;
+exports.installCopilotHookCommand = installCopilotHookCommand;
 exports.installClaudeHookCommand = installClaudeHookCommand;
 exports.uninstallClaudeHookCommand = uninstallClaudeHookCommand;
 const fs = __importStar(require("fs"));
@@ -211,7 +213,7 @@ function syncCopilotToolHooks(command) {
         const entries = Array.isArray(hooks[event]) ? hooks[event] : [];
         const kept = entries.filter(entry => !isManagedCommand(entry));
         if (command)
-            kept.push({ type: 'command', command, timeoutSec: event === 'PreToolUse' ? TOOL_HOOK_TIMEOUT_SEC : POST_TOOL_HOOK_TIMEOUT_SEC });
+            kept.push({ type: 'command', command: `${command} --agent-client copilot`, timeoutSec: event === 'PreToolUse' ? TOOL_HOOK_TIMEOUT_SEC : POST_TOOL_HOOK_TIMEOUT_SEC });
         if (kept.length)
             hooks[event] = kept;
         else
@@ -227,6 +229,10 @@ function syncCopilotToolHooks(command) {
     fs.writeFileSync(file, JSON.stringify(settings, null, 2) + '\n', 'utf8');
     return true;
 }
+function installCopilotHookCommand() {
+    syncCopilotToolHooks(buildHookCommand({ shadow: false, failClosed: false }));
+    console.log('Copilot CLI tool hooks configured. Restart Copilot CLI to load the changes.');
+}
 // PostToolUse companion of PreToolUse: enforces nothing; it is how a developer's
 // Allow on the client's own `ask` prompt (developer-scoped approval) is learned.
 // Same command — the bridge reads `hook_event_name` from the payload.

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

@@ -0,0 +1,17 @@
+import type { NativeClient } from '../nativeHook';
+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[];