# Build the server
bazel build //src/api:server

# Run the server (listens on localhost:50051)
bazel run //src/api:server

# Install Python client dependencies
pip install -r python_client/requirements.txt

# Generate Python gRPC bindings
python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. proto/sandbox.proto

# Run the client with individual files
python python_client/main.py --file examples/c/01_hello_world.c
python python_client/main.py --file examples/cpp/01_hello_world.cpp
python python_client/main.py --file examples/python/01_hello_world.py

# Example: Custom port with 8GB memory limit
bazel run //src/api:server -- --port 9090 --sandbox_memory_limit_bytes 8589934592

# Example: Strict limits for testing untrusted code
bazel run //src/api:server -- --sandbox_cpu_time_limit_seconds 3 --sandbox_memory_limit_bytes 52428800

# Execute all C examples
python python_client/main.py --directory examples/c

# Execute all C++ examples
python python_client/main.py --directory examples/cpp

# Execute all Python examples  
python python_client/main.py --directory examples/python

# Execute a single file (language auto-detected from extension)
python python_client/main.py --file examples/c/01_hello_world.c
python python_client/main.py --file examples/cpp/01_hello_world.cpp
python python_client/main.py --file examples/python/01_hello_world.py

# Run each file twice to demonstrate caching
python python_client/main.py --directory examples/c --cache-demo

# Interactive mode
python python_client/main.py --interactive

# Connect to remote server
python python_client/main.py --server 192.168.1.100:50051 --directory examples/cpp

# Pass stdin data to a program
python python_client/main.py --file examples/cpp/13_stdin_input.cpp --stdin 'DCodeX\n5\n10\n20\n30\n40\n50\n'

# Pass stdin from a file
python python_client/main.py --file examples/cpp/13_stdin_input.cpp --stdin-file /tmp/input.txt

// Old approach - creates an extra process for each timeout
pid_t watcher_pid = fork();
if (watcher_pid == 0) {
    for (int fd = 0; fd < 1024; ++fd) close(fd);
    sleep(timeout_seconds);
    if (kill(pid, 0) == 0) kill(pid, SIGKILL);
    _exit(0);
}

// New approach - uses gRPC Alarm for efficient timeout
auto timeout_manager = std::make_unique<ProcessTimeoutManager>(
    pid, timeout, [&timed_out_flag, pid]() {
      timed_out_flag.store(true);
      if (kill(pid, 0) == 0) kill(pid, SIGKILL);
    });
timeout_manager->Start();

# Terminal 1: Monitor process count
watch -n 0.5 'ps -e | wc -l'

# Terminal 2: Start server
bazel run //src/api:server

# Terminal 3: Send concurrent requests with timeouts
for i in {1..50}; do
  python python_client/main.py --file examples/python/06_infinite_loop.py &
done

ExecutionContext
       │
       ▼
┌─────────────────────┐
│ CreateSourceFileStep│  Creates temp file with code
└─────────────────────┘
       │
       ▼
┌─────────────────────┐
│    CompileStep      │  Compiles source (C++ only)
└─────────────────────┘
       │
       ▼
┌─────────────────────┐
│   RunProcessStep    │  Executes with sandboxing
│   + gRPC Alarm      │  Timeout management
└─────────────────────┘
       │
       ▼
┌─────────────────────┐
│ FinalizeResultStep  │  Formats result and trace
└─────────────────────┘
       │
       ▼
  ExecutionResult

DCodeX/
├── src/api/                      # C++ gRPC server
│   ├── main.cpp                  # Server entry point
│   ├── code_executor_service.h/cpp   # gRPC service implementation
│   └── execute_reactor.h/cpp     # gRPC stream reactor
├── src/engine/                   # Execution engine
│   ├── sandbox.h/cpp             # SandboxedProcess orchestrator
│   ├── execution_types.h         # ExecutionResult, ResourceStats
│   ├── execution_step.h          # Command pattern steps
│   ├── execution_pipeline.h      # Template method pipeline
│   ├── execution_strategy.h      # Strategy pattern (C/C++/Python)
│   ├── process_timeout_manager.h # gRPC Alarm-based timeout
│   ├── warm_worker_pool.h/cpp    # Worker pool for concurrency
│   ├── process_runner.h          # RAII process management
│   ├── output_filter.h           # Output truncation
│   └── temp_file_manager.h       # Temp file utilities
├── src/common/                   # Common utilities
│   ├── execution_cache.h/cpp     # LRU cache with TTL
│   └── status_macros.h           # Local ABSL_RETURN_IF_ERROR macros
├── proto/
│   ├── sandbox.proto             # gRPC protocol definition
│   └── BUILD                     # Proto/CC gRPC library
├── python_client/                # Python client
│   ├── main.py                   # Entry point
│   ├── grpc_client.py            # gRPC client wrapper
│   ├── executor.py               # Execution orchestration
│   ├── formatter.py              # Output formatting
│   └── ...
├── examples/                     # Example code files
│   ├── c/                        # C examples
│   ├── cpp/                      # C++ examples
│   └── python/                   # Python examples
├── pyproject.toml                # Python project config
└── MODULE.bazel                  # Bazel workspace

// CacheInterface is injected, not statically accessed
class SandboxedProcess {
 public:
  explicit SandboxedProcess(std::shared_ptr<CacheInterface> cache);
 private:
  std::shared_ptr<CacheInterface> cache_;
};

// Server creates and injects the cache
auto cache = std::make_shared<ExecutionCache>(absl::Hours(1), 1000);
CodeExecutorServiceImpl service(max_sandboxes, std::move(cache));

// src/common/status_macros.h
#define ABSL_RETURN_IF_ERROR(expr) \
  if (const absl::Status _status = (expr); !_status.ok()) return _status

#define ABSL_ASSIGN_OR_RETURN(lhs, rexpr) \
  auto _result = (rexpr); \
  if (!_result.ok()) return _result.status(); \
  lhs = std::move(_result).value()