# Create a virtual environment
python3 -m venv venv
source venv/bin/activate

# Install essential packages
# watchdog: To monitor file changes safely
# python-dotenv: For secure configuration
# openai: For the agentic reasoning engine
pip install watchdog python-dotenv openai

# Initialize project
npm init -y

# Install dependencies
# chokidar: Robust file watching
# dotenv: Environment variable management
# zod: Schema validation for file paths
npm install chokidar dotenv zod
npm install --save-dev typescript @types/node

import os
import time
import logging
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Configure Logging
logging.basicConfig(level=logging.INFO, 
                    format='%(asctime)s - %(levelname)s - %(message)s')

class SecureAgentHandler(FileSystemEventHandler):
    """
    A handler that processes file events only within authorized scopes.
    This prevents the agent from attempting to access restricted system files.
    """
    def on_modified(self, event):
        if not event.is_directory:
            logging.info(f"🚀 Agent detected change in authorized file: {event.src_path}")
            self.process_file(event.src_path)

    def process_file(self, file_path):
        # Logic for AI processing would go here
        # Example: Reading the file content to feed into an LLM
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
                logging.info(f"✅ Successfully read {len(content)} characters.")
        except PermissionError:
            logging.error(f"❌ PERMISSION DENIED: Apple TCC blocked access to {file_path}")
        except Exception as e:
            logging.error(f"⚠️ Error reading file: {e}")

def start_agent(target_path: str):
    # Validate that the path is not a sensitive system directory
    protected_dirs = ['/System', '/Library', '/etc', '/usr']
    if any(target_path.startswith(p) for p in protected_dirs):
        raise ValueError("Security Violation: Agent attempted to access a protected system directory.")

    if not os.path.exists(target_path):
        raise FileNotFoundError(f"Path {target_path} does not exist.")

    event_handler = SecureAgentHandler()
    observer = Observer()
    observer.schedule(event_handler, target_path, recursive=False) # recursive=False is safer
    
    logging.info(f"🛡️ Agent started. Monitoring authorized path: {target_path}")
    observer.start()
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
        logging.info("🛑 Agent stopped by user.")
    observer.join()

if __name__ == "__main__":
    # IN PRODUCTION: This path should be provided by a user via a UI File Picker
    USER_AUTHORIZED_DIR = os.path.expanduser("~/Documents/AI_Workspace")
    
    # Create directory if it doesn't exist for demo purposes
    os.makedirs(USER_AUTHORIZED_DIR, exist_ok=True)
    
    start_agent(USER_AUTHORIZED_DIR)

import * as fs from 'fs/promises';
import * as path from 'path';
import { z } from 'zod';
import * as dotenv from 'dotenv';

dotenv.config();

// Define a schema for safe file operations
const FileOperationSchema = z.object({
  filePath: z.string().refine((p) => !p.includes('/Library') && !p.includes('/System'), {
    message: "Access to system directories is strictly prohibited by security policy.",
  }),
});

class SecureFileSystemAgent {
  private authorizedRoot: string;

  constructor(authorizedRoot: string) {
    // Resolve absolute path to prevent directory traversal attacks (e.g., ../../)
    this.authorizedRoot = path.resolve(authorizedRoot);
  }

  /**
   * Safely reads a file ensuring it resides within the authorized scope
   */
  async safeReadFile(requestedPath: string): Promise<string> {
    try {
      // 1. Resolve and validate path structure
      const absolutePath = path.resolve(requestedPath);
      
      // 2. Validate against schema
      FileOperationSchema.parse({ filePath: absolutePath });

      // 3. Ensure the path is inside the authorized root (Prevents path traversal)
      if (!absolutePath.startsWith(this.authorizedRoot)) {
        throw new Error(`Security Error: Attempted to access path outside of scope: ${absolutePath}`);
      }

      // 4. Perform the read
      const data = await fs.readFile(absolutePath, 'utf-8');
      console.log(`✅ Successfully read: ${absolutePath}`);
      return data;

    } catch (error) {
      if (error instanceof z.ZodError) {
        console.error(`❌ Validation Error: ${error.errors[0].message}`);
      } else if ((error as Error).code === 'EACCES') {
        console.error(`❌ macOS Permission Denied: Check System Settings > Privacy & Security`);
      } else {
        console.error(`⚠️ Operation failed: ${(error as Error).message}`);
      }
      throw error;
    }
  }
}

// --- Execution Block ---
async function main() {
  // Define a sandbox directory for the agent
  const sandbox = path.join(process.cwd(), 'agent_sandbox');
  
  // Ensure sandbox exists
  try { await fs.mkdir(sandbox, { recursive: true }); } catch {}

  const agent = new SecureFileSystemAgent(sandbox);

  // Test Case 1: Valid Access
  const validFile = path.join(sandbox, 'notes.txt');
  await fs.writeFile(validFile, 'Hello from the AI Agent!');
  await agent.safeReadFile(validFile);

  // Test Case 2: Path Traversal Attempt (Security Test)
  console.log("\n--- Testing Security Violation ---");
  try {
    await agent.safeReadFile('/etc/passwd'); 
  } catch (e) {
    // Expected failure
  }
}

main();

# AI Engine Configuration
OPENAI_API_KEY=sk-your-actual-key-here

# Security Configuration
# Define the ONLY directory the agent is allowed to touch
AGENT_WORKSPACE_PATH=/Users/yourname/Documents/AI_Project_Workspace

# Strict Mode: If true, the agent will crash on any permission error
STRICT_SECURITY_MODE=true