@jumpgroup/laravel-tools 3.3.0

package/src/forge/provisioning.js

@@ -0,0 +1,191 @@
+import { readFileSync, existsSync } from 'fs';
+import { select, confirm } from '@inquirer/prompts';
+import { get, post } from './client.js';
+
+const REGIONS = [
+  { name: 'EU Frankfurt — eu-central-1', value: 'eu-central-1' },
+  { name: 'US West Oregon — us-west-2', value: 'us-west-2' },
+];
+
+const PHP_VERSION_MAP = {
+  '8.4': 'php84',
+  '8.3': 'php83',
+  '8.2': 'php82',
+  '8.1': 'php81',
+  '8.0': 'php80',
+};
+
+const SERVER_POLL_INTERVAL_MS = 20000;
+const SERVER_POLL_TIMEOUT_MS = 25 * 60 * 1000;
+
+export const getAwsCredential = async () => {
+  const data = await get('/credentials');
+  const credentials = data.credentials || [];
+  const aws = credentials.find((c) => c.type === 'aws' || c.name?.toLowerCase().includes('aws'));
+  if (!aws) {
+    throw new Error(
+      'Nessuna credenziale AWS trovata su Forge. ' +
+        'Aggiungi un provider AWS in Forge → Profile → Server Providers.'
+    );
+  }
+  return aws;
+};
+
+export const getSizesForRegion = async (credentialId, region) => {
+  try {
+    const data = await get(`/regions?provider=aws`);
+    const regions = data.regions?.aws || [];
+    const found = regions.find((r) => r.id === region);
+    if (found?.sizes?.length > 0) return found.sizes;
+  } catch {
+    // fall through to defaults
+  }
+
+  return [
+    { id: '253736', name: '1 GB RAM · t3.micro · 2 vCPU' },
+    { id: '253836', name: '2 GB RAM · t3.small · 2 vCPU' },
+    { id: '253700', name: '4 GB RAM · t3.medium · 2 vCPU' },
+    { id: '253689', name: '8 GB RAM · t2.large · 2 vCPU' },
+  ];
+};
+
+export const readPhpVersionFromComposer = () => {
+  if (!existsSync('composer.json')) {
+    throw new Error(
+      'composer.json non trovato. Esegui il comando dalla root del progetto Laravel.'
+    );
+  }
+
+  const composer = JSON.parse(readFileSync('composer.json', 'utf8'));
+  const phpConstraint = composer.require?.php;
+
+  if (!phpConstraint) {
+    throw new Error('Versione PHP non trovata in composer.json → require.php.');
+  }
+
+  const match = phpConstraint.match(/(\d+)\.(\d+)/);
+  if (!match) {
+    throw new Error(`Impossibile leggere la versione PHP dal constraint: ${phpConstraint}`);
+  }
+
+  const version = `${match[1]}.${match[2]}`;
+  const forgeVersion = PHP_VERSION_MAP[version];
+
+  if (!forgeVersion) {
+    throw new Error(
+      `Versione PHP ${version} non supportata da Forge. ` +
+        `Versioni supportate: ${Object.keys(PHP_VERSION_MAP).join(', ')}`
+    );
+  }
+
+  return { version, forgeVersion };
+};
+
+export const readAppName = () => {
+  try {
+    const raw = readFileSync('.env.example', 'utf8');
+    const match = raw.match(/^APP_NAME=(.+)$/m);
+    if (!match) throw new Error('APP_NAME non trovato');
+    return match[1].trim().replace(/['"]/g, '');
+  } catch {
+    throw new Error('Impossibile leggere APP_NAME da .env.example.');
+  }
+};
+
+export const resolveServerName = (baseName, existingServers) => {
+  const names = existingServers.map((s) => s.name);
+
+  if (!names.includes(baseName)) return baseName;
+
+  let n = 2;
+  while (names.includes(`${baseName}-${n}`)) n++;
+  return `${baseName}-${n}`;
+};
+
+export const promptServerConfig = async (credentialId, existingServers = []) => {
+  const appName = readAppName();
+  const { version, forgeVersion } = readPhpVersionFromComposer();
+
+  console.log(`\n📦 PHP rilevato da composer.json: ${version} → Forge: ${forgeVersion}`);
+  console.log(`🌍 Regione: EU Milan (eu-south-1)`);
+
+  const environment = await select({
+    message: 'Ambiente:',
+    choices: [
+      { name: 'staging', value: 'staging' },
+      { name: 'production', value: 'production' },
+    ],
+  });
+
+  const baseName = `${appName}-${environment}`;
+  const serverName = resolveServerName(baseName, existingServers);
+
+  const confirmed = await confirm({
+    message: `Nome server: ${serverName} — confermi?`,
+    default: true,
+  });
+  if (!confirmed) {
+    throw new Error('Operazione annullata.');
+  }
+
+  console.log('⏳ Recupero piani disponibili...');
+  const sizes = await getSizesForRegion(credentialId, 'eu-south-1');
+
+  const size = await select({
+    message: 'Piano EC2:',
+    choices: sizes.map((s) => ({ name: s.name || s.size, value: s.id })),
+  });
+
+  const installRedis = await confirm({
+    message: 'Installare Redis?',
+    default: false,
+  });
+
+  return {
+    name: serverName,
+    region: 'eu-south-1',
+    size,
+    php_version: forgeVersion,
+    install_redis: installRedis,
+  };
+};
+
+export const createServer = async (credentialId, config) => {
+  const payload = {
+    provider: 'aws',
+    credential_id: credentialId,
+    type: 'app',
+    database_type: 'mysql8',
+    ubuntu_version: '24.04',
+    ...config,
+  };
+
+  const data = await post('/servers', payload);
+  return data.server;
+};
+
+export const pollServerReady = async (serverId) => {
+  const start = Date.now();
+
+  process.stdout.write('⏳ Provisioning in corso');
+
+  while (Date.now() - start < SERVER_POLL_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, SERVER_POLL_INTERVAL_MS));
+
+    const data = await get(`/servers/${serverId}`);
+    const server = data.server;
+
+    process.stdout.write('.');
+
+    if (server.is_ready) {
+      process.stdout.write('\n');
+      return server;
+    }
+  }
+
+  process.stdout.write('\n');
+  throw new Error(
+    'Timeout provisioning server (25 min). ' +
+      'Controlla lo stato su Forge e riprova se necessario.'
+  );
+};

package/src/forge/servers.js

@@ -0,0 +1,27 @@
+import { select } from '@inquirer/prompts';
+import { get, del } from './client.js';
+
+export const listServers = async () => {
+  const data = await get('/servers');
+  return data.servers || [];
+};
+
+export const deleteServer = async (serverId) => {
+  await del(`/servers/${serverId}`);
+};
+
+export const pickServer = async () => {
+  const servers = await listServers();
+
+  if (servers.length === 0) {
+    throw new Error('Nessun server trovato sull\'account Forge.');
+  }
+
+  return await select({
+    message: 'Seleziona il server:',
+    choices: servers.map((s) => ({
+      name: `${s.name} (${s.ip_address}) — ${s.type}`,
+      value: s,
+    })),
+  });
+};

package/src/forge/sites.js

@@ -0,0 +1,93 @@
+import { select, password, confirm } from '@inquirer/prompts';
+import { get, post, put } from './client.js';
+
+export const listSites = async (serverId) => {
+  const data = await get(`/servers/${serverId}/sites`);
+  return data.sites || [];
+};
+
+export const pickSite = async (serverId) => {
+  const sites = await listSites(serverId);
+
+  if (sites.length === 0) {
+    throw new Error('Nessun sito trovato su questo server.');
+  }
+
+  return await select({
+    message: 'Seleziona il sito:',
+    choices: sites.map((s) => ({
+      name: `${s.name} — ${s.status}`,
+      value: s,
+    })),
+  });
+};
+
+export const deploySite = async (serverId, siteId) => {
+  await post(`/servers/${serverId}/sites/${siteId}/deployment/deploy`);
+};
+
+export const getDeploymentLog = async (serverId, siteId) => {
+  const data = await get(`/servers/${serverId}/sites/${siteId}/deployment/log`);
+  return data.content || data || '';
+};
+
+export const getEnv = async (serverId, siteId) => {
+  const data = await get(`/servers/${serverId}/sites/${siteId}/env`);
+  return typeof data === 'string' ? data : (data.content ?? '');
+};
+
+export const setEnv = async (serverId, siteId, content) => {
+  await put(`/servers/${serverId}/sites/${siteId}/env`, { content });
+};
+
+export const confirmDestructiveEnvWrite = async () => {
+  const confirmed = await confirm({
+    message: '\x1b[31mDISTRUTTIVO: Se confermi l\'env remote verrà sovrascritto! Sicuro di voler continuare?\x1b[0m',
+    default: false,
+  });
+  return confirmed;
+};
+
+const SITE_POLL_INTERVAL_MS = 5000;
+const SITE_POLL_TIMEOUT_MS = 5 * 60 * 1000;
+
+export const createSite = async (serverId, payload) => {
+  const data = await post(`/servers/${serverId}/sites`, payload);
+  return data.site;
+};
+
+export const pollSiteInstalled = async (serverId, siteId) => {
+  const start = Date.now();
+
+  process.stdout.write('⏳ Attendo installazione sito');
+
+  while (Date.now() - start < SITE_POLL_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, SITE_POLL_INTERVAL_MS));
+
+    const data = await get(`/servers/${serverId}/sites/${siteId}`);
+    const site = data.site;
+
+    process.stdout.write('.');
+
+    if (site.status === 'installed') {
+      process.stdout.write('\n');
+      return site;
+    }
+  }
+
+  process.stdout.write('\n');
+  throw new Error('Timeout installazione sito (5 min). Controlla lo stato su Forge.');
+};
+
+export const installGitRepo = async (serverId, siteId, payload) => {
+  await post(`/servers/${serverId}/sites/${siteId}/git`, payload);
+};
+
+export const getDeployScript = async (serverId, siteId) => {
+  const data = await get(`/servers/${serverId}/sites/${siteId}/deployment/script`);
+  return data.content || '';
+};
+
+export const updateDeployScript = async (serverId, siteId, content) => {
+  await put(`/servers/${serverId}/sites/${siteId}/deployment/script`, { content });
+};

package/src/google/groupMembers.js

@@ -0,0 +1,35 @@
+import { domain, getLocalKeys } from './utilities.js';
+
+export const getMembersOfGroupEmail = async (groupKey, groupSecret, email) => {
+  let resolvedGroupKey = groupKey;
+  let resolvedGroupSecret = groupSecret;
+
+  if (!resolvedGroupKey || !resolvedGroupSecret) {
+    const secretFetcherOptions = await getLocalKeys();
+    resolvedGroupKey = secretFetcherOptions.groupKey;
+    resolvedGroupSecret = secretFetcherOptions.groupSecret;
+  }
+
+  if (!resolvedGroupKey || !resolvedGroupSecret) {
+    throw new Error('Missing groupKey/groupSecret in .secret-fetcher');
+  }
+
+  const resolvedEmail = email || `${resolvedGroupKey}@jumpgroup.it`;
+  const url = `${domain}groups/${resolvedEmail}/members?word=${resolvedGroupKey}&encrypted_word=${resolvedGroupSecret}`;
+
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch group members (${response.status} ${response.statusText})`);
+  }
+
+  const payload = await response.json();
+  if (!payload?.members || !Array.isArray(payload.members)) {
+    return [];
+  }
+
+  return payload.members;
+};

package/src/google/utilities.js

@@ -0,0 +1,39 @@
+import { existsSync } from 'fs';
+import { config } from 'dotenv';
+import { getMembersOfGroupEmail } from './groupMembers.js';
+
+export const domain = 'https://gmailgroupalias.jumpgroup.it/api/';
+
+export const getLocalKeys = async () => {
+  if (!existsSync('.secret-fetcher')) {
+    throw new Error('No .secret-fetcher file found');
+  }
+
+  const parsed = config({ path: '.secret-fetcher' }).parsed;
+  if (!parsed) {
+    throw new Error('Could not read .secret-fetcher');
+  }
+  return parsed;
+};
+
+export const getPeopleName = async () => {
+  const secretFetcherOptions = await getLocalKeys();
+  const groupKey = secretFetcherOptions.groupKey;
+  const groupSecret = secretFetcherOptions.groupSecret;
+
+  const techTeamMembers = await getMembersOfGroupEmail(
+    groupKey,
+    groupSecret,
+    'tech@jumpgroup.it'
+  );
+
+  const uniqueNames = [...new Set(
+    techTeamMembers
+      .map((member) => member?.email)
+      .filter(Boolean)
+      .map((email) => email.split('@')[0].split('.')[0])
+      .filter(Boolean)
+  )].sort();
+
+  return uniqueNames.map((name) => ({ name, value: name }));
+};

package/src/local/doctor.js

@@ -0,0 +1,214 @@
+import { existsSync, readFileSync } from 'fs';
+import { parse } from 'dotenv';
+import { spawnSync } from 'child_process';
+
+const ICONS = {
+  ok: '✅',
+  fail: '❌',
+  warn: '⚠️ ',
+};
+
+const runCommand = (command, args = []) =>
+  spawnSync(command, args, {
+    stdio: 'pipe',
+    encoding: 'utf8',
+  });
+
+const checkCommandAvailable = (command, args = ['--version']) => {
+  const result = runCommand(command, args);
+  return !result.error && result.status === 0;
+};
+
+const checkDockerContainerState = (containerName) => {
+  const result = runCommand('docker', ['inspect', '-f', '{{.State.Running}}', containerName]);
+  if (result.status !== 0) {
+    return {
+      exists: false,
+      running: false,
+    };
+  }
+
+  return {
+    exists: true,
+    running: result.stdout.trim() === 'true',
+  };
+};
+
+const readEnvFile = (path) => {
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    return parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+};
+
+const createCollector = () => {
+  const checks = [];
+  return {
+    add: (status, label, details = '') => {
+      checks.push({ status, label, details });
+    },
+    getChecks: () => checks,
+    counts: () => {
+      const failures = checks.filter((c) => c.status === 'fail').length;
+      const warnings = checks.filter((c) => c.status === 'warn').length;
+      const ok = checks.filter((c) => c.status === 'ok').length;
+      return { ok, failures, warnings };
+    },
+  };
+};
+
+const printResults = (checks) => {
+  for (const check of checks) {
+    const icon = ICONS[check.status];
+    if (check.details) {
+      console.log(`${icon} ${check.label} — ${check.details}`);
+    } else {
+      console.log(`${icon} ${check.label}`);
+    }
+  }
+};
+
+export const runLocalDoctor = async () => {
+  const collector = createCollector();
+
+  const envExampleExists = existsSync('.env.example');
+  const secretFetcherExists = existsSync('.secret-fetcher');
+  const envExists = existsSync('.env');
+  const dockerComposeExists = existsSync('docker-compose.yml');
+  const certExists = existsSync('docker/certs/site.test.pem');
+  const certKeyExists = existsSync('docker/certs/site.key');
+  const laravelToolsConfigExists = existsSync('laravel-tools.yml');
+
+  collector.add(
+    envExampleExists ? 'ok' : 'fail',
+    '.env.example',
+    envExampleExists ? 'presente' : 'mancante'
+  );
+  collector.add(
+    secretFetcherExists ? 'ok' : 'fail',
+    '.secret-fetcher',
+    secretFetcherExists ? 'presente' : 'mancante'
+  );
+  collector.add(envExists ? 'ok' : 'warn', '.env', envExists ? 'presente' : 'mancante');
+  collector.add(
+    dockerComposeExists ? 'ok' : 'warn',
+    'docker-compose.yml',
+    dockerComposeExists ? 'presente' : 'mancante'
+  );
+  collector.add(
+    certExists && certKeyExists ? 'ok' : 'warn',
+    'Certificati locali (docker/certs/site.test.pem + site.key)',
+    certExists && certKeyExists ? 'presenti' : 'mancanti'
+  );
+  collector.add(
+    laravelToolsConfigExists ? 'ok' : 'warn',
+    'laravel-tools.yml',
+    laravelToolsConfigExists
+      ? 'presente (comandi remoti disponibili)'
+      : 'mancante (comandi remoti DB/cache non disponibili)'
+  );
+
+  const envExample = readEnvFile('.env.example');
+  if (!envExample) {
+    collector.add('fail', 'Parsing .env.example', 'impossibile leggere il file');
+  } else {
+    const required = ['APP_NAME', 'APP_URL', 'ASSETS_URL', 'DB_USERNAME', 'DB_PASSWORD'];
+    for (const key of required) {
+      collector.add(
+        envExample[key] ? 'ok' : 'fail',
+        `.env.example:${key}`,
+        envExample[key] ? 'ok' : 'mancante o vuoto'
+      );
+    }
+
+    const hasDbName = Boolean(envExample.DB_DATABASE || envExample.DB_NAME);
+    collector.add(
+      hasDbName ? 'ok' : 'fail',
+      '.env.example:DB_DATABASE/DB_NAME',
+      hasDbName ? 'ok' : 'entrambi mancanti o vuoti'
+    );
+  }
+
+  const env = readEnvFile('.env');
+  if (envExists && !env) {
+    collector.add('fail', 'Parsing .env', 'impossibile leggere il file');
+  }
+
+  const dockerAvailable = checkCommandAvailable('docker', ['compose', 'version']);
+  const mkcertAvailable = checkCommandAvailable('mkcert', ['-help']);
+  const composerAvailable = checkCommandAvailable('composer', ['--version']);
+  const sudoAvailable = checkCommandAvailable('sudo', ['--version']);
+
+  collector.add(
+    dockerAvailable ? 'ok' : 'fail',
+    'docker compose',
+    dockerAvailable ? 'disponibile' : 'non disponibile'
+  );
+  collector.add(
+    mkcertAvailable ? 'ok' : 'warn',
+    'mkcert',
+    mkcertAvailable ? 'disponibile' : 'non disponibile'
+  );
+  collector.add(
+    composerAvailable ? 'ok' : 'warn',
+    'composer',
+    composerAvailable ? 'disponibile' : 'non disponibile'
+  );
+  collector.add(
+    sudoAvailable ? 'ok' : 'warn',
+    'sudo',
+    sudoAvailable ? 'disponibile' : 'non disponibile'
+  );
+
+  if (dockerAvailable) {
+    const dockerDaemon = runCommand('docker', ['info']);
+    const daemonOk = dockerDaemon.status === 0;
+    collector.add(
+      daemonOk ? 'ok' : 'fail',
+      'Docker daemon',
+      daemonOk ? 'in esecuzione' : 'non raggiungibile'
+    );
+
+    const appName = env?.APP_NAME || envExample?.APP_NAME;
+    if (!appName) {
+      collector.add('warn', 'Container checks', 'APP_NAME non disponibile');
+    } else if (daemonOk) {
+      const apiState = checkDockerContainerState(`${appName}-api`);
+      const mysqlState = checkDockerContainerState(`${appName}-mysql`);
+
+      collector.add(
+        apiState.exists ? (apiState.running ? 'ok' : 'warn') : 'warn',
+        `${appName}-api`,
+        apiState.exists
+          ? apiState.running
+            ? 'container in esecuzione'
+            : 'container presente ma fermo'
+          : 'container non trovato'
+      );
+      collector.add(
+        mysqlState.exists ? (mysqlState.running ? 'ok' : 'warn') : 'warn',
+        `${appName}-mysql`,
+        mysqlState.exists
+          ? mysqlState.running
+            ? 'container in esecuzione'
+            : 'container presente ma fermo'
+          : 'container non trovato'
+      );
+    }
+  }
+
+  console.log('\n🩺 Local doctor report\n');
+  printResults(collector.getChecks());
+
+  const { ok, failures, warnings } = collector.counts();
+  console.log(`\n📊 Risultato: ${ok} ok, ${warnings} warning, ${failures} errori`);
+
+  if (failures > 0) {
+    throw new Error('Local doctor ha trovato errori bloccanti.');
+  }
+};