@dollhousemcp/mcp-server 2.0.29 → 2.0.31

package/dist/utils/permissionHookShared.js

@@ -0,0 +1,425 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { access, chmod, copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir, platform } from 'node:os';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { logger } from './logger.js';
+export const MANAGED_HOOK_WRAPPER_BASENAMES = {
+    'vscode': 'pretooluse-vscode.sh',
+    'cursor': 'pretooluse-cursor.sh',
+    'windsurf': 'pretooluse-windsurf.sh',
+    'gemini-cli': 'pretooluse-gemini.sh',
+    'codex': 'pretooluse-codex.sh',
+};
+export const WRAPPER_HOOK_HOSTS = Object.keys(MANAGED_HOOK_WRAPPER_BASENAMES);
+export const AUTO_REPAIRABLE_HOOK_HOSTS = ['claude-code', ...WRAPPER_HOOK_HOSTS];
+function repoRootFromModule() {
+    const currentFile = fileURLToPath(import.meta.url);
+    return dirname(dirname(dirname(currentFile)));
+}
+export function isMissingFileError(error) {
+    return Boolean(error
+        && typeof error === 'object'
+        && 'code' in error
+        && error.code === 'ENOENT');
+}
+export function detectIndent(raw) {
+    for (const line of raw.split('\n')) {
+        if (line.length === 0 || line.startsWith('{') || line.startsWith('}'))
+            continue;
+        if (line.startsWith('\t'))
+            return '\t';
+        if (line.startsWith(' ')) {
+            const spaces = line.length - line.trimStart().length;
+            if (spaces >= 2)
+                return spaces;
+        }
+    }
+    return 2;
+}
+export function getPermissionHookScriptPath(homeDir = homedir()) {
+    return join(homeDir, '.dollhouse', 'hooks', 'pretooluse-dollhouse.sh');
+}
+function getPermissionHookRunDir(homeDir = homedir()) {
+    return join(homeDir, '.dollhouse', 'run');
+}
+export function getPermissionHookDiagnosticsPath(homeDir = homedir()) {
+    return join(getPermissionHookRunDir(homeDir), 'permission-hook-diagnostics.jsonl');
+}
+export function normalizeHookHost(host) {
+    return UnicodeValidator.normalize(host).normalizedContent.trim().toLowerCase();
+}
+function isHookMarkerFilename(entry) {
+    return entry.startsWith('hook-installed-') && entry.endsWith('.json');
+}
+export function readHostSpecificHookStatus(homeDir, host) {
+    const normalized = normalizeHookHost(host);
+    const status = readMarkerStatus(getPermissionHookMarkerPath(homeDir, normalized));
+    if (status.installed || status.assetsPrepared) {
+        return status;
+    }
+    if (normalized === 'claude-code') {
+        return readMarkerStatus(getPermissionHookMarkerPath(homeDir));
+    }
+    return { installed: false };
+}
+export function collectHookMarkerPaths(homeDir) {
+    const markerPaths = new Set([getPermissionHookMarkerPath(homeDir)]);
+    const runDir = getPermissionHookRunDir(homeDir);
+    try {
+        for (const entry of readdirSync(runDir)) {
+            if (isHookMarkerFilename(entry)) {
+                markerPaths.add(join(runDir, entry));
+            }
+        }
+    }
+    catch {
+        // No run dir yet — fall through to default false.
+    }
+    return markerPaths;
+}
+export async function collectHookMarkerPathsAsync(homeDir) {
+    const markerPaths = new Set([getPermissionHookMarkerPath(homeDir)]);
+    const runDir = getPermissionHookRunDir(homeDir);
+    try {
+        for (const entry of await readdir(runDir)) {
+            if (isHookMarkerFilename(entry)) {
+                markerPaths.add(join(runDir, entry));
+            }
+        }
+    }
+    catch {
+        // No run dir yet — fall through to default false.
+    }
+    return markerPaths;
+}
+export function summarizeMarkerStatuses(markerPaths) {
+    let fallback = { installed: false };
+    for (const markerPath of markerPaths) {
+        const status = readMarkerStatus(markerPath);
+        if (status.installed)
+            return status;
+        if (!fallback.assetsPrepared && status.assetsPrepared)
+            fallback = status;
+    }
+    return fallback;
+}
+export function getHookWrapperBasename(host) {
+    const normalizedHost = normalizeHookHost(host);
+    return MANAGED_HOOK_WRAPPER_BASENAMES[normalizedHost] ?? null;
+}
+export function getHookWrapperPath(host, homeDir = homedir()) {
+    const basename = getHookWrapperBasename(host);
+    return basename ? join(homeDir, '.dollhouse', 'hooks', basename) : null;
+}
+export function getHookSourcePath(host) {
+    const root = repoRootFromModule();
+    const basename = getHookWrapperBasename(host);
+    return basename ? join(root, 'scripts', basename) : join(root, 'scripts', 'pretooluse-dollhouse.sh');
+}
+export function supportsManagedHookAssets(host) {
+    const normalized = normalizeHookHost(host);
+    return normalized === 'claude-code' || getHookWrapperBasename(normalized) !== null;
+}
+export function getPrimaryHookScriptPath(host, homeDir = homedir()) {
+    return getHookWrapperPath(host, homeDir) ?? getPermissionHookScriptPath(homeDir);
+}
+export async function readLastPermissionHookDiagnostic(homeDir = homedir()) {
+    const diagnosticsPath = getPermissionHookDiagnosticsPath(homeDir);
+    try {
+        const raw = await readFile(diagnosticsPath, 'utf-8');
+        const lines = raw
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        const lastLine = lines.at(-1);
+        if (!lastLine) {
+            return null;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(lastLine);
+        }
+        catch (error) {
+            logger.warn(`[PermissionHooks] Failed to parse hook diagnostics JSON from ${diagnosticsPath}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            logger.warn(`[PermissionHooks] Ignoring malformed hook diagnostics entry from ${diagnosticsPath}: expected JSON object.`);
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        logger.warn(`[PermissionHooks] Failed to read hook diagnostics from ${diagnosticsPath}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+export function getManagedHookAssets(host, homeDir = homedir(), sourceScriptPath) {
+    const normalized = normalizeHookHost(host);
+    const hooksDir = dirname(getPermissionHookScriptPath(homeDir));
+    const assets = [
+        {
+            kind: 'bridge',
+            sourcePath: sourceScriptPath ?? join(repoRootFromModule(), 'scripts', 'pretooluse-dollhouse.sh'),
+            targetPath: getPermissionHookScriptPath(homeDir),
+        },
+        {
+            kind: 'port-helper',
+            sourcePath: join(repoRootFromModule(), 'scripts', 'permission-port-discovery.sh'),
+            targetPath: join(hooksDir, 'permission-port-discovery.sh'),
+        },
+        {
+            kind: 'config-helper',
+            sourcePath: join(repoRootFromModule(), 'scripts', 'permission-hook-config.sh'),
+            targetPath: join(hooksDir, 'permission-hook-config.sh'),
+        },
+    ];
+    const wrapperTargetPath = getHookWrapperPath(normalized, homeDir);
+    if (wrapperTargetPath) {
+        assets.push({
+            kind: 'wrapper',
+            sourcePath: getHookSourcePath(normalized),
+            targetPath: wrapperTargetPath,
+        });
+    }
+    return assets;
+}
+async function readOptionalUtf8File(filePath) {
+    try {
+        return await readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function auditHookAssets(host, homeDir = homedir(), sourceScriptPath) {
+    const assets = getManagedHookAssets(host, homeDir, sourceScriptPath);
+    const staleAssets = [];
+    let assetsPrepared = true;
+    for (const asset of assets) {
+        const sourceRaw = await readFile(asset.sourcePath, 'utf-8');
+        const targetRaw = await readOptionalUtf8File(asset.targetPath);
+        if (targetRaw === undefined) {
+            assetsPrepared = false;
+            staleAssets.push(asset);
+            continue;
+        }
+        if (targetRaw !== sourceRaw) {
+            staleAssets.push(asset);
+        }
+    }
+    return {
+        assetsPrepared,
+        assetsCurrent: staleAssets.length === 0,
+        staleAssets,
+    };
+}
+export function getPermissionHookMarkerPath(homeDir = homedir(), host) {
+    if (!host) {
+        return join(getPermissionHookRunDir(homeDir), 'hook-installed.json');
+    }
+    return join(getPermissionHookRunDir(homeDir), `hook-installed-${normalizeHookHost(host)}.json`);
+}
+export function getClaudeHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.claude', 'settings.json');
+}
+export function getVsCodeHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.copilot', 'hooks', 'dollhouse-permissions.json');
+}
+export function getVsCodeUserSettingsPath(homeDir = homedir()) {
+    const currentPlatform = platform();
+    if (currentPlatform === 'darwin') {
+        return join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+    }
+    if (currentPlatform === 'win32') {
+        const appData = process.env.APPDATA || join(homeDir, 'AppData', 'Roaming');
+        return join(appData, 'Code', 'User', 'settings.json');
+    }
+    return join(homeDir, '.config', 'Code', 'User', 'settings.json');
+}
+export function getGeminiHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.gemini', 'settings.json');
+}
+export function getCursorHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.cursor', 'hooks.json');
+}
+export function getWindsurfHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.codeium', 'windsurf', 'hooks.json');
+}
+export function getCodexHookSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.codex', 'hooks.json');
+}
+export function getCodexConfigPath(homeDir = homedir()) {
+    return join(homeDir, '.codex', 'config.toml');
+}
+function toPermissionHookStatus(raw) {
+    if (typeof raw.host !== 'string' ||
+        typeof raw.scriptPath !== 'string') {
+        return { installed: false };
+    }
+    const scriptReady = existsSync(raw.scriptPath);
+    const settingsReady = !raw.settingsPath || existsSync(raw.settingsPath);
+    const additionalPathsReady = !raw.additionalPaths || raw.additionalPaths.every((path) => existsSync(path));
+    const assetsPrepared = (raw.assetsPrepared ?? raw.configured ?? true) && scriptReady;
+    const configured = (raw.configured ?? true) && scriptReady && settingsReady && additionalPathsReady;
+    return {
+        installed: configured,
+        configured,
+        assetsPrepared,
+        host: raw.host,
+        scriptPath: raw.scriptPath,
+        settingsPath: raw.settingsPath,
+        additionalPaths: raw.additionalPaths,
+    };
+}
+function readMarkerStatus(markerPath) {
+    try {
+        const raw = readFileSync(markerPath, 'utf-8');
+        return toPermissionHookStatus(JSON.parse(raw));
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            logger.warn(`[Permissions] Failed to read hook marker at ${markerPath}: ${String(error)}`);
+        }
+        return { installed: false };
+    }
+}
+export function normalizeHooksRoot(parsed) {
+    const hooksValue = parsed.hooks;
+    if (!hooksValue || typeof hooksValue !== 'object' || Array.isArray(hooksValue)) {
+        parsed.hooks = {};
+    }
+    return parsed.hooks;
+}
+export function ensureCommandHook(parsed, eventName, command, matcher, extraHookFields = {}) {
+    const hooksRoot = normalizeHooksRoot(parsed);
+    const existingEntries = Array.isArray(hooksRoot[eventName])
+        ? hooksRoot[eventName].filter((entry) => typeof entry === 'object' && entry !== null)
+        : [];
+    hooksRoot[eventName] = existingEntries;
+    const commandExists = existingEntries.some((entry) => {
+        const hooks = Array.isArray(entry?.hooks) ? entry.hooks : [];
+        return hooks.some((hook) => hook?.type === 'command' && hook?.command === command);
+    });
+    if (commandExists) {
+        return { changed: false, parsed };
+    }
+    const wildcardEntry = existingEntries.find((entry) => (entry?.matcher === matcher || entry?.matcher === undefined) && Array.isArray(entry?.hooks));
+    if (wildcardEntry) {
+        const hooks = wildcardEntry.hooks;
+        hooks.push({
+            type: 'command',
+            command,
+            ...extraHookFields,
+        });
+    }
+    else {
+        existingEntries.push({
+            matcher,
+            hooks: [
+                {
+                    type: 'command',
+                    command,
+                    ...extraHookFields,
+                },
+            ],
+        });
+    }
+    return { changed: true, parsed };
+}
+async function copyHookAsset(sourcePath, targetPath) {
+    await mkdir(dirname(targetPath), { recursive: true });
+    const sourceRaw = await readFile(sourcePath, 'utf-8');
+    let targetRaw;
+    try {
+        targetRaw = await readFile(targetPath, 'utf-8');
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+    const changed = targetRaw === undefined || sourceRaw !== targetRaw;
+    if (changed) {
+        await copyFile(sourcePath, targetPath);
+    }
+    else {
+        await access(targetPath);
+    }
+    await chmod(targetPath, 0o755);
+    return changed;
+}
+export async function readOptionalUtf8(filePath, fallback) {
+    try {
+        return await readFile(filePath, 'utf-8');
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return fallback;
+        }
+        throw error;
+    }
+}
+export async function writeBackupIfPresent(filePath, raw) {
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    const backupPath = `${filePath}.dollhouse.bak`;
+    await writeFile(backupPath, raw, 'utf-8');
+    return backupPath;
+}
+export async function writeHookMarker(homeDir, marker) {
+    const markerPath = getPermissionHookMarkerPath(homeDir, marker.host);
+    await mkdir(dirname(markerPath), { recursive: true });
+    await writeFile(markerPath, JSON.stringify(marker, null, 2) + '\n', 'utf-8');
+    return markerPath;
+}
+export async function installHookAssetsForHost(client, homeDir, sourceScriptPath) {
+    const normalizedClient = normalizeHookHost(client);
+    const hooksDir = dirname(getPermissionHookScriptPath(homeDir));
+    const sharedTargetPath = getPermissionHookScriptPath(homeDir);
+    const sharedSourcePath = sourceScriptPath ?? join(repoRootFromModule(), 'scripts', 'pretooluse-dollhouse.sh');
+    const portHelperSourcePath = join(repoRootFromModule(), 'scripts', 'permission-port-discovery.sh');
+    const portHelperTargetPath = join(hooksDir, 'permission-port-discovery.sh');
+    const configHelperSourcePath = join(repoRootFromModule(), 'scripts', 'permission-hook-config.sh');
+    const configHelperTargetPath = join(hooksDir, 'permission-hook-config.sh');
+    const sharedStat = statSync(sharedSourcePath);
+    if (!sharedStat.isFile()) {
+        logger.warn(`[PermissionHooks] Shared hook bridge missing for ${normalizedClient}: ${sharedSourcePath}`);
+        throw new Error(`Permission hook source script not found: ${sharedSourcePath}`);
+    }
+    await copyHookAsset(sharedSourcePath, sharedTargetPath);
+    const portHelperStat = statSync(portHelperSourcePath);
+    if (!portHelperStat.isFile()) {
+        logger.warn(`[PermissionHooks] Port discovery helper missing for ${normalizedClient}: ${portHelperSourcePath}`);
+        throw new Error(`Permission hook helper script not found: ${portHelperSourcePath}`);
+    }
+    await copyHookAsset(portHelperSourcePath, portHelperTargetPath);
+    const configHelperStat = statSync(configHelperSourcePath);
+    if (!configHelperStat.isFile()) {
+        logger.warn(`[PermissionHooks] Config helper missing for ${normalizedClient}: ${configHelperSourcePath}`);
+        throw new Error(`Permission hook config helper not found: ${configHelperSourcePath}`);
+    }
+    await copyHookAsset(configHelperSourcePath, configHelperTargetPath);
+    const wrapperTargetPath = getHookWrapperPath(normalizedClient, homeDir);
+    if (!wrapperTargetPath) {
+        return { scriptPath: sharedTargetPath };
+    }
+    const wrapperSourcePath = getHookSourcePath(normalizedClient);
+    const wrapperStat = statSync(wrapperSourcePath);
+    if (!wrapperStat.isFile()) {
+        logger.warn(`[PermissionHooks] Wrapper hook script missing for ${normalizedClient}: ${wrapperSourcePath}`);
+        throw new Error(`Permission hook wrapper script not found: ${wrapperSourcePath}`);
+    }
+    await copyHookAsset(wrapperSourcePath, wrapperTargetPath);
+    return { scriptPath: wrapperTargetPath };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionHookShared.js","sourceRoot":"","sources":["../../src/utils/permissionHookShared.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';\nimport { access, chmod, copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { homedir, platform } from 'node:os';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { logger } from './logger.js';\n\nexport interface PermissionHookMarker {\n  host: string;\n  scriptPath: string;\n  settingsPath?: string;\n  additionalPaths?: string[];\n  configured?: boolean;\n  assetsPrepared?: boolean;\n  installedAt: string;\n}\n\nexport interface PermissionHookStatus {\n  installed: boolean;\n  configured?: boolean;\n  assetsPrepared?: boolean;\n  assetsCurrent?: boolean;\n  autoRepaired?: boolean;\n  needsRepair?: boolean;\n  repairError?: string;\n  host?: string;\n  scriptPath?: string;\n  settingsPath?: string;\n  additionalPaths?: string[];\n}\n\n/** Latest JSONL diagnostic event emitted by a local permission hook wrapper. */\nexport interface PermissionHookDiagnosticRecord {\n  timestamp: string;\n  invocationId: string;\n  event: string;\n  platform: string;\n  stage: string;\n  outcome?: string;\n  reason?: string;\n  hookPath?: string;\n  diagnosticsLogPath?: string;\n  sessionId?: string;\n  toolName?: string;\n  toolInput?: string;\n  rawInput?: string;\n  authorityHost?: string;\n  authorityMode?: string;\n  endpoint?: string;\n  port?: string;\n  payload?: string;\n  response?: string;\n  normalizedResponse?: string;\n  emittedResponse?: string;\n  attempt?: string;\n  maxRetries?: string;\n  timeoutSeconds?: string;\n  curlExit?: string;\n  rawInputLength?: number;\n  normalizedResponseLength?: number;\n  emittedResponseLength?: number;\n  responseLength?: number;\n}\n\nexport interface InstallPermissionHookResult {\n  supported: boolean;\n  installed: boolean;\n  configured: boolean;\n  assetsPrepared?: boolean;\n  host: string;\n  scriptPath?: string;\n  settingsPath?: string;\n  additionalPaths?: string[];\n  markerPath?: string;\n  backupPath?: string;\n  message: string;\n}\n\nexport interface InstallPermissionHookOptions {\n  homeDir?: string;\n  sourceScriptPath?: string;\n  now?: Date;\n}\n\nexport interface ReconcilePermissionHookOptions {\n  homeDir?: string;\n  sourceScriptPath?: string;\n  autoRepair?: boolean;\n}\n\n/** Aggregate health and repair state for all managed local hook hosts. */\nexport interface PermissionHookAuditSummary {\n  installedHosts: string[];\n  currentHosts: string[];\n  repairedHosts: string[];\n  needsRepairHosts: string[];\n  diagnosticsPath: string;\n  lastDiagnostic: PermissionHookDiagnosticRecord | null;\n  lastStartupRepair: PermissionHookStartupRepairSummary | null;\n}\n\n/** Condensed health view surfaced in setup, permissions, and build info. */\nexport interface PermissionHookHealthSummary {\n  status: 'ok' | 'warning' | 'error';\n  message: string;\n  repairedCount: number;\n  needsRepairCount: number;\n  lastCheckedAt?: string;\n}\n\nexport interface PermissionHookStartupRepairHostResult extends PermissionHookStatus {\n  host: string;\n  outcome: 'current' | 'repaired' | 'needs_repair' | 'not_installed' | 'error';\n}\n\n/** Result summary for the most recent startup-time hook asset repair pass. */\nexport interface PermissionHookStartupRepairSummary {\n  startedAt: string;\n  completedAt: string;\n  durationMs: number;\n  repairedCount: number;\n  needsRepairCount: number;\n  hostResults: PermissionHookStartupRepairHostResult[];\n}\n\nexport interface HookAssetDescriptor {\n  kind: 'bridge' | 'port-helper' | 'config-helper' | 'wrapper';\n  sourcePath: string;\n  targetPath: string;\n}\n\nexport interface HookAssetAuditResult {\n  assetsPrepared: boolean;\n  assetsCurrent: boolean;\n  staleAssets: HookAssetDescriptor[];\n}\n\nexport const MANAGED_HOOK_WRAPPER_BASENAMES = {\n  'vscode': 'pretooluse-vscode.sh',\n  'cursor': 'pretooluse-cursor.sh',\n  'windsurf': 'pretooluse-windsurf.sh',\n  'gemini-cli': 'pretooluse-gemini.sh',\n  'codex': 'pretooluse-codex.sh',\n} as const;\n\nexport const WRAPPER_HOOK_HOSTS = Object.keys(MANAGED_HOOK_WRAPPER_BASENAMES) as Array<keyof typeof MANAGED_HOOK_WRAPPER_BASENAMES>;\n\nexport const AUTO_REPAIRABLE_HOOK_HOSTS = ['claude-code', ...WRAPPER_HOOK_HOSTS] as const;\n\nfunction repoRootFromModule(): string {\n  const currentFile = fileURLToPath(import.meta.url);\n  return dirname(dirname(dirname(currentFile)));\n}\n\nexport function isMissingFileError(error: unknown): boolean {\n  return Boolean(\n    error\n    && typeof error === 'object'\n    && 'code' in error\n    && (error as { code?: string }).code === 'ENOENT',\n  );\n}\n\nexport function detectIndent(raw: string): number | string {\n  for (const line of raw.split('\\n')) {\n    if (line.length === 0 || line.startsWith('{') || line.startsWith('}')) continue;\n    if (line.startsWith('\\t')) return '\\t';\n    if (line.startsWith(' ')) {\n      const spaces = line.length - line.trimStart().length;\n      if (spaces >= 2) return spaces;\n    }\n  }\n  return 2;\n}\n\nexport function getPermissionHookScriptPath(homeDir = homedir()): string {\n  return join(homeDir, '.dollhouse', 'hooks', 'pretooluse-dollhouse.sh');\n}\n\nfunction getPermissionHookRunDir(homeDir = homedir()): string {\n  return join(homeDir, '.dollhouse', 'run');\n}\n\nexport function getPermissionHookDiagnosticsPath(homeDir = homedir()): string {\n  return join(getPermissionHookRunDir(homeDir), 'permission-hook-diagnostics.jsonl');\n}\n\nexport function normalizeHookHost(host: string): string {\n  return UnicodeValidator.normalize(host).normalizedContent.trim().toLowerCase();\n}\n\nfunction isHookMarkerFilename(entry: string): boolean {\n  return entry.startsWith('hook-installed-') && entry.endsWith('.json');\n}\n\nexport function readHostSpecificHookStatus(homeDir: string, host: string): PermissionHookStatus {\n  const normalized = normalizeHookHost(host);\n  const status = readMarkerStatus(getPermissionHookMarkerPath(homeDir, normalized));\n  if (status.installed || status.assetsPrepared) {\n    return status;\n  }\n  if (normalized === 'claude-code') {\n    return readMarkerStatus(getPermissionHookMarkerPath(homeDir));\n  }\n  return { installed: false };\n}\n\nexport function collectHookMarkerPaths(homeDir: string): Set<string> {\n  const markerPaths = new Set<string>([getPermissionHookMarkerPath(homeDir)]);\n  const runDir = getPermissionHookRunDir(homeDir);\n  try {\n    for (const entry of readdirSync(runDir)) {\n      if (isHookMarkerFilename(entry)) {\n        markerPaths.add(join(runDir, entry));\n      }\n    }\n  } catch {\n    // No run dir yet — fall through to default false.\n  }\n  return markerPaths;\n}\n\nexport async function collectHookMarkerPathsAsync(homeDir: string): Promise<Set<string>> {\n  const markerPaths = new Set<string>([getPermissionHookMarkerPath(homeDir)]);\n  const runDir = getPermissionHookRunDir(homeDir);\n  try {\n    for (const entry of await readdir(runDir)) {\n      if (isHookMarkerFilename(entry)) {\n        markerPaths.add(join(runDir, entry));\n      }\n    }\n  } catch {\n    // No run dir yet — fall through to default false.\n  }\n  return markerPaths;\n}\n\nexport function summarizeMarkerStatuses(markerPaths: Iterable<string>): PermissionHookStatus {\n  let fallback: PermissionHookStatus = { installed: false };\n  for (const markerPath of markerPaths) {\n    const status = readMarkerStatus(markerPath);\n    if (status.installed) return status;\n    if (!fallback.assetsPrepared && status.assetsPrepared) fallback = status;\n  }\n  return fallback;\n}\n\nexport function getHookWrapperBasename(host: string): string | null {\n  const normalizedHost = normalizeHookHost(host);\n  return MANAGED_HOOK_WRAPPER_BASENAMES[normalizedHost as keyof typeof MANAGED_HOOK_WRAPPER_BASENAMES] ?? null;\n}\n\nexport function getHookWrapperPath(host: string, homeDir = homedir()): string | null {\n  const basename = getHookWrapperBasename(host);\n  return basename ? join(homeDir, '.dollhouse', 'hooks', basename) : null;\n}\n\nexport function getHookSourcePath(host: string): string {\n  const root = repoRootFromModule();\n  const basename = getHookWrapperBasename(host);\n  return basename ? join(root, 'scripts', basename) : join(root, 'scripts', 'pretooluse-dollhouse.sh');\n}\n\nexport function supportsManagedHookAssets(host: string): boolean {\n  const normalized = normalizeHookHost(host);\n  return normalized === 'claude-code' || getHookWrapperBasename(normalized) !== null;\n}\n\nexport function getPrimaryHookScriptPath(host: string, homeDir = homedir()): string {\n  return getHookWrapperPath(host, homeDir) ?? getPermissionHookScriptPath(homeDir);\n}\n\nexport async function readLastPermissionHookDiagnostic(\n  homeDir = homedir(),\n): Promise<PermissionHookDiagnosticRecord | null> {\n  const diagnosticsPath = getPermissionHookDiagnosticsPath(homeDir);\n\n  try {\n    const raw = await readFile(diagnosticsPath, 'utf-8');\n    const lines = raw\n      .split('\\n')\n      .map((line) => line.trim())\n      .filter((line) => line.length > 0);\n    const lastLine = lines.at(-1);\n    if (!lastLine) {\n      return null;\n    }\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(lastLine) as unknown;\n    } catch (error) {\n      logger.warn(\n        `[PermissionHooks] Failed to parse hook diagnostics JSON from ${diagnosticsPath}: ${\n          error instanceof Error ? error.message : String(error)\n        }`,\n      );\n      return null;\n    }\n\n    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {\n      logger.warn(\n        `[PermissionHooks] Ignoring malformed hook diagnostics entry from ${diagnosticsPath}: expected JSON object.`,\n      );\n      return null;\n    }\n\n    return parsed as PermissionHookDiagnosticRecord;\n  } catch (error) {\n    if (isMissingFileError(error)) {\n      return null;\n    }\n\n    logger.warn(\n      `[PermissionHooks] Failed to read hook diagnostics from ${diagnosticsPath}: ${\n        error instanceof Error ? error.message : String(error)\n      }`,\n    );\n    return null;\n  }\n}\n\nexport function getManagedHookAssets(\n  host: string,\n  homeDir = homedir(),\n  sourceScriptPath?: string,\n): HookAssetDescriptor[] {\n  const normalized = normalizeHookHost(host);\n  const hooksDir = dirname(getPermissionHookScriptPath(homeDir));\n  const assets: HookAssetDescriptor[] = [\n    {\n      kind: 'bridge',\n      sourcePath: sourceScriptPath ?? join(repoRootFromModule(), 'scripts', 'pretooluse-dollhouse.sh'),\n      targetPath: getPermissionHookScriptPath(homeDir),\n    },\n    {\n      kind: 'port-helper',\n      sourcePath: join(repoRootFromModule(), 'scripts', 'permission-port-discovery.sh'),\n      targetPath: join(hooksDir, 'permission-port-discovery.sh'),\n    },\n    {\n      kind: 'config-helper',\n      sourcePath: join(repoRootFromModule(), 'scripts', 'permission-hook-config.sh'),\n      targetPath: join(hooksDir, 'permission-hook-config.sh'),\n    },\n  ];\n\n  const wrapperTargetPath = getHookWrapperPath(normalized, homeDir);\n  if (wrapperTargetPath) {\n    assets.push({\n      kind: 'wrapper',\n      sourcePath: getHookSourcePath(normalized),\n      targetPath: wrapperTargetPath,\n    });\n  }\n\n  return assets;\n}\n\nasync function readOptionalUtf8File(filePath: string): Promise<string | undefined> {\n  try {\n    return await readFile(filePath, 'utf-8');\n  } catch (error) {\n    if (isMissingFileError(error)) {\n      return undefined;\n    }\n    throw error;\n  }\n}\n\nexport async function auditHookAssets(\n  host: string,\n  homeDir = homedir(),\n  sourceScriptPath?: string,\n): Promise<HookAssetAuditResult> {\n  const assets = getManagedHookAssets(host, homeDir, sourceScriptPath);\n  const staleAssets: HookAssetDescriptor[] = [];\n  let assetsPrepared = true;\n\n  for (const asset of assets) {\n    const sourceRaw = await readFile(asset.sourcePath, 'utf-8');\n    const targetRaw = await readOptionalUtf8File(asset.targetPath);\n    if (targetRaw === undefined) {\n      assetsPrepared = false;\n      staleAssets.push(asset);\n      continue;\n    }\n    if (targetRaw !== sourceRaw) {\n      staleAssets.push(asset);\n    }\n  }\n\n  return {\n    assetsPrepared,\n    assetsCurrent: staleAssets.length === 0,\n    staleAssets,\n  };\n}\n\nexport function getPermissionHookMarkerPath(homeDir = homedir(), host?: string): string {\n  if (!host) {\n    return join(getPermissionHookRunDir(homeDir), 'hook-installed.json');\n  }\n  return join(getPermissionHookRunDir(homeDir), `hook-installed-${normalizeHookHost(host)}.json`);\n}\n\nexport function getClaudeHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.claude', 'settings.json');\n}\n\nexport function getVsCodeHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.copilot', 'hooks', 'dollhouse-permissions.json');\n}\n\nexport function getVsCodeUserSettingsPath(homeDir = homedir()): string {\n  const currentPlatform = platform();\n  if (currentPlatform === 'darwin') {\n    return join(homeDir, 'Library', 'Application Support', 'Code', 'User', 'settings.json');\n  }\n  if (currentPlatform === 'win32') {\n    const appData = process.env.APPDATA || join(homeDir, 'AppData', 'Roaming');\n    return join(appData, 'Code', 'User', 'settings.json');\n  }\n  return join(homeDir, '.config', 'Code', 'User', 'settings.json');\n}\n\nexport function getGeminiHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.gemini', 'settings.json');\n}\n\nexport function getCursorHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.cursor', 'hooks.json');\n}\n\nexport function getWindsurfHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.codeium', 'windsurf', 'hooks.json');\n}\n\nexport function getCodexHookSettingsPath(homeDir = homedir()): string {\n  return join(homeDir, '.codex', 'hooks.json');\n}\n\nexport function getCodexConfigPath(homeDir = homedir()): string {\n  return join(homeDir, '.codex', 'config.toml');\n}\n\nfunction toPermissionHookStatus(raw: PermissionHookMarker): PermissionHookStatus {\n  if (\n    typeof raw.host !== 'string' ||\n    typeof raw.scriptPath !== 'string'\n  ) {\n    return { installed: false };\n  }\n\n  const scriptReady = existsSync(raw.scriptPath);\n  const settingsReady = !raw.settingsPath || existsSync(raw.settingsPath);\n  const additionalPathsReady = !raw.additionalPaths || raw.additionalPaths.every((path) => existsSync(path));\n  const assetsPrepared = (raw.assetsPrepared ?? raw.configured ?? true) && scriptReady;\n  const configured = (raw.configured ?? true) && scriptReady && settingsReady && additionalPathsReady;\n\n  return {\n    installed: configured,\n    configured,\n    assetsPrepared,\n    host: raw.host,\n    scriptPath: raw.scriptPath,\n    settingsPath: raw.settingsPath,\n    additionalPaths: raw.additionalPaths,\n  };\n}\n\nfunction readMarkerStatus(markerPath: string): PermissionHookStatus {\n  try {\n    const raw = readFileSync(markerPath, 'utf-8');\n    return toPermissionHookStatus(JSON.parse(raw) as PermissionHookMarker);\n  } catch (error) {\n    if (!isMissingFileError(error)) {\n      logger.warn(`[Permissions] Failed to read hook marker at ${markerPath}: ${String(error)}`);\n    }\n    return { installed: false };\n  }\n}\n\nexport function normalizeHooksRoot(parsed: Record<string, unknown>): Record<string, unknown[]> {\n  const hooksValue = parsed.hooks;\n  if (!hooksValue || typeof hooksValue !== 'object' || Array.isArray(hooksValue)) {\n    parsed.hooks = {};\n  }\n  return parsed.hooks as Record<string, unknown[]>;\n}\n\nexport function ensureCommandHook(\n  parsed: Record<string, unknown>,\n  eventName: string,\n  command: string,\n  matcher: string,\n  extraHookFields: Record<string, unknown> = {},\n): { changed: boolean; parsed: Record<string, unknown> } {\n  const hooksRoot = normalizeHooksRoot(parsed);\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    const hooks = Array.isArray(entry?.hooks) ? entry.hooks as Array<Record<string, unknown>> : [];\n    return hooks.some((hook) => hook?.type === 'command' && hook?.command === command);\n  });\n  if (commandExists) {\n    return { changed: false, parsed };\n  }\n\n  const wildcardEntry = existingEntries.find((entry): entry is Record<string, unknown> =>\n    (entry?.matcher === matcher || entry?.matcher === undefined) && Array.isArray(entry?.hooks),\n  );\n\n  if (wildcardEntry) {\n    const hooks = wildcardEntry.hooks as Array<Record<string, unknown>>;\n    hooks.push({\n      type: 'command',\n      command,\n      ...extraHookFields,\n    });\n  } else {\n    existingEntries.push({\n      matcher,\n      hooks: [\n        {\n          type: 'command',\n          command,\n          ...extraHookFields,\n        },\n      ],\n    });\n  }\n\n  return { changed: true, parsed };\n}\n\nasync function copyHookAsset(sourcePath: string, targetPath: string): Promise<boolean> {\n  await mkdir(dirname(targetPath), { recursive: true });\n\n  const sourceRaw = await readFile(sourcePath, 'utf-8');\n\n  let targetRaw: string | undefined;\n  try {\n    targetRaw = await readFile(targetPath, 'utf-8');\n  } catch (error) {\n    if (!isMissingFileError(error)) {\n      throw error;\n    }\n  }\n  const changed = targetRaw === undefined || sourceRaw !== targetRaw;\n\n  if (changed) {\n    await copyFile(sourcePath, targetPath);\n  } else {\n    await access(targetPath);\n  }\n\n  await chmod(targetPath, 0o755);\n  return changed;\n}\n\nexport async function readOptionalUtf8(filePath: string, fallback: string): Promise<string> {\n  try {\n    return await readFile(filePath, 'utf-8');\n  } catch (error) {\n    if (isMissingFileError(error)) {\n      return fallback;\n    }\n    throw error;\n  }\n}\n\nexport async function writeBackupIfPresent(filePath: string, raw: string): Promise<string | undefined> {\n  if (!existsSync(filePath)) {\n    return undefined;\n  }\n\n  const backupPath = `${filePath}.dollhouse.bak`;\n  await writeFile(backupPath, raw, 'utf-8');\n  return backupPath;\n}\n\nexport async function writeHookMarker(\n  homeDir: string,\n  marker: PermissionHookMarker,\n): Promise<string> {\n  const markerPath = getPermissionHookMarkerPath(homeDir, marker.host);\n  await mkdir(dirname(markerPath), { recursive: true });\n  await writeFile(markerPath, JSON.stringify(marker, null, 2) + '\\n', 'utf-8');\n  return markerPath;\n}\n\nexport async function installHookAssetsForHost(\n  client: string,\n  homeDir: string,\n  sourceScriptPath?: string,\n): Promise<{ scriptPath: string }> {\n  const normalizedClient = normalizeHookHost(client);\n  const hooksDir = dirname(getPermissionHookScriptPath(homeDir));\n  const sharedTargetPath = getPermissionHookScriptPath(homeDir);\n  const sharedSourcePath = sourceScriptPath ?? join(repoRootFromModule(), 'scripts', 'pretooluse-dollhouse.sh');\n  const portHelperSourcePath = join(repoRootFromModule(), 'scripts', 'permission-port-discovery.sh');\n  const portHelperTargetPath = join(hooksDir, 'permission-port-discovery.sh');\n  const configHelperSourcePath = join(repoRootFromModule(), 'scripts', 'permission-hook-config.sh');\n  const configHelperTargetPath = join(hooksDir, 'permission-hook-config.sh');\n\n  const sharedStat = statSync(sharedSourcePath);\n  if (!sharedStat.isFile()) {\n    logger.warn(`[PermissionHooks] Shared hook bridge missing for ${normalizedClient}: ${sharedSourcePath}`);\n    throw new Error(`Permission hook source script not found: ${sharedSourcePath}`);\n  }\n  await copyHookAsset(sharedSourcePath, sharedTargetPath);\n\n  const portHelperStat = statSync(portHelperSourcePath);\n  if (!portHelperStat.isFile()) {\n    logger.warn(`[PermissionHooks] Port discovery helper missing for ${normalizedClient}: ${portHelperSourcePath}`);\n    throw new Error(`Permission hook helper script not found: ${portHelperSourcePath}`);\n  }\n  await copyHookAsset(portHelperSourcePath, portHelperTargetPath);\n\n  const configHelperStat = statSync(configHelperSourcePath);\n  if (!configHelperStat.isFile()) {\n    logger.warn(`[PermissionHooks] Config helper missing for ${normalizedClient}: ${configHelperSourcePath}`);\n    throw new Error(`Permission hook config helper not found: ${configHelperSourcePath}`);\n  }\n  await copyHookAsset(configHelperSourcePath, configHelperTargetPath);\n\n  const wrapperTargetPath = getHookWrapperPath(normalizedClient, homeDir);\n  if (!wrapperTargetPath) {\n    return { scriptPath: sharedTargetPath };\n  }\n\n  const wrapperSourcePath = getHookSourcePath(normalizedClient);\n  const wrapperStat = statSync(wrapperSourcePath);\n  if (!wrapperStat.isFile()) {\n    logger.warn(`[PermissionHooks] Wrapper hook script missing for ${normalizedClient}: ${wrapperSourcePath}`);\n    throw new Error(`Permission hook wrapper script not found: ${wrapperSourcePath}`);\n  }\n  await copyHookAsset(wrapperSourcePath, wrapperTargetPath);\n  return { scriptPath: wrapperTargetPath };\n}\n"]}

package/dist/utils/permissionHookStatus.d.ts

@@ -0,0 +1,10 @@
+import { type PermissionHookAuditSummary, type PermissionHookHealthSummary, type PermissionHookStartupRepairSummary, type PermissionHookStatus, type ReconcilePermissionHookOptions } from './permissionHookShared.js';
+export declare function getPermissionHookStatus(homeDir?: string, host?: string): PermissionHookStatus;
+export declare function getPermissionHookStatusAsync(homeDir?: string, host?: string): Promise<PermissionHookStatus>;
+export declare function getLastPermissionHookStartupRepairSummary(): PermissionHookStartupRepairSummary | null;
+export declare function _resetPermissionHookStartupRepairSummaryForTests(): void;
+export declare function reconcilePermissionHookStatus(host: string, options?: ReconcilePermissionHookOptions): Promise<PermissionHookStatus>;
+export declare function getPermissionHookAuditSummary(homeDir?: string): Promise<PermissionHookAuditSummary>;
+export declare function summarizePermissionHookHealth(summary: PermissionHookAuditSummary): PermissionHookHealthSummary;
+export declare function repairPermissionHooksOnStartup(homeDir?: string, sourceScriptPath?: string): Promise<PermissionHookStartupRepairSummary>;
+//# sourceMappingURL=permissionHookStatus.d.ts.map

package/dist/utils/permissionHookStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissionHookStatus.d.ts","sourceRoot":"","sources":["../../src/utils/permissionHookStatus.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAGhC,KAAK,kCAAkC,EACvC,KAAK,oBAAoB,EACzB,KAAK,8BAA8B,EAapC,MAAM,2BAA2B,CAAC;AAInC,wBAAgB,uBAAuB,CAAC,OAAO,SAAY,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,oBAAoB,CAMhG;AAED,wBAAsB,4BAA4B,CAAC,OAAO,SAAY,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAMpH;AA2FD,wBAAgB,yCAAyC,IAAI,kCAAkC,GAAG,IAAI,CAErG;AAED,wBAAgB,gDAAgD,IAAI,IAAI,CAEvE;AAED,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,8BAAmC,GAC3C,OAAO,CAAC,oBAAoB,CAAC,CAgC/B;AAED,wBAAsB,6BAA6B,CAAC,OAAO,SAAY,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAgC5G;AA4CD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,0BAA0B,GAClC,2BAA2B,CAmD7B;AAED,wBAAsB,8BAA8B,CAClD,OAAO,SAAY,EACnB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,kCAAkC,CAAC,CA0D7C"}