@fecommunity/reactpress 2.0.0-beta-4-beta.1 → 3.0.0

package/lib/lifecycle.js

@@ -0,0 +1,160 @@
+const { spawn, spawnSync } = require('child_process');
+const { ensureProjectEnvironment } = require('./bootstrap');
+const { loadServerSiteUrl, waitForHttp } = require('./http');
+const {
+  getServerBin,
+  getServerDir,
+  isUsingMonorepoServer,
+  getPidFile,
+} = require('./paths');
+const { readPid, isProcessRunning, clearPidFile, writePid } = require('./process');
+const { getMonorepoRoot } = require('./root');
+const { t } = require('./i18n');
+
+async function ensureConfig(projectRoot) {
+  try {
+    await ensureProjectEnvironment(projectRoot);
+    return true;
+  } catch (err) {
+    console.error(t('dev.envFailed'), err.message || err);
+    return false;
+  }
+}
+
+function stopApi(projectRoot) {
+  const pid = readPid(projectRoot);
+  if (pid && isProcessRunning(pid)) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      console.log(t('lifecycle.apiStopped', { pid }));
+    } catch (err) {
+      console.warn(t('lifecycle.stopPidFailed', { pid }), err.message);
+    }
+  }
+  clearPidFile(projectRoot);
+}
+
+async function startApi(projectRoot, { wait = true } = {}) {
+  if (!(await ensureConfig(projectRoot))) {
+    return 1;
+  }
+
+  const existing = readPid(projectRoot);
+  if (existing && isProcessRunning(existing)) {
+    console.log(t('lifecycle.apiAlreadyRunning', { pid: existing }));
+    return 0;
+  }
+  clearPidFile(projectRoot);
+
+  if (!isUsingMonorepoServer()) {
+    console.warn(t('lifecycle.noServerSrc'));
+    const start = spawnSync('pnpm', ['exec', 'reactpress-cli', 'start'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+    return start.status ?? 1;
+  }
+
+  console.log(t('lifecycle.startingLocalApi'));
+  const child = spawn(process.execPath, [getServerBin()], {
+    cwd: getServerDir(),
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      REACTPRESS_ORIGINAL_CWD: projectRoot,
+    },
+  });
+
+  child.unref();
+  writePid(projectRoot, child.pid);
+  console.log(t('lifecycle.apiStartedBg', { pid: child.pid }));
+
+  if (!wait) {
+    return 0;
+  }
+
+  const serverUrl = loadServerSiteUrl(projectRoot);
+  const ready = await waitForHttp(serverUrl);
+  if (!ready) {
+    console.error(t('lifecycle.apiTimeout120', { url: serverUrl }));
+    return 1;
+  }
+  console.log(t('lifecycle.apiReady', { url: serverUrl }));
+  return 0;
+}
+
+async function statusApi(projectRoot) {
+  const pid = readPid(projectRoot);
+  const serverUrl = loadServerSiteUrl(projectRoot);
+  const { isHttpResponding } = require('./http');
+  const httpOk = await isHttpResponding(serverUrl);
+
+  const source = isUsingMonorepoServer()
+    ? t('lifecycle.source.monorepo')
+    : t('lifecycle.source.bundle');
+
+  console.log(t('lifecycle.apiStatusTitle'));
+  console.log(t('lifecycle.source', { source }));
+  console.log(t('lifecycle.pidFile', { path: getPidFile(projectRoot) }));
+  console.log(
+    t('lifecycle.recordedPid', {
+      pid: pid ?? t('common.none'),
+    })
+  );
+  console.log(
+    t('lifecycle.processAlive', {
+      alive: pid
+        ? isProcessRunning(pid)
+          ? t('common.yes')
+          : t('common.no')
+        : '—',
+    })
+  );
+  console.log(
+    t('lifecycle.httpStatus', {
+      url: serverUrl,
+      status: httpOk ? t('lifecycle.httpReachable') : t('lifecycle.httpUnreachable'),
+    })
+  );
+}
+
+async function runLifecycleCommand(command, projectRoot = process.env.REACTPRESS_ORIGINAL_CWD || getMonorepoRoot()) {
+  switch (command) {
+    case 'start':
+      return startApi(projectRoot, { wait: true });
+    case 'start:bg':
+      return startApi(projectRoot, { wait: false });
+    case 'stop':
+      stopApi(projectRoot);
+      if (!isUsingMonorepoServer()) {
+        spawnSync('pnpm', ['exec', 'reactpress-cli', 'stop'], {
+          cwd: projectRoot,
+          stdio: 'inherit',
+        });
+      }
+      return 0;
+    case 'restart':
+      stopApi(projectRoot);
+      if (!isUsingMonorepoServer()) {
+        spawnSync('pnpm', ['exec', 'reactpress-cli', 'restart'], {
+          cwd: projectRoot,
+          stdio: 'inherit',
+        });
+        return 0;
+      }
+      return startApi(projectRoot, { wait: true });
+    case 'status':
+      await statusApi(projectRoot);
+      return 0;
+    default:
+      throw new Error(t('lifecycle.unknownCommand', { command }));
+  }
+}
+
+module.exports = {
+  startApi,
+  stopApi,
+  statusApi,
+  runLifecycleCommand,
+};

package/lib/paths.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+const { getMonorepoRoot } = require('./root');
+
+function getMonorepoServerDir() {
+  return path.join(getMonorepoRoot(), 'server');
+}
+
+function hasMonorepoServerSource() {
+  return fs.existsSync(path.join(getMonorepoServerDir(), 'src', 'main.ts'));
+}
+
+function getCliPackageRoot() {
+  const ownRoot = path.join(__dirname, '..');
+  if (fs.existsSync(path.join(ownRoot, 'dist', 'index.js'))) {
+    return ownRoot;
+  }
+  try {
+    return path.dirname(
+      require.resolve('@fecommunity/reactpress-cli-core/package.json')
+    );
+  } catch {
+    return path.dirname(require.resolve('@fecommunity/reactpress-cli/package.json'));
+  }
+}
+
+function getBundledServerDir() {
+  return path.join(getCliPackageRoot(), 'server');
+}
+
+function getServerDir() {
+  if (hasMonorepoServerSource()) {
+    return getMonorepoServerDir();
+  }
+  return getBundledServerDir();
+}
+
+function getServerBin() {
+  return path.join(getServerDir(), 'bin', 'reactpress-server.js');
+}
+
+function getSwaggerPath() {
+  return path.join(getServerDir(), 'public', 'swagger.json');
+}
+
+function getServerMain() {
+  return path.join(getServerDir(), 'dist', 'main.js');
+}
+
+function isUsingMonorepoServer() {
+  return hasMonorepoServerSource();
+}
+
+function getClientBin() {
+  return path.join(getMonorepoRoot(), 'client', 'bin', 'reactpress-client.js');
+}
+
+function getPidFile(projectRoot) {
+  return path.join(projectRoot, '.reactpress', 'server.pid');
+}
+
+module.exports = {
+  getMonorepoRoot,
+  getMonorepoServerDir,
+  hasMonorepoServerSource,
+  isUsingMonorepoServer,
+  getCliPackageRoot,
+  getBundledServerDir,
+  getServerDir,
+  getServerBin,
+  getSwaggerPath,
+  getServerMain,
+  getClientBin,
+  getPidFile,
+};

package/lib/pm2.js

@@ -0,0 +1,32 @@
+const { spawn } = require('child_process');
+const { getServerBin, getServerDir } = require('./paths');
+const { ensureOriginalCwd } = require('./root');
+const { t } = require('./i18n');
+
+function startApiWithPm2(projectRoot = ensureOriginalCwd()) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [getServerBin(), '--pm2'], {
+      stdio: 'inherit',
+      cwd: getServerDir(),
+      env: {
+        ...process.env,
+        REACTPRESS_ORIGINAL_CWD: projectRoot,
+      },
+    });
+
+    child.on('error', (error) => {
+      console.error(t('pm2.startFailed'), error);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(Object.assign(new Error(t('pm2.exitCode', { code })), { exitCode: code }));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+module.exports = { startApiWithPm2 };

package/lib/process.js

@@ -0,0 +1,45 @@
+const fs = require('fs');
+const path = require('path');
+const { getPidFile } = require('./paths');
+
+function readPid(projectRoot) {
+  const pidFile = getPidFile(projectRoot);
+  try {
+    const raw = fs.readFileSync(pidFile, 'utf8').trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function clearPidFile(projectRoot) {
+  const pidFile = getPidFile(projectRoot);
+  if (fs.existsSync(pidFile)) {
+    fs.unlinkSync(pidFile);
+  }
+}
+
+function writePid(projectRoot, pid) {
+  const pidFile = getPidFile(projectRoot);
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, String(pid));
+}
+
+module.exports = {
+  readPid,
+  isProcessRunning,
+  clearPidFile,
+  writePid,
+  getPidFile,
+};

package/{scripts/reactpress-publish.js → lib/publish.js}

@@ -6,28 +6,30 @@ const path = require('path');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const crypto = require('crypto');
+const { t } = require('./i18n');
 
-// Package build order (dependencies first)
-const packages = [
+function getPackages() {
+  return [
   {
     name: '@fecommunity/reactpress',
-    path: '.',
-    description: 'Main ReactPress package'
+    path: 'cli',
+    description: t('publish.pkg.main')
   },
   {
-    name: '@fecommunity/reactpress-server', 
-    path: 'server',
-    description: 'Backend API server package'
+    name: '@fecommunity/reactpress-toolkit',
+    path: 'toolkit',
+    description: 'API client and utilities toolkit'
   },
   {
     name: '@fecommunity/reactpress-client',
-    path: 'client', 
+    path: 'client',
     description: 'Frontend application package'
   },
   {
-    name: '@fecommunity/reactpress-toolkit',
-    path: 'toolkit',
-    description: 'API client and utilities toolkit'
+    name: '@fecommunity/reactpress-server',
+    path: 'server',
+    description: t('publish.pkg.server'),
+    deprecated: true
   },
   {
     name: '@fecommunity/reactpress-template-hello-world',
@@ -40,6 +42,9 @@ const packages = [
     description: 'Twenty Twenty Five blog template for ReactPress'
   }
 ];
+}
+
+const packages = getPackages();
 
 // Generate a hash for a file or directory
 function generateHash(filePath) {
@@ -380,8 +385,6 @@ function buildPackage(pkg) {
     try {
       if (pkg.path === 'config') {
         execSync('pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
-      } else if (pkg.path === 'server') {
-        execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
       } else if (pkg.path === 'client') {
         execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
       } else if (pkg.path === 'toolkit') {
@@ -933,13 +936,17 @@ async function main() {
     // Default behavior - show help
     console.log(chalk.blue('🏗️  ReactPress CLI\n'));
     console.log('Usage:');
-    console.log('  node scripts/reactpress-cli.js --build    Build all packages');
-    console.log('  node scripts/reactpress-cli.js --publish  Publish packages (interactive)');
+    console.log('  reactpress publish --build     Build all packages');
+    console.log('  reactpress publish --publish   Publish packages (interactive)');
     console.log('');
   }
 }
 
-main().catch(error => {
-  console.error(chalk.red('❌ Operation failed:'), error);
-  process.exit(1);
-});
+module.exports = { main, buildPackages, publishPackages };
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(chalk.red('❌ Operation failed:'), error);
+    process.exit(1);
+  });
+}

package/lib/root.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const path = require('path');
+
+/** Monorepo root (parent of cli/) */
+function getMonorepoRoot() {
+  return path.resolve(__dirname, '../..');
+}
+
+function getProjectRoot() {
+  return path.resolve(process.env.REACTPRESS_ORIGINAL_CWD || process.cwd());
+}
+
+function ensureOriginalCwd() {
+  const root = getProjectRoot();
+  process.env.REACTPRESS_ORIGINAL_CWD = root;
+  return root;
+}
+
+function isMonorepoCheckout(cwd = getMonorepoRoot()) {
+  return (
+    fs.existsSync(path.join(cwd, 'pnpm-workspace.yaml')) ||
+    fs.existsSync(path.join(cwd, 'server', 'src', 'main.ts'))
+  );
+}
+
+module.exports = {
+  getMonorepoRoot,
+  getProjectRoot,
+  ensureOriginalCwd,
+  isMonorepoCheckout,
+};

package/lib/spawn.js

@@ -0,0 +1,91 @@
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const chalk = require('chalk');
+const { getMonorepoRoot } = require('./root');
+const { getCliPackageRoot } = require('./paths');
+const { t, resolveLocale } = require('./i18n');
+
+function runSync(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || getMonorepoRoot(),
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      REACTPRESS_LANG: process.env.REACTPRESS_LANG || resolveLocale(),
+      REACTPRESS_ORIGINAL_CWD:
+        options.cwd || process.env.REACTPRESS_ORIGINAL_CWD || process.cwd(),
+    },
+    shell: options.shell ?? false,
+  });
+  if (result.status !== 0) {
+    const err = new Error(
+      t('spawn.commandFailed', { command, code: result.status ?? 1 })
+    );
+    err.exitCode = result.status ?? 1;
+    throw err;
+  }
+  return result;
+}
+
+function runNodeScript(scriptPath, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath, ...args], {
+      stdio: 'inherit',
+      cwd: options.cwd || getMonorepoRoot(),
+      env: {
+        ...process.env,
+        REACTPRESS_LANG: process.env.REACTPRESS_LANG || resolveLocale(),
+        REACTPRESS_ORIGINAL_CWD:
+          options.cwd || process.env.REACTPRESS_ORIGINAL_CWD || process.cwd(),
+        ...options.env,
+      },
+    });
+
+    child.on('error', (error) => {
+      console.error(chalk.red('[ReactPress]'), error.message || error);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(Object.assign(new Error(t('spawn.exitCode', { code })), { exitCode: code }));
+        return;
+      }
+      resolve(code);
+    });
+  });
+}
+
+function spawnDetached(scriptPath, args = [], options = {}) {
+  const child = spawn(process.execPath, [scriptPath, ...args], {
+    stdio: options.stdio ?? 'ignore',
+    detached: true,
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      REACTPRESS_LANG: process.env.REACTPRESS_LANG || resolveLocale(),
+      REACTPRESS_ORIGINAL_CWD:
+        options.cwd || process.env.REACTPRESS_ORIGINAL_CWD || process.cwd(),
+      ...options.env,
+    },
+  });
+  child.unref();
+  return child;
+}
+
+function runReactpressCli(args, options = {}) {
+  const cliBin = path.join(getCliPackageRoot(), 'dist', 'index.js');
+  return runSync(process.execPath, [cliBin, ...args], options);
+}
+
+function resolveCliScript(relativePath) {
+  return path.join(__dirname, '..', relativePath);
+}
+
+module.exports = {
+  runSync,
+  runNodeScript,
+  spawnDetached,
+  runReactpressCli,
+  resolveCliScript,
+};

package/lib/status.js

@@ -0,0 +1,108 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const {
+  loadServerSiteUrl,
+  loadClientSiteUrl,
+  getHealthUrl,
+  checkHealth,
+  isHttpResponding,
+} = require('./http');
+const { isUsingMonorepoServer } = require('./paths');
+const { readPid, isProcessRunning } = require('./process');
+const { isDockerRunning } = require('./docker');
+const { ensureOriginalCwd } = require('./root');
+const { t } = require('./i18n');
+
+function envFileStatus(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  const configPath = path.join(projectRoot, '.reactpress', 'config.json');
+  return {
+    env: fs.existsSync(envPath),
+    config: fs.existsSync(configPath),
+    envPath,
+    configPath,
+  };
+}
+
+async function printUnifiedStatus(projectRoot = ensureOriginalCwd()) {
+  const env = envFileStatus(projectRoot);
+  const apiUrl = loadServerSiteUrl(projectRoot);
+  const clientUrl = loadClientSiteUrl(projectRoot);
+  const pid = readPid(projectRoot);
+  const healthUrl = getHealthUrl(projectRoot);
+  const [apiHttp, clientHttp, health] = await Promise.all([
+    isHttpResponding(apiUrl),
+    isHttpResponding(clientUrl),
+    checkHealth(healthUrl),
+  ]);
+
+  const apiSource = isUsingMonorepoServer()
+    ? t('status.apiSource.monorepo')
+    : t('status.apiSource.bundle');
+
+  console.log('');
+  console.log(chalk.bold.cyan(t('status.title')));
+  console.log(chalk.gray('  ─────────────────────────────────────'));
+  console.log(t('status.dir', { path: projectRoot }));
+  console.log(t('status.apiSource', { source: apiSource }));
+  console.log(
+    `  ${chalk.bold('Config')}    ${
+      env.config
+        ? chalk.green(t('status.configOk'))
+        : chalk.yellow(t('status.configBad'))
+    }`,
+  );
+  console.log(
+    `  ${chalk.bold('.env')}        ${
+      env.env ? chalk.green(t('status.envOk')) : chalk.yellow(t('status.envBad'))
+    }`,
+  );
+  console.log(chalk.gray('  ─────────────────────────────────────'));
+  console.log(chalk.bold('  API'));
+  console.log(`    URL       ${apiUrl}`);
+  console.log(
+    `    HTTP      ${
+      apiHttp ? chalk.green(t('status.apiOnline')) : chalk.red(t('status.apiOffline'))
+    }`,
+  );
+  console.log(
+    `    Health    ${
+      health.ok
+        ? chalk.green(`${healthUrl} ✓`)
+        : chalk.gray(t('status.apiUnreachable', { url: healthUrl }))
+    }`,
+  );
+  if (health.ok && health.data?.data) {
+    const db = health.data.data.database;
+    console.log(
+      `    Database  ${
+        db === 'up'
+          ? chalk.green(t('status.dbUp'))
+          : chalk.red(db === 'down' ? t('status.dbDown') : '—')
+      }`,
+    );
+  }
+  console.log(
+    `    PID       ${pid ?? '—'} ${
+      pid && isProcessRunning(pid) ? chalk.green(t('status.pidRunning')) : ''
+    }`,
+  );
+  console.log(chalk.bold(t('status.frontend')));
+  console.log(`    URL       ${clientUrl}`);
+  console.log(
+    `    HTTP      ${
+      clientHttp ? chalk.green(t('status.apiOnline')) : chalk.gray(t('status.apiOffline'))
+    }`,
+  );
+  console.log(chalk.gray('  ─────────────────────────────────────'));
+  console.log(chalk.bold(t('status.docker')));
+  console.log(
+    `    Engine    ${
+      isDockerRunning() ? chalk.green(t('status.dockerUp')) : chalk.red(t('status.dockerDown'))
+    }`,
+  );
+  console.log('');
+}
+
+module.exports = { printUnifiedStatus, envFileStatus };