@fecommunity/reactpress 3.0.3 → 3.0.4

package/lib/nginx.js

@@ -0,0 +1,342 @@
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const { spawnSync } = require('child_process');
+const open = require('open');
+const { detectProjectType } = require('./project-type');
+const { isDockerRunning, pickDockerComposeCommand } = require('./docker');
+const { t } = require('./i18n');
+
+const NGINX_CONTAINER = 'reactpress_nginx';
+const DEFAULT_NGINX_PORT = 80;
+
+function resolveNginxMode(options = {}) {
+  return options.prod ? 'prod' : 'dev';
+}
+
+function resolveNginxConfigBasename(mode) {
+  return mode === 'prod' ? 'nginx.conf' : 'nginx.dev.conf';
+}
+
+function resolveNginxConfigPath(projectRoot, mode = 'dev') {
+  const basename = resolveNginxConfigBasename(mode);
+  const type = detectProjectType(projectRoot);
+  if (type === 'monorepo') {
+    return path.join(projectRoot, basename);
+  }
+  return path.join(projectRoot, '.reactpress', basename);
+}
+
+function bundledTemplatePath(mode) {
+  const file = mode === 'prod' ? 'nginx.prod.conf' : 'nginx.dev.conf';
+  return path.join(__dirname, '..', 'templates', file);
+}
+
+function resolveNginxPort(projectRoot) {
+  const envPath = path.join(projectRoot, '.env');
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    const m = content.match(/^NGINX_PORT=(.+)$/m);
+    if (m) {
+      const port = parseInt(m[1].trim().replace(/^['"]|['"]$/g, ''), 10);
+      if (port > 0) return port;
+    }
+  } catch {
+    // ignore
+  }
+  return DEFAULT_NGINX_PORT;
+}
+
+function nginxEntryUrl(projectRoot) {
+  const port = resolveNginxPort(projectRoot);
+  return port === 80 ? 'http://localhost' : `http://localhost:${port}`;
+}
+
+/**
+ * Write default nginx config from CLI templates when missing (or when force).
+ *
+ * @returns {{ configPath: string, created: boolean, mode: 'dev' | 'prod' }}
+ */
+function ensureNginxConfig(projectRoot, options = {}) {
+  const mode = resolveNginxMode(options);
+  const configPath = resolveNginxConfigPath(projectRoot, mode);
+  const templatePath = bundledTemplatePath(mode);
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(t('nginx.templateMissing', { path: templatePath }));
+  }
+
+  const exists = fs.existsSync(configPath);
+  if (exists && !options.force) {
+    return { configPath, created: false, mode };
+  }
+
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.copyFileSync(templatePath, configPath);
+  return { configPath, created: !exists || !!options.force, mode };
+}
+
+function resolveNginxComposeContext(projectRoot, mode = 'dev') {
+  const type = detectProjectType(projectRoot);
+  if (mode === 'prod' && type === 'monorepo') {
+    return {
+      composeFile: path.join(projectRoot, 'docker-compose.prod.yml'),
+      cwd: projectRoot,
+      service: 'nginx',
+    };
+  }
+  if (type === 'monorepo') {
+    return {
+      composeFile: path.join(projectRoot, 'docker-compose.dev.yml'),
+      cwd: projectRoot,
+      service: 'nginx',
+    };
+  }
+  return {
+    composeFile: path.join(projectRoot, '.reactpress', 'docker-compose.yml'),
+    cwd: path.join(projectRoot, '.reactpress'),
+    service: 'nginx',
+  };
+}
+
+function composeDefinesNginxService(composeFile) {
+  try {
+    const content = fs.readFileSync(composeFile, 'utf8');
+    return /^\s*nginx:\s*$/m.test(content);
+  } catch {
+    return false;
+  }
+}
+
+function runComposeOnContext(ctx, args, options = {}) {
+  const { command, baseArgs } = pickDockerComposeCommand();
+  return spawnSync(command, [...baseArgs, '-f', ctx.composeFile, ...args], {
+    stdio: options.stdio ?? 'inherit',
+    cwd: ctx.cwd,
+    ...options,
+  });
+}
+
+function isNginxContainerRunning() {
+  const res = spawnSync(
+    'docker',
+    ['inspect', '-f', '{{.State.Running}}', NGINX_CONTAINER],
+    { encoding: 'utf8' }
+  );
+  return res.status === 0 && res.stdout.trim() === 'true';
+}
+
+function startNginxContainer(configPath, port) {
+  spawnSync('docker', ['rm', '-f', NGINX_CONTAINER], { stdio: 'ignore' });
+  const absConfig = path.resolve(configPath);
+  const res = spawnSync(
+    'docker',
+    [
+      'run',
+      '-d',
+      '--name',
+      NGINX_CONTAINER,
+      '-p',
+      `${port}:80`,
+      '-v',
+      `${absConfig}:/etc/nginx/conf.d/default.conf:ro`,
+      '--add-host',
+      'host.docker.internal:host-gateway',
+      'nginx:alpine',
+    ],
+    { encoding: 'utf8' }
+  );
+  if (res.status !== 0) {
+    throw new Error(res.stderr?.trim() || t('nginx.startFailed'));
+  }
+}
+
+function stopNginxContainer() {
+  spawnSync('docker', ['rm', '-sf', NGINX_CONTAINER], { stdio: 'ignore' });
+}
+
+function nginxUp(projectRoot, options = {}) {
+  if (!isDockerRunning()) {
+    throw new Error(t('docker.notRunning'));
+  }
+
+  const mode = resolveNginxMode(options);
+  const type = detectProjectType(projectRoot);
+
+  if (mode === 'prod' && type !== 'monorepo') {
+    throw new Error(t('nginx.prodMonorepoOnly'));
+  }
+
+  const { configPath } = ensureNginxConfig(projectRoot, { mode, force: options.force });
+  const port = resolveNginxPort(projectRoot);
+  const ctx = resolveNginxComposeContext(projectRoot, mode);
+
+  if (fs.existsSync(ctx.composeFile) && composeDefinesNginxService(ctx.composeFile)) {
+    const result = runComposeOnContext(ctx, ['up', '-d', ctx.service]);
+    if (result.status !== 0) {
+      throw new Error(t('nginx.startFailed'));
+    }
+  } else {
+    startNginxContainer(configPath, port);
+  }
+
+  console.log(t('nginx.started', { url: nginxEntryUrl(projectRoot) }));
+  console.log(t('nginx.configPath', { path: configPath }));
+}
+
+function nginxDown(projectRoot, options = {}) {
+  const mode = resolveNginxMode(options);
+  const ctx = resolveNginxComposeContext(projectRoot, mode);
+  if (fs.existsSync(ctx.composeFile) && composeDefinesNginxService(ctx.composeFile)) {
+    runComposeOnContext(ctx, ['stop', ctx.service], { stdio: 'ignore' });
+  }
+  stopNginxContainer();
+  console.log(t('nginx.stopped'));
+}
+
+function nginxRestart(projectRoot, options = {}) {
+  nginxDown(projectRoot, options);
+  nginxUp(projectRoot, options);
+}
+
+function nginxStatus(projectRoot, options = {}) {
+  const mode = resolveNginxMode(options);
+  const configPath = resolveNginxConfigPath(projectRoot, mode);
+  const port = resolveNginxPort(projectRoot);
+  const running = isNginxContainerRunning();
+  const configExists = fs.existsSync(configPath);
+
+  console.log(t('nginx.statusTitle'));
+  console.log(t('nginx.statusContainer', { name: NGINX_CONTAINER, running: running ? t('common.yes') : t('common.no') }));
+  console.log(t('nginx.statusConfig', { path: configPath, exists: configExists ? t('common.yes') : t('common.no') }));
+  console.log(t('nginx.statusUrl', { url: nginxEntryUrl(projectRoot), port }));
+  console.log(t('nginx.statusMode', { mode }));
+}
+
+function nginxLogs(extraArgs = []) {
+  const args = ['logs', '-f', NGINX_CONTAINER, ...extraArgs];
+  spawnSync('docker', args, { stdio: 'inherit' });
+}
+
+function dockerExecNginx(args) {
+  return spawnSync('docker', ['exec', NGINX_CONTAINER, 'nginx', ...args], {
+    encoding: 'utf8',
+  });
+}
+
+function nginxTest() {
+  if (!isNginxContainerRunning()) {
+    throw new Error(t('nginx.notRunning'));
+  }
+  const res = dockerExecNginx(['-t']);
+  process.stdout.write(res.stdout || '');
+  process.stderr.write(res.stderr || '');
+  if (res.status !== 0) {
+    throw new Error(t('nginx.testFailed'));
+  }
+  console.log(t('nginx.testOk'));
+}
+
+function nginxReload() {
+  nginxTest();
+  const res = dockerExecNginx(['-s', 'reload']);
+  if (res.status !== 0) {
+    throw new Error(res.stderr?.trim() || t('nginx.reloadFailed'));
+  }
+  console.log(t('nginx.reloadOk'));
+}
+
+async function nginxOpen(projectRoot) {
+  const url = nginxEntryUrl(projectRoot);
+  console.log(t('nginx.opening', { url }));
+  await open(url);
+}
+
+function probeNginxHealth(projectRoot, timeoutMs = 2000) {
+  const url = new URL('/health', nginxEntryUrl(projectRoot));
+  return new Promise((resolve) => {
+    const req = http.get(url, { timeout: timeoutMs }, (res) => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+async function checkNginx(projectRoot) {
+  if (!isDockerRunning()) {
+    return { ok: true, message: t('nginx.doctorSkippedDocker') };
+  }
+  if (!isNginxContainerRunning()) {
+    return { ok: true, message: t('nginx.doctorSkippedNotRunning') };
+  }
+  const healthy = await probeNginxHealth(projectRoot);
+  if (healthy) {
+    return {
+      ok: true,
+      message: t('nginx.doctorOk', { url: nginxEntryUrl(projectRoot) }),
+    };
+  }
+  return {
+    ok: false,
+    message: t('nginx.doctorUnhealthy', { url: nginxEntryUrl(projectRoot) }),
+    fix: t('nginx.doctorUnhealthyFix'),
+  };
+}
+
+async function runNginxCommand(command, projectRoot, extraArgs = [], options = {}) {
+  switch (command) {
+    case 'ensure': {
+      const { configPath, created } = ensureNginxConfig(projectRoot, options);
+      console.log(
+        created ? t('nginx.configCreated', { path: configPath }) : t('nginx.configExists', { path: configPath })
+      );
+      return;
+    }
+    case 'up':
+      nginxUp(projectRoot, options);
+      return;
+    case 'down':
+    case 'stop':
+      nginxDown(projectRoot, options);
+      return;
+    case 'restart':
+      nginxRestart(projectRoot, options);
+      return;
+    case 'status':
+      nginxStatus(projectRoot, options);
+      return;
+    case 'logs':
+      nginxLogs(extraArgs);
+      return;
+    case 'test':
+      nginxTest();
+      return;
+    case 'reload':
+      nginxReload();
+      return;
+    case 'open':
+      await nginxOpen(projectRoot);
+      return;
+    default:
+      throw new Error(t('nginx.unknownCommand', { command }));
+  }
+}
+
+module.exports = {
+  NGINX_CONTAINER,
+  DEFAULT_NGINX_PORT,
+  resolveNginxMode,
+  resolveNginxConfigPath,
+  resolveNginxComposeContext,
+  ensureNginxConfig,
+  nginxEntryUrl,
+  resolveNginxPort,
+  isNginxContainerRunning,
+  probeNginxHealth,
+  checkNginx,
+  runNginxCommand,
+};

package/lib/project-type.js

@@ -0,0 +1,72 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Decide whether a given directory is a ReactPress monorepo checkout (with
+ * editable `server/src`, `client/`, `toolkit/`) or a standalone project that
+ * was created with `reactpress init` and relies on the bundled runtime.
+ *
+ * @param {string} root absolute project root
+ * @returns {'monorepo' | 'standalone' | 'unknown'}
+ */
+function detectProjectType(root) {
+  if (!root) return 'unknown';
+  const abs = path.resolve(root);
+
+  const monorepoMarkers = [
+    path.join(abs, 'pnpm-workspace.yaml'),
+    path.join(abs, 'server', 'src', 'main.ts'),
+  ];
+  if (monorepoMarkers.some((p) => fs.existsSync(p))) {
+    return 'monorepo';
+  }
+
+  if (fs.existsSync(path.join(abs, '.reactpress', 'config.json'))) {
+    return 'standalone';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * @param {string} root
+ */
+function hasClient(root) {
+  return fs.existsSync(path.join(root, 'client', 'package.json'));
+}
+
+/**
+ * @param {string} root
+ */
+function hasServerSource(root) {
+  return fs.existsSync(path.join(root, 'server', 'src', 'main.ts'));
+}
+
+/**
+ * @param {string} root
+ */
+function hasToolkit(root) {
+  return fs.existsSync(path.join(root, 'toolkit', 'package.json'));
+}
+
+/**
+ * @param {string} root
+ */
+function describeProject(root) {
+  const type = detectProjectType(root);
+  return {
+    type,
+    root,
+    hasClient: hasClient(root),
+    hasServerSource: hasServerSource(root),
+    hasToolkit: hasToolkit(root),
+  };
+}
+
+module.exports = {
+  detectProjectType,
+  describeProject,
+  hasClient,
+  hasServerSource,
+  hasToolkit,
+};

package/lib/publish.js

@@ -7,6 +7,15 @@ const chalk = require('chalk');
 const inquirer = require('inquirer');
 const crypto = require('crypto');
 const { t } = require('./i18n');
+const { getMonorepoRoot } = require('./root');
+
+function getWorkspaceRoot() {
+  const root = getMonorepoRoot();
+  if (fs.existsSync(path.join(root, 'pnpm-workspace.yaml'))) {
+    return root;
+  }
+  return process.cwd();
+}
 
 function getPackages() {
   return [
@@ -67,7 +76,7 @@ function generateHash(filePath) {
 
 // Get package content hash
 function getPackageHash(packagePath) {
-  const fullPath = path.join(process.cwd(), packagePath);
+  const fullPath = path.join(getWorkspaceRoot(), packagePath);
   return generateHash(fullPath);
 }
 
@@ -75,7 +84,7 @@ function getPackageHash(packagePath) {
 function hasMeaningfulChangesForBuild(packagePath, packageName) {
   try {
     // Create a hash file path to store previous hash in node_modules
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
+    const hashFilePath = path.join(getWorkspaceRoot(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
     
     // Generate current hash
     const currentHash = getPackageHash(packagePath);
@@ -98,7 +107,7 @@ function hasMeaningfulChangesForBuild(packagePath, packageName) {
 function hasMeaningfulChangesForPublish(packagePath, packageName) {
   try {
     // Create a hash file path to store previous hash in node_modules
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
+    const hashFilePath = path.join(getWorkspaceRoot(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
     
     // Generate current hash
     const currentHash = getPackageHash(packagePath);
@@ -120,7 +129,7 @@ function hasMeaningfulChangesForPublish(packagePath, packageName) {
 // Save package hash (for build)
 function savePackageHashForBuild(packagePath, packageName) {
   try {
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
+    const hashFilePath = path.join(getWorkspaceRoot(), 'node_modules', '.build-cache', `${packageName.replace('/', '_')}.hash`);
     
     // Ensure cache directory exists
     const cacheDir = path.dirname(hashFilePath);
@@ -139,7 +148,7 @@ function savePackageHashForBuild(packagePath, packageName) {
 // Save package hash (for publish)
 function savePackageHashForPublish(packagePath, packageName) {
   try {
-    const hashFilePath = path.join(process.cwd(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
+    const hashFilePath = path.join(getWorkspaceRoot(), 'node_modules', '.publish-cache', `${packageName.replace('/', '_')}.hash`);
     
     // Ensure cache directory exists
     const cacheDir = path.dirname(hashFilePath);
@@ -158,7 +167,7 @@ function savePackageHashForPublish(packagePath, packageName) {
 // Get current versions
 function getCurrentVersion(packagePath) {
   try {
-    const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+    const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
     return pkg.version;
   } catch (error) {
@@ -168,10 +177,12 @@ function getCurrentVersion(packagePath) {
 
 // Increment version based on type
 function incrementVersion(version, type) {
-  const parts = version.split('-')[0].split('.');
-  const major = parseInt(parts[0]);
-  const minor = parseInt(parts[1]);
-  const patch = parseInt(parts[2]);
+  const base = String(version).split('-')[0];
+  const parts = base.split('.').map((p) => parseInt(p, 10));
+  while (parts.length < 3) parts.push(0);
+  const major = Number.isFinite(parts[0]) ? parts[0] : 0;
+  const minor = Number.isFinite(parts[1]) ? parts[1] : 0;
+  const patch = Number.isFinite(parts[2]) ? parts[2] : 0;
   
   switch (type) {
     case 'major':
@@ -246,7 +257,7 @@ function getNextAvailableVersion(packageName, currentVersion, versionType) {
 function updateVersion(packagePath, newVersion) {
   console.log(chalk.blue(`\n✏️  Updating version to ${newVersion}...`));
   
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+  const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
   const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
   
   const oldVersion = pkg.version;
@@ -260,7 +271,7 @@ function updateVersion(packagePath, newVersion) {
 function fixWorkspaceDependenciesForBuild(packagePath) {
   console.log(chalk.blue(`🔧 Fixing workspace dependencies for build: ${packagePath}...`));
   
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+  const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
   const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
   
   // Fix dependencies
@@ -291,7 +302,7 @@ function fixWorkspaceDependenciesForBuild(packagePath) {
 function restoreWorkspaceDependenciesAfterBuild(packagePath) {
   console.log(chalk.blue(`🔄 Restoring workspace dependencies after build: ${packagePath}...`));
   
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+  const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
   const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
   
   // Restore dependencies
@@ -319,7 +330,7 @@ function restoreWorkspaceDependenciesAfterBuild(packagePath) {
 function fixWorkspaceDependenciesForPublish(packagePath, packageVersions) {
   console.log(chalk.blue(`🔧 Fixing workspace dependencies for publish: ${packagePath}...`));
   
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+  const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
   const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
   
   // Fix dependencies
@@ -350,7 +361,7 @@ function fixWorkspaceDependenciesForPublish(packagePath, packageVersions) {
 function restoreWorkspaceDependenciesAfterPublish(packagePath) {
   console.log(chalk.blue(`🔄 Restoring workspace dependencies for ${packagePath}...`));
   
-  const pkgPath = path.join(process.cwd(), packagePath, 'package.json');
+  const pkgPath = path.join(getWorkspaceRoot(), packagePath, 'package.json');
   const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
   
   // Restore dependencies
@@ -383,15 +394,22 @@ function buildPackage(pkg) {
     fixWorkspaceDependenciesForBuild(pkg.path);
     
     try {
-      if (pkg.path === 'config') {
-        execSync('pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
+      const pkgDir = path.join(getWorkspaceRoot(), pkg.path);
+      if (pkg.path === 'cli') {
+        execSync('node scripts/sync-bundled-core.mjs', { cwd: pkgDir, stdio: 'inherit' });
+        if (fs.existsSync(path.join(pkgDir, 'server', 'package.json'))) {
+          execSync('pnpm run build', { cwd: path.join(pkgDir, 'server'), stdio: 'inherit' });
+        }
+      } else if (pkg.path === 'server') {
+        execSync('pnpm run build', { cwd: pkgDir, stdio: 'inherit' });
       } else if (pkg.path === 'client') {
-        execSync('pnpm run prebuild && pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
+        execSync('pnpm run prebuild && pnpm run build', { cwd: pkgDir, stdio: 'inherit' });
       } else if (pkg.path === 'toolkit') {
-        execSync('pnpm run build', { cwd: path.join(process.cwd(), pkg.path), stdio: 'inherit' });
+        execSync('pnpm run build', { cwd: pkgDir, stdio: 'inherit' });
       } else if (pkg.path === 'templates/hello-world' || pkg.path === 'templates/twentytwentyfive') {
-        // Templates don't need to be built, just validate package.json
         console.log(chalk.gray('  Templates do not require building, skipping...'));
+      } else if (fs.existsSync(path.join(pkgDir, 'package.json'))) {
+        execSync('pnpm run build', { cwd: pkgDir, stdio: 'inherit' });
       }
       console.log(chalk.green(`✅ ${pkg.name} built successfully`));
     } finally {
@@ -410,7 +428,7 @@ function publishPackage(packagePath, packageName, tag = 'latest') {
   
   try {
     const command = `pnpm publish --access public --tag ${tag} --registry https://registry.npmjs.org --no-git-checks`;
-    execSync(command, { cwd: path.join(process.cwd(), packagePath), stdio: 'inherit' });
+    execSync(command, { cwd: path.join(getWorkspaceRoot(), packagePath), stdio: 'inherit' });
     console.log(chalk.green(`✅ ${packageName} published successfully!`));
   } catch (error) {
     console.log(chalk.red(`❌ Failed to publish ${packageName}`));
@@ -472,7 +490,7 @@ async function buildPackages() {
     
     // Check for meaningful changes in each package
     for (const pkg of packages) {
-      if (fs.existsSync(path.join(process.cwd(), pkg.path))) {
+      if (fs.existsSync(path.join(getWorkspaceRoot(), pkg.path))) {
         if (hasMeaningfulChangesForBuild(pkg.path, pkg.name)) {
           packagesToBuild.push(pkg);
           console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be built`));
@@ -552,7 +570,7 @@ async function publishPackages() {
     
     // Check for meaningful changes in each package
     for (const pkg of packages) {
-      if (fs.existsSync(path.join(process.cwd(), pkg.path))) {
+      if (fs.existsSync(path.join(getWorkspaceRoot(), pkg.path))) {
         if (hasMeaningfulChangesForPublish(pkg.path, pkg.name)) {
           packagesToBuild.push(pkg);
           console.log(chalk.blue(`\n📦 ${pkg.name} has changes, will be built`));
@@ -569,17 +587,15 @@ async function publishPackages() {
       return;
     }
     
-    // Build packages that have changes
     for (const pkg of packagesToBuild) {
-      buildPackage(pkg);
-      // Save the hash after successful build
+      await buildPackage(pkg);
       savePackageHashForPublish(pkg.path, pkg.name);
     }
-    
+
     console.log(chalk.green(`\n🎉 ${packagesToBuild.length} package(s) built successfully!`));
     return;
   }
-  
+
   if (action === 'publish-one') {
     const { selectedPackage } = await inquirer.prompt([
       {
@@ -706,7 +722,7 @@ async function publishPackages() {
     
     // Check for meaningful changes in each package
     for (const pkg of packages) {
-      if (!fs.existsSync(path.join(process.cwd(), pkg.path))) {
+      if (!fs.existsSync(path.join(getWorkspaceRoot(), pkg.path))) {
         console.log(chalk.yellow(`⚠️  Package ${pkg.name} directory not found, skipping...`));
         continue;
       }
@@ -845,7 +861,7 @@ async function publishPackages() {
     
     // Check for meaningful changes in each package
     for (const pkg of packages) {
-      if (!fs.existsSync(path.join(process.cwd(), pkg.path))) {
+      if (!fs.existsSync(path.join(getWorkspaceRoot(), pkg.path))) {
         console.log(chalk.yellow(`⚠️  Package ${pkg.name} directory not found, skipping...`));
         continue;
       }