import docker
import tempfile
import os

class AICodeSandbox:
    """
    A simple sandbox to run AI-generated code in isolated Docker containers.
    Prevents malicious code from affecting your host system.
    """
    
    def __init__(self):
        self.client = docker.from_env()
        self.container = None
    
    def run_code_safely(self, code_string, language="python"):
        """
        Execute AI-generated code in a disposable container.
        
        Args:
            code_string: The code to execute (from ChatGPT, etc.)
            language: Runtime language (python, node, bash)
        
        Returns:
            Tuple of (output, error, exit_code)
        """
        # Create temporary file with the code
        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
            f.write(code_string)
            temp_file = f.name
        
        try:
            # Run in ephemeral container
            self.container = self.client.containers.run(
                image=f"{language}:latest",
                command=f"python {os.path.basename(temp_file)}",
                volumes={os.path.dirname(temp_file): {'bind': '/tmp', 'mode': 'ro'}},
                working_dir='/tmp',
                remove=True,  # Auto-remove after execution
                stdout=True,
                stderr=True
            )
            
            output = self.container.decode('utf-8') if self.container else ""
            return output, "", 0
            
        except docker.errors.ContainerError as e:
            return "", str(e.stderr, 'utf-8'), e.exit_status
        finally:
            # Cleanup temp file
            os.unlink(temp_file)

# Example usage
if __name__ == "__main__":
    sandbox = AICodeSandbox()
    
    # AI-generated code (potentially dangerous!)
    risky_code = """
import os
print("Hello from AI!")
# This could be malicious in real scenarios
print(f"Current dir: {os.getcwd()}")
"""
    
    output, error, code = sandbox.run_code_safely(risky_code)
    print(f"Output: {output}")
    print(f"Error: {error}")
    print(f"Exit Code: {code}")

The Infrastructure of Our AI-Generated Demise

Let's be clear: the problem Daytona is solving is genuine. Asking ChatGPT to write a Python script and then blindly executing it on your machine is the digital equivalent of accepting candy from a stranger in a white van. The stranger might be a nice person offering a Snickers, or they might be offering a payload that exfiltrates your SSH keys. Daytona's premise is to put that candy in a biohazard container first.

Security Theater, Now With More YAML

The platform's main selling point is security. It runs AI-generated code in isolated, ephemeral environments. This is smart! It's also what every competent cloud platform has been doing for a decade. The innovation here isn't the sandbox—it's the assumption that the primary source of code entering the sandbox will be profoundly, hilariously naive.

Think about it: we've spent 50 years teaching humans not to write buffer overflows, SQL injections, and race conditions. Now we're building specialized infrastructure for entities that have 'learned' coding from Stack Overflow answers with 200 downvotes and Medium articles titled 'Learn Blockchain in 10 Minutes!' The 'secure' part feels less like a feature and more like a liability waiver.

Elasticity: For When Your AI Wants to Fork Bomb the Cloud

The 'elastic' part is where the true comedy unfolds. Elastic infrastructure scales to meet demand. So, what's the demand signal here? The unhinged ambition of a large language model that just read a blog post about microservices?

Scenario: You ask your AI, "Write a script to find all duplicate files on my system." The AI, eager to please and trained on every over-engineered solution on GitHub, generates a distributed map-reduce job that spawns 500 containers, each scanning a single byte. Daytona elastically scales to accommodate this brilliance. Your cloud bill elastically scales to $14,000. The duplicate file, 'cat_meme_ final_FINAL2.jpg', remains unfound.

The TypeScript of It All

It's written in TypeScript. Of course it is. The infrastructure for running potentially catastrophic AI code is itself built in a language famous for its 'any' type and the ability to make 10,000 npm dependencies a core business requirement. The poetic symmetry is beautiful. It's like building a safety cage for tigers out of chicken wire and optimism.

Why This is Peak 2020s Tech

Daytona is a perfect snapshot of our current tech ethos:

• Solution in Search of a Catastrophe: We created AI that writes bad code, and instead of making the AI write better code, we built a better place for the bad code to live. This is the 'moat' strategy applied to garbage collection.
• The Abstraction Layering: We now have: Hardware -> OS -> Hypervisor -> Container Runtime -> Orchestrator (K8s) -> Daytona -> AI Agent -> Generated Code. Each layer exists to clean up the mess of the layer above it. We're building a digital onion where every layer makes you cry.
• VC-Bait Terminology: 'AI-Generated Code Infrastructure.' Say that five times fast at a cocktail party and a venture capitalist will materialize to offer you a term sheet. It doesn't matter if it solves a problem; it matters that it sounds like it could.

The Real Test: Can It Run 'Hello, World!' Without a Crypto Miner?

The ultimate benchmark for Daytona won't be its star count or its scalability. It will be its ability to take the output of an AI that has been subtly poisoned to insert vulnerabilities and not let those vulnerabilities escape the sandbox. It's a high-stakes game of whack-a-mole where the moles are being generated at 100 tokens per second by a model that thinks 'secure password hashing' involves using ROT13 twice.

Perhaps the most ironic use case is that Daytona itself could, in theory, be built by AI-generated code running on Daytona. We are approaching the tech singularity where the infrastructure and the workload become a perfect, self-sustaining ouroboros of hype, funding, and pull requests.