@fecommunity/reactpress 3.0.3 → 3.0.4

package/lib/docker.js

@@ -1,6 +1,9 @@
-const { spawn, execSync } = require('child_process');
+const fs = require('fs');
 const path = require('path');
+const { spawn, execSync, spawnSync } = require('child_process');
+const ora = require('ora');
 const { ensureOriginalCwd } = require('./root');
+const { detectProjectType, hasClient } = require('./project-type');
 const { t } = require('./i18n');
 
 function isDockerRunning() {
@@ -12,18 +15,58 @@ function isDockerRunning() {
   }
 }
 
+function pickDockerComposeCommand() {
+  const v2 = spawnSync('docker', ['compose', 'version'], { stdio: 'ignore' });
+  if (v2.status === 0) return { command: 'docker', baseArgs: ['compose'] };
+
+  const v1 = spawnSync('docker-compose', ['version'], { stdio: 'ignore' });
+  if (v1.status === 0) return { command: 'docker-compose', baseArgs: [] };
+
+  return { command: 'docker', baseArgs: ['compose'] };
+}
+
+/**
+ * Resolve which docker-compose file to use for the current project.
+ *
+ * - Monorepo checkouts use `docker-compose.dev.yml` at the repo root.
+ * - Standalone projects use `.reactpress/docker-compose.yml` (managed by init).
+ *
+ * @returns {{ composeFile: string, cwd: string, type: 'monorepo' | 'standalone' }}
+ */
+function resolveComposeContext(projectRoot) {
+  const type = detectProjectType(projectRoot);
+  if (type === 'monorepo') {
+    const composeFile = path.join(projectRoot, 'docker-compose.dev.yml');
+    if (fs.existsSync(composeFile)) {
+      return { composeFile, cwd: projectRoot, type };
+    }
+  }
+  const standaloneCompose = path.join(projectRoot, '.reactpress', 'docker-compose.yml');
+  if (fs.existsSync(standaloneCompose)) {
+    return { composeFile: standaloneCompose, cwd: path.dirname(standaloneCompose), type: 'standalone' };
+  }
+  const fallback = path.join(projectRoot, 'docker-compose.dev.yml');
+  return { composeFile: fallback, cwd: projectRoot, type };
+}
+
+function runCompose(args, ctx, options = {}) {
+  const { command, baseArgs } = pickDockerComposeCommand();
+  return spawnSync(
+    command,
+    [...baseArgs, '-f', ctx.composeFile, ...args],
+    { stdio: options.stdio ?? 'inherit', cwd: ctx.cwd, ...options }
+  );
+}
+
 function stopDockerServices(projectRoot) {
   console.log(t('docker.stopping'));
-  try {
-    execSync('docker-compose -f docker-compose.dev.yml down', {
-      stdio: 'inherit',
-      cwd: projectRoot,
-    });
-    console.log(t('docker.stopped'));
-  } catch (error) {
-    console.error(t('docker.stopFailed'), error.message);
-    throw error;
+  const ctx = resolveComposeContext(projectRoot);
+  const result = runCompose(['down'], ctx);
+  if (result.status !== 0) {
+    console.error(t('docker.stopFailed'));
+    throw new Error(t('docker.stopFailed'));
   }
+  console.log(t('docker.stopped'));
 }
 
 function startDockerServices(projectRoot) {
@@ -31,42 +74,86 @@ function startDockerServices(projectRoot) {
   if (!isDockerRunning()) {
     throw new Error(t('docker.notRunning'));
   }
-  execSync('docker-compose -f docker-compose.dev.yml up -d', {
-    stdio: 'inherit',
-    cwd: projectRoot,
-  });
+  try {
+    const { ensureNginxConfig } = require('./nginx');
+    const { configPath, created } = ensureNginxConfig(projectRoot, { mode: 'dev' });
+    if (created) {
+      console.log(t('nginx.configCreated', { path: configPath }));
+    }
+  } catch (err) {
+    console.warn(t('nginx.ensureWarn', { message: err.message || err }));
+  }
+  const ctx = resolveComposeContext(projectRoot);
+  const result = runCompose(['up', '-d'], ctx);
+  if (result.status !== 0) {
+    throw new Error(t('docker.notRunning'));
+  }
   console.log(t('docker.started'));
 }
 
-async function waitForMysql(maxAttempts = 30) {
-  console.log(t('docker.waitingMysql'));
+function resolveDbContainerName(ctx, projectRoot) {
+  if (ctx.type === 'standalone') return 'reactpress_cli_db';
+  return 'reactpress_db';
+}
+
+function resolveDbCredentialsFromEnv(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  let user = 'reactpress';
+  let password = 'reactpress';
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const u = content.match(/^DB_USER=(.+)$/m);
+    const p = content.match(/^(DB_PASSWD|DB_PASSWORD)=(.+)$/m);
+    if (u) user = u[1].trim().replace(/^['"]|['"]$/g, '');
+    if (p) password = p[2].trim().replace(/^['"]|['"]$/g, '');
+  } catch {
+    // ignore
+  }
+  return { user, password };
+}
+
+async function waitForMysql(projectRoot, maxAttempts = 30) {
+  const ctx = resolveComposeContext(projectRoot);
+  const container = resolveDbContainerName(ctx, projectRoot);
+  const { user, password } = resolveDbCredentialsFromEnv(projectRoot);
+
+  const spinner = ora({
+    text: t('docker.waitingMysql'),
+    color: 'magenta',
+    spinner: 'dots',
+  }).start();
+
   let attempts = 0;
   while (attempts < maxAttempts) {
-    try {
-      execSync('docker exec reactpress_db mysql -u reactpress -preactpress -e "SELECT 1"', {
-        stdio: 'ignore',
-      });
-      console.log(t('docker.mysqlReady'));
+    const probe = spawnSync(
+      'docker',
+      ['exec', container, 'mysql', `-u${user}`, `-p${password}`, '-e', 'SELECT 1'],
+      { stdio: 'ignore' }
+    );
+    if (probe.status === 0) {
+      spinner.succeed(t('docker.mysqlReady'));
       return true;
-    } catch {
-      attempts += 1;
-      if (attempts % 5 === 0) {
-        console.log(t('docker.waitingMysqlProgress', { attempts, max: maxAttempts }));
-      }
-      await new Promise((r) => setTimeout(r, 1000));
     }
+    attempts += 1;
+    spinner.text = t('docker.waitingMysqlProgress', { attempts, max: maxAttempts });
+    await new Promise((r) => setTimeout(r, 1000));
   }
-  console.error(t('docker.mysqlTimeout'));
+  spinner.fail(t('docker.mysqlTimeout'));
   return false;
 }
 
 async function dockerStartWithDev(projectRoot) {
   startDockerServices(projectRoot);
-  const ready = await waitForMysql();
+  const ready = await waitForMysql(projectRoot);
   if (!ready) {
     throw new Error(t('docker.mysqlNotReady'));
   }
 
+  if (!hasClient(projectRoot)) {
+    console.log(t('dev.standaloneHint'));
+    return;
+  }
+
   const { buildToolkit } = require('./dev');
   await buildToolkit(projectRoot);
 
@@ -108,39 +195,67 @@ async function dockerStartWithDev(projectRoot) {
   });
 }
 
+/**
+ * Run mysqldump inside the compose `db` container (MySQL image ships mysqldump).
+ * Used when the host has no `mysqldump` binary but Docker DB is running.
+ *
+ * @returns {{ ok: true, stdout: string } | { ok: false, stderr: string }}
+ */
+function mysqldumpFromDbContainer(projectRoot, { user, password, database }) {
+  const ctx = resolveComposeContext(projectRoot);
+  if (!fs.existsSync(ctx.composeFile)) {
+    return { ok: false, stderr: 'compose file missing' };
+  }
+  if (!isDockerRunning()) {
+    return { ok: false, stderr: 'docker not running' };
+  }
+  const container = resolveDbContainerName(ctx, projectRoot);
+  const res = spawnSync(
+    'docker',
+    ['exec', container, 'mysqldump', `-u${user}`, `-p${password}`, database],
+    { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 }
+  );
+  if (res.error) {
+    return { ok: false, stderr: res.error.message };
+  }
+  if (res.status !== 0) {
+    return { ok: false, stderr: res.stderr || res.stdout || `exit ${res.status}` };
+  }
+  return { ok: true, stdout: res.stdout };
+}
+
 async function runDockerCommand(command, projectRoot = ensureOriginalCwd(), extraArgs = []) {
+  const ctx = resolveComposeContext(projectRoot);
   switch (command) {
     case 'up':
       startDockerServices(projectRoot);
-      await waitForMysql();
+      await waitForMysql(projectRoot);
       return;
     case 'down':
+    case 'stop':
       stopDockerServices(projectRoot);
       return;
     case 'start':
       await dockerStartWithDev(projectRoot);
       return;
-    case 'stop':
-      stopDockerServices(projectRoot);
-      return;
     case 'restart':
       stopDockerServices(projectRoot);
       await new Promise((r) => setTimeout(r, 2000));
       startDockerServices(projectRoot);
-      await waitForMysql();
+      await waitForMysql(projectRoot);
       return;
-    case 'status':
-      execSync('docker-compose -f docker-compose.dev.yml ps', {
-        stdio: 'inherit',
-        cwd: projectRoot,
-      });
+    case 'status': {
+      const res = runCompose(['ps'], ctx);
+      if (res.status !== 0) {
+        throw new Error(t('docker.unknownCommand', { command: 'ps' }));
+      }
       return;
+    }
     case 'logs': {
-      const service = extraArgs[0] || '';
-      execSync(`docker-compose -f docker-compose.dev.yml logs -f ${service}`.trim(), {
-        stdio: 'inherit',
-        cwd: projectRoot,
-      });
+      const service = extraArgs[0];
+      const args = ['logs', '-f'];
+      if (service) args.push(service);
+      runCompose(args, ctx);
       return;
     }
     default:
@@ -154,4 +269,7 @@ module.exports = {
   stopDockerServices,
   waitForMysql,
   isDockerRunning,
+  resolveComposeContext,
+  pickDockerComposeCommand,
+  mysqldumpFromDbContainer,
 };

package/lib/doctor.js

@@ -2,9 +2,21 @@ const fs = require('fs');
 const net = require('net');
 const path = require('path');
 const { execSync } = require('child_process');
-const chalk = require('chalk');
+const ora = require('ora');
+const {
+  brand,
+  icon,
+  ok,
+  warn,
+  divider,
+  sectionHeader,
+  terminalWidth,
+  gradientText,
+  palette,
+} = require('../ui/theme');
 const { getHealthUrl, checkHealth } = require('./http');
 const { isDockerRunning } = require('./docker');
+const { checkNginx } = require('./nginx');
 const { envFileStatus } = require('./status');
 const { t } = require('./i18n');
 
@@ -64,6 +76,16 @@ async function checkPorts(projectRoot) {
   const env = parseEnv(projectRoot);
   const apiPort = parseInt(env.SERVER_PORT || '3002', 10);
   const clientPort = parseInt(env.CLIENT_PORT || '3001', 10);
+
+  const healthUrl = getHealthUrl(projectRoot);
+  const apiHealth = await checkHealth(healthUrl);
+  if (apiHealth.ok) {
+    return {
+      ok: true,
+      message: t('doctor.portOk', { apiPort, clientPort }),
+    };
+  }
+
   const [apiBusy, clientBusy] = await Promise.all([checkPort(apiPort), checkPort(clientPort)]);
   const issues = [];
   if (apiBusy) issues.push(t('doctor.portApiBusy', { port: apiPort }));
@@ -152,6 +174,21 @@ function checkPnpm() {
   }
 }
 
+async function runCheckWithSpinner(name, run) {
+  const spinner = ora({
+    text: t('doctor.checking', { name }),
+    color: 'magenta',
+    spinner: 'dots',
+  }).start();
+  const result = await run();
+  if (result.ok) {
+    spinner.stop();
+  } else {
+    spinner.stop();
+  }
+  return result;
+}
+
 async function runDoctor(projectRoot) {
   const env = envFileStatus(projectRoot);
   const checks = [
@@ -174,34 +211,53 @@ async function runDoctor(projectRoot) {
       }),
     },
     { name: 'Docker', run: () => checkDocker() },
+    { name: t('doctor.check.nginx'), run: () => checkNginx(projectRoot) },
     { name: t('doctor.check.ports'), run: () => checkPorts(projectRoot) },
     { name: t('doctor.check.database'), run: () => checkDatabase(projectRoot) },
     { name: t('doctor.check.api'), run: () => checkApiHealth(projectRoot) },
   ];
 
+  const w = Math.min(terminalWidth() - 4, 52);
+  const results = [];
+  const fixes = [];
+
   console.log('');
-  console.log(chalk.bold.cyan('  ReactPress Doctor'));
-  console.log(chalk.gray(t('doctor.project', { path: projectRoot })));
-  console.log(chalk.gray('  ─────────────────────────────────────'));
+  console.log(
+    `  ${gradientText(t('doctor.title'), [palette.primary, palette.accent], { bold: true })}  ${brand.dim(t('doctor.subtitle'))}`
+  );
+  console.log(`  ${brand.dim(t('doctor.project', { path: projectRoot }))}`);
+  console.log(`  ${divider(w)}`);
 
-  let failed = 0;
   for (const { name, run } of checks) {
-    const result = await run();
-    const icon = result.ok ? chalk.green('✓') : chalk.red('✗');
-    console.log(`  ${icon} ${chalk.bold(name)}  ${result.message}`);
+    const result = await runCheckWithSpinner(name, run);
+    results.push({ name, ...result });
+    const mark = result.ok ? icon.ok : icon.fail;
+    const msgColor = result.ok ? brand.dim : brand.warn;
+    console.log(`  ${mark}  ${brand.bold(name)}  ${msgColor(result.message)}`);
     if (!result.ok && result.fix) {
-      console.log(chalk.yellow(`      → ${result.fix}`));
-      failed += 1;
-    } else if (!result.ok) {
-      failed += 1;
+      fixes.push({ name, fix: result.fix });
     }
   }
 
-  console.log(chalk.gray('  ─────────────────────────────────────'));
+  const passed = results.filter((r) => r.ok).length;
+  const failed = results.length - passed;
+
+  console.log(`  ${divider(w)}`);
+  console.log(
+    `  ${brand.dim(t('doctor.summary', { passed, failed, total: results.length }))}`
+  );
+
   if (failed === 0) {
-    console.log(chalk.green(t('doctor.allPass')));
+    console.log(`  ${ok(t('doctor.allPass'))}`);
   } else {
-    console.log(chalk.yellow(t('doctor.failed', { count: failed })));
+    console.log(`  ${warn(t('doctor.failed', { count: failed }))}`);
+    if (fixes.length) {
+      console.log('');
+      console.log(sectionHeader(t('doctor.fixesHeader')));
+      for (const { name, fix } of fixes) {
+        console.log(`    ${brand.primary('→')}  ${brand.dim(name)}  ${brand.warn(fix)}`);
+      }
+    }
   }
   console.log('');
   return failed === 0 ? 0 : 1;

package/lib/http.js

@@ -50,13 +50,13 @@ function getHealthUrl(projectRoot) {
   return `${base}${prefix}/health`;
 }
 
-function checkHealth(url, timeoutMs = 3000) {
+function probeHttp(url, timeoutMs = 3000) {
   return new Promise((resolve) => {
     let parsed;
     try {
       parsed = new URL(url);
     } catch {
-      resolve({ ok: false });
+      resolve({ ok: false, statusCode: 0, data: null });
       return;
     }
     const port = parsed.port || (parsed.protocol === 'https:' ? 443 : 80);
@@ -87,13 +87,48 @@ function checkHealth(url, timeoutMs = 3000) {
     );
     req.on('timeout', () => {
       req.destroy();
-      resolve({ ok: false });
+      resolve({ ok: false, statusCode: 0, data: null });
     });
-    req.on('error', () => resolve({ ok: false }));
+    req.on('error', () => resolve({ ok: false, statusCode: 0, data: null }));
     req.end();
   });
 }
 
+/**
+ * Health probe: prefers `/api/health` JSON; falls back to API prefix (e.g. Swagger)
+ * for older bundled servers that omit the health route.
+ */
+async function checkHealth(url, timeoutMs = 3000) {
+  const primary = await probeHttp(url, timeoutMs);
+  if (primary.ok) return primary;
+
+  if (primary.statusCode === 404 || primary.statusCode === 0) {
+    try {
+      const parsed = new URL(url);
+      const prefix = parsed.pathname.replace(/\/health\/?$/, '') || '/api';
+      const candidates = [
+        `${parsed.origin}${prefix}/`,
+        `${parsed.origin}${prefix}`,
+        parsed.origin,
+      ];
+      for (const fallback of candidates) {
+        const alt = await probeHttp(fallback, timeoutMs);
+        if (alt.statusCode === 200) {
+          return {
+            ok: true,
+            statusCode: 200,
+            data: { status: 'ok', database: 'unknown' },
+          };
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return primary;
+}
+
 function isHttpResponding(url, timeoutMs = 2000) {
   return new Promise((resolve) => {
     let parsed;