os.py

#PART 1

import os
import sys
import subprocess
import signal
import shlex
from pathlib import Path
import platform

class BasicShell:
    def __init__(self):
        self.history = []
        self.jobs = {}
        self.job_counter = 0
        self.running = True
        
        # Setup signal handlers (Windows-compatible)
        signal.signal(signal.SIGINT, self.handle_sigint)
        # SIGCHLD only exists on Unix/Linux, skip on Windows
        if platform.system() != 'Windows':
            signal.signal(signal.SIGCHLD, self.handle_sigchld)
    
    def handle_sigint(self, signum, frame):
        """Handle Ctrl+C (SIGINT) - don't exit shell"""
        print("\n")
        self.display_prompt()
    
    def handle_sigchld(self, signum, frame):
        """Handle child process termination (SIGCHLD) - Unix only"""
        try:
            while True:
                pid, status = os.waitpid(-1, os.WNOHANG) #checks if any child process has ended
                if pid == 0:
                    break
                # Remove completed background job
                for job_id, job_info in list(self.jobs.items()):# iterates through jobs to find completed one
                    if job_info['pid'] == pid:
                        print(f"\n[{job_id}] Done    {' '.join(job_info['command'])}")
                        del self.jobs[job_id]
                        break
        except (ChildProcessError, AttributeError):
            pass
    
    def check_background_jobs(self): #check background jobs status if on Windows
        """Check status of background jobs (Windows-compatible)"""
        for job_id, job_info in list(self.jobs.items()):
            if job_info['process'].poll() is not None:
                print(f"\n[{job_id}] Done    {' '.join(job_info['command'])}")
                del self.jobs[job_id]
    
    def display_prompt(self): 
        """Display shell prompt"""
        cwd = os.getcwd()
        home = str(Path.home())
        if cwd.startswith(home):
            cwd = cwd.replace(home, '~', 1)
        print(f"\n{cwd} $ ", end='', flush=True)
    
    def parse_input(self, user_input):# Parse user input and return list of commands with pipes
        """Parse user input and return list of commands with pipes"""
        if not user_input.strip():
            return None
        
        # Check for background process
        background = False
        if user_input.strip().endswith('&'):
            background = True
            user_input = user_input.rstrip('&').strip()
        
        # Split by pipe
        commands = []
        for cmd in user_input.split('|'):
            cmd = cmd.strip()
            if cmd:
                commands.append(self.parse_command(cmd))
        
        return {'commands': commands, 'background': background}
    
    def parse_command(self, command):
        """Parse a single command for I/O redirection"""
        tokens = shlex.split(command)
        cmd_args = []
        stdin_file = None
        stdout_file = None
        stdout_append = False
        
        i = 0
        while i < len(tokens):
            if tokens[i] == '<':
                if i + 1 < len(tokens):
                    stdin_file = tokens[i + 1]
                    i += 2
                else:
                    raise ValueError("Syntax error: expected filename after '<'")
            elif tokens[i] == '>':
                if i + 1 < len(tokens):
                    stdout_file = tokens[i + 1]
                    stdout_append = False
                    i += 2
                else:
                    raise ValueError("Syntax error: expected filename after '>'")
            elif tokens[i] == '>>':
                if i + 1 < len(tokens):
                    stdout_file = tokens[i + 1]
                    stdout_append = True
                    i += 2
                else:
                    raise ValueError("Syntax error: expected filename after '>>'")
            else:
                cmd_args.append(tokens[i])
                i += 1
        
        return {
            'args': cmd_args,
            'stdin': stdin_file,
            'stdout': stdout_file,
            'append': stdout_append
        }
    
    
    #PART 2
    def execute_builtin(self, command): 
        """Execute built-in commands"""
        args = command['args']
        cmd = args[0]
        
        if cmd == 'exit':
            print("Exiting shell...")
            self.running = False
            return True
        
        elif cmd == 'cd':
            try:
                if len(args) == 1:
                    os.chdir(str(Path.home()))
                else:
                    os.chdir(args[1])
            except FileNotFoundError:
                print(f"cd: {args[1]}: No such file or directory")
            except PermissionError:
                print(f"cd: {args[1]}: Permission denied")
            except Exception as e:
                print(f"cd: error: {e}")
            return True
        
        elif cmd == 'pwd':
            print(os.getcwd())
            return True
        
        elif cmd == 'history':
            for i, cmd in enumerate(self.history, 1):
                print(f"{i:4d}  {cmd}")
            return True
        
        elif cmd == 'jobs':
            # Check for completed jobs first
            self.check_background_jobs()
            
            if not self.jobs:
                print("No background jobs")
            else:
                for job_id, job_info in self.jobs.items():
                    print(f"[{job_id}] Running    {' '.join(job_info['command'])}")
            return True
        
        elif cmd == 'fg':
            if not self.jobs:
                print("fg: no current job")
                return True
            
            # Get job to bring to foreground
            if len(args) > 1:
                try:
                    job_id = int(args[1])
                    if job_id not in self.jobs:
                        print(f"fg: {job_id}: no such job")
                        return True
                except ValueError:
                    print(f"fg: {args[1]}: invalid job specification")
                    return True
            else:
                job_id = max(self.jobs.keys())
            
            job_info = self.jobs[job_id]
            print(f"{' '.join(job_info['command'])}")
            
            try:
                # Wait for process to complete
                job_info['process'].wait()
                del self.jobs[job_id]
            except Exception as e:
                print(f"fg: error: {e}")
                if job_id in self.jobs:
                    del self.jobs[job_id]
            
            return True
        
        elif cmd == 'help':
            print("\n" + "="*70)
            print(" BASIC SHELL - BUILT-IN COMMANDS")
            print("="*70)
            print(" cd [dir]        Change directory (default: home)")
            print(" pwd             Print working directory")
            print(" exit            Exit the shell")
            print(" history         Show command history")
            print(" jobs            List background jobs")
            print(" fg [job_id]     Bring background job to foreground")
            print(" help            Show this help message")
            print("\n FEATURES:")
            print("   I/O Redirection:  cmd < input.txt")
            print("                     cmd > output.txt")
            print("                     cmd >> output.txt")
            print("   Piping:           cmd1 | cmd2 | cmd3")
            print("   Background:       cmd &")
            print("="*70 + "\n")
            return True
        
        elif cmd == 'clear' or cmd == 'cls':
            os.system('cls' if platform.system() == 'Windows' else 'clear')
            return True
        
        return False
    
    
    #PART 3
    def execute_external(self, parsed_input):
        """Execute external commands with piping and I/O redirection"""
        commands = parsed_input['commands']
        background = parsed_input['background']
        
        # Check if it's a built-in command (only for single commands)
        if len(commands) == 1 and not background:
            if self.execute_builtin(commands[0]):
                return
        
        try:
            processes = []
            prev_stdout = None
            stdin_handle = None
            stdout_handle = None
            
            for i, command in enumerate(commands):
                args = command['args']
                
                if not args:
                    continue
                
                # Setup stdin
                if command['stdin']:
                    stdin_handle = open(command['stdin'], 'r')
                    stdin = stdin_handle
                elif i > 0:
                    stdin = prev_stdout
                else:
                    stdin = None
                
                # Setup stdout
                if command['stdout']:
                    mode = 'a' if command['append'] else 'w'
                    stdout_handle = open(command['stdout'], mode)
                    stdout = stdout_handle
                elif i < len(commands) - 1:
                    stdout = subprocess.PIPE
                else:
                    stdout = None
                
                # Create process with shell=True for Windows compatibility
                if platform.system() == 'Windows':
                    process = subprocess.Popen(
                        ' '.join(args),
                        stdin=stdin,
                        stdout=stdout,
                        stderr=subprocess.PIPE,
                        shell=True
                    )
                else:
                    process = subprocess.Popen(
                        args,
                        stdin=stdin,
                        stdout=stdout,
                        stderr=subprocess.PIPE
                    )
                
                processes.append(process)
                
                # Close previous pipe
                if prev_stdout and prev_stdout != stdin_handle:
                    prev_stdout.close()
                
                # Save stdout for next command in pipeline
                if stdout == subprocess.PIPE:
                    prev_stdout = process.stdout
            
            # Handle background vs foreground execution
            if background:
                self.job_counter += 1
                self.jobs[self.job_counter] = {
                    'pid': processes[-1].pid,
                    'process': processes[-1],
                    'command': [arg for cmd in commands for arg in cmd['args']]
                }
                print(f"[{self.job_counter}] {processes[-1].pid}")
            else:
                # Wait for all processes to complete
                for process in processes:
                    stdout, stderr = process.communicate()
                    if stderr:
                        error_msg = stderr.decode().strip()
                        if error_msg:
                            print(error_msg, file=sys.stderr)
            
            # Close file handles
            if stdin_handle:
                stdin_handle.close()
            if stdout_handle:
                stdout_handle.close()
        
        except FileNotFoundError:
            print(f"shell: {args[0]}: command not found")
        except PermissionError:
            print(f"shell: {args[0]}: permission denied")
        except Exception as e:
            print(f"shell: error: {e}")
    
    def run(self):
        """Main shell loop"""
        print("=" * 70)
        print(" BASIC SHELL IMPLEMENTATION - OPERATING SYSTEMS PROJECT")
        print("=" * 70)
        print(f" Platform: {platform.system()}")
        print(" Built-in Commands: cd, pwd, exit, history, jobs, fg, help, clear")
        print(" Features: I/O redirection (<, >, >>), piping (|), background (&)")
        print(" Type 'help' for more info or 'exit' to quit")
        print("=" * 70)
        
        while self.running:
            try:
                # Check background jobs status
                self.check_background_jobs()
                
                self.display_prompt()
                user_input = input()
                
                if not user_input.strip():
                    continue
                
                # Add to history
                self.history.append(user_input)
                
                # Parse and execute
                parsed_input = self.parse_input(user_input)
                if parsed_input:
                    self.execute_external(parsed_input)
            
            except EOFError:
                print("\nExiting shell...")
                break
            except KeyboardInterrupt:
                print()
                continue
            except Exception as e:
                print(f"shell: error: {e}")

def main():
    """Entry point"""
    shell = BasicShell()
    shell.run()

if __name__ == "__main__":
    main()