@fleetbase/fleetops-engine 0.6.57 → 0.6.59

package/scripts/coverage-summary.php

@@ -0,0 +1,149 @@
+<?php
+
+declare(strict_types=1);
+
+$cloverPath = 'coverage/clover.xml';
+$failUnder  = null;
+
+foreach (array_slice($argv, 1) as $arg) {
+    if (str_starts_with($arg, '--fail-under=')) {
+        $failUnder = (float) substr($arg, strlen('--fail-under='));
+
+        continue;
+    }
+
+    if ($arg !== '') {
+        $cloverPath = $arg;
+    }
+}
+
+if (!is_file($cloverPath)) {
+    fwrite(STDERR, "Coverage file not found: {$cloverPath}\n");
+    fwrite(STDERR, "Run `composer test:coverage:clover` first.\n");
+    exit(1);
+}
+
+$xml = simplexml_load_file($cloverPath);
+if (!$xml) {
+    fwrite(STDERR, "Unable to parse Clover coverage file: {$cloverPath}\n");
+    exit(1);
+}
+
+function coveragePercent(int $covered, int $total): float
+{
+    return $total === 0 ? 0.0 : round(($covered / $total) * 100, 2);
+}
+
+function intMetric(SimpleXMLElement $node, string $name): int
+{
+    return (int) ($node->metrics[$name] ?? 0);
+}
+
+function hasMetric(SimpleXMLElement $node, string $name): bool
+{
+    return isset($node->metrics[$name]);
+}
+
+function deriveCoveredClasses(SimpleXMLElement $project): int
+{
+    $coveredClasses = 0;
+
+    foreach ($project->xpath('.//class') ?: [] as $class) {
+        $methods        = intMetric($class, 'methods');
+        $coveredMethods = intMetric($class, 'coveredmethods');
+
+        if ($methods > 0 && $coveredMethods >= $methods) {
+            $coveredClasses++;
+        }
+    }
+
+    return $coveredClasses;
+}
+
+$project = $xml->project;
+$metrics = $project->metrics;
+
+$statements        = (int) ($metrics['statements'] ?? 0);
+$coveredStatements = (int) ($metrics['coveredstatements'] ?? 0);
+$methods           = (int) ($metrics['methods'] ?? 0);
+$coveredMethods    = (int) ($metrics['coveredmethods'] ?? 0);
+$classes           = (int) ($metrics['classes'] ?? 0);
+$coveredClasses    = hasMetric($project, 'coveredclasses') ? (int) $metrics['coveredclasses'] : deriveCoveredClasses($project);
+
+$files       = [];
+$directories = [];
+
+foreach ($project->xpath('.//file') ?: [] as $file) {
+    $path              = (string) $file['name'];
+    $fileStatements    = intMetric($file, 'statements');
+    $coveredFileLines  = intMetric($file, 'coveredstatements');
+    $fileMethods       = intMetric($file, 'methods');
+    $coveredFileMethod = intMetric($file, 'coveredmethods');
+
+    if ($fileStatements === 0) {
+        continue;
+    }
+
+    $files[] = [
+        'path'            => $path,
+        'covered'         => $coveredFileLines,
+        'statements'      => $fileStatements,
+        'methods'         => $fileMethods,
+        'covered_methods' => $coveredFileMethod,
+        'percent'         => coveragePercent($coveredFileLines, $fileStatements),
+    ];
+
+    $relativePath = preg_replace('#^' . preg_quote(getcwd(), '#') . '/?#', '', $path);
+    $parts        = explode('/', $relativePath ?: $path);
+    $directory    = count($parts) > 2 ? $parts[0] . '/' . $parts[1] : dirname($relativePath ?: $path);
+
+    if (!isset($directories[$directory])) {
+        $directories[$directory] = [
+            'covered'    => 0,
+            'statements' => 0,
+        ];
+    }
+
+    $directories[$directory]['covered'] += $coveredFileLines;
+    $directories[$directory]['statements'] += $fileStatements;
+}
+
+usort($files, function (array $a, array $b): int {
+    return $a['percent'] <=> $b['percent']
+        ?: $b['statements'] <=> $a['statements'];
+});
+
+$directoryRows = [];
+foreach ($directories as $directory => $directoryMetrics) {
+    $directoryRows[] = [
+        'directory'  => $directory,
+        'covered'    => $directoryMetrics['covered'],
+        'statements' => $directoryMetrics['statements'],
+        'percent'    => coveragePercent($directoryMetrics['covered'], $directoryMetrics['statements']),
+    ];
+}
+
+usort($directoryRows, function (array $a, array $b): int {
+    return $a['percent'] <=> $b['percent']
+        ?: $b['statements'] <=> $a['statements'];
+});
+
+printf("Line coverage: %.2f%% (%d/%d statements)\n", coveragePercent($coveredStatements, $statements), $coveredStatements, $statements);
+printf("Method coverage: %.2f%% (%d/%d methods)\n", coveragePercent($coveredMethods, $methods), $coveredMethods, $methods);
+printf("Class coverage: %.2f%% (%d/%d classes)\n", coveragePercent($coveredClasses, $classes), $coveredClasses, $classes);
+
+echo "\nLowest covered directories:\n";
+foreach (array_slice($directoryRows, 0, 10) as $row) {
+    printf("  %6.2f%%  %5d/%-5d  %s\n", $row['percent'], $row['covered'], $row['statements'], $row['directory']);
+}
+
+echo "\nLowest covered files:\n";
+foreach (array_slice($files, 0, 20) as $file) {
+    $relativePath = preg_replace('#^' . preg_quote(getcwd(), '#') . '/?#', '', $file['path']);
+    printf("  %6.2f%%  %5d/%-5d  %s\n", $file['percent'], $file['covered'], $file['statements'], $relativePath ?: $file['path']);
+}
+
+if ($failUnder !== null && coveragePercent($coveredStatements, $statements) < $failUnder) {
+    fwrite(STDERR, sprintf("\nCoverage %.2f%% is below the required %.2f%% line threshold.\n", coveragePercent($coveredStatements, $statements), $failUnder));
+    exit(1);
+}

package/scripts/pest-bootstrap.php

@@ -0,0 +1,411 @@
+<?php
+
+declare(strict_types=1);
+
+$autoloadCandidates = [
+    getcwd() . '/server_vendor/autoload.php',
+    getcwd() . '/vendor/autoload.php',
+];
+
+foreach ($autoloadCandidates as $candidate) {
+    if (is_file($candidate)) {
+        require_once $candidate;
+        break;
+    }
+}
+
+if (!function_exists('config')) {
+    function config(string|array|null $key = null, mixed $default = null): mixed
+    {
+        if (class_exists('Illuminate\Container\Container')) {
+            $app = Illuminate\Container\Container::getInstance();
+
+            if ($app->bound('config')) {
+                $config = $app->make('config');
+
+                if ($key === null) {
+                    return $config;
+                }
+
+                // Laravel's helper doubles as a setter when handed an array
+                if (is_array($key)) {
+                    foreach ($key as $configKey => $configValue) {
+                        $config->set($configKey, $configValue);
+                    }
+
+                    return null;
+                }
+
+                return $config->get($key, $default);
+            }
+        }
+
+        return $default;
+    }
+}
+
+if (class_exists('Illuminate\Container\Container') && class_exists('Illuminate\Support\Facades\Facade')) {
+    $app = Illuminate\Container\Container::getInstance();
+    Illuminate\Support\Facades\Facade::setFacadeApplication($app);
+
+    if (!$app->bound('config') && class_exists('Illuminate\Config\Repository')) {
+        $app->singleton('config', fn () => new Illuminate\Config\Repository([
+            'fleetops'   => [],
+            'services'   => [],
+            'telematics' => [],
+        ]));
+    }
+
+    if (!$app->bound(Illuminate\Contracts\Routing\ResponseFactory::class)) {
+        $responseFactory = new class {
+            public function json(mixed $data = [], int $status = 200): mixed
+            {
+                if (class_exists('Illuminate\Http\JsonResponse')) {
+                    return new Illuminate\Http\JsonResponse($data, $status);
+                }
+
+                return new class($data, $status) {
+                    public function __construct(public mixed $data, public int $status)
+                    {
+                    }
+
+                    public function getStatusCode(): int
+                    {
+                        return $this->status;
+                    }
+                };
+            }
+
+            public function make(mixed $content = '', int $status = 200, array $headers = []): mixed
+            {
+                if (class_exists('Illuminate\\Http\\Response')) {
+                    return new Illuminate\Http\Response($content, $status, $headers);
+                }
+
+                return new class($content, $status) {
+                    public function __construct(public mixed $content, public int $status)
+                    {
+                    }
+
+                    public function getContent(): mixed
+                    {
+                        return $this->content;
+                    }
+
+                    public function getStatusCode(): int
+                    {
+                        return $this->status;
+                    }
+                };
+            }
+
+            public function error(mixed $error = null, int $status = 500): mixed
+            {
+                return $this->json(['error' => $error], $status);
+            }
+
+            public function apiError(mixed $error = null, int $statusCode = 400, ?array $data = []): mixed
+            {
+                if ($error instanceof Illuminate\Support\MessageBag) {
+                    $error = $error->all();
+                }
+
+                return $this->json(['error' => $error] + ($data ?? []), $statusCode);
+            }
+        };
+
+        $app->instance(Illuminate\Contracts\Routing\ResponseFactory::class, $responseFactory);
+        $app->instance('Illuminate\Contracts\Routing\ResponseFactory', $responseFactory);
+        $app->instance('response', $responseFactory);
+    }
+
+    if (!$app->bound('db')) {
+        // Unbound 'db' resolutions recurse the container until memory is
+        // exhausted when model boot paths reach the DB facade — proxy to the
+        // Eloquent connection resolver instead. Fixture instance bindings
+        // override this fallback.
+        $app->singleton('db', function () {
+            return new class {
+                public function connection($name = null)
+                {
+                    return Illuminate\Database\Eloquent\Model::getConnectionResolver()
+                        ? Illuminate\Database\Eloquent\Model::resolveConnection($name)
+                        : null;
+                }
+
+                public function raw($value)
+                {
+                    return new Illuminate\Database\Query\Expression($value);
+                }
+
+                public function __call($method, $arguments)
+                {
+                    $connection = $this->connection();
+
+                    return $connection ? $connection->{$method}(...$arguments) : null;
+                }
+            };
+        });
+    }
+
+    if (!$app->bound('http') && class_exists('Illuminate\Http\Client\Factory')) {
+        $app->singleton('http', fn () => new Illuminate\Http\Client\Factory());
+    }
+
+    if (!$app->bound('cache') && class_exists('Illuminate\Cache\Repository') && class_exists('Illuminate\Cache\ArrayStore')) {
+        $app->singleton('cache.store', fn () => new Illuminate\Cache\Repository(new Illuminate\Cache\ArrayStore()));
+        $app->singleton('cache', fn ($app) => $app->make('cache.store'));
+    }
+
+    if (!$app->bound('session.store') && class_exists('Illuminate\Session\Store') && class_exists('Illuminate\Session\ArraySessionHandler')) {
+        $app->singleton('session.store', fn () => new Illuminate\Session\Store('pest', new Illuminate\Session\ArraySessionHandler(120)));
+        $app->singleton('session', fn ($app) => $app->make('session.store'));
+    }
+
+    if (!$app->bound('log') && class_exists('Psr\Log\NullLogger')) {
+        if (!class_exists('Fleetbase\TestSupport\LoggerManager')) {
+            eval('namespace Fleetbase\TestSupport; class LoggerManager extends \Psr\Log\NullLogger { public function channel(?string $name = null): self { return $this; } }');
+        }
+
+        $app->singleton('log', fn () => new Fleetbase\TestSupport\LoggerManager());
+    }
+}
+
+if (!function_exists('app')) {
+    function app(?string $abstract = null, array $parameters = []): mixed
+    {
+        if (class_exists('Illuminate\Container\Container')) {
+            $container = Illuminate\Container\Container::getInstance();
+
+            return $abstract === null ? $container : $container->make($abstract, $parameters);
+        }
+
+        return $abstract === null ? null : new $abstract(...array_values($parameters));
+    }
+}
+
+if (!function_exists('request')) {
+    function request(?string $key = null, mixed $default = null): mixed
+    {
+        if (class_exists('Illuminate\Container\Container')) {
+            $container = Illuminate\Container\Container::getInstance();
+
+            if ($container->bound('request')) {
+                $request = $container->make('request');
+
+                return $key === null ? $request : $request->input($key, $default);
+            }
+        }
+
+        $request = class_exists('Illuminate\Http\Request') ? Illuminate\Http\Request::create('/') : new stdClass();
+
+        return $key === null ? $request : $default;
+    }
+}
+
+if (!function_exists('response')) {
+    function response(): object
+    {
+        return new class {
+            public function json(mixed $data = [], int $status = 200): mixed
+            {
+                if (class_exists('Illuminate\Http\JsonResponse')) {
+                    return new Illuminate\Http\JsonResponse($data, $status);
+                }
+
+                return new class($data, $status) {
+                    public function __construct(public mixed $data, public int $status)
+                    {
+                    }
+
+                    public function getStatusCode(): int
+                    {
+                        return $this->status;
+                    }
+                };
+            }
+
+            public function make(mixed $content = '', int $status = 200, array $headers = []): mixed
+            {
+                if (class_exists('Illuminate\\Http\\Response')) {
+                    return new Illuminate\Http\Response($content, $status, $headers);
+                }
+
+                return new class($content, $status) {
+                    public function __construct(public mixed $content, public int $status)
+                    {
+                    }
+
+                    public function getContent(): mixed
+                    {
+                        return $this->content;
+                    }
+
+                    public function getStatusCode(): int
+                    {
+                        return $this->status;
+                    }
+                };
+            }
+
+            public function error(mixed $error = null, int $status = 500): mixed
+            {
+                return $this->json(['error' => $error], $status);
+            }
+
+            public function apiError(mixed $error = null, int $statusCode = 400, ?array $data = []): mixed
+            {
+                if ($error instanceof Illuminate\Support\MessageBag) {
+                    $error = $error->all();
+                }
+
+                return $this->json(['error' => $error] + ($data ?? []), $statusCode);
+            }
+        };
+    }
+}
+
+if (!function_exists('session')) {
+    function session(array|string|null $key = null, mixed $default = null): mixed
+    {
+        static $values = [];
+
+        if (is_array($key)) {
+            $values = array_merge($values, $key);
+
+            return null;
+        }
+
+        return $key === null ? $values : ($values[$key] ?? $default);
+    }
+}
+
+if (!function_exists('now') && class_exists('Illuminate\Support\Carbon')) {
+    function now($tz = null): Illuminate\Support\Carbon
+    {
+        return Illuminate\Support\Carbon::now($tz);
+    }
+}
+
+if (!class_exists('Illuminate\Validation\ValidationException')) {
+    // Laravel's real constructor takes the failing validator and an optional
+    // response, not a message. Both shapes are accepted so
+    // `new ValidationException($validator, $response)` works alongside the
+    // `withMessages()` string form.
+    eval('namespace Illuminate\Validation; class ValidationException extends \Exception { public array $messages = []; public $validator; public $response; public function __construct($validator = null, $response = null) { parent::__construct(is_string($validator) ? $validator : "The given data was invalid."); $this->response = $response; if (!is_string($validator) && is_object($validator)) { $this->validator = $validator; if (method_exists($validator, "errors")) { $errors = $validator->errors(); $this->messages = is_object($errors) && method_exists($errors, "messages") ? $errors->messages() : (array) $errors; } } } public static function withMessages(array $messages): self { $exception = new self("The given data was invalid."); $exception->messages = $messages; return $exception; } public function errors(): array { return $this->messages; } public function getResponse() { return $this->response; } }');
+}
+
+if (class_exists('Illuminate\Http\Request') && method_exists('Illuminate\Http\Request', 'macro')) {
+    if (!method_exists('Illuminate\Http\Request', 'array')) {
+        Illuminate\Http\Request::macro('array', function (string $key, array $default = []): array {
+            $value = $this->input($key, $default);
+
+            return is_array($value) ? $value : $default;
+        });
+    }
+
+    if (!method_exists('Illuminate\Http\Request', 'validate')) {
+        Illuminate\Http\Request::macro('validate', function (array $rules, ...$parameters): array {
+            if (app()->bound('validator')) {
+                $validator = app('validator')->make($this->all(), $rules);
+                if (is_object($validator) && method_exists($validator, 'fails') && $validator->fails()) {
+                    $messages = method_exists($validator, 'errors') ? $validator->errors()->toArray() : ['error' => ['Validation failed.']];
+                    throw Illuminate\Validation\ValidationException::withMessages($messages);
+                }
+            }
+
+            return $this->all();
+        });
+    }
+}
+
+if (!trait_exists('Illuminate\Foundation\Auth\Access\AuthorizesRequests')) {
+    eval('namespace Illuminate\Foundation\Auth\Access; trait AuthorizesRequests {}');
+}
+
+if (!class_exists('Fleetbase\TestSupport\PendingDispatch')) {
+    eval('namespace Fleetbase\TestSupport; class PendingDispatch { public function __call($name, $arguments) { return $this; } public function __toString(): string { return \'\'; } }');
+}
+
+if (!class_exists('Fleetbase\TestSupport\DispatchRecorder')) {
+    eval('namespace Fleetbase\TestSupport; class DispatchRecorder { public static array $dispatched = []; public static function record(string $job, array $arguments): void { self::$dispatched[] = [\'job\' => $job, \'arguments\' => $arguments]; } }');
+}
+
+if (!trait_exists('Illuminate\Foundation\Bus\Dispatchable')) {
+    eval('namespace Illuminate\Foundation\Bus; trait Dispatchable {
+        public static function dispatch(...$arguments) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); return new \Fleetbase\TestSupport\PendingDispatch(); }
+        public static function dispatchIf($boolean, ...$arguments) { if ($boolean) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); } return new \Fleetbase\TestSupport\PendingDispatch(); }
+        public static function dispatchUnless($boolean, ...$arguments) { if (!$boolean) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); } return new \Fleetbase\TestSupport\PendingDispatch(); }
+        public static function dispatchSync(...$arguments) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); return null; }
+        public static function dispatchAfterResponse(...$arguments) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); return null; }
+        public static function dispatchNow(...$arguments) { \Fleetbase\TestSupport\DispatchRecorder::record(static::class, $arguments); return null; }
+    }');
+}
+
+if (!trait_exists('Illuminate\Foundation\Events\Dispatchable')) {
+    eval('namespace Illuminate\Foundation\Events; trait Dispatchable {}');
+}
+
+if (!trait_exists('Illuminate\Foundation\Bus\DispatchesJobs')) {
+    eval('namespace Illuminate\Foundation\Bus; trait DispatchesJobs {}');
+}
+
+if (!trait_exists('Illuminate\Foundation\Validation\ValidatesRequests')) {
+    eval('namespace Illuminate\Foundation\Validation; trait ValidatesRequests {}');
+}
+
+if (!trait_exists('Fleetbase\Traits\HasApiModelCache')) {
+    eval('namespace Fleetbase\Traits; trait HasApiModelCache {}');
+}
+
+if (!trait_exists('Fleetbase\Traits\HasCustomFields')) {
+    eval('namespace Fleetbase\Traits; trait HasCustomFields {}');
+}
+
+if (!class_exists('Illuminate\Foundation\Http\FormRequest') && class_exists('Illuminate\Http\Request')) {
+    eval('namespace Illuminate\Foundation\Http; class FormRequest extends \Illuminate\Http\Request { public function authorize(): bool { return true; } public function rules(): array { return []; } public function responseWithErrors(\Illuminate\Contracts\Validation\Validator $validator) { return $validator; } }');
+}
+
+if (!class_exists('Illuminate\Foundation\Auth\User') && class_exists('Illuminate\Database\Eloquent\Model')) {
+    eval('namespace Illuminate\Foundation\Auth; class User extends \Illuminate\Database\Eloquent\Model {}');
+}
+
+if (!class_exists('Fleetbase\Models\ScheduleItem') && class_exists('Fleetbase\Models\Model')) {
+    eval('namespace Fleetbase\Models; class ScheduleItem extends Model {}');
+}
+
+if (!interface_exists('Fleetbase\Ai\Contracts\AIContextCapabilityInterface')) {
+    eval('namespace Fleetbase\Ai\Contracts; interface AIContextCapabilityInterface {}');
+}
+
+if (!interface_exists('Fleetbase\Ai\Contracts\AIActionCapabilityInterface')) {
+    eval('namespace Fleetbase\Ai\Contracts; interface AIActionCapabilityInterface {}');
+}
+
+if (!class_exists('Fleetbase\Ai\Models\AiTask')) {
+    eval('namespace Fleetbase\Ai\Models; class AiTask { public function __construct(array $attributes = []) { foreach ($attributes as $key => $value) { $this->{$key} = $value; } } }');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\Capabilities\AbstractAICapability')) {
+    eval('namespace Fleetbase\Ai\Support\Capabilities; abstract class AbstractAICapability {}');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\AiQueryableResource')) {
+    eval('namespace Fleetbase\Ai\Support; class AiQueryableResource { public string $key; public array $fields; public array $aliases; public function __construct(string $key, string $label = "", string $module = "", string $modelClass = "", string $permission = "", array $aliases = [], array $fields = [], array $sampleFields = [], ?string $locationField = null, ?string $directivePermission = null, int $maxLimit = 100) { $this->key = $key; $this->fields = $fields; $this->aliases = $aliases; } public function hasField(string $field): bool { return array_key_exists($field, $this->fields); } }');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\AiQueryRegistry')) {
+    eval('namespace Fleetbase\Ai\Support; class AiQueryRegistry { private array $resources = []; public function register(AiQueryableResource $resource): void { $this->resources[$resource->key] = $resource; foreach ($resource->aliases as $alias) { $this->resources[$alias] = $resource; } } public function find(string $key): ?AiQueryableResource { return $this->resources[$key] ?? null; } }');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\AiRelativeDateResolver') && class_exists('Illuminate\Support\Carbon')) {
+    eval('namespace Fleetbase\Ai\Support; class AiRelativeDateResolver { public function __construct($parser = null) {} public function resolveDateTime(string $prompt, ?string $timezone = null): ?\Illuminate\Support\Carbon { if (preg_match("/(\d+)\s+days?\s+from\s+now/i", $prompt, $matches)) { return \Illuminate\Support\Carbon::now($timezone)->addDays((int) $matches[1]); } return null; } public function resolveWindow(string $prompt, ?string $timezone = null): ?array { $timezone = $timezone ?: date_default_timezone_get(); $now = \Illuminate\Support\Carbon::now($timezone); if (str_contains(strtolower($prompt), "last week")) { $start = $now->copy()->subWeek()->startOfWeek(); $end = $now->copy()->subWeek()->endOfWeek(); return ["label" => "last week", "timezone" => $timezone, "start" => $start, "end" => $end]; } if (str_contains(strtolower($prompt), "yesterday")) { $start = $now->copy()->subDay()->startOfDay(); $end = $now->copy()->subDay()->endOfDay(); return ["label" => "yesterday", "timezone" => $timezone, "start" => $start, "end" => $end]; } return null; } }');
+}
+
+set_error_handler(function (int $severity, string $message): bool {
+    if (str_contains($message, '/pestphp/pest/vendor/autoload.php')) {
+        return true;
+    }
+
+    return false;
+}, E_WARNING);

package/scripts/pest-file-runner.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+$autoloadCandidates = [
+    getcwd() . '/server_vendor/autoload.php',
+    getcwd() . '/vendor/autoload.php',
+];
+
+$autoload = null;
+foreach ($autoloadCandidates as $candidate) {
+    if (is_file($candidate)) {
+        $autoload = $candidate;
+        break;
+    }
+}
+
+if ($autoload === null) {
+    fwrite(STDERR, "Unable to find Composer autoload. Run composer install first.\n");
+    exit(1);
+}
+
+require_once $autoload;
+
+$runner = getcwd() . '/scripts/pest-runner.php';
+if (!is_file($runner)) {
+    fwrite(STDERR, "Unable to find Pest runner at scripts/pest-runner.php.\n");
+    exit(1);
+}
+
+$testsPath = getcwd() . '/server/tests';
+$files     = [];
+
+$iterator = new RecursiveIteratorIterator(
+    new RecursiveDirectoryIterator($testsPath, FilesystemIterator::SKIP_DOTS)
+);
+
+foreach ($iterator as $fileInfo) {
+    if ($fileInfo->isFile() && $fileInfo->getExtension() === 'php') {
+        $files[] = $fileInfo->getPathname();
+    }
+}
+
+$files = array_values(array_unique($files));
+sort($files);
+
+if ($files === []) {
+    fwrite(STDERR, "Unable to find Pest test files in server/tests.\n");
+    exit(1);
+}
+
+$args    = array_slice($argv, 1);
+$timeout = (float) (getenv('PEST_FILE_TIMEOUT') ?: 120);
+
+foreach ($files as $file) {
+    $relativeFile = str_replace(getcwd() . '/', '', $file);
+
+    fwrite(STDOUT, "::group::{$relativeFile}\n");
+
+    $command = array_merge([PHP_BINARY, $runner], $args, [$file]);
+    $timeoutBinary = trim((string) shell_exec('command -v timeout'));
+    if ($timeoutBinary !== '') {
+        $command = array_merge([$timeoutBinary, "{$timeout}s"], $command);
+    }
+
+    fwrite(STDOUT, '$ ' . implode(' ', array_map('escapeshellarg', $command)) . "\n");
+
+    passthru(implode(' ', array_map('escapeshellarg', $command)), $exitCode);
+
+    if ($exitCode === 124) {
+        fwrite(STDERR, "\nTimed out after {$timeout} seconds while running {$relativeFile}.\n");
+        fwrite(STDOUT, "::endgroup::\n");
+        exit(1);
+    }
+
+    fwrite(STDOUT, "::endgroup::\n");
+
+    if ($exitCode !== 0) {
+        if (!in_array('--debug', $args, true)) {
+            fwrite(STDOUT, "::group::{$relativeFile} debug\n");
+            $debugCommand = array_merge([PHP_BINARY, $runner], $args, ['--debug', $file]);
+            if ($timeoutBinary !== '') {
+                $debugCommand = array_merge([$timeoutBinary, "{$timeout}s"], $debugCommand);
+            }
+
+            fwrite(STDOUT, '$ ' . implode(' ', array_map('escapeshellarg', $debugCommand)) . "\n");
+            passthru(implode(' ', array_map('escapeshellarg', $debugCommand)));
+            fwrite(STDOUT, "::endgroup::\n");
+        }
+
+        fwrite(STDERR, "\nPest failed for {$relativeFile} with exit code {$exitCode}.\n");
+        exit($exitCode);
+    }
+}