Live terminal

app/Actions/Console/GenerateTerminalToken.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Actions\Console;
+
+use App\Models\Server;
+use App\Models\User;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Str;
+
+class GenerateTerminalToken
+{
+    /**
+     * @return array{token: string}
+     */
+    public function generate(Server $server, User $user, string $sshUser): array
+    {
+        $token = Str::random(64);
+
+        Cache::put("terminal_token:{$token}", [
+            'server_id' => $server->id,
+            'user_id' => $user->id,
+            'ssh_user' => $sshUser,
+        ], 30);
+
+        return ['token' => $token];
+    }
+
+    /**
+     * @return array{server_id: int, user_id: int, ssh_user: string}|null
+     */
+    public function validate(string $token): ?array
+    {
+        return Cache::pull("terminal_token:{$token}");
+    }
+}

app/Console/Commands/WebSocketServeCommand.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\WebSocket\TerminalHandler;
+use App\WebSocket\WebSocketServer;
+use Illuminate\Console\Command;
+use React\EventLoop\Loop;
+use React\Socket\SocketServer;
+
+class WebSocketServeCommand extends Command
+{
+    protected $signature = 'ws:serve
+        {--host=127.0.0.1 : The host to listen on}
+        {--port=8085 : The port to listen on}
+        {--max-connections=50 : Maximum concurrent WebSocket connections}';
+
+    protected $description = 'Start the WebSocket server';
+
+    public function handle(): void
+    {
+        $host = $this->option('host') ?? config('core.ws_host', '127.0.0.1');
+        $port = $this->option('port') ?? config('core.ws_port', '8085');
+        $maxConnections = (int) $this->option('max-connections');
+
+        $loop = Loop::get();
+
+        $server = new WebSocketServer($loop, $maxConnections);
+
+        $server->route('/ws/terminal', new TerminalHandler($loop));
+
+        $socket = new SocketServer("{$host}:{$port}", [], $loop);
+
+        $socket->on('connection', [$server, 'handleConnection']);
+
+        $socket->on('error', function (\Throwable $e): void {
+            $this->error('Socket error: '.$e->getMessage());
+        });
+
+        $this->info("WebSocket server started on {$host}:{$port}");
+        $this->info("Max connections: {$maxConnections}");
+
+        $loop->run();
+    }
+}

app/Http/Controllers/ConsoleController.php

@@ -2,23 +2,35 @@
 
 namespace App\Http\Controllers;
 
+use App\Actions\Console\GenerateTerminalToken;
+use App\Http\Resources\ServerResource;
 use App\Models\Server;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
-use Illuminate\Support\Facades\Cache;
 use Illuminate\Validation\Rule;
+use Inertia\Inertia;
+use Inertia\Response;
 use Spatie\RouteAttributes\Attributes\Get;
 use Spatie\RouteAttributes\Attributes\Middleware;
 use Spatie\RouteAttributes\Attributes\Post;
 use Spatie\RouteAttributes\Attributes\Prefix;
-use Symfony\Component\HttpFoundation\StreamedResponse;
 
 #[Prefix('servers/{server}/console')]
 #[Middleware(['auth', 'has-project'])]
 class ConsoleController extends Controller
 {
-    #[Post('/run', name: 'console.run')]
-    public function run(Server $server, Request $request): StreamedResponse
+    #[Get('/', name: 'console')]
+    public function index(Server $server): Response
+    {
+        $this->authorize('update', $server);
+
+        return Inertia::render('servers/console', [
+            'server' => ServerResource::make($server),
+        ]);
+    }
+
+    #[Post('/token', name: 'console.token')]
+    public function token(Server $server, Request $request): JsonResponse
     {
         $this->authorize('update', $server);
 
@@ -27,57 +39,28 @@ public function run(Server $server, Request $request): StreamedResponse
                 'required',
                 Rule::in($server->getSshUsers()),
             ],
-            'command' => 'required|string',
         ]);
 
-        $ssh = $server->ssh($request->user);
-        $log = 'console-'.time();
-
-        $user = $request->input('user');
-        $currentDir = $user == 'root' ? '/root' : '/home/'.$user;
-        if (Cache::has('console.'.$server->id.'.dir')) {
-            $currentDir = Cache::get('console.'.$server->id.'.dir');
-        }
-
-        return response()->stream(
-            function () use ($server, $request, $ssh, $log, $currentDir): void {
-                $command = 'cd '.$currentDir.' && '.$request->command.' && echo -n "VITO_WORKING_DIR: " && pwd';
-                $output = '';
-                $ssh->exec(command: $command, log: $log, stream: true, streamCallback: function (string $out) use (&$output): void {
-                    echo preg_replace('/^VITO_WORKING_DIR:.*(\r?\n)?/m', '', $out);
-                    $output .= $out;
-                    ob_flush();
-                    flush();
-                });
-                // extract the working dir and put it in the session
-                if (preg_match('/VITO_WORKING_DIR: (.*)/', $output, $matches)) {
-                    Cache::put('console.'.$server->id.'.dir', $matches[1]);
-                }
-            },
-            200,
-            [
-                'Cache-Control' => 'no-cache',
-                'X-Accel-Buffering' => 'no',
-                'Content-Type' => 'text/event-stream',
-            ]
+        $result = app(GenerateTerminalToken::class)->generate(
+            $server,
+            $request->user(),
+            $request->input('user'),
         );
-    }
-
-    #[Get('/working-dir', name: 'console.working-dir')]
-    public function workingDir(Server $server): JsonResponse
-    {
-        return response()->json([
-            'dir' => Cache::get('console.'.$server->id.'.dir', '~'),
-        ]);
-    }
 
-    #[Get('/new-session', name: 'console.new-session')]
-    public function newSession(Server $server): JsonResponse
-    {
-        $this->authorize('update', $server);
+        $appUrl = parse_url(config('app.url'));
+        $isSecure = ($appUrl['scheme'] ?? 'http') === 'https';
+        $wsProtocol = $isSecure ? 'wss' : 'ws';
+        $host = $appUrl['host'] ?? 'localhost';
+        $port = $appUrl['port'] ?? ($isSecure ? 443 : 80);
 
-        Cache::forget('console.'.$server->id.'.dir');
+        if (app()->environment('local')) {
+            $wsPort = config('core.ws_port', 8085);
+            $result['url'] = "{$wsProtocol}://{$host}:{$wsPort}/ws/terminal";
+        } else {
+            $portSuffix = (($isSecure && $port == 443) || (! $isSecure && $port == 80)) ? '' : ":{$port}";
+            $result['url'] = "{$wsProtocol}://{$host}{$portSuffix}/ws/terminal";
+        }
 
-        return response()->json(['status' => 'ok']);
+        return response()->json($result);
     }
 }