@fleetbase/registry-bridge-engine 0.0.1

package/server/src/Console/Commands/Initialize.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Console\Commands;
+
+use Fleetbase\RegistryBridge\Providers\RegistryBridgeServiceProvider;
+use Illuminate\Console\Command;
+
+class Initialize extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'registry:init';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Runs initialization for registry bridge.';
+
+    /**
+     * Execute the console command.
+     *
+     * @return int
+     */
+    public function handle()
+    {
+        RegistryBridgeServiceProvider::bootRegistryAuth(true);
+
+        return 0;
+    }
+}

package/server/src/Console/Commands/PostInstallExtension.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Console\Commands;
+
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+use Illuminate\Console\Command;
+use Symfony\Component\Process\Exception\ProcessFailedException;
+use Symfony\Component\Process\Process;
+
+class PostInstallExtension extends Command
+{
+    /**
+     * The name and signature of the console command.
+     *
+     * @var string
+     */
+    protected $signature = 'registry:post-install {extensionId}';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Post install an extension by running necessary commands';
+
+    /**
+     * Execute the console command.
+     *
+     * @return int
+     */
+    public function handle()
+    {
+        $extensionId = $this->argument('extensionId');
+        $extension   = RegistryExtension::disableCache()->where('public_id', $extensionId)->first();
+
+        if ($extension) {
+            $this->postInstallExtension($extension);
+            $this->info('Post install commands executed successfully.');
+        } else {
+            $this->error('Extension not found.');
+        }
+
+        return 0;
+    }
+
+    /**
+     * Post install extension commands.
+     */
+    public function postInstallExtension(RegistryExtension $extension): void
+    {
+        if (isset($extension->currentBundle)) {
+            $composerJson = $extension->currentBundle->meta['composer.json'];
+            if ($composerJson) {
+                $extensionPath = base_path('vendor/' . $composerJson['name']);
+
+                $commands = [
+                    'rm -rf /fleetbase/.pnpm-store',
+                    'rm -rf node_modules',
+                    'pnpm install',
+                    'pnpm build',
+                ];
+
+                $this->info('Running post install for: ' . $extension->name);
+                $this->info('Extension install path: ' . $extensionPath);
+                foreach ($commands as $command) {
+                    $this->info('Running extension post install command: `' . $command . '`');
+                    $process = Process::fromShellCommandline($command, $extensionPath);
+                    $process->run(function ($type, $buffer) {
+                        if (Process::ERR === $type) {
+                            $this->error($buffer);
+                        } else {
+                            $this->info($buffer);
+                        }
+                    });
+
+                    // Check if the process was successful
+                    if (!$process->isSuccessful()) {
+                        throw new ProcessFailedException($process);
+                    }
+                }
+            }
+        }
+    }
+}

package/server/src/Exceptions/InstallFailedException.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Exceptions;
+
+/**
+ * Represents an exception thrown when a package installation fails.
+ */
+class InstallFailedException extends \Exception
+{
+    /**
+     * Constructs the InstallFailedException.
+     *
+     * @param string          $message  the Exception message to throw
+     * @param int             $code     the Exception code
+     * @param \Throwable|null $previous the previous throwable used for the exception chaining
+     */
+    public function __construct($message = '', $code = 0, ?\Throwable $previous = null)
+    {
+        parent::__construct($message, $code, $previous);
+    }
+}

package/server/src/Expansions/CategoryExpansion.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Expansions;
+
+use Fleetbase\Build\Expansion;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+
+class CategoryExpansion implements Expansion
+{
+    /**
+     * Get the target class to expand.
+     *
+     * @return string|Class
+     */
+    public static function target()
+    {
+        return \Fleetbase\Models\Category::class;
+    }
+
+    /**
+     * @return \Illuminate\Database\Eloquent\Relations\HasMany
+     */
+    public static function registryExtensions()
+    {
+        return function () {
+            /* @var \Illuminate\Database\Eloquent\Model $this */
+            return $this->hasMany(RegistryExtension::class, 'category_uuid', 'uuid')->where('status', 'published');
+        };
+    }
+}

package/server/src/Http/Controllers/Internal/v1/ExtensionInstallerController.php

@@ -0,0 +1,153 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\RegistryBridge\Http\Requests\InstallExtensionRequest;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+use Fleetbase\RegistryBridge\Models\RegistryExtensionInstall;
+
+class ExtensionInstallerController extends Controller
+{
+    /**
+     * Installs a specified extension for a company.
+     *
+     * This method handles the installation process of an extension. It first looks up
+     * the extension in the `RegistryExtension` model using its public identifier provided
+     * in the request. Then, it ensures that the installation is recorded in the
+     * `RegistryExtensionInstall` model, linking the extension to the current company.
+     * If the installation record already exists, it does not create a duplicate.
+     *
+     * @param InstallExtensionRequest $request The request object containing the extension
+     *                                         identifier. Expected to have an 'extension'
+     *                                         field with the public ID of the extension.
+     *
+     * @return \Illuminate\Http\JsonResponse Returns a JSON response indicating the status.
+     *                                       The response contains a 'status' key with the
+     *                                       value 'ok' if the process is successful.
+     *
+     * @throws \Exception throws an exception if the specified extension is not found in the
+     *                    `RegistryExtension` model, leading to a potential error when
+     *                    trying to access properties of a non-object (`$extension->uuid`)
+     */
+    public function install(InstallExtensionRequest $request)
+    {
+        set_time_limit(120 * 6);
+        $extension = RegistryExtension::where('public_id', $request->input('extension'))->first();
+
+        // Check if already installed
+        $installed = RegistryExtensionInstall::disableCache()->where(['company_uuid' => session('company'), 'extension_uuid' => $extension->uuid])->exists();
+        if ($installed) {
+            return response()->error('This extension is already installed.');
+        }
+
+        // Check if extensions are pre-installed to system
+        $PREINSTALLED_EXTENSIONS = config('registry-bridge.extensions.preinstalled') === true;
+
+        // Run installers if extension needs to be installed
+        if ($PREINSTALLED_EXTENSIONS === false) {
+            // Install for Composer
+            try {
+                $extension->currentBundle->installComposerPackage();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+
+            // Install for Console
+            try {
+                $extension->currentBundle->installEnginePackage();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+
+            // Rebuild Console
+            try {
+                $extension->currentBundle->buildConsole();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+        }
+
+        // Run installer progress if preinstalled
+        if ($PREINSTALLED_EXTENSIONS === true) {
+            $extension->currentBundle->runInstallerProgress();
+        }
+
+        // Create install record
+        $install = RegistryExtensionInstall::create([
+            'company_uuid'   => session('company'),
+            'extension_uuid' => $extension->uuid,
+        ]);
+
+        return response()->json(['status' => 'ok', 'install' => $install]);
+    }
+
+    /**
+     * Uninstall a specific extension for the current company.
+     *
+     * This function handles the uninstallation of an extension specified by the public ID
+     * provided in the request. It first checks if the extension is already uninstalled for
+     * the company identified by the `company_uuid` stored in the session. If the extension
+     * is not installed, an error response is returned.
+     *
+     * If the extension is installed, it proceeds to uninstall the extension using Composer
+     * and removes the corresponding installation records from the database. If any errors
+     * occur during the Composer uninstallation process, an error response is returned.
+     *
+     * @param InstallExtensionRequest $request the request containing the public ID of the extension to be uninstalled
+     *
+     * @return \Illuminate\Http\JsonResponse a JSON response indicating the status of the uninstallation process
+     */
+    public function uninstall(InstallExtensionRequest $request)
+    {
+        set_time_limit(120 * 6);
+        $extension   = RegistryExtension::where('public_id', $request->input('extension'))->first();
+        $uninstalled = false;
+
+        // Check if already uninstalled
+        $uninstalled = RegistryExtensionInstall::disableCache()->where(['company_uuid' => session('company'), 'extension_uuid' => $extension->uuid])->doesntExist();
+        if ($uninstalled) {
+            return response()->error('This extension is not installed.');
+        }
+
+        // Check if extensions are pre-installed to system
+        $PREINSTALLED_EXTENSIONS = config('registry-bridge.extensions.preinstalled') === true;
+
+        // Run installers if extension needs to be installed
+        if ($PREINSTALLED_EXTENSIONS === false) {
+            // Uninstall for Composer
+            try {
+                $extension->currentBundle->uninstallComposerPackage();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+
+            // Unnstall for Console
+            try {
+                $extension->currentBundle->uninstallEnginePackage();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+
+            // Rebuild Console
+            try {
+                $extension->currentBundle->buildConsole();
+            } catch (\Throwable $e) {
+                return response()->error($e->getMessage());
+            }
+        }
+
+        // Run installer progress if preinstalled
+        if ($PREINSTALLED_EXTENSIONS === true) {
+            $extension->currentBundle->runUninstallerProgress();
+        }
+
+        // Remove install records
+        $uninstalled = RegistryExtensionInstall::where([
+            'company_uuid'   => session('company'),
+            'extension_uuid' => $extension->uuid,
+        ])->delete();
+
+        return response()->json(['status' => 'ok', 'uninstalled' => $uninstalled]);
+    }
+}

package/server/src/Http/Controllers/Internal/v1/RegistryAuthController.php

@@ -0,0 +1,230 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Models\User;
+use Fleetbase\RegistryBridge\Http\Requests\AddRegistryUserRequest;
+use Fleetbase\RegistryBridge\Http\Requests\AuthenticateRegistryUserRequest;
+use Fleetbase\RegistryBridge\Http\Requests\RegistryAuthRequest;
+use Fleetbase\RegistryBridge\Http\Resources\RegistryUser as RegistryUserResource;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+use Fleetbase\RegistryBridge\Models\RegistryUser;
+use Fleetbase\RegistryBridge\Support\Bridge;
+use Fleetbase\Support\Auth;
+
+class RegistryAuthController extends Controller
+{
+    public function test()
+    {
+        dd(Bridge::get('~/flb/extensions'));
+    }
+
+    /**
+     * Authenticates a registry user based on provided credentials.
+     *
+     * This method attempts to authenticate a user using an identity (which can be either an email or username)
+     * and a password. Upon successful authentication, it either retrieves an existing token associated with
+     * the user or generates a new one. The method returns the token and user information in JSON format.
+     *
+     * If authentication fails or a token cannot be generated or retrieved, an error response is returned.
+     *
+     * @param AuthenticateRegistryUserRequest $request the request object containing identity and password
+     *
+     * @return RegistryUserResource Returns a JSON resource representing the registry user along with groups and containing the auth token and additional user data.
+     *                              Returns an error response if authentication fails or token generation is unsuccessful.
+     */
+    public function authenticate(AuthenticateRegistryUserRequest $request)
+    {
+        $identity = $request->input('identity');
+        $password = $request->input('password');
+
+        // Find user by email or username
+        $user = User::where(function ($query) use ($identity) {
+            $query->where('email', $identity)->orWhere('phone', $identity)->orWhere('username', $identity);
+        })->first();
+
+        // Authenticate user with password
+        if (Auth::isInvalidPassword($password, $user->password)) {
+            return response()->error('Invalid credentials.', 401);
+        }
+
+        // Get existing token for current user
+        $registryUser = RegistryUser::where(['company_uuid' => $user->company_uuid, 'user_uuid' => $user->uuid])->first();
+        if (!$registryUser) {
+            // Create registry user
+            $registryUser = RegistryUser::create([
+                'company_uuid' => $user->company_uuid,
+                'user_uuid'    => $user->uuid,
+                'scope'        => '*',
+                'expires_at'   => now()->addYear(),
+                'name'         => $user->public_id . ' developer token',
+            ]);
+        }
+
+        // If no token response with error
+        if (!$registryUser) {
+            return response()->error('Unable to authenticate.');
+        }
+
+        return new RegistryUserResource($registryUser);
+    }
+
+    /**
+     * Adds a new user to the registry with authentication credentials.
+     *
+     * This method creates a registry user linked to the currently active company
+     * of the user. It requires an identity (email or username) and password for
+     * authentication. After successful authentication, it generates a developer
+     * key for the user with a scope and expiration date.
+     *
+     * @param AddRegistryUserRequest $request the request object containing identity and password
+     *
+     * @return \Illuminate\Http\JsonResponse returns the newly created registry user data in JSON format
+     */
+    public function addUser(AddRegistryUserRequest $request)
+    {
+        $identity    = $request->input('identity');
+        $password    = $request->input('password');
+
+        // Find user by email or username
+        $user = User::where(function ($query) use ($identity) {
+            $query->where('email', $identity)->orWhere('phone', $identity)->orWhere('username', $identity);
+        })->first();
+
+        // Authenticate user with password
+        if (Auth::isInvalidPassword($password, $user->password)) {
+            return response()->error('Invalid credentials.', 401);
+        }
+
+        // Check if registry user already exists first
+        $registryUser = RegistryUser::where(['company_uuid' => $user->company_uuid, 'user_uuid' => $user->uuid])->first();
+        if (!$registryUser) {
+            // Create registry user
+            $registryUser = RegistryUser::create([
+                'company_uuid' => $user->company_uuid,
+                'user_uuid'    => $user->uuid,
+                'scope'        => '*',
+                'expires_at'   => now()->addYear(),
+                'name'         => $user->public_id . ' developer token',
+            ]);
+        }
+
+        return response()->json($registryUser);
+    }
+
+    /**
+     * Checks if a user has access to the registry based on their identity.
+     *
+     * This function receives a request containing an 'identity' (which could be an email or username) and
+     * attempts to find a corresponding user. If the user is found and they have admin privileges, it grants access
+     * to the registry by returning a JSON response indicating that access is allowed. If the user doesn't have
+     * admin privileges or the user can't be found based on the provided identity, it returns an error response.
+     *
+     * @param RegistryAuthRequest $request the request containing the user's identity information
+     *
+     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Response
+     *                                                                 Returns a JSON response indicating access is allowed if the user is an admin,
+     *                                                                 or an error response if the user is not an admin or can't be found
+     */
+    public function checkAccess(RegistryAuthRequest $request)
+    {
+        // Get identity
+        $identity    = $request->input('identity');
+
+        // Find user by email or username
+        $user = User::where('email', $identity)->orWhere('username', $identity)->first();
+
+        // If user is not admin respond with error
+        if (!$user->isAdmin()) {
+            return response()->error('User is not allowed access to the registry.', 401);
+        }
+
+        // For now only admin users can access registry
+        return response()->json(['allowed' => true]);
+    }
+
+    /**
+     * Validates whether a user is allowed to publish or unpublish a specified package in the registry.
+     *
+     * This function extracts the user's identity, the package name, and the desired action ('publish' or 'unpublish')
+     * from the request. It then performs several checks:
+     *   1. Verifies that the specified package (extension) exists in the registry.
+     *   2. Confirms the existence of the user associated with the provided identity.
+     *   3. Checks if the user has administrative privileges.
+     *   4. Ensures that the extension's status allows the desired action (either 'approved' or 'published' for publishing,
+     *      'published' for unpublishing).
+     * If these conditions are met, the function updates the extension's status based on the action and returns a
+     * JSON response indicating the action is allowed. If any of these checks fail, it returns an error response.
+     *
+     * @param RegistryAuthRequest $request the request containing the user's identity, package information, and action
+     *
+     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Response
+     *                                                                 Returns a JSON response indicating the action is allowed if all checks pass, or
+     *                                                                 an error response if any check fails
+     */
+    public function checkPublishAllowed(RegistryAuthRequest $request)
+    {
+        $identity    = $request->input('identity');
+        $package     = $request->input('package');
+        $action      = $request->input('action', 'publish');
+        $force       = $request->boolean('force');
+        $password    = $request->input('password');
+
+        // If force publish bypass checks, authenticate by user login
+        if ($force === true) {
+            // Find user by email or username
+            $user = User::where(function ($query) use ($identity) {
+                $query->where('email', $identity)->orWhere('phone', $identity)->orWhere('username', $identity);
+            })->first();
+
+            // Authenticate user with password
+            if (Auth::isInvalidPassword($password, $user->password)) {
+                return response()->error('Invalid credentials, unable to force publish.', 401);
+            }
+
+            return response()->json(['allowed' => true]);
+        }
+
+        // Make sure package is provided
+        if (!$package) {
+            return response()->error('No package specified for publish.', 401);
+        }
+
+        // Find package
+        $extension = RegistryExtension::findByPackageName($package);
+        if (!$extension) {
+            return response()->error('Attempting to publish extension which has no record.', 401);
+        }
+
+        // Find user by email or username
+        $user = User::where(function ($query) use ($identity) {
+            $query->where('email', $identity)->orWhere('phone', $identity)->orWhere('username', $identity);
+        })->first();
+        if (!$user) {
+            return response()->error('Attempting to publish extension with invalid user.', 401);
+        }
+
+        // If user is not admin respond with error
+        if (!$user->isAdmin()) {
+            return response()->error('User is not allowed publish to the registry.', 401);
+        }
+
+        // Extension should be approved
+        if (!in_array($extension->status, ['approved', 'published'])) {
+            return response()->error('Attempting to publish extension which is not approved.', 401);
+        }
+
+        // Change status to published
+        if ($action === 'publish') {
+            $extension->update(['status' => 'published']);
+            $extension->currentBundle()->update(['status' => 'published']);
+        } elseif ($action === 'unpublish') {
+            $extension->update(['status' => 'unpublished']);
+            $extension->currentBundle()->update(['status' => 'unpublished']);
+        }
+
+        // Passed all checks
+        return response()->json(['allowed' => true]);
+    }
+}

package/server/src/Http/Controllers/Internal/v1/RegistryController.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Fleetbase\RegistryBridge\Http\Controllers\Internal\v1;
+
+use Fleetbase\Http\Controllers\Controller;
+use Fleetbase\Http\Resources\Category as CategoryResource;
+use Fleetbase\Models\Category;
+use Fleetbase\RegistryBridge\Models\RegistryExtension;
+
+class RegistryController extends Controller
+{
+    /**
+     * Retrieve a collection of categories that have registry extensions.
+     *
+     * This method fetches categories that have associated registry extensions
+     * and meet the specified criteria (core_category equals 1 and 'for' equals
+     * 'extension_category'). The retrieved categories are then wrapped using
+     * the CategoryResource and returned as a collection of CategoryResource.
+     *
+     * @return \Illuminate\Http\Resources\Json\AnonymousResourceCollection
+     *                                                                     A collection of CategoryResource objects representing the categories
+     */
+    public function categories()
+    {
+        $categories = Category::whereHas('registryExtensions')->where(['core_category' => 1, 'for' => 'extension_category'])->get();
+
+        CategoryResource::wrap('categories');
+
+        return CategoryResource::collection($categories);
+    }
+
+    /**
+     * Retrieve a list of installed engines for the current company session.
+     *
+     * This method fetches registry extensions that have been installed by the
+     * company identified in the current session. It disables caching for the
+     * query, filters the results based on the company's UUID stored in the session,
+     * and maps the retrieved extensions to extract the 'package.json' metadata.
+     * The result is returned as a JSON response.
+     *
+     * @return \Illuminate\Http\JsonResponse
+     *                                       A JSON response containing a list of installed engines with their metadata
+     */
+    public function getInstalledEngines()
+    {
+        $installedExtensions = RegistryExtension::disableCache()->whereHas('installs', function ($query) {
+            $query->where('company_uuid', session('company'));
+        })->get()->map(function ($extension) {
+            return $extension->currentBundle->meta['package.json'] ?? [];
+        });
+
+        return response()->json($installedExtensions);
+    }
+}