Adds pull command

app/Commands/PullCommand.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace App\Commands;
+
+use App\Services\LocalRecipesService;
+use App\Services\MiseService;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Process;
+use LaravelZero\Framework\Commands\Command;
+
+use function Laravel\Prompts\confirm;
+use function Laravel\Prompts\error;
+use function Laravel\Prompts\info;
+use function Laravel\Prompts\multisearch;
+use function Laravel\Prompts\note;
+use function Laravel\Prompts\select;
+use function Laravel\Prompts\table;
+
+class PullCommand extends Command
+{
+    protected $signature =
+        'pull {recipe?*}' .
+        '{--no-process : prevent processes from executing}';
+
+    protected $description = 'Pull a recipe from mise.dev';
+
+    public function handle(): void
+    {
+        if ($this->option('no-process')) {
+            info('Dry run enabled');
+            Process::fake();
+        }
+
+        $remoteRecipes = $this->selectRemoteRecipes();
+
+        $recipeDiff = $this->diffRecipes($remoteRecipes);
+
+        $recipesToInstall = $this->handleConflicts($recipeDiff);
+
+        if (empty($recipesToInstall)) {
+            info('No recipes to install.');
+
+            return;
+        }
+
+        foreach ($recipesToInstall as $recipe) {
+            $this->install($recipe);
+        }
+
+        if (confirm(sprintf('Should I apply %s?', implode(', ', $recipesToInstall)))) {
+            $this->call('apply', [
+                'recipe' => $recipesToInstall,
+                '--no-process' => $this->option('no-process'),
+            ]);
+        }
+    }
+
+    private function selectRemoteRecipes(): array
+    {
+        $selectedRemoteRecipes = $this->argument('recipe');
+
+        if (empty($selectedRemoteRecipes)) {
+            $options = app(MiseService::class)->allForSelect();
+
+            return multisearch(
+                'Which recipe(s) should I pull?',
+                fn (string $value) => strlen($value) > 0
+                    ? $options->filter(fn ($option) => str_contains($option, $value))->all()
+                    : $options->all(),
+            );
+        }
+
+        if (count($missingRecipes = array_diff($selectedRemoteRecipes, app(MiseService::class)->keys()->toArray())) > 0) {
+            error('The following keys were not found and will be skipped');
+            note(collect($missingRecipes)->map(fn ($key) => "  {$key}")->implode("\n"));
+        }
+
+        return app(MiseService::class)->keys()->filter(
+            fn (string $key) => in_array($key, $selectedRemoteRecipes)
+        )->toArray();
+    }
+
+    private function diffRecipes(array $recipeKeys): Collection
+    {
+        $miseService = app(MiseService::class)->all();
+
+        return collect($recipeKeys)->map(function ($key) use ($miseService) {
+            $remoteRecipe = $miseService->first(fn ($recipe) => $recipe['key'] === $key);
+
+            $status = 'new';
+
+            if (app(LocalRecipesService::class)->exists($key)) {
+                $localRecipe = app(LocalRecipesService::class)->findByKey($key);
+
+                $status = $localRecipe['integrity'] === $remoteRecipe['integrity'] && $localRecipe['version'] === $remoteRecipe['version']
+                    ? 'unchanged'
+                    : 'updated';
+            }
+
+            return [
+                'key' => $key,
+                'status' => $status,
+            ];
+        });
+    }
+
+    private function handleConflicts(Collection $recipeAnalysis): array
+    {
+        $this->showConflictSummary($recipeAnalysis);
+
+        $existingRecipes = $recipeAnalysis->whereIn('status', ['unchanged', 'updated']);
+
+        if ($existingRecipes->isEmpty()) {
+            return $recipeAnalysis->pluck('key')->toArray();
+        }
+
+        return $this->resolveConflictsInteractively($recipeAnalysis);
+    }
+
+    private function showConflictSummary(Collection $recipeAnalysis): void
+    {
+        if ($recipeAnalysis->isEmpty()) {
+            return;
+        }
+
+        info('Checking for conflicts...');
+
+        $tableData = $recipeAnalysis->map(function ($recipe) {
+            $actionText = match ($recipe['status']) {
+                'new' => 'Will install',
+                'unchanged' => 'No changes',
+                'updated' => 'Updated available',
+            };
+
+            return [
+                $recipe['key'],
+                ucfirst($recipe['status']),
+                $actionText,
+            ];
+        })->toArray();
+
+        table(['Recipe', 'Status', 'Action'], $tableData);
+    }
+
+    private function resolveConflictsInteractively(Collection $recipeAnalysis): array
+    {
+        $choice = select(
+            label: 'How should I handle existing recipes?',
+            options: [
+                'skip-unchanged' => 'Skip unchanged recipes (recommended)',
+                'overwrite-all' => 'Overwrite all existing recipes',
+            ],
+            default: 'skip-unchanged'
+        );
+
+        return match ($choice) {
+            'skip-unchanged' => $recipeAnalysis->whereIn('status', ['new', 'updated'])->pluck('key')->toArray(),
+            'overwrite-all' => $recipeAnalysis->pluck('key')->toArray(),
+        };
+    }
+
+    private function install($key)
+    {
+        info('Installing recipe: ' . $key);
+
+        $data = app(MiseService::class)->findByKey($key);
+
+        app(LocalRecipesService::class)->install([
+            'key' => $key,
+            'name' => $data->get('name'),
+            'namespace' => $data->get('namespace'),
+            'version' => $data->get('version'),
+            'url' => $data->get('download_url'),
+            'integrity' => $data->get('integrity'),
+        ]);
+    }
+}

app/Recipes.php

@@ -5,12 +5,15 @@
 use App\Recipes\Recipe;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\File;
+use Illuminate\Support\Facades\Storage;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
 
 class Recipes
 {
     public function all(): Collection
     {
-        $customRecipesDir = $_SERVER['HOME'] . '/.mise/Recipes';
+        $customRecipesDir = Storage::disk('local-recipes')->path('');
 
         if (is_dir($customRecipesDir)) {
             $this->loadFilesInPath($customRecipesDir);
@@ -48,7 +51,9 @@ public function keys(): Collection
     protected function allInPath(string $path): Collection
     {
         return collect(File::allFiles($path))
-            ->map(fn ($file) => 'App\\Recipes\\' . str_replace('/', '\\',
+            ->map(fn ($file) => 'App\\Recipes\\' . str_replace(
+                '/',
+                '\\',
                 trim(str_replace([$path, '.php'], '', $file->getPathname()), '/')
             ))
             ->filter(fn ($class) => class_exists($class) && is_subclass_of($class, Recipe::class))
@@ -57,8 +62,14 @@ protected function allInPath(string $path): Collection
 
     protected function loadFilesInPath(string $path): void
     {
-        foreach (glob($path . '/*.php') as $file) {
-            require_once $file;
+        $iterator = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::SKIP_DOTS)
+        );
+
+        foreach ($iterator as $file) {
+            if ($file->isFile() && $file->getExtension() === 'php') {
+                require_once $file->getPathname();
+            }
         }
     }
 }

app/Services/LocalRecipesService.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace App\Services;
+
+use Exception;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Storage;
+use ZipArchive;
+
+class LocalRecipesService
+{
+    const Lock = 'mise-lock.json';
+    const Disk = 'local-recipes';
+
+    public function install($package): void
+    {
+        $response = Http::get($package['url'])->throw();
+        $zipContent = $response->body();
+
+        if ($this->validateIntegrity($zipContent) !== $package['integrity']) {
+            throw new Exception('Integrity verification failed. Downloaded file integrity check failed.');
+        }
+
+        $this->extractRecipe($zipContent, $package['namespace']);
+
+        $this->updateLock($package['key'], [
+            'name' => $package['name'],
+            'version' => $package['version'],
+            'integrity' => $package['integrity'],
+            'source' => ['url' => $package['url']],
+        ]);
+    }
+
+    public function all(): Collection
+    {
+        if (! $this->lockExists()) {
+            return collect();
+        }
+
+        $content = Storage::disk(self::Disk)->get(self::Lock);
+
+        return collect(json_decode($content, true)['recipes'] ?? []);
+    }
+
+    public function findByKey(string $key): ?array
+    {
+        return $this->all()->first(fn ($recipe) => $recipe['key'] === $key);
+    }
+
+    public function exists(string $key): bool
+    {
+        return $this->all()->contains('key', $key);
+    }
+
+    private function lockExists(): bool
+    {
+        return Storage::disk(self::Disk)->exists(self::Lock);
+    }
+
+    private function validateIntegrity(string $content): string
+    {
+        return hash('sha512', $content);
+    }
+
+    private function updateLock(string $key, array $data): void
+    {
+        $lockData = $this->lockExists() ? json_decode(Storage::disk(self::Disk)->get(self::Lock), true) : ['recipes' => []];
+
+        $existingIndex = collect($lockData['recipes'])->search(fn ($recipe) => $recipe['key'] === $key);
+
+        if (is_int($existingIndex)) {
+            $lockData['recipes'][$existingIndex] = array_merge(['key' => $key], $data);
+        } else {
+            $lockData['recipes'][] = array_merge(['key' => $key], $data);
+        }
+
+        Storage::disk(self::Disk)->put(self::Lock, json_encode($lockData, JSON_PRETTY_PRINT));
+    }
+
+    private function extractRecipe($content, $namespace): void
+    {
+        $tempZipName = 'temp_recipe_' . uniqid() . '.zip';
+        $tempDisk = Storage::disk('local');
+        $tempDisk->put($tempZipName, $content);
+        $tempZipPath = $tempDisk->path($tempZipName);
+
+        $zip = new ZipArchive;
+        if ($zip->open($tempZipPath) !== true) {
+            $tempDisk->delete($tempZipName);
+            throw new Exception('Failed to open zip file.');
+        }
+
+        $disk = Storage::disk(self::Disk);
+        $extractPath = $disk->path($namespace);
+
+        if (! $zip->extractTo($extractPath)) {
+            $zip->close();
+            $tempDisk->delete($tempZipName);
+            throw new Exception('Failed to extract zip file.');
+        }
+
+        $zip->close();
+        $tempDisk->delete($tempZipName);
+    }
+}

app/Services/MiseService.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Services;
+
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Http;
+
+class MiseService
+{
+    protected string $url;
+
+    public function __construct()
+    {
+        $this->url = config('app.mise-url');
+    }
+
+    public function all(): Collection
+    {
+        $data = Http::get($this->url . '/api/recipes')
+            ->throw()
+            ->json('data');
+
+        return collect($data);
+    }
+
+    public function findByKey(string $recipe): Collection
+    {
+        $data = Http::get($this->url . '/api/recipes/' . $recipe)
+            ->throw()
+            ->json('data');
+
+        return collect($data);
+    }
+
+    public function allForSelect(): Collection
+    {
+        return $this->all()->pluck('name', 'key');
+    }
+
+    public function keys(): Collection
+    {
+        return $this->all()->pluck('key');
+    }
+}

composer.json

@@ -24,6 +24,8 @@
         "php": "^8.2.0"
     },
     "require-dev": {
+        "illuminate/http": "^11.5",
+        "laravel-zero/framework": "^11.36.1",
         "friendsofphp/php-cs-fixer": "^3.75",
         "illuminate/log": "^11.5",
         "illuminate/queue": "^v11.44.2",