@fecommunity/reactpress 2.0.0-beta.0 → 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,
+};