Castor : un outil qui envoie du bois

Qui prend un réel plaisir à maintenir des Makefiles complexes ? Ce moment de solitude où une commande échoue à cause d'une tabulation manquante ou d'une condition Bash est une expérience qu'on a tous vécue.

Je suis développeur PHP. Je pense en objets, en types et en exceptions. Pourquoi devrais-je devenir un expert en dialecte Shell des années 70 pour orchestrer mon projet moderne ?

L'arrivée de Castor, développé par l'équipe de JoliCode, propose un changement de paradigme : remplacez vos scripts shell fragiles par du PHP typé, autocomplété et robuste.

Castor : la DX avant tout

Castor est un task runner qui s'exécute via un binaire autonome. Il ne nécessite aucune dépendance externe pour démarrer. Son atout majeur ? Vous écrivez votre automatisation dans le langage que vous maîtrisez déjà.

Un démarrage de projet intelligent

Comparer un démarrage via Makefile et via Castor, c'est comparer un script aveugle à un programme intelligent.

Approche classique (Make/Bash) : On lance docker compose up, puis on ajoute un sleep 10 arbitraire en priant pour que la base de données soit prête avant que l'application ne tente de s'y connecter.

Approche Castor (PHP) : On peut écrire une véritable logique d'attente active, typée et lisible.

#[AsTask(description: 'Démarre l\'environnement de développement')]
function start(): int
{
    io()->title('Démarrage de la stack');
    
    // 1. Lancement des conteneurs
    run('docker compose up -d --build');

    // 2. Attente intelligente de la base de données
    io()->section('Attente de la disponibilité de PostgreSQL...');
    
    $isDbReady = false;
    // Tentative de connexion toutes les secondes pendant 30s
    for ($i = 0; $i < 30; ++$i) {
        try {
            // Si cette commande échoue, Castor lance une exception catchable
            run('docker compose exec database pg_isready -q');
            $isDbReady = true;
            break;
        } catch (Throwable) {
            sleep(1);
            io()->write('.');
        }
    }
    
    if (!$isDbReady) {
        io()->error('La base de données ne répond pas.');
        return Command::FAILURE;
    }

    // 3. Suite des opérations (Composer, Migrations...)
    io()->section('Installation des dépendances...');
    run('docker compose exec php composer install --no-interaction');

    return Command::SUCCESS;
}

N'importe quel développeur PHP comprend ce code instantanément. Pas de codes de retour $?, pas de syntaxes if [ ... ] obscures.

Le confort de l'expérience développeur (DX)

Castor ne se limite pas à exécuter des commandes. Il offre une boîte à outils complète pour interagir avec l'utilisateur :

• Inputs interactifs : io()->confirm(), io()->ask()
• Feedback visuel : Barres de progression, tableaux, sections colorées.
• Mode Watch : Idéal pour compiler du CSS (Tailwind) ou du JS en continu.

Exemple de commande "Watch" native :

#[AsTask(name: 'tw', description: 'Build Tailwind CSS en mode watch')]
function tailwind_watch(): void {
    io()->title('Tailwind CSS Watch Mode');
    io()->note('Pressez Ctrl+C pour arrêter');
    // Castor gère parfaitement le streaming de l'output
    run('docker compose exec php bin/console tailwind:build --watch');
}

Cas concret : Sync de Production

C'est le test ultime de robustesse. Récupérer la base de données de production en local est une opération critique. En Bash, gérer les confirmations de sécurité ("Êtes-vous vraiment sûr d'écraser votre base locale ?") est laborieux.

Avec Castor, la sécurité est native :

#[AsTask(description: 'Sync database from PROD to DEV')]
function db_sync(): int
{
    io()->warning('ATTENTION : Cette opération va ÉCRASER votre base de données locale.');
    
    if (!io()->confirm('Confirmer la synchronisation ?', false)) {
        io()->error('Annulé.');
        return Command::INVALID;
    }

    try {
        io()->section('Début de la synchronisation...');
        
        // Dump distant via SSH
        run('ssh prod@server "pg_dump mydb > /tmp/dump.sql"');
        
        // Transfert local via SCP
        run('scp prod@server:/tmp/dump.sql /tmp/');
        
        // Import local
        run('docker compose exec -T database psql -U dev < /tmp/dump.sql');
        
        io()->success('Synchronisation terminée !');
        return Command::SUCCESS;
    } catch (Exception $e) {
        io()->error(sprintf('Erreur lors de la synchro : %s', $e->getMessage()));
        return Command::FAILURE;
    }
}

Déploiement : PHP dépasse le Shell

Même pour le déploiement en production (CI/CD), Castor brille. Il permet de manipuler des données complexes plus aisement que le Shell.

Imaginez devoir extraire une clé secrète d'un fichier PHP distant pour l'injecter dans un build Docker.

• Bash : Une suite de grep, sed, awk illisible.
• Castor :

$output = run(
    command: 'php -r "echo require(\'config/secrets/prod.key\');"',
    quiet: true
)->getOutput();

$key = trim($output) ?: throw new RuntimeException('Clé secrète introuvable');

Les limites à connaître

Castor n'est pas une solution miracle. Avant d'adopter l'outil, considérez ces aspects :

• Performance : PHP a un overhead vs Bash pur (acceptable pour des tasks d'orchestration, moins pertinent pour du traitement de logs massifs).
• Courbe d'apprentissage : Votre équipe doit maîtriser PHP. Évident dans un projet Symfony, moins si vos collègues travaillent uniquement en infrastructure pure.
• Écosystème : Moins de ressources et tutoriels que Make, un outil mature depuis 40 ans avec une documentation exhaustive.

Le mot de la fin

L'adoption de Castor dans un projet PHP moderne n'est pas une simple commodité, c'est une montée en gamme.

1. Réduction de la charge cognitive : Vous restez dans votre langage de prédilection.
2. Robustesse : Gestion d'erreurs, typage, exceptions.
3. Documentation vivante : Votre fichier castor.php devient le point d'entrée documenté et autocomplété de votre projet.

Ne laissez plus des scripts Bash fragiles piloter votre infrastructure. Donnez à votre outillage la même qualité de code qu'à votre application.