@fecommunity/reactpress-cli 0.1.0 → 0.2.1

package/lib/docker.js

@@ -0,0 +1,156 @@
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const { ensureOriginalCwd } = require('./root');
+
+function isDockerRunning() {
+  try {
+    execSync('docker info', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function stopDockerServices(projectRoot) {
+  console.log('[reactpress] 正在停止 Docker 服务…');
+  try {
+    execSync('docker-compose -f docker-compose.dev.yml down', {
+      stdio: 'inherit',
+      cwd: projectRoot,
+    });
+    console.log('[reactpress] Docker 服务已停止。');
+  } catch (error) {
+    console.error('[reactpress] 停止 Docker 失败:', error.message);
+    throw error;
+  }
+}
+
+function startDockerServices(projectRoot) {
+  console.log('[reactpress] 正在启动 Docker 服务…');
+  if (!isDockerRunning()) {
+    throw new Error('Docker 未运行，请先启动 Docker Desktop。');
+  }
+  execSync('docker-compose -f docker-compose.dev.yml up -d', {
+    stdio: 'inherit',
+    cwd: projectRoot,
+  });
+  console.log('[reactpress] Docker 服务已启动。');
+}
+
+async function waitForMysql(maxAttempts = 30) {
+  console.log('[reactpress] 等待 MySQL 就绪…');
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    try {
+      execSync('docker exec reactpress_db mysql -u reactpress -preactpress -e "SELECT 1"', {
+        stdio: 'ignore',
+      });
+      console.log('[reactpress] MySQL 已就绪。');
+      return true;
+    } catch {
+      attempts += 1;
+      if (attempts % 5 === 0) {
+        console.log(`[reactpress] 等待 MySQL… (${attempts}/${maxAttempts})`);
+      }
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+  }
+  console.error('[reactpress] MySQL 在超时时间内未就绪。');
+  return false;
+}
+
+async function dockerStartWithDev(projectRoot) {
+  startDockerServices(projectRoot);
+  const ready = await waitForMysql();
+  if (!ready) {
+    throw new Error('MySQL 未就绪');
+  }
+
+  const { buildToolkit } = require('./dev');
+  await buildToolkit(projectRoot);
+
+  const apiRunner = path.join(__dirname, 'api-dev-runner.js');
+  console.log('[reactpress] 启动 API + 前端 (Docker MySQL)…');
+  console.log('[reactpress] 访问: http://localhost:8080 (nginx) / http://localhost:3001 (client)');
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(
+      'npx',
+      [
+        'concurrently',
+        '-n',
+        'api,web',
+        '-c',
+        'blue,green',
+        `node "${apiRunner}"`,
+        'pnpm run --dir ./client dev',
+      ],
+      {
+        stdio: 'inherit',
+        shell: true,
+        cwd: projectRoot,
+        env: {
+          ...process.env,
+          REACTPRESS_ORIGINAL_CWD: projectRoot,
+        },
+      }
+    );
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(Object.assign(new Error(`开发进程退出: ${code}`), { exitCode: code }));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+async function runDockerCommand(command, projectRoot = ensureOriginalCwd(), extraArgs = []) {
+  switch (command) {
+    case 'up':
+      startDockerServices(projectRoot);
+      await waitForMysql();
+      return;
+    case 'down':
+      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();
+      return;
+    case 'status':
+      execSync('docker-compose -f docker-compose.dev.yml ps', {
+        stdio: 'inherit',
+        cwd: projectRoot,
+      });
+      return;
+    case 'logs': {
+      const service = extraArgs[0] || '';
+      execSync(`docker-compose -f docker-compose.dev.yml logs -f ${service}`.trim(), {
+        stdio: 'inherit',
+        cwd: projectRoot,
+      });
+      return;
+    }
+    default:
+      throw new Error(`未知 docker 命令: ${command}`);
+  }
+}
+
+module.exports = {
+  runDockerCommand,
+  startDockerServices,
+  stopDockerServices,
+  waitForMysql,
+  isDockerRunning,
+};

package/lib/http.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const http = require('http');
+const path = require('path');
+
+function loadServerSiteUrl(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const match = content.match(/^SERVER_SITE_URL=(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // ignore
+  }
+  return 'http://localhost:3002';
+}
+
+function loadClientSiteUrl(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const match = content.match(/^CLIENT_SITE_URL=(.+)$/m);
+    if (match) {
+      return match[1].trim().replace(/^['"]|['"]$/g, '');
+    }
+  } catch {
+    // ignore
+  }
+  return 'http://localhost:3001';
+}
+
+function isHttpResponding(url, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      resolve(false);
+      return;
+    }
+
+    const port = parsed.port || (parsed.protocol === 'https:' ? 443 : 80);
+    const req = http.request(
+      {
+        hostname: parsed.hostname,
+        port,
+        path: parsed.pathname || '/',
+        method: 'GET',
+        timeout: timeoutMs,
+      },
+      (res) => resolve(res.statusCode > 0)
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+    req.on('error', () => resolve(false));
+    req.end();
+  });
+}
+
+async function waitForHttp(url, timeoutMs = 120_000, intervalMs = 500) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await isHttpResponding(url)) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return false;
+}
+
+module.exports = {
+  loadServerSiteUrl,
+  loadClientSiteUrl,
+  isHttpResponding,
+  waitForHttp,
+};

package/lib/lifecycle.js

@@ -0,0 +1,138 @@
+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');
+
+async function ensureConfig(projectRoot) {
+  try {
+    await ensureProjectEnvironment(projectRoot);
+    return true;
+  } catch (err) {
+    console.error('[reactpress] 环境准备失败:', err.message || err);
+    return false;
+  }
+}
+
+function stopApi(projectRoot) {
+  const pid = readPid(projectRoot);
+  if (pid && isProcessRunning(pid)) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      console.log(`[reactpress] 已停止 API 进程 (pid ${pid})`);
+    } catch (err) {
+      console.warn(`[reactpress] 停止 pid ${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(`[reactpress] API 已在运行 (pid ${existing})`);
+    return 0;
+  }
+  clearPidFile(projectRoot);
+
+  if (!isUsingMonorepoServer()) {
+    console.warn('[reactpress] 未检测到 server/src，回退到 reactpress-cli start');
+    const start = spawnSync('pnpm', ['exec', 'reactpress-cli', 'start'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+    return start.status ?? 1;
+  }
+
+  console.log('[reactpress] 正在启动本地 API (server/)…');
+  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(`[reactpress] API 已后台启动 (pid ${child.pid})`);
+
+  if (!wait) {
+    return 0;
+  }
+
+  const serverUrl = loadServerSiteUrl(projectRoot);
+  const ready = await waitForHttp(serverUrl);
+  if (!ready) {
+    console.error(`[reactpress] API 在 120s 内未就绪: ${serverUrl}`);
+    return 1;
+  }
+  console.log(`[reactpress] API 已就绪: ${serverUrl}`);
+  return 0;
+}
+
+async function statusApi(projectRoot) {
+  const pid = readPid(projectRoot);
+  const serverUrl = loadServerSiteUrl(projectRoot);
+  const { isHttpResponding } = require('./http');
+  const httpOk = await isHttpResponding(serverUrl);
+
+  console.log('[reactpress] API 状态');
+  console.log(`  来源: ${isUsingMonorepoServer() ? 'monorepo server/' : 'reactpress-cli bundle'}`);
+  console.log(`  PID 文件: ${getPidFile(projectRoot)}`);
+  console.log(`  记录 PID: ${pid ?? '(无)'}`);
+  console.log(`  进程存活: ${pid ? (isProcessRunning(pid) ? '是' : '否') : '—'}`);
+  console.log(`  HTTP (${serverUrl}): ${httpOk ? '可访问' : '不可访问'}`);
+}
+
+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(`未知 lifecycle 命令: ${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,31 @@
+const { spawn } = require('child_process');
+const { getServerBin, getServerDir } = require('./paths');
+const { ensureOriginalCwd } = require('./root');
+
+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('[reactpress] PM2 启动 API 失败:', error);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(Object.assign(new Error(`PM2 退出码 ${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,
+};