@dollhousemcp/mcp-server 2.0.24 → 2.0.26

package/dist/utils/permissionAuthority.js

@@ -0,0 +1,341 @@
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { SecurityMonitor } from '../security/securityMonitor.js';
+import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
+import { logger } from './logger.js';
+import { getClaudeHookSettingsPath } from './permissionHooks.js';
+// These modes intentionally describe who has the final say when Dollhouse and the host disagree:
+// - off: the host permission system is fully in charge
+// - shared: both systems participate, but the host can still be stricter
+// - authoritative: Dollhouse is the source of truth for the managed host slice
+export const PERMISSION_AUTHORITY_MODES = ['off', 'shared', 'authoritative'];
+export const PERMISSION_AUTHORITY_HOSTS = [
+    'claude-code',
+    'codex',
+    'cursor',
+    'vscode',
+    'windsurf',
+    'gemini-cli',
+];
+export function getPermissionAuthorityStatePath(homeDir = homedir()) {
+    return join(homeDir, '.dollhouse', 'run', 'permission-authority.json');
+}
+function getPermissionAuthorityBackupDir(homeDir = homedir()) {
+    return join(homeDir, '.dollhouse', 'run', 'permission-authority-backups');
+}
+export function getDefaultPermissionAuthorityState(now = new Date()) {
+    return {
+        version: 1,
+        defaultMode: 'shared',
+        updatedAt: now.toISOString(),
+        hosts: {},
+    };
+}
+export async function readPermissionAuthorityState(homeDir = homedir()) {
+    const statePath = getPermissionAuthorityStatePath(homeDir);
+    try {
+        const raw = await readFile(statePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            version: 1,
+            defaultMode: isPermissionAuthorityMode(parsed.defaultMode) ? parsed.defaultMode : 'shared',
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),
+            hosts: normalizeHostStateMap(parsed.hosts),
+        };
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            logger.warn(`[PermissionAuthority] Failed to read ${statePath}: ${String(error)}`);
+        }
+        return getDefaultPermissionAuthorityState();
+    }
+}
+export async function writePermissionAuthorityState(state, homeDir = homedir()) {
+    const statePath = getPermissionAuthorityStatePath(homeDir);
+    await mkdir(dirname(statePath), { recursive: true });
+    await writeTextFileAtomically(statePath, JSON.stringify(state, null, 2) + '\n');
+}
+export function getHostAuthorityMode(state, host) {
+    return state.hosts[host]?.mode ?? state.defaultMode;
+}
+export async function setPermissionAuthorityMode(input) {
+    const homeDir = input.homeDir ?? homedir();
+    const now = input.now ?? new Date();
+    const state = await readPermissionAuthorityState(homeDir);
+    const normalizedHost = normalizeAuthorityHostInput(input.host);
+    const normalizedMode = normalizeAuthorityModeInput(input.mode);
+    const normalizedReason = normalizeAuthorityReason(input.reason);
+    const previousHostState = state.hosts[normalizedHost];
+    const previousMode = previousHostState?.mode ?? state.defaultMode;
+    try {
+        if (normalizedMode === 'authoritative') {
+            if (normalizedHost !== 'claude-code') {
+                throw new Error(`Authoritative mode is not implemented yet for ${normalizedHost}.`);
+            }
+            if (!input.policies) {
+                throw new Error('Authoritative mode requires a policy snapshot.');
+            }
+            const syncResult = await syncClaudeCodeAuthoritativeMode({
+                homeDir,
+                host: normalizedHost,
+                previousBackupPath: previousHostState?.backupPath,
+                policies: input.policies,
+                now,
+            });
+            state.hosts[normalizedHost] = {
+                mode: 'authoritative',
+                reason: normalizedReason,
+                updatedAt: now.toISOString(),
+                backupPath: syncResult.backupPath,
+                lastSyncedAt: syncResult.syncedAt,
+                scope: 'user',
+            };
+        }
+        else {
+            if (previousMode === 'authoritative' && previousHostState?.backupPath) {
+                await restoreAuthorityBackup(previousHostState.backupPath, getHostSettingsPath(normalizedHost, homeDir));
+            }
+            state.hosts[normalizedHost] = {
+                mode: normalizedMode,
+                reason: normalizedReason,
+                updatedAt: now.toISOString(),
+                scope: 'user',
+            };
+        }
+        state.updatedAt = now.toISOString();
+        await writePermissionAuthorityState(state, homeDir);
+        SecurityMonitor.logSecurityEvent({
+            type: 'CONFIG_UPDATED',
+            severity: 'LOW',
+            source: 'permissionAuthority.setPermissionAuthorityMode',
+            details: `Permission authority for ${normalizedHost} changed from ${previousMode} to ${normalizedMode}`,
+            additionalData: {
+                host: normalizedHost,
+                previousMode,
+                mode: normalizedMode,
+                reason: normalizedReason,
+            },
+        });
+        return state;
+    }
+    catch (error) {
+        throw withAuthorityContext(error, `Failed to set permission authority for ${normalizedHost} to ${normalizedMode}`);
+    }
+}
+function normalizeAuthorityText(value) {
+    return UnicodeValidator.normalize(value).normalizedContent.trim();
+}
+function normalizeAuthorityHostInput(value) {
+    const normalized = normalizeAuthorityText(value).toLowerCase();
+    if (!isPermissionAuthorityHost(normalized)) {
+        throw new Error(`Unsupported permission authority host: ${value}`);
+    }
+    return normalized;
+}
+function normalizeAuthorityModeInput(value) {
+    const normalized = normalizeAuthorityText(value).toLowerCase();
+    if (!isPermissionAuthorityMode(normalized)) {
+        throw new Error(`Unsupported permission authority mode: ${value}`);
+    }
+    return normalized;
+}
+function normalizeAuthorityReason(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = normalizeAuthorityText(value);
+    return normalized === '' ? undefined : normalized;
+}
+function normalizeHostStateMap(rawHosts) {
+    if (!rawHosts || typeof rawHosts !== 'object' || Array.isArray(rawHosts)) {
+        return {};
+    }
+    const normalized = {};
+    for (const [rawHost, rawState] of Object.entries(rawHosts)) {
+        if (!isPermissionAuthorityHost(rawHost)) {
+            continue;
+        }
+        const hostState = normalizeHostState(rawState);
+        if (!hostState) {
+            continue;
+        }
+        normalized[rawHost] = hostState;
+    }
+    return normalized;
+}
+function normalizeHostState(rawState) {
+    if (!rawState || typeof rawState !== 'object' || Array.isArray(rawState)) {
+        return null;
+    }
+    const hostState = rawState;
+    if (!isPermissionAuthorityMode(hostState.mode)) {
+        return null;
+    }
+    return {
+        mode: hostState.mode,
+        reason: typeof hostState.reason === 'string' ? hostState.reason : undefined,
+        updatedAt: typeof hostState.updatedAt === 'string' ? hostState.updatedAt : new Date().toISOString(),
+        backupPath: typeof hostState.backupPath === 'string' ? hostState.backupPath : undefined,
+        lastSyncedAt: typeof hostState.lastSyncedAt === 'string' ? hostState.lastSyncedAt : undefined,
+        scope: hostState.scope === 'user' ? 'user' : undefined,
+    };
+}
+function isPermissionAuthorityMode(value) {
+    return typeof value === 'string' && PERMISSION_AUTHORITY_MODES.includes(value);
+}
+function isPermissionAuthorityHost(value) {
+    return PERMISSION_AUTHORITY_HOSTS.includes(value);
+}
+function isMissingFileError(error) {
+    return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT');
+}
+function getHostSettingsPath(host, homeDir) {
+    if (host === 'claude-code') {
+        return getClaudeHookSettingsPath(homeDir);
+    }
+    throw new Error(`No host settings path registered for ${host}.`);
+}
+async function syncClaudeCodeAuthoritativeMode(input) {
+    const settingsPath = getHostSettingsPath(input.host, input.homeDir);
+    await mkdir(dirname(settingsPath), { recursive: true });
+    try {
+        const currentRaw = existsSync(settingsPath) ? await readFile(settingsPath, 'utf-8') : null;
+        const backupPath = input.previousBackupPath
+            ?? await createAuthorityBackup(input.homeDir, input.host, currentRaw, input.now);
+        const parsed = currentRaw && currentRaw.trim().length > 0
+            ? JSON.parse(currentRaw)
+            : {};
+        const syncedAt = input.now.toISOString();
+        const synced = buildClaudeAuthoritySettings(parsed, input.policies, syncedAt);
+        await writeTextFileAtomically(settingsPath, JSON.stringify(synced, null, 2) + '\n');
+        return { backupPath, syncedAt };
+    }
+    catch (error) {
+        throw withAuthorityContext(error, `Failed to sync authoritative Claude Code settings at ${settingsPath}`);
+    }
+}
+function buildClaudeAuthoritySettings(parsed, policies, syncedAt) {
+    const priorMetadata = getAuthorityMetadata(parsed);
+    const priorManaged = priorMetadata?.managedPermissions ?? { allow: [], ask: [], deny: [] };
+    const permissions = getPermissionsRoot(parsed);
+    const managedAllow = uniquePatterns((policies.combinedAllowPatterns ?? []).filter((pattern) => !CLAUDE_REQUIRED_ASK_PATTERNS.includes(pattern)));
+    const managedAsk = uniquePatterns([
+        ...(policies.combinedConfirmPatterns ?? []),
+        ...CLAUDE_REQUIRED_ASK_PATTERNS,
+    ]);
+    const managedDeny = uniquePatterns(policies.combinedDenyPatterns ?? []);
+    const userAllow = removeManagedEntries(permissions.allow, priorManaged.allow);
+    const userAsk = removeManagedEntries(permissions.ask, priorManaged.ask)
+        .filter((entry) => !shouldStripClaudeAskEntry(entry, managedAllow));
+    const userDeny = removeManagedEntries(permissions.deny, priorManaged.deny);
+    parsed.permissions = {
+        allow: uniquePatterns([...userAllow, ...managedAllow]),
+        ask: uniquePatterns([...userAsk, ...managedAsk]),
+        deny: uniquePatterns([...userDeny, ...managedDeny]),
+    };
+    parsed['_dollhousePermissionAuthority'] = {
+        version: 1,
+        host: 'claude-code',
+        managedPermissions: {
+            allow: managedAllow,
+            ask: managedAsk,
+            deny: managedDeny,
+        },
+        syncedAt,
+    };
+    return parsed;
+}
+function getAuthorityMetadata(parsed) {
+    const metadata = parsed['_dollhousePermissionAuthority'];
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return null;
+    }
+    const raw = metadata;
+    if (raw.version !== 1 || raw.host !== 'claude-code') {
+        return null;
+    }
+    return {
+        version: 1,
+        host: 'claude-code',
+        syncedAt: typeof raw.syncedAt === 'string' ? raw.syncedAt : new Date().toISOString(),
+        managedPermissions: {
+            allow: Array.isArray(raw.managedPermissions?.allow) ? raw.managedPermissions.allow.filter(isString) : [],
+            ask: Array.isArray(raw.managedPermissions?.ask) ? raw.managedPermissions.ask.filter(isString) : [],
+            deny: Array.isArray(raw.managedPermissions?.deny) ? raw.managedPermissions.deny.filter(isString) : [],
+        },
+    };
+}
+function getPermissionsRoot(parsed) {
+    const permissionsValue = parsed.permissions;
+    if (!permissionsValue || typeof permissionsValue !== 'object' || Array.isArray(permissionsValue)) {
+        return { allow: [], ask: [], deny: [] };
+    }
+    const permissions = permissionsValue;
+    return {
+        allow: Array.isArray(permissions.allow) ? permissions.allow.filter(isString) : [],
+        ask: Array.isArray(permissions.ask) ? permissions.ask.filter(isString) : [],
+        deny: Array.isArray(permissions.deny) ? permissions.deny.filter(isString) : [],
+    };
+}
+function isString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function uniquePatterns(patterns) {
+    return Array.from(new Set(patterns));
+}
+function removeManagedEntries(entries, managedEntries) {
+    const managed = new Set(managedEntries);
+    return entries.filter((entry) => !managed.has(entry));
+}
+const CLAUDE_REQUIRED_ASK_PATTERNS = ['mcp__DollhouseMCP__mcp_aql_execute*'];
+function shouldStripClaudeAskEntry(entry, allowPatterns) {
+    if (allowPatterns.includes(entry)) {
+        return true;
+    }
+    const normalizedEntry = entry.endsWith('*') ? entry.slice(0, -1) : entry;
+    if (!normalizedEntry.includes(':') && allowPatterns.some((pattern) => pattern.startsWith(`${normalizedEntry}:`))) {
+        return true;
+    }
+    if (!entry.endsWith('*')) {
+        return false;
+    }
+    return allowPatterns.some((pattern) => pattern.startsWith(normalizedEntry));
+}
+async function createAuthorityBackup(homeDir, host, raw, now) {
+    const backupDir = getPermissionAuthorityBackupDir(homeDir);
+    await mkdir(backupDir, { recursive: true });
+    const filename = `${host}-${now.toISOString().replaceAll(':', '-')}.json`;
+    const backupPath = join(backupDir, filename);
+    const backup = raw === null
+        ? { version: 1, existed: false }
+        : { version: 1, existed: true, raw };
+    await writeTextFileAtomically(backupPath, JSON.stringify(backup, null, 2) + '\n');
+    return backupPath;
+}
+async function restoreAuthorityBackup(backupPath, targetPath) {
+    try {
+        const raw = await readFile(backupPath, 'utf-8');
+        const backup = JSON.parse(raw);
+        if (backup.existed) {
+            await mkdir(dirname(targetPath), { recursive: true });
+            await writeTextFileAtomically(targetPath, backup.raw ?? '');
+            return;
+        }
+        await rm(targetPath, { force: true });
+    }
+    catch (error) {
+        throw withAuthorityContext(error, `Failed to restore authority backup ${backupPath} to ${targetPath}`);
+    }
+}
+async function writeTextFileAtomically(filePath, contents) {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempPath, contents, 'utf-8');
+    await rename(tempPath, filePath);
+}
+function withAuthorityContext(error, context) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new Error(`${context}: ${message}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissionAuthority.js","sourceRoot":"","sources":["../../src/utils/permissionAuthority.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,iGAAiG;AACjG,uDAAuD;AACvD,yEAAyE;AACzE,+EAA+E;AAC/E,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,eAAe,CAAU,CAAC;AAGtF,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,aAAa;IACb,OAAO;IACP,QAAQ;IACR,QAAQ;IACR,UAAU;IACV,YAAY;CACJ,CAAC;AAmDX,MAAM,UAAU,+BAA+B,CAAC,OAAO,GAAG,OAAO,EAAE;IACjE,OAAO,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,2BAA2B,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,+BAA+B,CAAC,OAAO,GAAG,OAAO,EAAE;IAC1D,OAAO,IAAI,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,8BAA8B,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,kCAAkC,CAAC,GAAG,GAAG,IAAI,IAAI,EAAE;IACjE,OAAO;QACL,OAAO,EAAE,CAAC;QACV,WAAW,EAAE,QAAQ;QACrB,SAAS,EAAE,GAAG,CAAC,WAAW,EAAE;QAC5B,KAAK,EAAE,EAAE;KACV,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,4BAA4B,CAAC,OAAO,GAAG,OAAO,EAAE;IACpE,MAAM,SAAS,GAAG,+BAA+B,CAAC,OAAO,CAAC,CAAC;IAC3D,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAsC,CAAC;QACpE,OAAO;YACL,OAAO,EAAE,CAAC;YACV,WAAW,EAAE,yBAAyB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ;YAC1F,SAAS,EAAE,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAC7F,KAAK,EAAE,qBAAqB,CAAC,MAAM,CAAC,KAAK,CAAC;SAC3C,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,MAAM,CAAC,IAAI,CAAC,wCAAwC,SAAS,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACrF,CAAC;QACD,OAAO,kCAAkC,EAAE,CAAC;IAC9C,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,6BAA6B,CACjD,KAA+B,EAC/B,OAAO,GAAG,OAAO,EAAE;IAEnB,MAAM,SAAS,GAAG,+BAA+B,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACrD,MAAM,uBAAuB,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AAClF,CAAC;AAED,MAAM,UAAU,oBAAoB,CAClC,KAA+B,EAC/B,IAA6B;IAE7B,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,KAAK,CAAC,WAAW,CAAC;AACtD,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,KAAsC;IACrF,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,OAAO,EAAE,CAAC;IAC3C,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,IAAI,IAAI,EAAE,CAAC;IACpC,MAAM,KAAK,GAAG,MAAM,4BAA4B,CAAC,OAAO,CAAC,CAAC;IAC1D,MAAM,cAAc,GAAG,2BAA2B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/D,MAAM,cAAc,GAAG,2BAA2B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC/D,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAChE,MAAM,iBAAiB,GAAG,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;IACtD,MAAM,YAAY,GAAG,iBAAiB,EAAE,IAAI,IAAI,KAAK,CAAC,WAAW,CAAC;IAClE,IAAI,CAAC;QACH,IAAI,cAAc,KAAK,eAAe,EAAE,CAAC;YACvC,IAAI,cAAc,KAAK,aAAa,EAAE,CAAC;gBACrC,MAAM,IAAI,KAAK,CAAC,iDAAiD,cAAc,GAAG,CAAC,CAAC;YACtF,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;gBACpB,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;YACpE,CAAC;YAED,MAAM,UAAU,GAAG,MAAM,+BAA+B,CAAC;gBACvD,OAAO;gBACP,IAAI,EAAE,cAAc;gBACpB,kBAAkB,EAAE,iBAAiB,EAAE,UAAU;gBACjD,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,GAAG;aACJ,CAAC,CAAC;YAEH,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG;gBAC5B,IAAI,EAAE,eAAe;gBACrB,MAAM,EAAE,gBAAgB;gBACxB,SAAS,EAAE,GAAG,CAAC,WAAW,EAAE;gBAC5B,UAAU,EAAE,UAAU,CAAC,UAAU;gBACjC,YAAY,EAAE,UAAU,CAAC,QAAQ;gBACjC,KAAK,EAAE,MAAM;aACd,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,IAAI,YAAY,KAAK,eAAe,IAAI,iBAAiB,EAAE,UAAU,EAAE,CAAC;gBACtE,MAAM,sBAAsB,CAAC,iBAAiB,CAAC,UAAU,EAAE,mBAAmB,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;YAC3G,CAAC;YAED,KAAK,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG;gBAC5B,IAAI,EAAE,cAAc;gBACpB,MAAM,EAAE,gBAAgB;gBACxB,SAAS,EAAE,GAAG,CAAC,WAAW,EAAE;gBAC5B,KAAK,EAAE,MAAM;aACd,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,SAAS,GAAG,GAAG,CAAC,WAAW,EAAE,CAAC;QACpC,MAAM,6BAA6B,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QAEpD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,gBAAgB;YACtB,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,gDAAgD;YACxD,OAAO,EAAE,4BAA4B,cAAc,iBAAiB,YAAY,OAAO,cAAc,EAAE;YACvG,cAAc,EAAE;gBACd,IAAI,EAAE,cAAc;gBACpB,YAAY;gBACZ,IAAI,EAAE,cAAc;gBACpB,MAAM,EAAE,gBAAgB;aACzB;SACF,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,oBAAoB,CAAC,KAAK,EAAE,0CAA0C,cAAc,OAAO,cAAc,EAAE,CAAC,CAAC;IACrH,CAAC;AACH,CAAC;AAED,SAAS,sBAAsB,CAAC,KAAa;IAC3C,OAAO,gBAAgB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;AACpE,CAAC;AAED,SAAS,2BAA2B,CAAC,KAA8B;IACjE,MAAM,UAAU,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IAC/D,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,0CAA0C,KAAK,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,2BAA2B,CAAC,KAA8B;IACjE,MAAM,UAAU,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;IAC/D,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,0CAA0C,KAAK,EAAE,CAAC,CAAC;IACrE,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,wBAAwB,CAAC,KAAyB;IACzD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,UAAU,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;IACjD,OAAO,UAAU,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC;AACpD,CAAC;AAED,SAAS,qBAAqB,CAC5B,QAAiB;IAEjB,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzE,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,UAAU,GAA2E,EAAE,CAAC;IAC9F,KAAK,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAmC,CAAC,EAAE,CAAC;QACtF,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,EAAE,CAAC;YACxC,SAAS;QACX,CAAC;QAED,MAAM,SAAS,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAAC;QAC/C,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,SAAS;QACX,CAAC;QAED,UAAU,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC;IAClC,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,SAAS,kBAAkB,CAAC,QAAiB;IAC3C,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,SAAS,GAAG,QAAiD,CAAC;IACpE,IAAI,CAAC,yBAAyB,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,IAAI,EAAE,SAAS,CAAC,IAAI;QACpB,MAAM,EAAE,OAAO,SAAS,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;QAC3E,SAAS,EAAE,OAAO,SAAS,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACnG,UAAU,EAAE,OAAO,SAAS,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;QACvF,YAAY,EAAE,OAAO,SAAS,CAAC,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;QAC7F,KAAK,EAAE,SAAS,CAAC,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;KACvD,CAAC;AACJ,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAc;IAC/C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,0BAA0B,CAAC,QAAQ,CAAC,KAAgC,CAAC,CAAC;AAC5G,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAa;IAC9C,OAAQ,0BAAgD,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC3E,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc;IACxC,OAAO,OAAO,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAI,KAAK,IAAK,KAA2B,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC;AAC1H,CAAC;AAED,SAAS,mBAAmB,CAAC,IAA6B,EAAE,OAAe;IACzE,IAAI,IAAI,KAAK,aAAa,EAAE,CAAC;QAC3B,OAAO,yBAAyB,CAAC,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,wCAAwC,IAAI,GAAG,CAAC,CAAC;AACnE,CAAC;AAED,KAAK,UAAU,+BAA+B,CAAC,KAM9C;IACC,MAAM,YAAY,GAAG,mBAAmB,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACpE,MAAM,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAExD,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC3F,MAAM,UAAU,GAAG,KAAK,CAAC,kBAAkB;eACtC,MAAM,qBAAqB,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;QAEnF,MAAM,MAAM,GAAG,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC;YACvD,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAA4B;YACnD,CAAC,CAAC,EAAE,CAAC;QAEP,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC;QACzC,MAAM,MAAM,GAAG,4BAA4B,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC9E,MAAM,uBAAuB,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAEpF,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;IAClC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,oBAAoB,CAAC,KAAK,EAAE,wDAAwD,YAAY,EAAE,CAAC,CAAC;IAC5G,CAAC;AACH,CAAC;AAED,SAAS,4BAA4B,CACnC,MAA+B,EAC/B,QAAiC,EACjC,QAAgB;IAEhB,MAAM,aAAa,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACnD,MAAM,YAAY,GAAG,aAAa,EAAE,kBAAkB,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAC3F,MAAM,WAAW,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAE/C,MAAM,YAAY,GAAG,cAAc,CACjC,CAAC,QAAQ,CAAC,qBAAqB,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,4BAA4B,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAC5G,CAAC;IACF,MAAM,UAAU,GAAG,cAAc,CAAC;QAChC,GAAG,CAAC,QAAQ,CAAC,uBAAuB,IAAI,EAAE,CAAC;QAC3C,GAAG,4BAA4B;KAChC,CAAC,CAAC;IACH,MAAM,WAAW,GAAG,cAAc,CAAC,QAAQ,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC;IAExE,MAAM,SAAS,GAAG,oBAAoB,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IAC9E,MAAM,OAAO,GAAG,oBAAoB,CAAC,WAAW,CAAC,GAAG,EAAE,YAAY,CAAC,GAAG,CAAC;SACpE,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,yBAAyB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC;IACtE,MAAM,QAAQ,GAAG,oBAAoB,CAAC,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC;IAE3E,MAAM,CAAC,WAAW,GAAG;QACnB,KAAK,EAAE,cAAc,CAAC,CAAC,GAAG,SAAS,EAAE,GAAG,YAAY,CAAC,CAAC;QACtD,GAAG,EAAE,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,UAAU,CAAC,CAAC;QAChD,IAAI,EAAE,cAAc,CAAC,CAAC,GAAG,QAAQ,EAAE,GAAG,WAAW,CAAC,CAAC;KACpD,CAAC;IACF,MAAM,CAAC,+BAA+B,CAAC,GAAG;QACxC,OAAO,EAAE,CAAC;QACV,IAAI,EAAE,aAAa;QACnB,kBAAkB,EAAE;YAClB,KAAK,EAAE,YAAY;YACnB,GAAG,EAAE,UAAU;YACf,IAAI,EAAE,WAAW;SAClB;QACD,QAAQ;KAC6B,CAAC;IAExC,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,oBAAoB,CAAC,MAA+B;IAC3D,MAAM,QAAQ,GAAG,MAAM,CAAC,+BAA+B,CAAC,CAAC;IACzD,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACzE,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,GAAG,GAAG,QAAgD,CAAC;IAC7D,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,OAAO,EAAE,CAAC;QACV,IAAI,EAAE,aAAa;QACnB,QAAQ,EAAE,OAAO,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACpF,kBAAkB,EAAE;YAClB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;YACxG,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;YAClG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;SACtG;KACF,CAAC;AACJ,CAAC;AAED,SAAS,kBAAkB,CAAC,MAA+B;IACzD,MAAM,gBAAgB,GAAG,MAAM,CAAC,WAAW,CAAC;IAC5C,IAAI,CAAC,gBAAgB,IAAI,OAAO,gBAAgB,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACjG,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IAC1C,CAAC;IAED,MAAM,WAAW,GAAG,gBAA2C,CAAC;IAChE,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;QACjF,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;QAC3E,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE;KAC/E,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAC9D,CAAC;AAED,SAAS,cAAc,CAAC,QAAkB;IACxC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,SAAS,oBAAoB,CAAC,OAAiB,EAAE,cAAwB;IACvE,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC;IACxC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,4BAA4B,GAAG,CAAC,qCAAqC,CAAC,CAAC;AAE7E,SAAS,yBAAyB,CAAC,KAAa,EAAE,aAAuB;IACvE,IAAI,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,eAAe,GAAG,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACzE,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,eAAe,GAAG,CAAC,CAAC,EAAE,CAAC;QACjH,OAAO,IAAI,CAAC;IACd,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED,KAAK,UAAU,qBAAqB,CAClC,OAAe,EACf,IAA6B,EAC7B,GAAkB,EAClB,GAAS;IAET,MAAM,SAAS,GAAG,+BAA+B,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,KAAK,CAAC,SAAS,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE5C,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,GAAG,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC;IAC1E,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC7C,MAAM,MAAM,GAA8B,GAAG,KAAK,IAAI;QACpD,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE;QAChC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;IAEvC,MAAM,uBAAuB,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAClF,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,KAAK,UAAU,sBAAsB,CAAC,UAAkB,EAAE,UAAkB;IAC1E,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAA8B,CAAC;QAE5D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,MAAM,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACtD,MAAM,uBAAuB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;QAED,MAAM,EAAE,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,oBAAoB,CAAC,KAAK,EAAE,sCAAsC,UAAU,OAAO,UAAU,EAAE,CAAC,CAAC;IACzG,CAAC;AACH,CAAC;AAED,KAAK,UAAU,uBAAuB,CAAC,QAAgB,EAAE,QAAgB;IACvE,MAAM,QAAQ,GAAG,GAAG,QAAQ,IAAI,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC;IAChE,MAAM,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7C,MAAM,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACnC,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAc,EAAE,OAAe;IAC3D,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,IAAI,KAAK,CAAC,GAAG,OAAO,KAAK,OAAO,EAAE,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import { homedir } from 'node:os';\nimport { dirname, join } from 'node:path';\nimport { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';\nimport { existsSync } from 'node:fs';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { logger } from './logger.js';\nimport { getClaudeHookSettingsPath } from './permissionHooks.js';\n\n// These modes intentionally describe who has the final say when Dollhouse and the host disagree:\n// - off: the host permission system is fully in charge\n// - shared: both systems participate, but the host can still be stricter\n// - authoritative: Dollhouse is the source of truth for the managed host slice\nexport const PERMISSION_AUTHORITY_MODES = ['off', 'shared', 'authoritative'] as const;\nexport type PermissionAuthorityMode = typeof PERMISSION_AUTHORITY_MODES[number];\n\nexport const PERMISSION_AUTHORITY_HOSTS = [\n  'claude-code',\n  'codex',\n  'cursor',\n  'vscode',\n  'windsurf',\n  'gemini-cli',\n] as const;\nexport type PermissionAuthorityHost = typeof PERMISSION_AUTHORITY_HOSTS[number];\n\nexport interface PermissionAuthorityHostState {\n  mode: PermissionAuthorityMode;\n  reason?: string;\n  updatedAt: string;\n  backupPath?: string;\n  lastSyncedAt?: string;\n  scope?: 'user';\n}\n\nexport interface PermissionAuthorityState {\n  version: 1;\n  defaultMode: PermissionAuthorityMode;\n  updatedAt: string;\n  hosts: Partial<Record<PermissionAuthorityHost, PermissionAuthorityHostState>>;\n}\n\nexport interface AuthorityPolicySnapshot {\n  combinedAllowPatterns?: string[];\n  combinedConfirmPatterns?: string[];\n  combinedDenyPatterns?: string[];\n}\n\ninterface PermissionAuthorityMetadata {\n  version: 1;\n  host: PermissionAuthorityHost;\n  managedPermissions: {\n    allow: string[];\n    ask: string[];\n    deny: string[];\n  };\n  syncedAt: string;\n}\n\ninterface PermissionAuthorityBackup {\n  version: 1;\n  existed: boolean;\n  raw?: string;\n}\n\nexport interface SetPermissionAuthorityModeInput {\n  host: PermissionAuthorityHost;\n  mode: PermissionAuthorityMode;\n  reason?: string;\n  policies?: AuthorityPolicySnapshot;\n  homeDir?: string;\n  now?: Date;\n}\n\nexport function getPermissionAuthorityStatePath(homeDir = homedir()): string {\n  return join(homeDir, '.dollhouse', 'run', 'permission-authority.json');\n}\n\nfunction getPermissionAuthorityBackupDir(homeDir = homedir()): string {\n  return join(homeDir, '.dollhouse', 'run', 'permission-authority-backups');\n}\n\nexport function getDefaultPermissionAuthorityState(now = new Date()): PermissionAuthorityState {\n  return {\n    version: 1,\n    defaultMode: 'shared',\n    updatedAt: now.toISOString(),\n    hosts: {},\n  };\n}\n\nexport async function readPermissionAuthorityState(homeDir = homedir()): Promise<PermissionAuthorityState> {\n  const statePath = getPermissionAuthorityStatePath(homeDir);\n  try {\n    const raw = await readFile(statePath, 'utf-8');\n    const parsed = JSON.parse(raw) as Partial<PermissionAuthorityState>;\n    return {\n      version: 1,\n      defaultMode: isPermissionAuthorityMode(parsed.defaultMode) ? parsed.defaultMode : 'shared',\n      updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date().toISOString(),\n      hosts: normalizeHostStateMap(parsed.hosts),\n    };\n  } catch (error) {\n    if (!isMissingFileError(error)) {\n      logger.warn(`[PermissionAuthority] Failed to read ${statePath}: ${String(error)}`);\n    }\n    return getDefaultPermissionAuthorityState();\n  }\n}\n\nexport async function writePermissionAuthorityState(\n  state: PermissionAuthorityState,\n  homeDir = homedir(),\n): Promise<void> {\n  const statePath = getPermissionAuthorityStatePath(homeDir);\n  await mkdir(dirname(statePath), { recursive: true });\n  await writeTextFileAtomically(statePath, JSON.stringify(state, null, 2) + '\\n');\n}\n\nexport function getHostAuthorityMode(\n  state: PermissionAuthorityState,\n  host: PermissionAuthorityHost,\n): PermissionAuthorityMode {\n  return state.hosts[host]?.mode ?? state.defaultMode;\n}\n\nexport async function setPermissionAuthorityMode(input: SetPermissionAuthorityModeInput): Promise<PermissionAuthorityState> {\n  const homeDir = input.homeDir ?? homedir();\n  const now = input.now ?? new Date();\n  const state = await readPermissionAuthorityState(homeDir);\n  const normalizedHost = normalizeAuthorityHostInput(input.host);\n  const normalizedMode = normalizeAuthorityModeInput(input.mode);\n  const normalizedReason = normalizeAuthorityReason(input.reason);\n  const previousHostState = state.hosts[normalizedHost];\n  const previousMode = previousHostState?.mode ?? state.defaultMode;\n  try {\n    if (normalizedMode === 'authoritative') {\n      if (normalizedHost !== 'claude-code') {\n        throw new Error(`Authoritative mode is not implemented yet for ${normalizedHost}.`);\n      }\n      if (!input.policies) {\n        throw new Error('Authoritative mode requires a policy snapshot.');\n      }\n\n      const syncResult = await syncClaudeCodeAuthoritativeMode({\n        homeDir,\n        host: normalizedHost,\n        previousBackupPath: previousHostState?.backupPath,\n        policies: input.policies,\n        now,\n      });\n\n      state.hosts[normalizedHost] = {\n        mode: 'authoritative',\n        reason: normalizedReason,\n        updatedAt: now.toISOString(),\n        backupPath: syncResult.backupPath,\n        lastSyncedAt: syncResult.syncedAt,\n        scope: 'user',\n      };\n    } else {\n      if (previousMode === 'authoritative' && previousHostState?.backupPath) {\n        await restoreAuthorityBackup(previousHostState.backupPath, getHostSettingsPath(normalizedHost, homeDir));\n      }\n\n      state.hosts[normalizedHost] = {\n        mode: normalizedMode,\n        reason: normalizedReason,\n        updatedAt: now.toISOString(),\n        scope: 'user',\n      };\n    }\n\n    state.updatedAt = now.toISOString();\n    await writePermissionAuthorityState(state, homeDir);\n\n    SecurityMonitor.logSecurityEvent({\n      type: 'CONFIG_UPDATED',\n      severity: 'LOW',\n      source: 'permissionAuthority.setPermissionAuthorityMode',\n      details: `Permission authority for ${normalizedHost} changed from ${previousMode} to ${normalizedMode}`,\n      additionalData: {\n        host: normalizedHost,\n        previousMode,\n        mode: normalizedMode,\n        reason: normalizedReason,\n      },\n    });\n\n    return state;\n  } catch (error) {\n    throw withAuthorityContext(error, `Failed to set permission authority for ${normalizedHost} to ${normalizedMode}`);\n  }\n}\n\nfunction normalizeAuthorityText(value: string): string {\n  return UnicodeValidator.normalize(value).normalizedContent.trim();\n}\n\nfunction normalizeAuthorityHostInput(value: PermissionAuthorityHost): PermissionAuthorityHost {\n  const normalized = normalizeAuthorityText(value).toLowerCase();\n  if (!isPermissionAuthorityHost(normalized)) {\n    throw new Error(`Unsupported permission authority host: ${value}`);\n  }\n  return normalized;\n}\n\nfunction normalizeAuthorityModeInput(value: PermissionAuthorityMode): PermissionAuthorityMode {\n  const normalized = normalizeAuthorityText(value).toLowerCase();\n  if (!isPermissionAuthorityMode(normalized)) {\n    throw new Error(`Unsupported permission authority mode: ${value}`);\n  }\n  return normalized;\n}\n\nfunction normalizeAuthorityReason(value: string | undefined): string | undefined {\n  if (typeof value !== 'string') {\n    return undefined;\n  }\n\n  const normalized = normalizeAuthorityText(value);\n  return normalized === '' ? undefined : normalized;\n}\n\nfunction normalizeHostStateMap(\n  rawHosts: unknown,\n): Partial<Record<PermissionAuthorityHost, PermissionAuthorityHostState>> {\n  if (!rawHosts || typeof rawHosts !== 'object' || Array.isArray(rawHosts)) {\n    return {};\n  }\n\n  const normalized: Partial<Record<PermissionAuthorityHost, PermissionAuthorityHostState>> = {};\n  for (const [rawHost, rawState] of Object.entries(rawHosts as Record<string, unknown>)) {\n    if (!isPermissionAuthorityHost(rawHost)) {\n      continue;\n    }\n\n    const hostState = normalizeHostState(rawState);\n    if (!hostState) {\n      continue;\n    }\n\n    normalized[rawHost] = hostState;\n  }\n\n  return normalized;\n}\n\nfunction normalizeHostState(rawState: unknown): PermissionAuthorityHostState | null {\n  if (!rawState || typeof rawState !== 'object' || Array.isArray(rawState)) {\n    return null;\n  }\n\n  const hostState = rawState as Partial<PermissionAuthorityHostState>;\n  if (!isPermissionAuthorityMode(hostState.mode)) {\n    return null;\n  }\n\n  return {\n    mode: hostState.mode,\n    reason: typeof hostState.reason === 'string' ? hostState.reason : undefined,\n    updatedAt: typeof hostState.updatedAt === 'string' ? hostState.updatedAt : new Date().toISOString(),\n    backupPath: typeof hostState.backupPath === 'string' ? hostState.backupPath : undefined,\n    lastSyncedAt: typeof hostState.lastSyncedAt === 'string' ? hostState.lastSyncedAt : undefined,\n    scope: hostState.scope === 'user' ? 'user' : undefined,\n  };\n}\n\nfunction isPermissionAuthorityMode(value: unknown): value is PermissionAuthorityMode {\n  return typeof value === 'string' && PERMISSION_AUTHORITY_MODES.includes(value as PermissionAuthorityMode);\n}\n\nfunction isPermissionAuthorityHost(value: string): value is PermissionAuthorityHost {\n  return (PERMISSION_AUTHORITY_HOSTS as readonly string[]).includes(value);\n}\n\nfunction isMissingFileError(error: unknown): boolean {\n  return Boolean(error && typeof error === 'object' && 'code' in error && (error as { code?: string }).code === 'ENOENT');\n}\n\nfunction getHostSettingsPath(host: PermissionAuthorityHost, homeDir: string): string {\n  if (host === 'claude-code') {\n    return getClaudeHookSettingsPath(homeDir);\n  }\n\n  throw new Error(`No host settings path registered for ${host}.`);\n}\n\nasync function syncClaudeCodeAuthoritativeMode(input: {\n  homeDir: string;\n  host: PermissionAuthorityHost;\n  previousBackupPath?: string;\n  policies: AuthorityPolicySnapshot;\n  now: Date;\n}): Promise<{ backupPath: string; syncedAt: string }> {\n  const settingsPath = getHostSettingsPath(input.host, input.homeDir);\n  await mkdir(dirname(settingsPath), { recursive: true });\n\n  try {\n    const currentRaw = existsSync(settingsPath) ? await readFile(settingsPath, 'utf-8') : null;\n    const backupPath = input.previousBackupPath\n      ?? await createAuthorityBackup(input.homeDir, input.host, currentRaw, input.now);\n\n    const parsed = currentRaw && currentRaw.trim().length > 0\n      ? JSON.parse(currentRaw) as Record<string, unknown>\n      : {};\n\n    const syncedAt = input.now.toISOString();\n    const synced = buildClaudeAuthoritySettings(parsed, input.policies, syncedAt);\n    await writeTextFileAtomically(settingsPath, JSON.stringify(synced, null, 2) + '\\n');\n\n    return { backupPath, syncedAt };\n  } catch (error) {\n    throw withAuthorityContext(error, `Failed to sync authoritative Claude Code settings at ${settingsPath}`);\n  }\n}\n\nfunction buildClaudeAuthoritySettings(\n  parsed: Record<string, unknown>,\n  policies: AuthorityPolicySnapshot,\n  syncedAt: string,\n): Record<string, unknown> {\n  const priorMetadata = getAuthorityMetadata(parsed);\n  const priorManaged = priorMetadata?.managedPermissions ?? { allow: [], ask: [], deny: [] };\n  const permissions = getPermissionsRoot(parsed);\n\n  const managedAllow = uniquePatterns(\n    (policies.combinedAllowPatterns ?? []).filter((pattern) => !CLAUDE_REQUIRED_ASK_PATTERNS.includes(pattern)),\n  );\n  const managedAsk = uniquePatterns([\n    ...(policies.combinedConfirmPatterns ?? []),\n    ...CLAUDE_REQUIRED_ASK_PATTERNS,\n  ]);\n  const managedDeny = uniquePatterns(policies.combinedDenyPatterns ?? []);\n\n  const userAllow = removeManagedEntries(permissions.allow, priorManaged.allow);\n  const userAsk = removeManagedEntries(permissions.ask, priorManaged.ask)\n    .filter((entry) => !shouldStripClaudeAskEntry(entry, managedAllow));\n  const userDeny = removeManagedEntries(permissions.deny, priorManaged.deny);\n\n  parsed.permissions = {\n    allow: uniquePatterns([...userAllow, ...managedAllow]),\n    ask: uniquePatterns([...userAsk, ...managedAsk]),\n    deny: uniquePatterns([...userDeny, ...managedDeny]),\n  };\n  parsed['_dollhousePermissionAuthority'] = {\n    version: 1,\n    host: 'claude-code',\n    managedPermissions: {\n      allow: managedAllow,\n      ask: managedAsk,\n      deny: managedDeny,\n    },\n    syncedAt,\n  } satisfies PermissionAuthorityMetadata;\n\n  return parsed;\n}\n\nfunction getAuthorityMetadata(parsed: Record<string, unknown>): PermissionAuthorityMetadata | null {\n  const metadata = parsed['_dollhousePermissionAuthority'];\n  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {\n    return null;\n  }\n  const raw = metadata as Partial<PermissionAuthorityMetadata>;\n  if (raw.version !== 1 || raw.host !== 'claude-code') {\n    return null;\n  }\n  return {\n    version: 1,\n    host: 'claude-code',\n    syncedAt: typeof raw.syncedAt === 'string' ? raw.syncedAt : new Date().toISOString(),\n    managedPermissions: {\n      allow: Array.isArray(raw.managedPermissions?.allow) ? raw.managedPermissions.allow.filter(isString) : [],\n      ask: Array.isArray(raw.managedPermissions?.ask) ? raw.managedPermissions.ask.filter(isString) : [],\n      deny: Array.isArray(raw.managedPermissions?.deny) ? raw.managedPermissions.deny.filter(isString) : [],\n    },\n  };\n}\n\nfunction getPermissionsRoot(parsed: Record<string, unknown>): { allow: string[]; ask: string[]; deny: string[] } {\n  const permissionsValue = parsed.permissions;\n  if (!permissionsValue || typeof permissionsValue !== 'object' || Array.isArray(permissionsValue)) {\n    return { allow: [], ask: [], deny: [] };\n  }\n\n  const permissions = permissionsValue as Record<string, unknown>;\n  return {\n    allow: Array.isArray(permissions.allow) ? permissions.allow.filter(isString) : [],\n    ask: Array.isArray(permissions.ask) ? permissions.ask.filter(isString) : [],\n    deny: Array.isArray(permissions.deny) ? permissions.deny.filter(isString) : [],\n  };\n}\n\nfunction isString(value: unknown): value is string {\n  return typeof value === 'string' && value.trim().length > 0;\n}\n\nfunction uniquePatterns(patterns: string[]): string[] {\n  return Array.from(new Set(patterns));\n}\n\nfunction removeManagedEntries(entries: string[], managedEntries: string[]): string[] {\n  const managed = new Set(managedEntries);\n  return entries.filter((entry) => !managed.has(entry));\n}\n\nconst CLAUDE_REQUIRED_ASK_PATTERNS = ['mcp__DollhouseMCP__mcp_aql_execute*'];\n\nfunction shouldStripClaudeAskEntry(entry: string, allowPatterns: string[]): boolean {\n  if (allowPatterns.includes(entry)) {\n    return true;\n  }\n\n  const normalizedEntry = entry.endsWith('*') ? entry.slice(0, -1) : entry;\n  if (!normalizedEntry.includes(':') && allowPatterns.some((pattern) => pattern.startsWith(`${normalizedEntry}:`))) {\n    return true;\n  }\n\n  if (!entry.endsWith('*')) {\n    return false;\n  }\n\n  return allowPatterns.some((pattern) => pattern.startsWith(normalizedEntry));\n}\n\nasync function createAuthorityBackup(\n  homeDir: string,\n  host: PermissionAuthorityHost,\n  raw: string | null,\n  now: Date,\n): Promise<string> {\n  const backupDir = getPermissionAuthorityBackupDir(homeDir);\n  await mkdir(backupDir, { recursive: true });\n\n  const filename = `${host}-${now.toISOString().replaceAll(':', '-')}.json`;\n  const backupPath = join(backupDir, filename);\n  const backup: PermissionAuthorityBackup = raw === null\n    ? { version: 1, existed: false }\n    : { version: 1, existed: true, raw };\n\n  await writeTextFileAtomically(backupPath, JSON.stringify(backup, null, 2) + '\\n');\n  return backupPath;\n}\n\nasync function restoreAuthorityBackup(backupPath: string, targetPath: string): Promise<void> {\n  try {\n    const raw = await readFile(backupPath, 'utf-8');\n    const backup = JSON.parse(raw) as PermissionAuthorityBackup;\n\n    if (backup.existed) {\n      await mkdir(dirname(targetPath), { recursive: true });\n      await writeTextFileAtomically(targetPath, backup.raw ?? '');\n      return;\n    }\n\n    await rm(targetPath, { force: true });\n  } catch (error) {\n    throw withAuthorityContext(error, `Failed to restore authority backup ${backupPath} to ${targetPath}`);\n  }\n}\n\nasync function writeTextFileAtomically(filePath: string, contents: string): Promise<void> {\n  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;\n  await writeFile(tempPath, contents, 'utf-8');\n  await rename(tempPath, filePath);\n}\n\nfunction withAuthorityContext(error: unknown, context: string): Error {\n  const message = error instanceof Error ? error.message : String(error);\n  return new Error(`${context}: ${message}`);\n}\n"]}

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

@@ -1 +1 @@
-{"version":3,"file":"permissionHooks.d.ts","sourceRoot":"","sources":["../../src/utils/permissionHooks.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"permissionHooks.d.ts","sourceRoot":"","sources":["../../src/utils/permissionHooks.ts"],"names":[],"mappings":"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"}