@dollhousemcp/mcp-server 2.0.29 → 2.0.30

package/dist/utils/permissionHookInstallers.js

@@ -0,0 +1,465 @@
+import { dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { detectIndent, ensureCommandHook, getClaudeHookSettingsPath, getCodexConfigPath, getCodexHookSettingsPath, getCursorHookSettingsPath, getGeminiHookSettingsPath, getHookWrapperBasename, normalizeHooksRoot, getVsCodeHookSettingsPath, getVsCodeUserSettingsPath, getWindsurfHookSettingsPath, installHookAssetsForHost, normalizeHookHost, readOptionalUtf8, writeHookMarker, writeBackupIfPresent, } from './permissionHookShared.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+function normalizePermissionHookClient(client) {
+    const normalizedClient = UnicodeValidator.normalize(client).normalizedContent;
+    return normalizeHookHost(normalizedClient);
+}
+export function ensureClaudePreToolUseHook(parsed, command) {
+    return ensureCommandHook(parsed, 'PreToolUse', command, '*');
+}
+export function ensureVsCodePreToolUseHook(parsed, command) {
+    return ensureCommandHook(parsed, 'PreToolUse', command, '*');
+}
+export function ensureGeminiBeforeToolHook(parsed, command) {
+    return ensureCommandHook(parsed, 'BeforeTool', command, '.*');
+}
+export function ensureCodexPreToolUseHook(parsed, command) {
+    return ensureCommandHook(parsed, 'PreToolUse', command, 'Bash', {
+        statusMessage: 'Checking Bash permissions',
+    });
+}
+export function ensureCursorPreToolUseHook(parsed, command) {
+    if (parsed.version !== 1) {
+        parsed.version = 1;
+    }
+    const hooksRoot = normalizeHooksRoot(parsed);
+    const existingEntries = Array.isArray(hooksRoot.preToolUse)
+        ? hooksRoot.preToolUse.filter((entry) => typeof entry === 'object' && entry !== null)
+        : [];
+    hooksRoot.preToolUse = existingEntries;
+    const commandExists = existingEntries.some((entry) => entry.command === command
+        && (entry.type === 'command' || entry.type === undefined));
+    if (commandExists) {
+        return { changed: false, parsed };
+    }
+    existingEntries.push({
+        type: 'command',
+        command,
+        matcher: '.*',
+    });
+    return { changed: true, parsed };
+}
+export function ensureWindsurfHooks(parsed, command) {
+    const hooksRoot = normalizeHooksRoot(parsed);
+    let changed = false;
+    const ensureEventHook = (eventName) => {
+        const existingEntries = Array.isArray(hooksRoot[eventName])
+            ? hooksRoot[eventName].filter((entry) => typeof entry === 'object' && entry !== null)
+            : [];
+        hooksRoot[eventName] = existingEntries;
+        const commandExists = existingEntries.some((entry) => entry.command === command && (entry.type === 'command' || entry.type === undefined));
+        if (commandExists) {
+            return;
+        }
+        existingEntries.push({
+            type: 'command',
+            command,
+        });
+        changed = true;
+    };
+    ensureEventHook('pre_run_command');
+    ensureEventHook('pre_mcp_tool_use');
+    return { changed, parsed };
+}
+async function mergeClaudeSettings(settingsPath, command) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureClaudePreToolUseHook(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeVsCodeHookSettings(settingsPath, command) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureVsCodePreToolUseHook(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeVsCodeUserSettings(settingsPath) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const current = parsed['chat.hookFilesLocations'];
+    const locations = (current && typeof current === 'object' && !Array.isArray(current))
+        ? { ...current }
+        : {};
+    if (locations['~/.copilot/hooks'] === true) {
+        return { changed: false };
+    }
+    locations['~/.copilot/hooks'] = true;
+    parsed['chat.hookFilesLocations'] = locations;
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(parsed, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeGeminiSettings(settingsPath, command) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureGeminiBeforeToolHook(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeCursorHooks(settingsPath, command) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{\n  "version": 1,\n  "hooks": {}\n}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureCursorPreToolUseHook(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeWindsurfHooks(settingsPath, command) {
+    await mkdir(dirname(settingsPath), { recursive: true });
+    const raw = await readOptionalUtf8(settingsPath, '{\n  "hooks": {}\n}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureWindsurfHooks(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(settingsPath, raw);
+    await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+async function mergeCodexHooks(hooksPath, command) {
+    await mkdir(dirname(hooksPath), { recursive: true });
+    const raw = await readOptionalUtf8(hooksPath, '{}\n');
+    const indent = detectIndent(raw);
+    const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw);
+    const { changed, parsed: updated } = ensureCodexPreToolUseHook(parsed, command);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(hooksPath, raw);
+    await writeFile(hooksPath, JSON.stringify(updated, null, indent) + '\n', 'utf-8');
+    return { changed: true, backupPath };
+}
+function getTomlLineContent(line) {
+    const commentIndex = line.indexOf('#');
+    return (commentIndex >= 0 ? line.slice(0, commentIndex) : line).trim();
+}
+function isTomlSectionLine(line, section) {
+    return getTomlLineContent(line) === `[${section}]`;
+}
+function parseTomlBooleanAssignment(line, key) {
+    const content = getTomlLineContent(line);
+    if (!content.startsWith(`${key} = `)) {
+        return null;
+    }
+    const value = content.slice(`${key} = `.length).trim();
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return null;
+}
+function updateTomlBooleanAssignment(line, key, nextValue) {
+    const commentIndex = line.indexOf('#');
+    const commentSuffix = commentIndex >= 0 ? line.slice(commentIndex) : '';
+    let prefixLength = 0;
+    while (prefixLength < line.length && /\s/.test(line.charAt(prefixLength))) {
+        prefixLength += 1;
+    }
+    const prefix = line.slice(0, prefixLength);
+    const assignment = `${prefix}${key} = ${nextValue ? 'true' : 'false'}`;
+    const trimmedCommentSuffix = commentSuffix.trimStart();
+    const suffix = trimmedCommentSuffix.length > 0 ? ` ${trimmedCommentSuffix}` : '';
+    return `${assignment}${suffix}`.trimEnd();
+}
+function stripTrailingNewlines(value) {
+    let end = value.length;
+    while (end > 0 && value.charAt(end - 1) === '\n') {
+        end -= 1;
+    }
+    return value.slice(0, end);
+}
+function ensureCodexHooksEnabled(raw) {
+    const lines = raw.length > 0 ? raw.split('\n') : [];
+    const dottedIndex = lines.findIndex((line) => parseTomlBooleanAssignment(line, 'features.codex_hooks') !== null);
+    if (dottedIndex >= 0) {
+        if (parseTomlBooleanAssignment(lines[dottedIndex], 'features.codex_hooks') === true) {
+            return { changed: false, content: raw };
+        }
+        const updatedLines = [...lines];
+        updatedLines[dottedIndex] = updateTomlBooleanAssignment(updatedLines[dottedIndex], 'features.codex_hooks', true);
+        return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\n'))}\n` };
+    }
+    const sectionIndex = lines.findIndex((line) => isTomlSectionLine(line, 'features'));
+    if (sectionIndex >= 0) {
+        const nextSectionIndex = lines.findIndex((line, index) => index > sectionIndex && getTomlLineContent(line).startsWith('[') && getTomlLineContent(line).endsWith(']'));
+        const sectionEnd = nextSectionIndex >= 0 ? nextSectionIndex : lines.length;
+        const keyIndex = lines.findIndex((line, index) => index > sectionIndex && index < sectionEnd && parseTomlBooleanAssignment(line, 'codex_hooks') !== null);
+        if (keyIndex >= 0) {
+            if (parseTomlBooleanAssignment(lines[keyIndex], 'codex_hooks') === true) {
+                return { changed: false, content: raw };
+            }
+            const updatedLines = [...lines];
+            updatedLines[keyIndex] = updateTomlBooleanAssignment(updatedLines[keyIndex], 'codex_hooks', true);
+            return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\n'))}\n` };
+        }
+        const updatedLines = [...lines];
+        updatedLines.splice(sectionIndex + 1, 0, 'codex_hooks = true');
+        return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\n'))}\n` };
+    }
+    const prefix = raw.trim().length > 0 ? `${stripTrailingNewlines(raw)}\n\n` : '';
+    return {
+        changed: true,
+        content: `${prefix}[features]\ncodex_hooks = true\n`,
+    };
+}
+async function mergeCodexConfig(configPath) {
+    await mkdir(dirname(configPath), { recursive: true });
+    const raw = await readOptionalUtf8(configPath, '');
+    const { changed, content } = ensureCodexHooksEnabled(raw);
+    if (!changed) {
+        return { changed: false };
+    }
+    const backupPath = await writeBackupIfPresent(configPath, raw);
+    await writeFile(configPath, content, 'utf-8');
+    return { changed: true, backupPath };
+}
+async function installClaudeCodePermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'claude-code';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getClaudeHookSettingsPath(homeDir);
+    const settingsResult = await mergeClaudeSettings(settingsPath, `bash ${scriptPath}`);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        markerPath,
+        backupPath: settingsResult.backupPath,
+        message: 'Installed Claude Code permission hook and updated settings.json.',
+    };
+}
+async function installVsCodePermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'vscode';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getVsCodeHookSettingsPath(homeDir);
+    const userSettingsPath = getVsCodeUserSettingsPath(homeDir);
+    const hookResult = await mergeVsCodeHookSettings(settingsPath, `bash ${scriptPath}`);
+    const userSettingsResult = await mergeVsCodeUserSettings(userSettingsPath);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        additionalPaths: [userSettingsPath],
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        additionalPaths: [userSettingsPath],
+        markerPath,
+        backupPath: hookResult.backupPath ?? userSettingsResult.backupPath,
+        message: 'Installed VS Code permission hook and enabled chat.hookFilesLocations for ~/.copilot/hooks.',
+    };
+}
+async function installGeminiCliPermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'gemini-cli';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getGeminiHookSettingsPath(homeDir);
+    const settingsResult = await mergeGeminiSettings(settingsPath, `bash ${scriptPath}`);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        markerPath,
+        backupPath: settingsResult.backupPath,
+        message: 'Installed Gemini CLI permission hook and updated settings.json.',
+    };
+}
+async function installCursorPermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'cursor';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getCursorHookSettingsPath(homeDir);
+    const settingsResult = await mergeCursorHooks(settingsPath, `bash ${scriptPath}`);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        markerPath,
+        backupPath: settingsResult.backupPath,
+        message: 'Installed Cursor permission hook and updated hooks.json.',
+    };
+}
+async function installWindsurfPermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'windsurf';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getWindsurfHookSettingsPath(homeDir);
+    const settingsResult = await mergeWindsurfHooks(settingsPath, `bash ${scriptPath}`);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        markerPath,
+        backupPath: settingsResult.backupPath,
+        message: 'Installed Windsurf permission hooks and updated hooks.json.',
+    };
+}
+async function installCodexPermissionHook(homeDir, installedAt, sourceScriptPath) {
+    const host = 'codex';
+    const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);
+    const settingsPath = getCodexHookSettingsPath(homeDir);
+    const configPath = getCodexConfigPath(homeDir);
+    const hooksResult = await mergeCodexHooks(settingsPath, `bash ${scriptPath}`);
+    const configResult = await mergeCodexConfig(configPath);
+    const markerPath = await writeHookMarker(homeDir, {
+        host,
+        scriptPath,
+        settingsPath,
+        additionalPaths: [configPath],
+        configured: true,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: true,
+        assetsPrepared: true,
+        host,
+        scriptPath,
+        settingsPath,
+        additionalPaths: [configPath],
+        markerPath,
+        backupPath: hooksResult.backupPath ?? configResult.backupPath,
+        message: 'Installed Codex Bash permission hook, created hooks.json, and enabled features.codex_hooks in config.toml.',
+    };
+}
+async function installManualPermissionHookAssets(normalizedClient, homeDir, installedAt, sourceScriptPath) {
+    const { scriptPath } = await installHookAssetsForHost(normalizedClient, homeDir, sourceScriptPath);
+    const markerPath = await writeHookMarker(homeDir, {
+        host: normalizedClient,
+        scriptPath,
+        settingsPath: undefined,
+        configured: false,
+        assetsPrepared: true,
+        installedAt,
+    });
+    return {
+        supported: true,
+        installed: true,
+        configured: false,
+        assetsPrepared: true,
+        host: normalizedClient,
+        scriptPath,
+        markerPath,
+        message: `Installed Dollhouse permission hook assets for ${normalizedClient}. Finish the client-specific hook registration manually.`,
+    };
+}
+export async function installPermissionHook(client, options = {}) {
+    const normalizedClient = normalizePermissionHookClient(client);
+    const homeDir = options.homeDir ?? homedir();
+    const installedAt = (options.now ?? new Date()).toISOString();
+    if (normalizedClient === 'claude-code') {
+        return installClaudeCodePermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (normalizedClient === 'vscode') {
+        return installVsCodePermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (normalizedClient === 'gemini-cli') {
+        return installGeminiCliPermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (normalizedClient === 'cursor') {
+        return installCursorPermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (normalizedClient === 'windsurf') {
+        return installWindsurfPermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (normalizedClient === 'codex') {
+        return installCodexPermissionHook(homeDir, installedAt, options.sourceScriptPath);
+    }
+    if (getHookWrapperBasename(normalizedClient)) {
+        return installManualPermissionHookAssets(normalizedClient, homeDir, installedAt, options.sourceScriptPath);
+    }
+    return {
+        supported: false,
+        installed: false,
+        configured: false,
+        host: normalizedClient,
+        message: `Automatic permission hook wiring is not yet supported for ${normalizedClient}.`,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionHookInstallers.js","sourceRoot":"","sources":["../../src/utils/permissionHookInstallers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAGL,YAAY,EACZ,iBAAiB,EACjB,yBAAyB,EACzB,kBAAkB,EAClB,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,EAClB,yBAAyB,EACzB,yBAAyB,EACzB,2BAA2B,EAC3B,wBAAwB,EACxB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAE9E,SAAS,6BAA6B,CAAC,MAAc;IACnD,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;IAC9E,OAAO,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,MAA+B,EAC/B,OAAe;IAEf,OAAO,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,MAA+B,EAC/B,OAAe;IAEf,OAAO,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,MAA+B,EAC/B,OAAe;IAEf,OAAO,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,yBAAyB,CACvC,MAA+B,EAC/B,OAAe;IAEf,OAAO,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE;QAC9D,aAAa,EAAE,2BAA2B;KAC3C,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,0BAA0B,CACxC,MAA+B,EAC/B,OAAe;IAEf,IAAI,MAAM,CAAC,OAAO,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;IACrB,CAAC;IACD,MAAM,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC7C,MAAM,eAAe,GAAmC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC;QACzF,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAoC,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;QACvH,CAAC,CAAC,EAAE,CAAC;IACP,SAAS,CAAC,UAAU,GAAG,eAAe,CAAC;IAEvC,MAAM,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CACnD,KAAK,CAAC,OAAO,KAAK,OAAO;WACtB,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAC1D,CAAC;IACF,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpC,CAAC;IAED,eAAe,CAAC,IAAI,CAAC;QACnB,IAAI,EAAE,SAAS;QACf,OAAO;QACP,OAAO,EAAE,IAAI;KACd,CAAC,CAAC;IAEH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,MAA+B,EAC/B,OAAe;IAEf,MAAM,SAAS,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,OAAO,GAAG,KAAK,CAAC;IAEpB,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAE,EAAE;QAC5C,MAAM,eAAe,GAAmC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YACzF,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAoC,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;YACvH,CAAC,CAAC,EAAE,CAAC;QACP,SAAS,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC;QAEvC,MAAM,aAAa,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CACnD,KAAK,CAAC,OAAO,KAAK,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CACpF,CAAC;QACF,IAAI,aAAa,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,eAAe,CAAC,IAAI,CAAC;YACnB,IAAI,EAAE,SAAS;YACf,OAAO;SACR,CAAC,CAAC;QACH,OAAO,GAAG,IAAI,CAAC;IACjB,CAAC,CAAC;IAEF,eAAe,CAAC,iBAAiB,CAAC,CAAC;IACnC,eAAe,CAAC,kBAAkB,CAAC,CAAC;IAEpC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;AAC7B,CAAC;AAED,KAAK,UAAU,mBAAmB,CAAC,YAAoB,EAAE,OAAe;IACtE,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAEjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,uBAAuB,CAAC,YAAoB,EAAE,OAAe;IAC1E,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAEjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,uBAAuB,CAAC,YAAoB;IACzD,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IACzD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,OAAO,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC;IAClD,MAAM,SAAS,GAAG,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACnF,CAAC,CAAC,EAAE,GAAI,OAAmC,EAAE;QAC7C,CAAC,CAAC,EAAE,CAAC;IAEP,IAAI,SAAS,CAAC,kBAAkB,CAAC,KAAK,IAAI,EAAE,CAAC;QAC3C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,SAAS,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACrC,MAAM,CAAC,yBAAyB,CAAC,GAAG,SAAS,CAAC;IAE9C,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IACjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACpF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,mBAAmB,CAAC,YAAoB,EAAE,OAAe;IACtE,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAEzD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAEjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,YAAoB,EAAE,OAAe;IACnE,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,wCAAwC,CAAC,CAAC;IAE3F,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,0BAA0B,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAEjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,kBAAkB,CAAC,YAAoB,EAAE,OAAe;IACrE,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,uBAAuB,CAAC,CAAC;IAE1E,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,mBAAmB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1E,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC;IAEjE,MAAM,SAAS,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IACrF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,eAAe,CAAC,SAAiB,EAAE,OAAe;IAC/D,MAAM,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAErD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAEtD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAA4B,CAAC;IACzF,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,yBAAyB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChF,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAE9D,MAAM,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC;IAClF,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAY;IACtC,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvC,OAAO,CAAC,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;AACzE,CAAC;AAED,SAAS,iBAAiB,CAAC,IAAY,EAAE,OAAe;IACtD,OAAO,kBAAkB,CAAC,IAAI,CAAC,KAAK,IAAI,OAAO,GAAG,CAAC;AACrD,CAAC;AAED,SAAS,0BAA0B,CAAC,IAAY,EAAE,GAAW;IAC3D,MAAM,OAAO,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;IACvD,IAAI,KAAK,KAAK,MAAM;QAAE,OAAO,IAAI,CAAC;IAClC,IAAI,KAAK,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACpC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,2BAA2B,CAAC,IAAY,EAAE,GAAW,EAAE,SAAkB;IAChF,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACvC,MAAM,aAAa,GAAG,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACxE,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,OAAO,YAAY,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,CAAC;QAC1E,YAAY,IAAI,CAAC,CAAC;IACpB,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;IAC3C,MAAM,UAAU,GAAG,GAAG,MAAM,GAAG,GAAG,MAAM,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;IACvE,MAAM,oBAAoB,GAAG,aAAa,CAAC,SAAS,EAAE,CAAC;IACvD,MAAM,MAAM,GAAG,oBAAoB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACjF,OAAO,GAAG,UAAU,GAAG,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC;AAC5C,CAAC;AAED,SAAS,qBAAqB,CAAC,KAAa;IAC1C,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;IACvB,OAAO,GAAG,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QACjD,GAAG,IAAI,CAAC,CAAC;IACX,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC7B,CAAC;AAED,SAAS,uBAAuB,CAAC,GAAW;IAC1C,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACpD,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,0BAA0B,CAAC,IAAI,EAAE,sBAAsB,CAAC,KAAK,IAAI,CAAC,CAAC;IACjH,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,IAAI,0BAA0B,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE,sBAAsB,CAAC,KAAK,IAAI,EAAE,CAAC;YACpF,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;QAC1C,CAAC;QACD,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAChC,YAAY,CAAC,WAAW,CAAC,GAAG,2BAA2B,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,sBAAsB,EAAE,IAAI,CAAC,CAAC;QACjH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3F,CAAC;IAED,MAAM,YAAY,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iBAAiB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;IACpF,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;QACtB,MAAM,gBAAgB,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,YAAY,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;QACtK,MAAM,UAAU,GAAG,gBAAgB,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;QAC3E,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,YAAY,IAAI,KAAK,GAAG,UAAU,IAAI,0BAA0B,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,IAAI,CAAC,CAAC;QAE1J,IAAI,QAAQ,IAAI,CAAC,EAAE,CAAC;YAClB,IAAI,0BAA0B,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,KAAK,IAAI,EAAE,CAAC;gBACxE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;YAC1C,CAAC;YACD,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;YAChC,YAAY,CAAC,QAAQ,CAAC,GAAG,2BAA2B,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;YAClG,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;QAC3F,CAAC;QAED,MAAM,YAAY,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAChC,YAAY,CAAC,MAAM,CAAC,YAAY,GAAG,CAAC,EAAE,CAAC,EAAE,oBAAoB,CAAC,CAAC;QAC/D,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC;IAC3F,CAAC;IAED,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IAChF,OAAO;QACL,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,GAAG,MAAM,kCAAkC;KACrD,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,gBAAgB,CAAC,UAAkB;IAChD,MAAM,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAEtD,MAAM,GAAG,GAAG,MAAM,gBAAgB,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;IAEnD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,uBAAuB,CAAC,GAAG,CAAC,CAAC;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED,MAAM,UAAU,GAAG,MAAM,oBAAoB,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;IAE/D,MAAM,SAAS,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,CAAC;AACvC,CAAC;AAED,KAAK,UAAU,+BAA+B,CAC5C,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,aAAa,CAAC;IAC3B,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,cAAc,GAAG,MAAM,mBAAmB,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IACrF,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU;QACV,UAAU,EAAE,cAAc,CAAC,UAAU;QACrC,OAAO,EAAE,kEAAkE;KAC5E,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,2BAA2B,CACxC,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,QAAQ,CAAC;IACtB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,gBAAgB,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAC5D,MAAM,UAAU,GAAG,MAAM,uBAAuB,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IACrF,MAAM,kBAAkB,GAAG,MAAM,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;IAC3E,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,eAAe,EAAE,CAAC,gBAAgB,CAAC;QACnC,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,eAAe,EAAE,CAAC,gBAAgB,CAAC;QACnC,UAAU;QACV,UAAU,EAAE,UAAU,CAAC,UAAU,IAAI,kBAAkB,CAAC,UAAU;QAClE,OAAO,EAAE,6FAA6F;KACvG,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,8BAA8B,CAC3C,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,YAAY,CAAC;IAC1B,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,cAAc,GAAG,MAAM,mBAAmB,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IACrF,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU;QACV,UAAU,EAAE,cAAc,CAAC,UAAU;QACrC,OAAO,EAAE,iEAAiE;KAC3E,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,2BAA2B,CACxC,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,QAAQ,CAAC;IACtB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,yBAAyB,CAAC,OAAO,CAAC,CAAC;IACxD,MAAM,cAAc,GAAG,MAAM,gBAAgB,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IAClF,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU;QACV,UAAU,EAAE,cAAc,CAAC,UAAU;QACrC,OAAO,EAAE,0DAA0D;KACpE,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,6BAA6B,CAC1C,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,UAAU,CAAC;IACxB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,2BAA2B,CAAC,OAAO,CAAC,CAAC;IAC1D,MAAM,cAAc,GAAG,MAAM,kBAAkB,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IACpF,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,UAAU;QACV,UAAU,EAAE,cAAc,CAAC,UAAU;QACrC,OAAO,EAAE,6DAA6D;KACvE,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,0BAA0B,CACvC,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,IAAI,GAAG,OAAO,CAAC;IACrB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,IAAI,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACvF,MAAM,YAAY,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAAC;IACvD,MAAM,UAAU,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAC/C,MAAM,WAAW,GAAG,MAAM,eAAe,CAAC,YAAY,EAAE,QAAQ,UAAU,EAAE,CAAC,CAAC;IAC9E,MAAM,YAAY,GAAG,MAAM,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACxD,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,eAAe,EAAE,CAAC,UAAU,CAAC;QAC7B,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,IAAI;QAChB,cAAc,EAAE,IAAI;QACpB,IAAI;QACJ,UAAU;QACV,YAAY;QACZ,eAAe,EAAE,CAAC,UAAU,CAAC;QAC7B,UAAU;QACV,UAAU,EAAE,WAAW,CAAC,UAAU,IAAI,YAAY,CAAC,UAAU;QAC7D,OAAO,EAAE,4GAA4G;KACtH,CAAC;AACJ,CAAC;AAED,KAAK,UAAU,iCAAiC,CAC9C,gBAAwB,EACxB,OAAe,EACf,WAAmB,EACnB,gBAAyB;IAEzB,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,wBAAwB,CAAC,gBAAgB,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC;IACnG,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,OAAO,EAAE;QAChD,IAAI,EAAE,gBAAgB;QACtB,UAAU;QACV,YAAY,EAAE,SAAS;QACvB,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,IAAI;QACpB,WAAW;KACZ,CAAC,CAAC;IAEH,OAAO;QACL,SAAS,EAAE,IAAI;QACf,SAAS,EAAE,IAAI;QACf,UAAU,EAAE,KAAK;QACjB,cAAc,EAAE,IAAI;QACpB,IAAI,EAAE,gBAAgB;QACtB,UAAU;QACV,UAAU;QACV,OAAO,EAAE,kDAAkD,gBAAgB,0DAA0D;KACtI,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAc,EACd,UAAwC,EAAE;IAE1C,MAAM,gBAAgB,GAAG,6BAA6B,CAAC,MAAM,CAAC,CAAC;IAC/D,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,OAAO,EAAE,CAAC;IAC7C,MAAM,WAAW,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAE9D,IAAI,gBAAgB,KAAK,aAAa,EAAE,CAAC;QACvC,OAAO,+BAA+B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACzF,CAAC;IAED,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAClC,OAAO,2BAA2B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACrF,CAAC;IAED,IAAI,gBAAgB,KAAK,YAAY,EAAE,CAAC;QACtC,OAAO,8BAA8B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACxF,CAAC;IAED,IAAI,gBAAgB,KAAK,QAAQ,EAAE,CAAC;QAClC,OAAO,2BAA2B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACrF,CAAC;IAED,IAAI,gBAAgB,KAAK,UAAU,EAAE,CAAC;QACpC,OAAO,6BAA6B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvF,CAAC;IAED,IAAI,gBAAgB,KAAK,OAAO,EAAE,CAAC;QACjC,OAAO,0BAA0B,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACpF,CAAC;IAED,IAAI,sBAAsB,CAAC,gBAAgB,CAAC,EAAE,CAAC;QAC7C,OAAO,iCAAiC,CAAC,gBAAgB,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC7G,CAAC;IAED,OAAO;QACL,SAAS,EAAE,KAAK;QAChB,SAAS,EAAE,KAAK;QAChB,UAAU,EAAE,KAAK;QACjB,IAAI,EAAE,gBAAgB;QACtB,OAAO,EAAE,6DAA6D,gBAAgB,GAAG;KAC1F,CAAC;AACJ,CAAC","sourcesContent":["import { dirname } from 'node:path';\nimport { homedir } from 'node:os';\nimport { mkdir, writeFile } from 'node:fs/promises';\nimport {\n  type InstallPermissionHookOptions,\n  type InstallPermissionHookResult,\n  detectIndent,\n  ensureCommandHook,\n  getClaudeHookSettingsPath,\n  getCodexConfigPath,\n  getCodexHookSettingsPath,\n  getCursorHookSettingsPath,\n  getGeminiHookSettingsPath,\n  getHookWrapperBasename,\n  normalizeHooksRoot,\n  getVsCodeHookSettingsPath,\n  getVsCodeUserSettingsPath,\n  getWindsurfHookSettingsPath,\n  installHookAssetsForHost,\n  normalizeHookHost,\n  readOptionalUtf8,\n  writeHookMarker,\n  writeBackupIfPresent,\n} from './permissionHookShared.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\n\nfunction normalizePermissionHookClient(client: string): string {\n  const normalizedClient = UnicodeValidator.normalize(client).normalizedContent;\n  return normalizeHookHost(normalizedClient);\n}\n\nexport function ensureClaudePreToolUseHook(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  return ensureCommandHook(parsed, 'PreToolUse', command, '*');\n}\n\nexport function ensureVsCodePreToolUseHook(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  return ensureCommandHook(parsed, 'PreToolUse', command, '*');\n}\n\nexport function ensureGeminiBeforeToolHook(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  return ensureCommandHook(parsed, 'BeforeTool', command, '.*');\n}\n\nexport function ensureCodexPreToolUseHook(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  return ensureCommandHook(parsed, 'PreToolUse', command, 'Bash', {\n    statusMessage: 'Checking Bash permissions',\n  });\n}\n\nexport function ensureCursorPreToolUseHook(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  if (parsed.version !== 1) {\n    parsed.version = 1;\n  }\n  const hooksRoot = normalizeHooksRoot(parsed);\n  const existingEntries: Array<Record<string, unknown>> = Array.isArray(hooksRoot.preToolUse)\n    ? hooksRoot.preToolUse.filter((entry): entry is Record<string, unknown> => typeof entry === 'object' && entry !== null)\n    : [];\n  hooksRoot.preToolUse = existingEntries;\n\n  const commandExists = existingEntries.some((entry) =>\n    entry.command === command\n    && (entry.type === 'command' || entry.type === undefined),\n  );\n  if (commandExists) {\n    return { changed: false, parsed };\n  }\n\n  existingEntries.push({\n    type: 'command',\n    command,\n    matcher: '.*',\n  });\n\n  return { changed: true, parsed };\n}\n\nexport function ensureWindsurfHooks(\n  parsed: Record<string, unknown>,\n  command: string,\n): { changed: boolean; parsed: Record<string, unknown> } {\n  const hooksRoot = normalizeHooksRoot(parsed);\n  let changed = false;\n\n  const ensureEventHook = (eventName: string) => {\n    const existingEntries: Array<Record<string, unknown>> = Array.isArray(hooksRoot[eventName])\n      ? hooksRoot[eventName].filter((entry): entry is Record<string, unknown> => typeof entry === 'object' && entry !== null)\n      : [];\n    hooksRoot[eventName] = existingEntries;\n\n    const commandExists = existingEntries.some((entry) =>\n      entry.command === command && (entry.type === 'command' || entry.type === undefined),\n    );\n    if (commandExists) {\n      return;\n    }\n\n    existingEntries.push({\n      type: 'command',\n      command,\n    });\n    changed = true;\n  };\n\n  ensureEventHook('pre_run_command');\n  ensureEventHook('pre_mcp_tool_use');\n\n  return { changed, parsed };\n}\n\nasync function mergeClaudeSettings(settingsPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureClaudePreToolUseHook(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n\n  await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeVsCodeHookSettings(settingsPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureVsCodePreToolUseHook(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n\n  await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeVsCodeUserSettings(settingsPath: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{}\\n');\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const current = parsed['chat.hookFilesLocations'];\n  const locations = (current && typeof current === 'object' && !Array.isArray(current))\n    ? { ...(current as Record<string, unknown>) }\n    : {};\n\n  if (locations['~/.copilot/hooks'] === true) {\n    return { changed: false };\n  }\n\n  locations['~/.copilot/hooks'] = true;\n  parsed['chat.hookFilesLocations'] = locations;\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n  await writeFile(settingsPath, JSON.stringify(parsed, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeGeminiSettings(settingsPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureGeminiBeforeToolHook(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n\n  await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeCursorHooks(settingsPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{\\n  \"version\": 1,\\n  \"hooks\": {}\\n}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureCursorPreToolUseHook(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n\n  await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeWindsurfHooks(settingsPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(settingsPath, '{\\n  \"hooks\": {}\\n}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureWindsurfHooks(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(settingsPath, raw);\n\n  await writeFile(settingsPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function mergeCodexHooks(hooksPath: string, command: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(hooksPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(hooksPath, '{}\\n');\n\n  const indent = detectIndent(raw);\n  const parsed = raw.trim().length === 0 ? {} : JSON.parse(raw) as Record<string, unknown>;\n  const { changed, parsed: updated } = ensureCodexPreToolUseHook(parsed, command);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(hooksPath, raw);\n\n  await writeFile(hooksPath, JSON.stringify(updated, null, indent) + '\\n', 'utf-8');\n  return { changed: true, backupPath };\n}\n\nfunction getTomlLineContent(line: string): string {\n  const commentIndex = line.indexOf('#');\n  return (commentIndex >= 0 ? line.slice(0, commentIndex) : line).trim();\n}\n\nfunction isTomlSectionLine(line: string, section: string): boolean {\n  return getTomlLineContent(line) === `[${section}]`;\n}\n\nfunction parseTomlBooleanAssignment(line: string, key: string): boolean | null {\n  const content = getTomlLineContent(line);\n  if (!content.startsWith(`${key} = `)) {\n    return null;\n  }\n  const value = content.slice(`${key} = `.length).trim();\n  if (value === 'true') return true;\n  if (value === 'false') return false;\n  return null;\n}\n\nfunction updateTomlBooleanAssignment(line: string, key: string, nextValue: boolean): string {\n  const commentIndex = line.indexOf('#');\n  const commentSuffix = commentIndex >= 0 ? line.slice(commentIndex) : '';\n  let prefixLength = 0;\n  while (prefixLength < line.length && /\\s/.test(line.charAt(prefixLength))) {\n    prefixLength += 1;\n  }\n  const prefix = line.slice(0, prefixLength);\n  const assignment = `${prefix}${key} = ${nextValue ? 'true' : 'false'}`;\n  const trimmedCommentSuffix = commentSuffix.trimStart();\n  const suffix = trimmedCommentSuffix.length > 0 ? ` ${trimmedCommentSuffix}` : '';\n  return `${assignment}${suffix}`.trimEnd();\n}\n\nfunction stripTrailingNewlines(value: string): string {\n  let end = value.length;\n  while (end > 0 && value.charAt(end - 1) === '\\n') {\n    end -= 1;\n  }\n  return value.slice(0, end);\n}\n\nfunction ensureCodexHooksEnabled(raw: string): { changed: boolean; content: string } {\n  const lines = raw.length > 0 ? raw.split('\\n') : [];\n  const dottedIndex = lines.findIndex((line) => parseTomlBooleanAssignment(line, 'features.codex_hooks') !== null);\n  if (dottedIndex >= 0) {\n    if (parseTomlBooleanAssignment(lines[dottedIndex], 'features.codex_hooks') === true) {\n      return { changed: false, content: raw };\n    }\n    const updatedLines = [...lines];\n    updatedLines[dottedIndex] = updateTomlBooleanAssignment(updatedLines[dottedIndex], 'features.codex_hooks', true);\n    return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\\n'))}\\n` };\n  }\n\n  const sectionIndex = lines.findIndex((line) => isTomlSectionLine(line, 'features'));\n  if (sectionIndex >= 0) {\n    const nextSectionIndex = lines.findIndex((line, index) => index > sectionIndex && getTomlLineContent(line).startsWith('[') && getTomlLineContent(line).endsWith(']'));\n    const sectionEnd = nextSectionIndex >= 0 ? nextSectionIndex : lines.length;\n    const keyIndex = lines.findIndex((line, index) => index > sectionIndex && index < sectionEnd && parseTomlBooleanAssignment(line, 'codex_hooks') !== null);\n\n    if (keyIndex >= 0) {\n      if (parseTomlBooleanAssignment(lines[keyIndex], 'codex_hooks') === true) {\n        return { changed: false, content: raw };\n      }\n      const updatedLines = [...lines];\n      updatedLines[keyIndex] = updateTomlBooleanAssignment(updatedLines[keyIndex], 'codex_hooks', true);\n      return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\\n'))}\\n` };\n    }\n\n    const updatedLines = [...lines];\n    updatedLines.splice(sectionIndex + 1, 0, 'codex_hooks = true');\n    return { changed: true, content: `${stripTrailingNewlines(updatedLines.join('\\n'))}\\n` };\n  }\n\n  const prefix = raw.trim().length > 0 ? `${stripTrailingNewlines(raw)}\\n\\n` : '';\n  return {\n    changed: true,\n    content: `${prefix}[features]\\ncodex_hooks = true\\n`,\n  };\n}\n\nasync function mergeCodexConfig(configPath: string): Promise<{ changed: boolean; backupPath?: string }> {\n  await mkdir(dirname(configPath), { recursive: true });\n\n  const raw = await readOptionalUtf8(configPath, '');\n\n  const { changed, content } = ensureCodexHooksEnabled(raw);\n  if (!changed) {\n    return { changed: false };\n  }\n\n  const backupPath = await writeBackupIfPresent(configPath, raw);\n\n  await writeFile(configPath, content, 'utf-8');\n  return { changed: true, backupPath };\n}\n\nasync function installClaudeCodePermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'claude-code';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getClaudeHookSettingsPath(homeDir);\n  const settingsResult = await mergeClaudeSettings(settingsPath, `bash ${scriptPath}`);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    markerPath,\n    backupPath: settingsResult.backupPath,\n    message: 'Installed Claude Code permission hook and updated settings.json.',\n  };\n}\n\nasync function installVsCodePermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'vscode';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getVsCodeHookSettingsPath(homeDir);\n  const userSettingsPath = getVsCodeUserSettingsPath(homeDir);\n  const hookResult = await mergeVsCodeHookSettings(settingsPath, `bash ${scriptPath}`);\n  const userSettingsResult = await mergeVsCodeUserSettings(userSettingsPath);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    additionalPaths: [userSettingsPath],\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    additionalPaths: [userSettingsPath],\n    markerPath,\n    backupPath: hookResult.backupPath ?? userSettingsResult.backupPath,\n    message: 'Installed VS Code permission hook and enabled chat.hookFilesLocations for ~/.copilot/hooks.',\n  };\n}\n\nasync function installGeminiCliPermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'gemini-cli';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getGeminiHookSettingsPath(homeDir);\n  const settingsResult = await mergeGeminiSettings(settingsPath, `bash ${scriptPath}`);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    markerPath,\n    backupPath: settingsResult.backupPath,\n    message: 'Installed Gemini CLI permission hook and updated settings.json.',\n  };\n}\n\nasync function installCursorPermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'cursor';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getCursorHookSettingsPath(homeDir);\n  const settingsResult = await mergeCursorHooks(settingsPath, `bash ${scriptPath}`);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    markerPath,\n    backupPath: settingsResult.backupPath,\n    message: 'Installed Cursor permission hook and updated hooks.json.',\n  };\n}\n\nasync function installWindsurfPermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'windsurf';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getWindsurfHookSettingsPath(homeDir);\n  const settingsResult = await mergeWindsurfHooks(settingsPath, `bash ${scriptPath}`);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    markerPath,\n    backupPath: settingsResult.backupPath,\n    message: 'Installed Windsurf permission hooks and updated hooks.json.',\n  };\n}\n\nasync function installCodexPermissionHook(\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const host = 'codex';\n  const { scriptPath } = await installHookAssetsForHost(host, homeDir, sourceScriptPath);\n  const settingsPath = getCodexHookSettingsPath(homeDir);\n  const configPath = getCodexConfigPath(homeDir);\n  const hooksResult = await mergeCodexHooks(settingsPath, `bash ${scriptPath}`);\n  const configResult = await mergeCodexConfig(configPath);\n  const markerPath = await writeHookMarker(homeDir, {\n    host,\n    scriptPath,\n    settingsPath,\n    additionalPaths: [configPath],\n    configured: true,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: true,\n    assetsPrepared: true,\n    host,\n    scriptPath,\n    settingsPath,\n    additionalPaths: [configPath],\n    markerPath,\n    backupPath: hooksResult.backupPath ?? configResult.backupPath,\n    message: 'Installed Codex Bash permission hook, created hooks.json, and enabled features.codex_hooks in config.toml.',\n  };\n}\n\nasync function installManualPermissionHookAssets(\n  normalizedClient: string,\n  homeDir: string,\n  installedAt: string,\n  sourceScriptPath?: string,\n): Promise<InstallPermissionHookResult> {\n  const { scriptPath } = await installHookAssetsForHost(normalizedClient, homeDir, sourceScriptPath);\n  const markerPath = await writeHookMarker(homeDir, {\n    host: normalizedClient,\n    scriptPath,\n    settingsPath: undefined,\n    configured: false,\n    assetsPrepared: true,\n    installedAt,\n  });\n\n  return {\n    supported: true,\n    installed: true,\n    configured: false,\n    assetsPrepared: true,\n    host: normalizedClient,\n    scriptPath,\n    markerPath,\n    message: `Installed Dollhouse permission hook assets for ${normalizedClient}. Finish the client-specific hook registration manually.`,\n  };\n}\n\nexport async function installPermissionHook(\n  client: string,\n  options: InstallPermissionHookOptions = {},\n): Promise<InstallPermissionHookResult> {\n  const normalizedClient = normalizePermissionHookClient(client);\n  const homeDir = options.homeDir ?? homedir();\n  const installedAt = (options.now ?? new Date()).toISOString();\n\n  if (normalizedClient === 'claude-code') {\n    return installClaudeCodePermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (normalizedClient === 'vscode') {\n    return installVsCodePermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (normalizedClient === 'gemini-cli') {\n    return installGeminiCliPermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (normalizedClient === 'cursor') {\n    return installCursorPermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (normalizedClient === 'windsurf') {\n    return installWindsurfPermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (normalizedClient === 'codex') {\n    return installCodexPermissionHook(homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  if (getHookWrapperBasename(normalizedClient)) {\n    return installManualPermissionHookAssets(normalizedClient, homeDir, installedAt, options.sourceScriptPath);\n  }\n\n  return {\n    supported: false,\n    installed: false,\n    configured: false,\n    host: normalizedClient,\n    message: `Automatic permission hook wiring is not yet supported for ${normalizedClient}.`,\n  };\n}\n"]}