@42wp/dev-env 1.0.4 → 1.0.6

package/README.md

@@ -76,6 +76,27 @@ pass `--force`.
 | `wpvip`               | clone + mount the VIP mu-plugins |
 | `initial_content`     | `true` (200 posts) or a number |
 
+### Project dependencies
+
+Before installing WordPress, `42wp start` installs the project's dependencies in
+your repo so WordPress and its mu-plugins load cleanly:
+
+- `composer install` — when `composer.json` is present
+- `<pm> install` — when `package.json` is present, where `<pm>` is inferred from the
+  lockfile: `pnpm-lock.yaml` → **pnpm**, `yarn.lock` → **yarn**, `package-lock.json`
+  → **npm** (defaults to npm)
+
+These run **on your machine**, in the mounted repo, before the containers start.
+**Composer is required**: if a project has a `composer.json` and its PHP
+dependencies can't be installed (composer missing, or the install fails), `start`
+stops — a project with unmet PHP deps would break during the WordPress install
+anyway. The JS install is best-effort (a missing tool or failure just warns). Skip
+the whole step with `--skip-deps`:
+
+```bash
+42wp start my-site --skip-deps
+```
+
 ### WordPress version
 
 By default projects are built on **`wordpress:php8.4-apache`** (newest WordPress,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@42wp/dev-env",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "42WP — a CLI to spin up disposable WordPress dev environments with Docker (Traefik + MySQL + per-project containers).",
   "type": "module",
   "bin": {

package/src/commands/start.js

@@ -15,6 +15,7 @@ import {
 } from '../lib/naming.js';
 import { projectDir } from '../lib/paths.js';
 import { readProjectConfig } from '../lib/projectConfig.js';
+import { installProjectDeps } from '../lib/deps.js';
 import {
   missingWpDirs,
   pathExists,
@@ -213,16 +214,42 @@ export async function start(rawName, opts = {}) {
     await fs.writeFile(path.join(envDir, 'dev-helper.php'), await readTemplate('dev-helper.php'), 'utf8');
   }
 
+  // 4d. Install the project's dependencies (composer / JS) on the host BEFORE the
+  //     containers start, so WordPress and its mu-plugins load cleanly during
+  //     install. Composer is required — if its deps can't be installed the project
+  //     would likely break during `wp core install`, so stop now. --skip-deps skips.
+  if (!opts['skip-deps']) {
+    try {
+      await installProjectDeps(repoDir);
+    } catch (err) {
+      error(err.message);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
   // 5. Build & start project containers.
   step(t('start.upping'));
   await compose(['up', '-d', '--build'], { cwd: envDir });
 
-  // 6. Wait for WP-CLI to answer inside the container (replaces `sleep 5`).
+  // 6. Wait for the WordPress core to be fully copied into the container before
+  //    installing. The wordpress image's entrypoint extracts core alphabetically,
+  //    so wp-includes/version.php lands BEFORE wp-settings.php — polling `wp core
+  //    version` alone can proceed mid-copy on slow disks (e.g. a VM), and then
+  //    `wp core install` fatals on a missing wp-settings.php. Waiting for
+  //    wp-settings.php (which `install` requires, and which comes after all of
+  //    wp-includes/) closes that window.
   step(t('start.waitingWp'));
   await pollUntil(
     async () => {
-      const { code } = await dockerExecCapture(container, ['wp', 'core', 'version', '--allow-root']);
-      return code === 0;
+      const settings = await dockerExecCapture(container, [
+        'test',
+        '-f',
+        '/var/www/html/wp-settings.php',
+      ]);
+      if (settings.code !== 0) return false;
+      const version = await dockerExecCapture(container, ['wp', 'core', 'version', '--allow-root']);
+      return version.code === 0;
     },
     { label: 'WordPress', timeout: 90000 },
   );

package/src/lib/deps.js

@@ -0,0 +1,69 @@
+// Installs a project's dependencies on the HOST (in the mounted repo) before the
+// WordPress install, so WordPress and its mu-plugins load cleanly. Best-effort: a
+// missing tool or a failed install warns and continues — it never aborts `start`.
+//
+// - PHP: `composer install` when composer.json is present. REQUIRED — a project
+//        whose PHP deps can't be installed would likely break during the WordPress
+//        install, so a missing composer or a failed install throws (aborts `start`).
+// - JS:  `<pm> install` when package.json is present, where <pm> is inferred from
+//        the lockfile (pnpm-lock.yaml -> pnpm, yarn.lock -> yarn, package-lock.json
+//        / npm-shrinkwrap.json -> npm), defaulting to npm. Best-effort (build
+//        assets don't block WordPress from booting), so it only warns on failure.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { run, capture } from './docker.js';
+import { step } from './log.js';
+import { t } from './i18n.js';
+
+// Infer the JS package manager from the repo's lockfile; default to npm.
+export function detectPackageManager(dir) {
+  if (fs.existsSync(path.join(dir, 'pnpm-lock.yaml'))) return 'pnpm';
+  if (fs.existsSync(path.join(dir, 'yarn.lock'))) return 'yarn';
+  if (fs.existsSync(path.join(dir, 'package-lock.json'))) return 'npm';
+  if (fs.existsSync(path.join(dir, 'npm-shrinkwrap.json'))) return 'npm';
+  return 'npm';
+}
+
+const has = (dir, name) => fs.existsSync(path.join(dir, name));
+
+// Is a host command available? (spawns `<cmd> --version`).
+async function toolAvailable(cmd) {
+  try {
+    const { code } = await capture(cmd, ['--version']);
+    return code === 0;
+  } catch {
+    return false; // ENOENT — not installed
+  }
+}
+
+// Run one dependency install (tool + args) in repoDir. When `required`, a missing
+// tool or a failed install throws (so the caller can abort); otherwise it warns.
+async function installWith(tool, args, repoDir, { required = false } = {}) {
+  if (!(await toolAvailable(tool))) {
+    if (required) throw new Error(t('deps.missingRequired', { tool }));
+    step(t('deps.missingTool', { tool }));
+    return;
+  }
+  step(t('deps.installing', { tool }));
+  try {
+    await run(tool, args, { cwd: repoDir });
+  } catch {
+    if (required) throw new Error(t('deps.failedRequired', { tool }));
+    step(t('deps.failed', { tool }));
+  }
+}
+
+// Install the project's PHP and JS dependencies on the host, in repoDir. Throws if
+// composer is required but unavailable/failing (caller aborts `start`).
+export async function installProjectDeps(repoDir) {
+  // Composer is required — a missing vendor/ autoload can fatal WordPress on load.
+  if (has(repoDir, 'composer.json')) {
+    await installWith('composer', ['install', '--no-interaction'], repoDir, { required: true });
+  }
+  // JS deps are best-effort (build assets, not needed for WordPress to boot).
+  if (has(repoDir, 'package.json')) {
+    await installWith(detectPackageManager(repoDir), ['install'], repoDir);
+  }
+}

package/src/locales/en.js

@@ -31,6 +31,13 @@ export default {
   'start.upping': 'Starting project containers...',
   'start.waitingWp': 'Waiting for the WordPress container to respond...',
   'start.installing': 'Running silent WordPress install...',
+  'deps.installing': 'Installing project dependencies (${tool})...',
+  'deps.failed': 'Could not install ${tool} dependencies (continuing anyway).',
+  'deps.missingTool': '${tool} not found on your machine — skipping. Install it and re-run to set up dependencies.',
+  'deps.missingRequired':
+    "${tool} is required to install this project's dependencies but was not found. Install ${tool} and re-run, or pass --skip-deps to skip.",
+  'deps.failedRequired':
+    'Failed to install ${tool} dependencies. Fix the error above and re-run, or pass --skip-deps to skip.',
   'start.installingLang': 'Installing WordPress language pack (${locale})...',
   'start.langFailed': 'Could not install the ${locale} language pack (continuing in English).',
   'start.activatingTheme': 'Activating theme (${theme})...',

package/src/locales/pt.js

@@ -31,6 +31,13 @@ export default {
   'start.upping': 'Subindo containers do projeto...',
   'start.waitingWp': 'Aguardando o container WP responder...',
   'start.installing': 'Executando instalação silenciosa do WordPress...',
+  'deps.installing': 'Instalando as dependências do projeto (${tool})...',
+  'deps.failed': 'Não foi possível instalar as dependências de ${tool} (continuando mesmo assim).',
+  'deps.missingTool': '${tool} não encontrado na sua máquina — pulando. Instale-o e rode novamente para configurar as dependências.',
+  'deps.missingRequired':
+    '${tool} é necessário para instalar as dependências deste projeto, mas não foi encontrado. Instale o ${tool} e rode novamente, ou use --skip-deps para pular.',
+  'deps.failedRequired':
+    'Falha ao instalar as dependências de ${tool}. Corrija o erro acima e rode novamente, ou use --skip-deps para pular.',
   'start.installingLang': 'Instalando o pacote de idioma do WordPress (${locale})...',
   'start.langFailed': 'Não foi possível instalar o pacote de idioma ${locale} (continuando em inglês).',
   'start.activatingTheme': 'Ativando o tema (${theme})...',