@jumpgroup/laravel-tools 3.3.0

package/bin/groups/forge.js

@@ -0,0 +1,272 @@
+import { input, select, confirm } from '@inquirer/prompts';
+import { setForgeToken } from '../../src/forge/config.js';
+import { listServers, pickServer, deleteServer } from '../../src/forge/servers.js';
+import { pickSite, deploySite, getDeploymentLog, getEnv, setEnv, confirmDestructiveEnvWrite, createSite, pollSiteInstalled, installGitRepo, getDeployScript, updateDeployScript } from '../../src/forge/sites.js';
+import { getAwsCredential, promptServerConfig, createServer, pollServerReady, readPhpVersionFromComposer, readAppName } from '../../src/forge/provisioning.js';
+
+export default (program) => {
+  const forge = program.command('forge').description('Operazioni su Laravel Forge');
+
+  // forge token set
+  forge
+    .command('token')
+    .description('Gestione token Forge API')
+    .command('set')
+    .description('Salva il token Forge API in ~/.laravel-tools')
+    .action(async () => {
+      try {
+        const token = await input({ message: 'Forge API token:' });
+        setForgeToken(token.trim());
+        console.log('✅ Token salvato in ~/.laravel-tools');
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge servers
+  forge
+    .command('servers')
+    .description('Elenca i server Forge dell\'account')
+    .action(async () => {
+      try {
+        const servers = await listServers();
+        if (servers.length === 0) {
+          console.log('Nessun server trovato.');
+          return;
+        }
+        console.log('');
+        servers.forEach((s) => {
+          console.log(`  ${s.name.padEnd(30)} ${s.ip_address.padEnd(18)} ${s.type}`);
+        });
+        console.log('');
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge server create
+  const server = forge.command('server').description('Gestione server Forge');
+
+  server
+    .command('create')
+    .description('Crea un nuovo server AWS Lightsail tramite Forge')
+    .action(async () => {
+      try {
+        console.log('🔑 Recupero credenziali AWS...');
+        const [credential, existingServers] = await Promise.all([
+          getAwsCredential(),
+          listServers(),
+        ]);
+        console.log(`✅ Credenziale trovata: ${credential.name}`);
+
+        const config = await promptServerConfig(credential.id, existingServers);
+
+        console.log(`\n🚀 Creazione server "${config.name}" in corso...`);
+        const newServer = await createServer(credential.id, config);
+        console.log(`✅ Server creato (ID: ${newServer.id}). Avvio provisioning...`);
+
+        const ready = await pollServerReady(newServer.id);
+        console.log(`\n✅ Server pronto!`);
+        console.log(`   Nome:  ${ready.name}`);
+        console.log(`   IP:    ${ready.ip_address}`);
+        console.log(`   PHP:   ${config.php_version}`);
+        console.log(`   Redis: ${config.install_redis ? 'sì' : 'no'}\n`);
+        console.log(`Prossimo passo: laravel-tools forge site create`);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  server
+    .command('delete')
+    .description('Elimina un server Forge')
+    .action(async () => {
+      try {
+        const s = await pickServer();
+        console.log(`\n  ⚠️  Stai per eliminare il server \x1b[31m${s.name}\x1b[0m (${s.ip_address})`);
+        console.log(`  Questa operazione è \x1b[31mIRREVERSIBILE\x1b[0m.\n`);
+        const confirmed = await confirm({
+          message: `Confermi l'eliminazione di ${s.name}?`,
+          default: false,
+        });
+        if (!confirmed) {
+          console.log('Operazione annullata.');
+          return;
+        }
+        await deleteServer(s.id);
+        console.log(`✅ Server ${s.name} eliminato.`);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge site create
+  const site = forge.command('site').description('Gestione siti Forge');
+
+  site
+    .command('create')
+    .description('Crea un sito su un server Forge e collega il repository Git')
+    .action(async () => {
+      try {
+        const { forgeVersion } = readPhpVersionFromComposer();
+        const appName = readAppName();
+        const dbDefault = appName.replace(/-/g, '_');
+
+        const server = await pickServer();
+
+        const domainDefault = server.name.includes('staging')
+          ? `api.${appName}.sitointest.it`
+          : `api.${appName}.it`;
+        const domain = await input({ message: 'Dominio del sito:', default: domainDefault });
+
+        const database = await input({
+          message: 'Nome database:',
+          default: dbDefault,
+        });
+
+        const provider = await select({
+          message: 'Provider Git:',
+          choices: [
+            { name: 'GitHub', value: 'github' },
+            { name: 'GitLab', value: 'gitlab' },
+            { name: 'Bitbucket', value: 'bitbucket' },
+          ],
+        });
+
+        const repository = await input({
+          message: 'Repository (org/repo):',
+        });
+
+        const branch = await input({
+          message: 'Branch:',
+          default: 'main',
+        });
+
+        console.log(`\n🌐 Creazione sito ${domain} su ${server.name}...`);
+        const newSite = await createSite(server.id, {
+          domain,
+          project_type: 'php',
+          directory: '/public',
+          php_version: forgeVersion,
+          database,
+        });
+
+        const installedSite = await pollSiteInstalled(server.id, newSite.id);
+        console.log(`✅ Sito installato (ID: ${installedSite.id})`);
+
+        console.log(`📦 Collegamento repository ${repository}...`);
+        await installGitRepo(server.id, installedSite.id, {
+          provider,
+          repository,
+          branch,
+          composer: true,
+        });
+
+        if (server.name.includes('staging')) {
+          console.log('🔧 Aggiunta migrate automatica al deploy script (staging)...');
+          const currentScript = await getDeployScript(server.id, installedSite.id);
+          const updatedScript = currentScript.trimEnd() + '\nphp artisan migrate --force\n';
+          await updateDeployScript(server.id, installedSite.id, updatedScript);
+          console.log('✅ Deploy script aggiornato.');
+        }
+
+        console.log(`\n✅ Sito pronto!`);
+        console.log(`   Dominio:     ${domain}`);
+        console.log(`   Repository:  ${repository} (${branch})`);
+        console.log(`   Database:    ${database}`);
+        console.log(`   PHP:         ${forgeVersion}\n`);
+        console.log(`Prossimi passi:`);
+        console.log(`  1. laravel-tools forge env set   → configura il .env remoto`);
+        console.log(`  2. laravel-tools forge deploy    → avvia il primo deploy\n`);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge deploy
+  forge
+    .command('deploy')
+    .description('Avvia il deploy di un sito su Forge')
+    .action(async () => {
+      try {
+        const server = await pickServer();
+        const site = await pickSite(server.id);
+        console.log(`🚀 Avvio deploy di ${site.name}...`);
+        await deploySite(server.id, site.id);
+        console.log('✅ Deploy avviato. Monitora l\'avanzamento nella UI Forge.');
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge env get
+  const env = forge.command('env').description('Gestione .env remoto su Forge');
+
+  env
+    .command('get')
+    .description('Legge il file .env remoto di un sito')
+    .action(async () => {
+      try {
+        const server = await pickServer();
+        const site = await pickSite(server.id);
+        const content = await getEnv(server.id, site.id);
+        console.log('\n' + content);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  env
+    .command('set')
+    .description('Sovrascrive il file .env remoto di un sito')
+    .action(async () => {
+      try {
+        const server = await pickServer();
+        const site = await pickSite(server.id);
+
+        const confirmed = await confirmDestructiveEnvWrite();
+        if (!confirmed) {
+          console.log('Operazione annullata.');
+          return;
+        }
+
+        console.log('Incolla il contenuto del .env (termina con una riga contenente solo EOF):');
+        const lines = [];
+        process.stdin.setEncoding('utf8');
+        for await (const chunk of process.stdin) {
+          lines.push(chunk);
+          if (lines.join('').includes('\nEOF\n') || lines.join('').endsWith('\nEOF')) break;
+        }
+        const content = lines.join('').replace(/\nEOF$/, '').replace(/\nEOF\n$/, '');
+
+        await setEnv(server.id, site.id, content);
+        console.log('✅ .env remoto aggiornato.');
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  // forge logs
+  forge
+    .command('logs')
+    .description('Mostra il log dell\'ultimo deploy di un sito')
+    .action(async () => {
+      try {
+        const server = await pickServer();
+        const site = await pickSite(server.id);
+        const log = await getDeploymentLog(server.id, site.id);
+        console.log('\n' + (log || 'Nessun log disponibile.'));
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+};

package/bin/groups/local.js

@@ -0,0 +1,78 @@
+import { Option } from 'commander';
+import { setupProject, setupRepo, setupLaravel, addUser } from '../../src/local/setup.js';
+import { runLocalDoctor } from '../../src/local/doctor.js';
+
+export default (program) => {
+  const local = program.command('local').description('Operazioni per l\'ambiente di sviluppo locale');
+
+  local
+    .command('setup-project')
+    .description(
+      'Definisce l\'identita\' del progetto locale e aggiorna APP_NAME, APP_URL e ASSETS_URL in .env.example'
+    )
+    .action(async () => {
+      try {
+        await setupProject();
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  local
+    .command('setup-repo')
+    .description(
+      'Prepara il repo locale: genera .env, copia gli stub Docker, crea i certificati e aggiorna /etc/hosts'
+    )
+    .addOption(
+      new Option('--phpversion <version>', 'Versione PHP da usare')
+        .choices(['php8.0', 'php8.1', 'php8.2', 'php8.3', 'php8.4'])
+        .default('php8.4')
+    )
+    .action(async (options) => {
+      try {
+        await setupRepo(options);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  const user = local.command('user').description('Gestione utenti del progetto locale');
+
+  user
+    .command('add')
+    .description('Crea un nuovo utente Filament nel container avviato')
+    .action(async () => {
+      try {
+        await addUser();
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  local
+    .command('setup-laravel')
+    .description('Inizializza Laravel nel container avviato: chiave applicativa, migration e seeder opzionali')
+    .action(async () => {
+      try {
+        await setupLaravel();
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  local
+    .command('doctor')
+    .description('Esegue controlli diagnostici su file, prerequisiti locali e stato Docker del progetto')
+    .action(async () => {
+      try {
+        await runLocalDoctor();
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+};

package/bin/groups/media.js

@@ -0,0 +1,110 @@
+import { Option } from 'commander';
+
+import { getAllBuckets, getBucketFromTag } from '../../src/aws/bucket.js';
+import {
+  getAllDistributions,
+  getDistributionByTagOrName,
+  createDistribution,
+} from '../../src/aws/cloudfront.js';
+import { setupAWS, setupIAM } from '../../src/media.js';
+
+export default (program) => {
+  const media = program.command('media').description('Operazioni AWS media (S3 + CloudFront)');
+
+  media
+    .command('setup-general')
+    .description('Setup completo media: bucket S3, CloudFront e IAM user')
+    .addOption(new Option('-n, --name [name]', 'Nome progetto (default: APP_NAME)'))
+    .addOption(new Option('--dry-run', 'Mostra le operazioni AWS senza applicare modifiche').default(false))
+    .action(async (options) => {
+      try {
+        await setupAWS(options.name, { dryRun: options.dryRun });
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  media
+    .command('setup-iam')
+    .description('Crea/aggiorna IAM user per accesso media')
+    .addOption(new Option('-n, --name [name]', 'Nome progetto (default: APP_NAME)'))
+    .addOption(new Option('-c, --cloudfront [cloudfront]', 'CloudFront distribution ID'))
+    .addOption(new Option('--dry-run', 'Mostra le operazioni AWS senza applicare modifiche').default(false))
+    .action(async (options) => {
+      try {
+        await setupIAM(options.name, options.cloudfront, { dryRun: options.dryRun });
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  const s3 = media.command('s3').description('Comandi S3');
+
+  s3
+    .command('list')
+    .description('Lista bucket S3')
+    .action(async () => {
+      try {
+        await getAllBuckets(true);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  s3
+    .command('get')
+    .description('Trova bucket tramite tag site')
+    .addOption(new Option('-t, --tag [tag]', 'Tag site'))
+    .action(async (options) => {
+      try {
+        await getBucketFromTag(options.tag);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  const cloudfront = media.command('cloudfront').description('Comandi CloudFront');
+
+  cloudfront
+    .command('list')
+    .description('Lista distribuzioni CloudFront')
+    .action(async () => {
+      try {
+        await getAllDistributions(true);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  cloudfront
+    .command('get')
+    .description('Trova distribuzione per tag site (match esatto)')
+    .addOption(new Option('-t, --tag [tag]', 'Tag site progetto'))
+    .action(async (options) => {
+      try {
+        await getDistributionByTagOrName(options.tag);
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+
+  cloudfront
+    .command('setup')
+    .description('Crea distribuzione CloudFront per progetto')
+    .addOption(new Option('-n, --name [name]', 'Nome progetto (default: APP_NAME)'))
+    .addOption(new Option('--dry-run', 'Mostra le operazioni AWS senza applicare modifiche').default(false))
+    .action(async (options) => {
+      try {
+        await createDistribution(options.name, undefined, { dryRun: options.dryRun });
+      } catch (error) {
+        console.error('❌ Errore:', error.message);
+        process.exit(1);
+      }
+    });
+};

package/bin/tools.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { createRequire } from 'module';
+
+import database from './groups/database.js';
+import cache from './groups/cache.js';
+import local from './groups/local.js';
+import media from './groups/media.js';
+import forge from './groups/forge.js';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+program.version(version);
+
+database(program);
+cache(program);
+local(program);
+media(program);
+forge(program);
+
+program.parse(process.argv);