feat: change structure

api/src/Bootstrap/Middleware.php

@@ -0,0 +1,40 @@
+<?php
+
+use Slim\App;
+use Slim\Middleware\ErrorMiddleware;
+use Slim\Middleware\BodyParsingMiddleware;
+
+return function (App $app) {
+    // Add body parsing middleware (for JSON, form, etc.)
+    $app->addBodyParsingMiddleware();
+
+    // Add error middleware
+    $container = $app->getContainer();
+    $settings = $container->get('settings');
+
+    $errorMiddleware = new ErrorMiddleware(
+        $app->getCallableResolver(),
+        $app->getResponseFactory(),
+        $settings['displayErrorDetails'],
+        true,
+        true
+    );
+
+    // Optional custom 404 handler
+    $errorMiddleware->setErrorHandler(
+        Slim\Exception\HttpNotFoundException::class,
+        function (
+            Psr\Http\Message\ServerRequestInterface $request,
+            Throwable $exception,
+            bool $displayErrorDetails,
+            bool $logErrors,
+            bool $logErrorDetails
+        ) use ($app) {
+            $response = $app->getResponseFactory()->createResponse();
+            $response->getBody()->write('404 Not Found — Custom Page');
+            return $response->withStatus(404);
+        }
+    );
+
+    $app->add($errorMiddleware);
+};

api/src/Controllers/CaptchaController.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Controllers;
+
+use App\Lib\PCaptcha;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+
+class CaptchaController
+{
+    /**
+     * Generates and outputs a captcha image.
+     */
+    public function get(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
+    {
+        if (session_status() === PHP_SESSION_NONE) {
+            session_start();
+        }
+        $captcha = new PCaptcha();
+        $captcha->width = 200;
+        $captcha->hight = 50;
+        $captcha->leng = 6;
+
+        try {
+            $imageData = $captcha->get_captcha();
+        } catch (\Throwable $e) {
+            $response->getBody()->write("Captcha error: " . $e->getMessage());
+            return $response->withStatus(500)->withHeader('Content-Type', 'text/plain');
+        }
+
+        $response->getBody()->write($imageData);
+        return $response->withHeader('Content-Type', 'image/png');
+    }
+}

api/src/Controllers/LoginController.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace App\Controllers;
+
+use App\Lib\PCaptcha;
+use App\Services\LxdService;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use App\Utils\LogWriterHelper;
+
+class LoginController
+{
+    /**
+     * Login with captcha
+     */
+    public function index(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
+    {   
+        
+        try {
+            $mainDomain = $_ENV['MAIN_DOMAIN'] ?? 'lxdapp.local';
+
+            $origin = $request->getHeaderLine('Origin');
+            if (!empty($origin)) {
+                $domain = parse_url($origin, PHP_URL_HOST);
+            } else {
+                $domain = $request->getHeaderLine('Host');
+            }
+
+            $configPath = __DIR__ . '/../../config.json';
+            $config = file_exists($configPath) ? json_decode(file_get_contents($configPath), true) : [];
+            $name = $config[$domain] ?? null;
+            
+            $params = (array)$request->getParsedBody();
+
+            $captcha = new PCaptcha();
+
+            if (!$captcha->validate_captcha($params['panswer'])) {
+                return $this->json($response, ['status' => 'error', 'message' => 'Invalid CAPTCHA'], 400);
+            }
+
+            $lxd = new LxdService();
+
+            $status = $lxd->getContainerState($name)['metadata']['status'] ?? 'Stopped';
+            if ($status !== 'Running') {
+                $lxd->startContainer($name);
+            }
+
+            // Write log
+            LogWriterHelper::write($name, $request->getUri());
+
+            $redirect = '/waiting?name='.$name .'&redirect='.urlencode($params['redirect']);
+            // Login success
+            return $this->json($response, ['status' => 'success', 'message' => 'Container started!', 'redirect' => $redirect]);
+        } catch (\Throwable $e) {
+            return $this->json($response, [
+                'status' => 'error',
+                'message' => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    public function status(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
+    {   
+        $queryParams = $request->getQueryParams();
+        $name = $queryParams['name'] ?? '';
+
+        if (empty($name)) {
+            return $this->json($response, [
+                'status' => 'error',
+                'message' => 'Missing container name.',
+            ], 400);
+        }
+
+        $lxd = new LxdService();
+
+        $state = $lxd->getContainerState($name);
+        if (!$state) {
+            return $this->json($response, [
+                'status' => 'not_found',
+                'message' => 'Container not found',
+            ], 404);
+        }
+
+        $status = $state['metadata']['status'] ?? 'Stopped';
+        if ($status !== 'Running') {
+            return $this->json($response, [
+                'status' => 'starting',
+                'message' => 'Container is not yet running',
+            ]);
+        }
+
+        $ip = $lxd->getContainerIP($name);
+        $nginx = $lxd->isServiceRunning($name, 'nginx');
+        $mysql = $lxd->isServiceRunning($name, 'mysql');
+        if ($ip && $nginx === 'active' && $mysql === 'active') {
+            return $this->json($response, [
+                'status' => 'ready',
+                'ip' => $ip,
+                'message' => 'Container is ready',
+            ]);
+        }
+
+        if($nginx === 'failed'){
+            return $this->json($response, [
+                'status' => 'failed',
+                'message' => 'Failed to start web server service in container',
+            ], 400);
+        }
+
+        if($mysql === 'failed'){
+            return $this->json($response, [
+                'status' => 'failed',
+                'message' => 'Failed to start mysql service in container',
+            ], 400);
+        }
+
+        return $this->json($response, [
+            'status' => 'running',
+            'message' => 'Container is running, waiting for services...',
+        ]);
+    }
+
+
+    /**
+     * Sends a JSON response.
+     */
+    protected function json($response, array $data, int $status = 200)
+    {
+        $payload = json_encode($data, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
+
+        $response->getBody()->write($payload);
+
+        return $response
+            ->withHeader('Content-Type', 'application/json')
+            ->withHeader('Access-Control-Allow-Origin', '*')
+            ->withStatus($status);
+    }
+
+}

api/src/Dependencies/Dependencies.php

@@ -0,0 +1,12 @@
+<?php
+
+use DI\ContainerBuilder;
+use function DI\autowire;
+use App\Services\LxdService;
+
+return function (ContainerBuilder $containerBuilder) {
+    // Example service binding
+    $containerBuilder->addDefinitions([
+        \App\Services\LxdService::class => autowire()
+    ]);
+};

api/src/Lib/PCaptcha.php

@@ -0,0 +1,239 @@
+<?php
+namespace App\Lib;
+/**
+ * PCaptcha :
+ * A simple/lightweight class provides you with the necessary tools to generate a friendly/secure captcha and validate it 
+ *
+ * @author Bader Almutairi (Phpfalcon)
+ * @link https://github.com/phpfalcon/pcaptcha/
+ * @license http://opensource.org/licenses/MIT MIT License
+ */
+
+class PCaptcha
+{
+	//options
+	var $width = 150;
+	var $hight = 45;
+	var $size = 0; //this will be generated automaticlly - you can set it manually
+	var $scale = 0; //this will be generated automaticlly - you can set it manually
+	var $leng  = 5;
+	var $noise_level = 0;
+	var $pixlized = 2;
+	var $angle = 20;
+	var $grid = true;
+	var $font; 
+	var $drawcross = false;
+	var $drawcircles = true;
+	var $background = array(0,  0, 0); //rand if empty
+	var $text = array(255, 255, 255); //white
+	var $colortwo = array(204, 204, 204); //grey
+	var $postfield = 'panswer';
+	
+	
+	/**
+	 * called outside to genearate captcha
+	 *
+	 * @return void
+	 */
+	function get_captcha()
+	{
+		if (@extension_loaded('gd') && function_exists('gd_info')) {
+            try {
+                $this->gen_cpatcha_image();
+            } catch (Throwable $e) {
+                http_response_code(500);
+                header("Content-Type: text/plain");
+                echo "Captcha generation failed: " . $e->getMessage();
+            }
+        } else {
+            http_response_code(500);
+            header("Content-Type: text/plain");
+            echo "GD library not found";
+        }
+        exit();
+	}
+	
+	
+	/**
+	 * Validate captcha data in post fields 
+	 *
+	 * @return bool
+	 */
+	function validate_captcha($answer)
+	{
+		// $answer = trim((string) ($_POST[$this->postfield] ?? ''));
+
+		if((!empty($_SESSION['p_code']) &&  $answer != '') && ($_SESSION['p_code'] == $answer))
+		{
+			unset($_SESSION['p_code']);
+			return true;
+		}
+		
+		return false;
+	}
+	
+	
+
+	/**
+	 * Generate a CAPTCHA 
+	 *
+	 * @return void
+	 */
+	function gen_cpatcha_image()
+	{
+		
+
+		if(!isset($this->font))
+		{
+			$this->font = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'arial.ttf';
+		}
+		if($this->background[0] == 0)
+		{
+			$this->background[0] = mt_rand(70, 200);
+			$this->background[1] = 0;
+			$this->background[2] = mt_rand(70, 200);
+		}
+		
+		//generate a secure random int by using openssl 
+		$hash = bin2hex(openssl_random_pseudo_bytes(16)); 
+		$num = hexdec( substr(sha1($hash) , 0,15) );
+		$security_code = substr(intval($num) ,0, $this->leng);  //trim it down to $leng 
+		
+		//store the security code
+		$_SESSION["p_code"] = $security_code;
+
+		//Set the image width and height
+		$width = $this->width;
+		$height = $this->hight; 
+		
+		$sc = 0;
+		
+		//gen scale
+		if($this->scale <= 0)
+		{
+			$sc = $height / $width;
+			$sc = ($sc < 1) ? 2 : $sc + 2;
+		}
+		else
+		{
+			$sc = $this->scale;
+		}
+		
+		//gen size
+		$size = ($this->size <= 0) ? round($height / $sc) : $this->size;
+	
+
+		//Create the image resource
+		$image = ImageCreate($width, $height);  
+
+		 
+		//grab our paint tools , colors, white, black and gray
+		$white = ImageColorAllocate($image, $this->text[0], $this->text[1], $this->text[2]);
+		$black = ImageColorAllocate($image, $this->background[0], $this->background[1], $this->background[2]);
+		$grey = ImageColorAllocate($image, $this->colortwo[0], $this->colortwo[1], $this->colortwo[2]);
+
+
+		//fill the world in black
+		ImageFill($image, 0, 0, $black); 
+		
+		$text_count = strlen($security_code);
+		$text = str_split($security_code); 
+		$step = round($width/3) - $sc * 15; 
+		$y = $size + mt_rand(0, round($height/3) - $sc) ;
+		foreach($text as $txt)  
+		{ 
+		    $box = imagettfbbox( $size, 0,  $this->font, $txt ); 
+		    $x = abs($box[2]-$box[0]); 
+
+		    imagettftext($image, $size, mt_rand(-$this->angle, 0), $step, $y, $white, $this->font, $txt ); 
+		    $step += ($x+5); 
+		} 
+		
+		if($this->pixlized > 1)
+		{
+			imagefilter($image, IMG_FILTER_PIXELATE, $this->pixlized, true);
+		}
+		
+		if($this->grid)
+		{
+			$transp = $black;
+			$this->imagegrid($image, $width, $height, 10, $transp);
+		}
+		
+		if($this->drawcircles)
+		{
+		$transp2 = ImageColorAllocate($image, $this->background[0] + 30, $this->background[1], $this->background[2] + 30);
+		$this->imagecircles($image, $width, $height, 10, $transp2);
+		}
+		
+		if ($this->noise_level > 0) 
+		{
+			$noise_level = $this->noise_level; 
+
+			for ($i = 0; $i < $noise_level; ++$i) 
+			{
+				$x = mt_rand(2, $width);
+				$y = mt_rand(2, $height);
+				$size = 2;
+				imagefilledarc($image, $x, $y, $size, $size, 0, 360, $white, IMG_ARC_PIE);
+			}
+			
+
+		}
+		
+		//drow borders
+		ImageRectangle($image,0,0,$width-1,$height-1,$grey); 
+		
+		if($this->drawcross)
+		{
+ 			imageline($image, 0, $height/2, $width, $height/2, $grey); 
+ 			imageline($image, $width/2, 0, $width/2, $height, $grey); 
+		}
+		
+		//header file
+		header("Content-Type: image/png"); 
+
+		//Output the newly created image in jpeg format 
+		ImagePng($image);
+   
+		//Free up resources
+		ImageDestroy($image);
+
+	}
+	
+	/**
+	 * Draw circles
+	 * @param image $image given image
+	 * @param width $w image's width
+	 * @param height $w image's height
+	 * @param size $w circles size
+	 * @param color $color
+	 * @return void
+	 */
+	function imagecircles($image, $w, $h, $s, $color)
+	{
+	    $x = $w/2;
+	    $y = $h/2;
+	    for($iw=1; $iw<$w; $iw++)
+	    {
+		    imagearc($image, $x, $y, $iw*$s, $iw*$s,  0, 360, $color);
+
+	    }
+	    
+	}
+	
+	/**
+	 * Draws a nice looking grid
+	 * @param image $image given image
+	 * @param width $w image's width
+	 * @param height $w image's height
+	 * @param size $w size
+	 * @param color $color
+	 * @return void
+	 */
+	function imagegrid($image, $w, $h, $s, $color)
+	{
+	    for($iw=1; $iw<$w/$s; $iw++){imageline($image, $iw*$s, 0, $iw*$s, $w, $color );}
+	    for($ih=1; $ih<$h/$s; $ih++){imageline($image, 0, $ih*$s, $w, $ih*$s, $color );}
+	}
+}

api/src/Middleware/CorsMiddleware.php

@@ -0,0 +1,28 @@
+<?php
+namespace App\Middleware;
+
+use Psr\Http\Server\MiddlewareInterface;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Psr\Http\Server\RequestHandlerInterface as RequestHandler;
+use Psr\Http\Message\ResponseInterface;
+use Slim\Psr7\Response;
+
+class CorsMiddleware implements MiddlewareInterface
+{
+    public function process(Request $request, RequestHandler $handler): ResponseInterface
+    {
+        $origin = $_SERVER['HTTP_ORIGIN'] ?? '*';
+
+        if ($request->getMethod() === 'OPTIONS') {
+            $response = new Response(204);
+        } else {
+            $response = $handler->handle($request);
+        }
+
+        return $response
+            ->withHeader('Access-Control-Allow-Origin', $origin)
+            ->withHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization')
+            ->withHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS')
+            ->withHeader('Access-Control-Allow-Credentials', 'true');
+    }
+}

api/src/Scripts/auto-stop-containers.php

@@ -0,0 +1,68 @@
+<?php
+
+require __DIR__ . '/../../vendor/autoload.php'; // Adjust path as needed
+
+use App\Services\LxdService;
+
+// Initialize LXD service
+$lxdService = new LxdService();
+
+// Define the directory containing access logs
+$logDir = realpath(__DIR__ . '/../../public/last-access-logs'); // Adjust if you're in /app/src/Cron or similar
+
+// Define the idle threshold in minutes
+$thresholdMinutes = 30;
+
+// Iterate over all log files in the specified directory
+foreach (glob($logDir . '/*.txt') as $filePath) {
+    // Extract the container name from the file name
+    $containerName = basename($filePath, '.txt');
+
+    // Get the last line from the log file
+    $lastLine = getLastLine($filePath);
+    if (!$lastLine) {
+        echo "No access logs found for $containerName.\n";
+        continue;
+    }
+
+    // Parse the timestamp from the last log entry
+    $parts = explode(' : ', $lastLine);
+    if (!isset($parts[0])) continue;
+
+    $lastAccess = DateTime::createFromFormat('Y-m-d H:i:s', trim($parts[0]));
+    if (!$lastAccess) continue;
+
+    // Calculate the idle time in seconds
+    $now = new DateTime();
+    $interval = $now->getTimestamp() - $lastAccess->getTimestamp();
+
+    // Check if the container has been idle for longer than the threshold
+    if ($interval > $thresholdMinutes * 60) {
+        echo "$containerName has been idle for over $thresholdMinutes minutes. Stopping...\n";
+
+        try {
+            // Check if the container exists and stop it if it does
+            if ($lxdService->containerExists($containerName)) {
+                $lxdService->stopContainer($containerName);
+                echo "Stopped container: $containerName\n";
+            } else {
+                echo "Container $containerName does not exist.\n";
+            }
+        } catch (Throwable $e) {
+            // Handle any errors that occur while stopping the container
+            echo "Error stopping $containerName: " . $e->getMessage() . "\n";
+        }
+    }
+}
+
+/**
+ * Get the last non-empty line from a file.
+ *
+ * @param string $filePath Path to the file.
+ * @return string|null The last line, or null if the file is empty.
+ */
+function getLastLine(string $filePath): ?string
+{
+    $lines = file($filePath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+    return $lines ? end($lines) : null;
+}

api/src/Services/LxdService.php

@@ -0,0 +1,172 @@
+<?php
+
+namespace App\Services;
+use Exception;
+class LxdService
+{    
+    private string $baseUrl; 
+
+    public function __construct() {
+        $this->baseUrl = $_ENV['LXD_API_URL'] ?? 'https://localhost:8443';
+    }
+
+
+    
+    /**
+     * Sends an HTTP request to the LXD API.
+     *
+     * @param string $method HTTP method (GET, POST, PUT, etc.)
+     * @param string $endpoint API endpoint
+     * @param array $body Request body (optional)
+     * @return array Response from the API
+     * @throws Exception
+     */
+    private function request(string $method, string $endpoint, array $body = []): array {
+        // if (!isset($_ENV['LXD_CLIENT_CERT'], $_ENV['LXD_CLIENT_KEY'])) {
+        //     throw new \Exception("LXD_CLIENT_CERT and LXD_CLIENT_KEY must be set in .env");
+        // }
+
+        $ch = curl_init("{$this->baseUrl}{$endpoint}");
+        
+        // Paths to client certificate and key for TLS authentication
+        $clientCert = $_ENV['LXD_CLIENT_CERT'] ?? '/etc/ssl/lxdapp/client.crt';
+        $clientKey  = $_ENV['LXD_CLIENT_KEY']  ?? '/etc/ssl/lxdapp/client.key';
+
+
+        curl_setopt($ch, CURLOPT_SSLCERT, $clientCert);
+        curl_setopt($ch, CURLOPT_SSLKEY, $clientKey);
+        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
+
+        if (!empty($body)) {
+            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($body));
+            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
+        }
+
+        $response = curl_exec($ch);
+        $httpCode = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
+
+        // Check if curl_exec failed
+        if (curl_errno($ch)) {
+            throw new Exception("Curl error: " . curl_error($ch));
+        }
+
+        curl_close($ch);
+
+        if (!$response) {
+            throw new Exception("LXD API error or not reachable.");
+        }
+
+        $json = json_decode($response, true);
+        if ($httpCode >= 400) {
+            throw new Exception("LXD API Error: " . ($json['error'] ?? 'Unknown'));
+        }
+
+        return $json;
+    }
+
+    /**
+     * Retrieves the status of a container.
+     *
+     * @param string $name Container name
+     * @return array|null Container status or null if an error occurs
+     */
+    public function getContainerState(string $name) {
+        try {
+            return $this->request('GET', "/1.0/instances/$name/state");
+        } catch (\Throwable $e) {
+            return null;
+            // echo 'Error: ' . $e->getMessage();
+        }
+    }
+
+    /**
+     * Checks if a container exists.
+     *
+     * @param string $name Container name
+     * @return bool True if the container exists, false otherwise
+     */
+    public function containerExists(string $name): bool {
+        return $this->getContainerState($name) !== null;
+    }
+ 
+    /**
+     * Starts a container.
+     *
+     * @param string $name Container name
+     * @return array Response from the API
+     * @throws Exception
+     */
+    public function startContainer(string $name): array {
+        $startResponse = $this->request('PUT', "/1.0/instances/$name/state", [
+            "action" => "start",
+            "timeout" => 30,
+            "force" => true
+        ]);
+        
+        if (!isset($startResponse['operation'])) {
+            throw new \Exception("Failed to start container, please try again.");
+        }
+
+        return $startResponse;        
+    }
+ 
+    /**
+     * Stops a container.
+     *
+     * @param string $name Container name
+     * @return array Response from the API
+     */
+    public function stopContainer(string $name): array {
+        $response = $this->request('PUT', "/1.0/instances/$name/state", [
+            "action" => "stop",
+            "timeout" => 30,
+            "force" => true
+        ]);
+
+        return $response;
+    }
+
+
+    /**
+     * Retrieves the IPv4 address of a container.
+     *
+     * @param string $name Container name
+     * @return string|null IPv4 address or null if not found
+     */
+    public function getContainerIP($name)
+    {
+        $container = $this->getContainerState($name);
+        return $this->getIPv4FromMetadata($container['metadata']);
+    }
+
+    /**
+     * Extracts the IPv4 address from container metadata.
+     *
+     * @param array $metadata Container metadata
+     * @return string|null IPv4 address or null if not found
+     */
+    public function getIPv4FromMetadata(array $metadata): ?string
+    {
+        if (
+            isset($metadata['network']['eth0']['addresses']) &&
+            is_array($metadata['network']['eth0']['addresses'])
+        ) {
+            foreach ($metadata['network']['eth0']['addresses'] as $addr) {
+                if (isset($addr['family']) && $addr['family'] === 'inet' && isset($addr['address'])) {
+                    return $addr['address'];
+                }
+            }
+        }
+        return null;
+    }
+
+    public function isServiceRunning(string $container, string $service): string
+    {
+        $lxcPath = $_ENV['LXC_PATH'] ?: 'lxc';
+        $cmd = "$lxcPath exec {$container} -- systemctl is-active {$service} 2>&1";
+        $output = shell_exec($cmd);
+        return trim($output);
+    }
+}

api/src/Settings/Settings.php

@@ -0,0 +1,11 @@
+<?php
+
+use DI\ContainerBuilder;
+
+return function (ContainerBuilder $containerBuilder) {
+    $containerBuilder->addDefinitions([
+        'settings' => [
+            'displayErrorDetails' => true, // turn off in production
+        ],
+    ]);
+};

api/src/Utils/LogWriterHelper.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Utils;
+
+class LogWriterHelper {
+    public static function write(string $name, string $uri): void {
+        // Dynamically resolve the log directory relative to the current file
+        $logDir = realpath(__DIR__ . '/../../public/last-access-logs');
+
+        // If the resolved path doesn't exist (e.g., public dir was missing), create it
+        if (!$logDir) {
+            $logDir = __DIR__ . '/../../public/last-access-logs';
+            if (!file_exists($logDir)) {
+                mkdir($logDir, 0777, true);
+            }
+        }
+
+        $logLine = date("Y-m-d H:i:s") . " : " . $uri . "\n";
+        file_put_contents($logDir . '/' . $name . '.txt', $logLine, FILE_APPEND);
+    }
+}