doobidoo · January 15, 2026 19:00
diff --git a/gist-README.md b/gist-README.md
diff --git a/permission-request.js b/permission-request.js
 #!/usr/bin/env node

 /**
 * Claude Code PermissionRequest Hook
 * Auto-approves non-destructive MCP tools from all servers
 *
 * This hook intercepts permission requests and automatically approves
 * read-only operations (tools with readOnlyHint or without destructiveHint),
 * eliminating the need for manual user confirmation on safe operations.
 *
 * Updated: 2026-01-08 - Universal MCP server support
 * Created: 2026-01-08
 * Related: MCP Tool Annotations (readOnlyHint, destructiveHint)
 */

 // Common destructive patterns to block (always require confirmation)
 const DESTRUCTIVE_PATTERNS = [
    'delete',
    'remove',
    'destroy',
    'drop',
    'clear',
    'wipe',
    'purge',
    'forget',
    'erase',
    'reset',
    'update',  // Can be destructive
    'modify',
    'edit',
    'change',
    'write',   // Can overwrite
    'create',  // Can create unwanted resources
    'deploy',
    'publish',
    'execute', // Code execution can be dangerous
    'run',
    'eval',
    'consolidate' // Modifies memories
 ];

 // Safe read-only patterns (can be auto-approved)
 const SAFE_PATTERNS = [
    'get',
    'list',
    'read',
    'retrieve',
    'fetch',
    'search',
    'find',
    'query',
    'recall',
    'check',
    'status',
    'health',
    'stats',
    'analyze',
    'view',
    'show',
    'describe',
    'inspect'
 ];

 /**
 * Main hook entry point
 * Receives JSON via stdin, processes permission request, returns decision
 */
 async function main() {
    try {
        // Read stdin input
        const input = await readStdin();
        const payload = JSON.parse(input);

        // Check if this is an MCP tool call
        if (isMCPToolCall(payload)) {
            const toolName = extractToolName(payload);

            // Check if tool is safe (non-destructive)
            if (isSafeTool(toolName)) {
                // Auto-approve safe tools
                outputDecision('allow', {
                    reason: `Auto-approved safe tool: ${toolName}`,
                    auto_approved: true,
                    server: payload.server_name,
                    tool_name: toolName
                });
            } else {
                // Require confirmation for potentially destructive tools
                outputDecision('prompt');
            }
        } else {
            // Not an MCP tool call, show normal dialog
            outputDecision('prompt');
        }
    } catch (error) {
        // On error, fall back to prompting user
        console.error('[PermissionRequest Hook] Error:', error.message);
        outputDecision('prompt');
    }
 }

 /**
 * Check if the payload represents an MCP tool call
 */
 function isMCPToolCall(payload) {
    return payload && (
        payload.hook_event_name === 'PermissionRequest' ||
        payload.type === 'mcp_tool_call' ||
        (payload.tool_name && payload.server_name)
    );
 }

 /**
 * Extract clean tool name from payload (strip mcp__ prefix)
 */
 function extractToolName(payload) {
    let toolName = payload.tool_name || '';

    // Strip mcp__servername__ prefix if present
    // Examples: mcp__memory__retrieve_memory -> retrieve_memory
    //           mcp__shodh-cloudflare__recall -> recall
    const mcpPrefix = /^mcp__[^_]+__/;
    toolName = toolName.replace(mcpPrefix, '');

    return toolName.toLowerCase();
 }

 /**
 * Check if the tool is safe (non-destructive) based on naming patterns
 */
 function isSafeTool(toolName) {
    if (!toolName) {
        return false;
    }

    // First check: Does the name contain any destructive pattern?
    for (const pattern of DESTRUCTIVE_PATTERNS) {
        if (toolName.includes(pattern)) {
            return false; // Destructive - require confirmation
        }
    }

    // Second check: Does the name match a safe pattern?
    for (const pattern of SAFE_PATTERNS) {
        if (toolName.includes(pattern)) {
            return true; // Safe - auto-approve
        }
    }

    // Unknown pattern - require confirmation (safer default)
    return false;
 }

 /**
 * Output the decision in Claude Code hook format
 */
 function outputDecision(behavior, metadata = {}) {
    const decision = {
        hookSpecificOutput: {
            hookEventName: 'PermissionRequest',
            decision: {
                behavior: behavior  // 'allow', 'deny', or 'prompt'
            }
        }
    };

    // Add metadata if provided (for logging/debugging)
    if (Object.keys(metadata).length > 0 && behavior !== 'prompt') {
        decision.hookSpecificOutput.metadata = metadata;
    }

    console.log(JSON.stringify(decision));
 }

 /**
 * Read all data from stdin
 */
 function readStdin() {
    return new Promise((resolve, reject) => {
        let data = '';

        process.stdin.setEncoding('utf8');

        process.stdin.on('readable', () => {
            let chunk;
            while ((chunk = process.stdin.read()) !== null) {
                data += chunk;
            }
        });

        process.stdin.on('end', () => {
            resolve(data);
        });

        process.stdin.on('error', (error) => {
            reject(error);
        });

        // Timeout after 1 second
        setTimeout(() => {
            if (data.length === 0) {
                reject(new Error('Timeout reading stdin'));
            }
        }, 1000);
    });
 }

 // Run main
 main().catch(error => {
    console.error('[PermissionRequest Hook] Fatal error:', error);
    outputDecision('prompt');
    process.exit(1);
 });
	#!/usr/bin/env node

	/**
	* Claude Code PermissionRequest Hook
	* Auto-approves non-destructive MCP tools from all servers
	*
	* This hook intercepts permission requests and automatically approves
	* read-only operations (tools with readOnlyHint or without destructiveHint),
	* eliminating the need for manual user confirmation on safe operations.
	*
	* Updated: 2026-01-08 - Universal MCP server support
	* Created: 2026-01-08
	* Related: MCP Tool Annotations (readOnlyHint, destructiveHint)
	*/

	// Common destructive patterns to block (always require confirmation)
	const DESTRUCTIVE_PATTERNS = [
	'delete',
	'remove',
	'destroy',
	'drop',
	'clear',
	'wipe',
	'purge',
	'forget',
	'erase',
	'reset',
	'update', // Can be destructive
	'modify',
	'edit',
	'change',
	'write', // Can overwrite
	'create', // Can create unwanted resources
	'deploy',
	'publish',
	'execute', // Code execution can be dangerous
	'run',
	'eval',
	'consolidate' // Modifies memories
	];

	// Safe read-only patterns (can be auto-approved)
	const SAFE_PATTERNS = [
	'get',
	'list',
	'read',
	'retrieve',
	'fetch',
	'search',
	'find',
	'query',
	'recall',
	'check',
	'status',
	'health',
	'stats',
	'analyze',
	'view',
	'show',
	'describe',
	'inspect'
	];

	/**
	* Main hook entry point
	* Receives JSON via stdin, processes permission request, returns decision
	*/
	async function main() {
	try {
	// Read stdin input
	const input = await readStdin();
	const payload = JSON.parse(input);

	// Check if this is an MCP tool call
	if (isMCPToolCall(payload)) {
	const toolName = extractToolName(payload);

	// Check if tool is safe (non-destructive)
	if (isSafeTool(toolName)) {
	// Auto-approve safe tools
	outputDecision('allow', {
	reason: `Auto-approved safe tool: ${toolName}`,
	auto_approved: true,
	server: payload.server_name,
	tool_name: toolName
	});
	} else {
	// Require confirmation for potentially destructive tools
	outputDecision('prompt');
	}
	} else {
	// Not an MCP tool call, show normal dialog
	outputDecision('prompt');
	}
	} catch (error) {
	// On error, fall back to prompting user
	console.error('[PermissionRequest Hook] Error:', error.message);
	outputDecision('prompt');
	}
	}

	/**
	* Check if the payload represents an MCP tool call
	*/
	function isMCPToolCall(payload) {
	return payload && (
	payload.hook_event_name === 'PermissionRequest' \|\|
	payload.type === 'mcp_tool_call' \|\|
	(payload.tool_name && payload.server_name)
	);
	}

	/**
	* Extract clean tool name from payload (strip mcp__ prefix)
	*/
	function extractToolName(payload) {
	let toolName = payload.tool_name \|\| '';

	// Strip mcp__servername__ prefix if present
	// Examples: mcp__memory__retrieve_memory -> retrieve_memory
	// mcp__shodh-cloudflare__recall -> recall
	const mcpPrefix = /^mcp__[^_]+__/;
	toolName = toolName.replace(mcpPrefix, '');

	return toolName.toLowerCase();
	}

	/**
	* Check if the tool is safe (non-destructive) based on naming patterns
	*/
	function isSafeTool(toolName) {
	if (!toolName) {
	return false;
	}

	// First check: Does the name contain any destructive pattern?
	for (const pattern of DESTRUCTIVE_PATTERNS) {
	if (toolName.includes(pattern)) {
	return false; // Destructive - require confirmation
	}
	}

	// Second check: Does the name match a safe pattern?
	for (const pattern of SAFE_PATTERNS) {
	if (toolName.includes(pattern)) {
	return true; // Safe - auto-approve
	}
	}

	// Unknown pattern - require confirmation (safer default)
	return false;
	}

	/**
	* Output the decision in Claude Code hook format
	*/
	function outputDecision(behavior, metadata = {}) {
	const decision = {
	hookSpecificOutput: {
	hookEventName: 'PermissionRequest',
	decision: {
	behavior: behavior // 'allow', 'deny', or 'prompt'
	}
	}
	};

	// Add metadata if provided (for logging/debugging)
	if (Object.keys(metadata).length > 0 && behavior !== 'prompt') {
	decision.hookSpecificOutput.metadata = metadata;
	}

	console.log(JSON.stringify(decision));
	}

	/**
	* Read all data from stdin
	*/
	function readStdin() {
	return new Promise((resolve, reject) => {
	let data = '';

	process.stdin.setEncoding('utf8');

	process.stdin.on('readable', () => {
	let chunk;
	while ((chunk = process.stdin.read()) !== null) {
	data += chunk;
	}
	});

	process.stdin.on('end', () => {
	resolve(data);
	});

	process.stdin.on('error', (error) => {
	reject(error);
	});

	// Timeout after 1 second
	setTimeout(() => {
	if (data.length === 0) {
	reject(new Error('Timeout reading stdin'));
	}
	}, 1000);
	});
	}

	// Run main
	main().catch(error => {
	console.error('[PermissionRequest Hook] Fatal error:', error);
	outputDecision('prompt');
	process.exit(1);
	});
No results found