#!/usr/bin/env bash
EVENT_DATA=$(cat)

TOOL_NAME=$(echo "$EVENT_DATA" | jq -r '.tool_name')

if [[ "$TOOL_NAME" == "launch-process" ]]; then
  # Extract the command being executed
  COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command')
  echo "Command: $COMMAND" >&2

  # Check for dangerous patterns
  if echo "$COMMAND" | grep -qE "rm -rf|sudo|curl.*sh"; then
    echo "Blocked dangerous command" >&2
    exit 2
  fi
fi

exit 0

#!/usr/bin/env python3
import sys, json

event_data = json.load(sys.stdin)
if event_data.get('tool_name') == 'str-replace-editor':
    path = event_data.get('tool_input', {}).get('path', '')
    if any(p in path for p in ['.env', 'secrets', 'credentials']):
        print(f"[AUDIT] Sensitive file: {path}", file=sys.stderr)

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

TOOL_NAME=$(echo "$EVENT_DATA" | jq -r '.tool_name')
TOOL_OUTPUT=$(echo "$EVENT_DATA" | jq -r '.tool_output // ""')

if [[ "$TOOL_NAME" == "launch-process" ]] && echo "$TOOL_OUTPUT" | grep -q "test.*passed"; then
  # Tests passed - inject success context
  cat << EOF
{
  "hookSpecificOutput": {
    "hookEventName": "PostToolUse",
    "additionalContext": "All tests passed successfully!"
  }
}
EOF
fi

exit 0

#!/usr/bin/env python3
import sys
import json

event_data = json.load(sys.stdin)
tool_name = event_data.get('tool_name', '')
tool_output = event_data.get('tool_output', '')

if tool_name == 'launch-process' and 'test' in tool_output and 'passed' in tool_output:
    # Tests passed - inject success context
    output = {
        "hookSpecificOutput": {
            "hookEventName": "PostToolUse",
            "additionalContext": "All tests passed successfully!"
        }
    }
    print(json.dumps(output))

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

TOOL_ERROR=$(echo "$EVENT_DATA" | jq -r '.tool_error // ""')

if [[ -n "$TOOL_ERROR" ]] && echo "$TOOL_ERROR" | grep -q "permission denied"; then
  # Inject troubleshooting tip
  cat << EOF
{
  "hookSpecificOutput": {
    "hookEventName": "PostToolUse",
    "additionalContext": "Permission denied error detected. Try running with appropriate permissions or check file ownership."
  }
}
EOF
fi

exit 0

#!/usr/bin/env python3
import sys
import json

event_data = json.load(sys.stdin)
tool_error = event_data.get('tool_error', '')

if tool_error and 'permission denied' in tool_error.lower():
    output = {
        "hookSpecificOutput": {
            "hookEventName": "PostToolUse",
            "additionalContext": "Permission denied error detected. Try with appropriate permissions."
        }
    }
    print(json.dumps(output))

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

USER_EMAIL=$(echo "$EVENT_DATA" | jq -r '.context.userEmail // ""')
TOOL_NAME=$(echo "$EVENT_DATA" | jq -r '.tool_name')
COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command // ""')

# Only allow deployments for specific users
if [[ "$TOOL_NAME" == "launch-process" ]] && echo "$COMMAND" | grep -q "deploy"; then
  if [[ "$USER_EMAIL" != "admin@example.com" ]]; then
    echo "Only admins can deploy" >&2
    exit 2
  fi
fi

exit 0

#!/usr/bin/env python3
import sys
import json

event_data = json.load(sys.stdin)
user_email = event_data.get('context', {}).get('userEmail', '')

# Only allow deployments for specific users
tool_name = event_data.get('tool_name', '')
command = event_data.get('tool_input', {}).get('command', '')

if tool_name == 'launch-process' and 'deploy' in command:
    if user_email != 'admin@example.com':
        print("Only admins can deploy", file=sys.stderr)
        sys.exit(2)

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

MCP_DECISION=$(echo "$EVENT_DATA" | jq -r '.mcp_metadata.mcpDecision // "no"')
MCP_TOTAL=$(echo "$EVENT_DATA" | jq -r '.mcp_metadata.mcpTotalToolsCount // 0')

# Block if too many MCP tools are enabled (security concern)
if [[ "$MCP_DECISION" == "yes" ]] && [[ "$MCP_TOTAL" -gt 100 ]]; then
  echo "Too many MCP tools enabled ($MCP_TOTAL). Contact admin." >&2
  exit 2
fi

exit 0

#!/usr/bin/env python3
# /etc/augment/hooks/mcp-limit.sh (Python via shebang)
import sys
import json

event_data = json.load(sys.stdin)
mcp_metadata = event_data.get('mcp_metadata', {})

mcp_decision = mcp_metadata.get('mcpDecision', 'no')
mcp_total = mcp_metadata.get('mcpTotalToolsCount', 0)

# Block if too many MCP tools are enabled (security concern)
if mcp_decision == 'yes' and mcp_total > 100:
    print(f"Too many MCP tools enabled ({mcp_total}). Contact admin.", file=sys.stderr)
    sys.exit(2)

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

# Extract code changes
CODE_RESPONSE=$(echo "$EVENT_DATA" | jq -r '.conversation.agentCodeResponse // []')

# Check if any test files were modified
TEST_FILES=$(echo "$CODE_RESPONSE" | jq -r '.[] | select(.path | test("test|spec")) | .path')

if [[ -z "$TEST_FILES" ]]; then
  # No test files modified - block stop
  cat << EOF
{
  "hookSpecificOutput": {
    "hookEventName": "Stop",
    "decision": "block",
    "reason": "Please add or update tests before finishing"
  }
}
EOF
  exit 0
fi

exit 0

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)
conversation = event_data.get('conversation', {})
code_response = conversation.get('agentCodeResponse', [])

# Check if any test files were modified
test_files = [
    change['path'] for change in code_response
    if re.search(r'test|spec', change.get('path', ''))
]

if not test_files:
    # No test files modified - block stop
    output = {
        "hookSpecificOutput": {
            "hookEventName": "Stop",
            "decision": "block",
            "reason": "Please add or update tests before finishing"
        }
    }
    print(json.dumps(output))
    sys.exit(0)

sys.exit(0)

#!/usr/bin/env bash

# Read entire JSON from stdin
EVENT_DATA=$(cat)

# Extract fields using jq
HOOK_EVENT=$(echo "$EVENT_DATA" | jq -r '.hook_event_name')
TOOL_NAME=$(echo "$EVENT_DATA" | jq -r '.tool_name // ""')
CONV_ID=$(echo "$EVENT_DATA" | jq -r '.conversation_id')

echo "Event: $HOOK_EVENT, Tool: $TOOL_NAME, Conversation: $CONV_ID"

#!/usr/bin/env python3
import sys
import json

event_data = json.load(sys.stdin)

hook_event = event_data['hook_event_name']
tool_name = event_data.get('tool_name', '')
conv_id = event_data['conversation_id']

print(f"Event: {hook_event}, Tool: {tool_name}, Conversation: {conv_id}")

#!/usr/bin/env bash
EVENT_DATA=$(cat)
COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command // ""')

if echo "$COMMAND" | grep -qE "rm -rf|sudo"; then
  echo "Blocked dangerous command: $COMMAND" >&2
  exit 2  # Blocks tool, stderr shown to agent
fi

exit 0  # Allow tool to proceed

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)
command = event_data.get('tool_input', {}).get('command', '')

if re.search(r'rm -rf|sudo', command):
    print(f"Blocked dangerous command: {command}", file=sys.stderr)
    sys.exit(2)  # Blocks tool, stderr shown to agent

sys.exit(0)  # Allow tool to proceed

#!/usr/bin/env bash
EVENT_DATA=$(cat)
FILE_PATH=$(echo "$EVENT_DATA" | jq -r '.tool_input.path // ""')

if echo "$FILE_PATH" | grep -qE "\.env|secrets"; then
  echo "Warning: Accessing sensitive file: $FILE_PATH" >&2
fi

exit 0  # Allow tool but show warning

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)
file_path = event_data.get('tool_input', {}).get('path', '')

if re.search(r'\.env|secrets', file_path):
    print(f"Warning: Accessing sensitive file: {file_path}", file=sys.stderr)

sys.exit(0)  # Allow tool but show warning

#!/usr/bin/env bash

# Load current issues from issue tracker
ISSUES=$(curl -s https://api.example.com/issues)

# Output to stdout - this will be injected as context for the agent
echo "Current open issues:"
echo "$ISSUES"

exit 0

#!/usr/bin/env python3
import sys
import requests

# Load current issues from issue tracker
response = requests.get('https://api.example.com/issues')
issues = response.text

# Output to stdout - this will be injected as context for the agent
print("Current open issues:")
print(issues)

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)
COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command // ""')

if echo "$COMMAND" | grep -qE "rm -rf"; then
  echo "Blocked dangerous command: $COMMAND" >&2
  exit 2  # Blocks tool, stderr shown to agent and user
fi

exit 0

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)
command = event_data.get('tool_input', {}).get('command', '')

if re.search(r'rm -rf', command):
    print(f"Blocked dangerous command: {command}", file=sys.stderr)
    sys.exit(2)  # Blocks tool, stderr shown to agent and user

sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)
COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command // ""')

if echo "$COMMAND" | grep -qE "rm -rf"; then
  cat << EOF
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "Command contains 'rm -rf' which violates security policy"
  }
}
EOF
  exit 0
fi

exit 0

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)
command = event_data.get('tool_input', {}).get('command', '')

if re.search(r'rm -rf', command):
    output = {
        "hookSpecificOutput": {
            "hookEventName": "PreToolUse",
            "permissionDecision": "deny",
            "permissionDecisionReason": "Command contains 'rm -rf' which violates security policy"
        }
    }
    print(json.dumps(output))
    sys.exit(0)

sys.exit(0)

#!/usr/bin/env bash
# /etc/augment/hooks/analytics.sh

EVENT_DATA=$(cat)

# Extract user context (available because includeUserContext=true)
USER_EMAIL=$(echo "$EVENT_DATA" | jq -r '.context.userEmail // ""')
MODEL_NAME=$(echo "$EVENT_DATA" | jq -r '.context.modelName // ""')

# Extract MCP metadata (available because includeMCPMetadata=true)
MCP_DECISION=$(echo "$EVENT_DATA" | jq -r '.mcp_metadata.mcpDecision // "no"')
MCP_SERVER=$(echo "$EVENT_DATA" | jq -r '.mcp_metadata.mcpExecutedToolServerName // ""')

# Log analytics
echo "User: $USER_EMAIL, Model: $MODEL_NAME, MCP: $MCP_DECISION, Server: $MCP_SERVER"
exit 0

#!/usr/bin/env python3
# /etc/augment/hooks/analytics.sh (Python via shebang)

import sys
import json

event_data = json.load(sys.stdin)

# Extract user context
context = event_data.get('context', {})
user_email = context.get('userEmail', '')
model_name = context.get('modelName', '')

# Extract MCP metadata
mcp = event_data.get('mcp_metadata', {})
mcp_decision = mcp.get('mcpDecision', 'no')
mcp_server = mcp.get('mcpExecutedToolServerName', '')

print(f"User: {user_email}, Model: {model_name}, MCP: {mcp_decision}")
sys.exit(0)

#!/usr/bin/env bash
EVENT_DATA=$(cat)

# Early return if not a launch-process tool
TOOL_NAME=$(echo "$EVENT_DATA" | jq -r '.tool_name')
if [[ "$TOOL_NAME" != "launch-process" ]]; then
  exit 0  # Not interested, return immediately
fi

# Only parse command if we got here
COMMAND=$(echo "$EVENT_DATA" | jq -r '.tool_input.command')

# Check command
if echo "$COMMAND" | grep -qE "rm -rf"; then
  echo "Blocked dangerous command" >&2
  exit 2
fi

exit 0

#!/usr/bin/env python3
import sys
import json
import re

event_data = json.load(sys.stdin)

# Early return if not a launch-process tool
tool_name = event_data.get('tool_name', '')
if tool_name != 'launch-process':
    sys.exit(0)  # Not interested, return immediately

# Only parse command if we got here
command = event_data.get('tool_input', {}).get('command', '')

# Check command
if re.search(r'rm -rf', command):
    print("Blocked dangerous command", file=sys.stderr)
    sys.exit(2)

sys.exit(0)