@42wp/dev-env 1.0.0

package/src/commands/start.js

@@ -0,0 +1,236 @@
+// `42wp start <project>` — port of start_project from 42script.sh.
+// Creates the DB, generates wp-config.php / Dockerfile / docker-compose.yml,
+// builds & starts the project containers, then runs a silent WordPress install.
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  normalizeName,
+  validateName,
+  dbName,
+  domain,
+  containerName,
+  routerRule,
+} from '../lib/naming.js';
+import { projectDir } from '../lib/paths.js';
+import { renderTemplate, render, readTemplate } from '../lib/render.js';
+import { fetchSalts } from '../lib/salts.js';
+import { run, compose, dockerExec, dockerExecCapture } from '../lib/docker.js';
+import { runSeeder } from '../lib/seeder.js';
+import { pollUntil } from '../lib/wait.js';
+import { step, success, plain, error, colors } from '../lib/log.js';
+import { t } from '../lib/i18n.js';
+import {
+  resolveWpTag,
+  wpImage,
+  multisiteConfig,
+  resolveDemoCount,
+  DEFAULT_ADMIN_USER,
+  DEFAULT_ADMIN_PASS,
+  VIP_MU_PLUGINS_REPO,
+} from '../lib/config.js';
+import { ensureDockerRunning, checkGlobalLayer } from './global.js';
+
+const ADMIN_EMAIL = 'dev@42wp.localhost';
+
+// Clone (or update) the VIP mu-plugins into <envDir>/mu-plugins; it gets mounted
+// into the container at wp-content/mu-plugins. Shallow + single-branch — the
+// prebuilt repo is large and we only need the working tree.
+async function ensureVipMuPlugins(envDir) {
+  const muDir = path.join(envDir, 'mu-plugins');
+  try {
+    await fs.access(path.join(muDir, '.git'));
+    step(t('start.vipUpdating'));
+    await run('git', ['-C', muDir, 'pull', '--ff-only']);
+  } catch {
+    step(t('start.vipCloning', { repo: VIP_MU_PLUGINS_REPO }));
+    await run('git', ['clone', '--depth', '1', '--single-branch', VIP_MU_PLUGINS_REPO, muDir]);
+  }
+}
+
+export async function start(rawName, opts = {}) {
+  if (!rawName) {
+    error(t('start.needName'));
+    process.exitCode = 1;
+    return;
+  }
+
+  // The repo the user is sitting in becomes the container's wp-content.
+  const repoDir = process.cwd();
+
+  const name = normalizeName(rawName);
+  validateName(name);
+
+  const dom = domain(name);
+  const db = dbName(name);
+  const container = containerName(db);
+  const envDir = projectDir(name);
+  const adminUser = opts.user || DEFAULT_ADMIN_USER;
+  const adminPass = opts.pass || DEFAULT_ADMIN_PASS;
+  // --subdomains implies multisite; without it, --multisite is subdirectory mode.
+  const subdomains = !!opts.subdomains;
+  const multisite = !!opts.multisite || subdomains;
+  const demoCount = resolveDemoCount(opts['demo-content']); // null when not requested
+
+  if (!(await ensureDockerRunning())) return;
+  await checkGlobalLayer();
+
+  step(t('start.preparing', { domain: dom }));
+  await fs.mkdir(envDir, { recursive: true });
+
+  // 1. Database on the global MySQL.
+  step(t('start.creatingDb', { db }));
+  await dockerExec('42wp_mysql', [
+    'mysql',
+    '-uroot',
+    '-proot',
+    '-e',
+    `CREATE DATABASE IF NOT EXISTS \`${db}\`;`,
+  ]);
+
+  // 2. Ephemeral wp-config.php. The multisite constants are added later (step 7b),
+  //    AFTER the network tables exist — defining MULTISITE before they're created
+  //    would break wp-cli's bootstrap. For now write it without them.
+  step(t('start.genConfig'));
+  const { salts, fromFallback } = await fetchSalts();
+  if (fromFallback) step(t('start.saltsFallback'));
+  const wpConfigPath = path.join(envDir, 'wp-config.php');
+  const wpConfigTemplate = await readTemplate('wp-config.php');
+  const writeWpConfig = (multisiteBlock) =>
+    fs.writeFile(
+      wpConfigPath,
+      render(wpConfigTemplate, { DB_NAME: db, WP_SALTS: salts, MULTISITE_CONFIG: multisiteBlock }),
+      'utf8',
+    );
+  await writeWpConfig('');
+
+  // 3. Dockerfile (FROM the resolved WordPress image tag).
+  const wpTag = resolveWpTag(opts.wp);
+  step(t('start.genDockerfile', { image: wpImage(wpTag) }));
+  const dockerfile = await renderTemplate('project.Dockerfile', { WP_TAG: wpTag });
+  await fs.writeFile(path.join(envDir, 'Dockerfile'), dockerfile, 'utf8');
+
+  // 4. Project docker-compose.yml. Extra bind mounts: VIP mu-plugins (--vip) and a
+  //    multisite .htaccess (wp-cli won't write network rewrite rules itself).
+  step(t('start.genCompose'));
+  const extraVolumeLines = [];
+  if (opts.vip) {
+    extraVolumeLines.push('      - ./mu-plugins:/var/www/html/wp-content/mu-plugins');
+    // Dev-helper mu-plugin (loads admin media includes). Mounted as a top-level
+    // mu-plugin so WordPress auto-loads it; the 00- prefix loads it first.
+    extraVolumeLines.push(
+      '      - ./dev-helper.php:/var/www/html/wp-content/mu-plugins/00-42wp-dev.php',
+    );
+  }
+  if (multisite) extraVolumeLines.push('      - ./.htaccess:/var/www/html/.htaccess');
+  const extraVolumes = extraVolumeLines.length ? `\n${extraVolumeLines.join('\n')}` : '';
+  const projectCompose = await renderTemplate('project.docker-compose.yml', {
+    DB_NAME: db,
+    DOMAIN: dom,
+    REPO_DIR: repoDir,
+    EXTRA_VOLUMES: extraVolumes,
+    // docker compose treats $ as interpolation, so a literal $ (the regex anchor)
+    // must be written as $$.
+    ROUTER_RULE: routerRule(dom, { subdomains }).split('$').join('$$'),
+  });
+  await fs.writeFile(path.join(envDir, 'docker-compose.yml'), projectCompose, 'utf8');
+
+  // 4b. Multisite needs custom rewrite rules; provide them via a mounted .htaccess
+  //     (written before `up` so the bind-mount source exists).
+  if (multisite) {
+    const htTemplate = subdomains ? 'htaccess.multisite-subdomain' : 'htaccess.multisite-subdir';
+    await fs.writeFile(path.join(envDir, '.htaccess'), await readTemplate(htTemplate), 'utf8');
+  }
+
+  // 4c. WordPress VIP: clone the mu-plugins and write the dev-helper mu-plugin
+  //     before bringing the container up (so both mount sources exist).
+  if (opts.vip) {
+    await ensureVipMuPlugins(envDir);
+    await fs.writeFile(path.join(envDir, 'dev-helper.php'), await readTemplate('dev-helper.php'), 'utf8');
+  }
+
+  // 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`).
+  step(t('start.waitingWp'));
+  await pollUntil(
+    async () => {
+      const { code } = await dockerExecCapture(container, ['wp', 'core', 'version', '--allow-root']);
+      return code === 0;
+    },
+    { label: 'WordPress', timeout: 90000 },
+  );
+
+  // 7. Silent install of the base single site.
+  step(t('start.installing'));
+  await dockerExec(container, [
+    'wp',
+    'core',
+    'install',
+    `--url=http://${dom}`,
+    `--title=Dev: ${dom}`,
+    `--admin_user=${adminUser}`,
+    `--admin_password=${adminPass}`,
+    `--admin_email=${ADMIN_EMAIL}`,
+    '--skip-email',
+    '--skip-plugins',
+    '--skip-themes',
+    '--allow-root',
+  ]);
+
+  // 7b. Multisite: create the network tables while WP is still single-site
+  //     (--skip-config: we manage wp-config ourselves), then enable the MULTISITE
+  //     constants. Order matters — the constants must come AFTER the tables exist.
+  if (multisite) {
+    step(t('start.enablingMultisite'));
+    const conv = await dockerExecCapture(container, [
+      'wp',
+      'core',
+      'multisite-convert',
+      '--skip-config',
+      ...(subdomains ? ['--subdomains'] : []),
+      `--title=Dev: ${dom}`,
+      '--allow-root',
+    ]);
+    // Tolerate an already-converted network so re-running `start` is idempotent.
+    if (conv.code !== 0 && !/already/i.test(`${conv.stdout}\n${conv.stderr}`)) {
+      throw new Error(conv.stderr || conv.stdout || 'wp core multisite-convert failed');
+    }
+    await writeWpConfig(multisiteConfig(dom, { subdomains }));
+  }
+
+  // 8. Pretty permalinks.
+  step(t('start.permalinks'));
+  await dockerExec(container, [
+    'wp',
+    'rewrite',
+    'structure',
+    '/%postname%/',
+    '--hard',
+    '--allow-root',
+  ]);
+
+  // 9. Optional demo content (--demo-content[=<n>]) — always creates, never fatal.
+  if (demoCount) {
+    step(t('start.demoGenerating', { count: demoCount }));
+    try {
+      await runSeeder(container, demoCount);
+    } catch {
+      step(t('start.demoFailed'));
+    }
+  }
+
+  const url = `http://${dom}`;
+  success(t('start.success'));
+  plain(colors.green(t('start.url', { url })));
+  plain(colors.green(t('start.admin', { url })));
+  plain(colors.green(t('start.user', { user: adminUser })));
+  plain(colors.green(t('start.pass', { pass: adminPass })));
+  if (multisite) {
+    const mode = subdomains ? 'subdomain' : 'subdirectory';
+    plain(colors.green(t('start.multisite', { mode, url })));
+  }
+}

package/src/commands/stop.js

@@ -0,0 +1,32 @@
+// `42wp stop <project>` — port of stop_project from 42script.sh.
+
+import fs from 'node:fs/promises';
+
+import { normalizeName, validateName } from '../lib/naming.js';
+import { projectDir } from '../lib/paths.js';
+import { compose } from '../lib/docker.js';
+import { step, error } from '../lib/log.js';
+import { t } from '../lib/i18n.js';
+
+export async function stop(rawName) {
+  if (!rawName) {
+    error(t('stop.needName'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const name = normalizeName(rawName);
+  validateName(name);
+  const envDir = projectDir(name);
+
+  try {
+    await fs.access(envDir);
+  } catch {
+    error(t('stop.notFound', { name, dir: envDir }));
+    process.exitCode = 1;
+    return;
+  }
+
+  step(t('stop.stopping', { name }));
+  await compose(['down'], { cwd: envDir });
+}

package/src/commands/update.js

@@ -0,0 +1,78 @@
+// `42wp update <project> [--wp <tag>]` — update an existing project to a newer
+// WordPress image. Regenerates the project's Dockerfile with the resolved tag,
+// re-pulls the base image, rebuilds & recreates the container, then runs
+// `wp core update-db` to migrate the database schema to the new core.
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { normalizeName, validateName, dbName, containerName } from '../lib/naming.js';
+import { projectDir } from '../lib/paths.js';
+import { renderTemplate } from '../lib/render.js';
+import { compose, dockerExec, dockerExecCapture } from '../lib/docker.js';
+import { pollUntil } from '../lib/wait.js';
+import { step, success, error } from '../lib/log.js';
+import { t } from '../lib/i18n.js';
+import { resolveWpTag, wpImage } from '../lib/config.js';
+import { ensureDockerRunning, checkGlobalLayer } from './global.js';
+
+export async function update(rawName, opts = {}) {
+  if (!rawName) {
+    error(t('update.needName'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const name = normalizeName(rawName);
+  validateName(name);
+  const db = dbName(name);
+  const container = containerName(db);
+  const envDir = projectDir(name);
+
+  // The project must already exist (created by `start`).
+  try {
+    await fs.access(path.join(envDir, 'docker-compose.yml'));
+  } catch {
+    error(t('update.notFound', { name, dir: envDir }));
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!(await ensureDockerRunning())) return;
+  await checkGlobalLayer();
+
+  const wpTag = resolveWpTag(opts.wp);
+  const image = wpImage(wpTag);
+
+  // Rewrite the Dockerfile with the new tag.
+  step(t('update.rebuilding', { name, image }));
+  const dockerfile = await renderTemplate('project.Dockerfile', { WP_TAG: wpTag });
+  await fs.writeFile(path.join(envDir, 'Dockerfile'), dockerfile, 'utf8');
+
+  // `--pull` forces a re-fetch of the base image even when the tag (e.g.
+  // php8.4-apache) is unchanged but has moved upstream; then recreate.
+  await compose(['build', '--pull'], { cwd: envDir });
+  await compose(['up', '-d'], { cwd: envDir });
+
+  // Wait for WP-CLI to respond in the recreated container.
+  step(t('start.waitingWp'));
+  await pollUntil(
+    async () => {
+      const { code } = await dockerExecCapture(container, ['wp', 'core', 'version', '--allow-root']);
+      return code === 0;
+    },
+    { label: 'WordPress', timeout: 90000 },
+  );
+
+  // Migrate the database schema to match the new core.
+  step(t('update.updatingDb'));
+  await dockerExec(container, ['wp', 'core', 'update-db', '--allow-root']);
+
+  const { stdout: version } = await dockerExecCapture(container, [
+    'wp',
+    'core',
+    'version',
+    '--allow-root',
+  ]);
+  success(t('update.done', { name, version: version || wpTag }));
+}

package/src/commands/wp.js

@@ -0,0 +1,28 @@
+// `42wp wp <project> <args...>` — port of wp_cli_proxy from 42script.sh.
+// Proxies a WP-CLI command into the project's running container.
+
+import { normalizeName, validateName, dbName, containerName } from '../lib/naming.js';
+import { containerIsRunning, dockerExec } from '../lib/docker.js';
+import { error } from '../lib/log.js';
+import { t } from '../lib/i18n.js';
+
+export async function wp(rawName, args) {
+  if (!rawName) {
+    error(t('wp.needArgs'));
+    process.exitCode = 1;
+    return;
+  }
+
+  const name = normalizeName(rawName);
+  validateName(name);
+  const container = containerName(dbName(name));
+
+  if (!(await containerIsRunning(container))) {
+    error(t('wp.notRunning', { container }));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Original always appends --allow-root.
+  await dockerExec(container, ['wp', ...args, '--allow-root'], { interactive: true });
+}

package/src/lib/config.js

@@ -0,0 +1,56 @@
+// Configurable defaults.
+//
+// The WordPress image tag is everything after `wordpress:` in the Dockerfile's
+// FROM line. The default is `php8.4-apache` — the newest WordPress while keeping
+// PHP pinned at 8.4 + Apache. Override per project with `--wp <tag>`, or globally
+// with FORTYTWO_WP_TAG. Examples of valid tags: `php8.4-apache`, `latest`,
+// `6.9-php8.5-apache`.
+
+export const DEFAULT_WP_TAG = 'php8.4-apache';
+
+// Default admin credentials for the silent install (override with --user / --pass).
+export const DEFAULT_ADMIN_USER = 'admin';
+export const DEFAULT_ADMIN_PASS = 'password';
+
+// WordPress VIP: the prebuilt mu-plugins, cloned into the project and mounted at
+// wp-content/mu-plugins when `start --vip` is used.
+export const VIP_MU_PLUGINS_REPO = 'https://github.com/Automattic/vip-go-mu-plugins-built';
+
+// Demo content: how many posts `--demo-content` generates by default.
+export const DEFAULT_DEMO_COUNT = 200;
+
+// Resolve the requested demo-post count from the --demo-content option value.
+// Returns null when not requested; the default when passed as a bare flag; or the
+// parsed positive integer for --demo-content=<n> (falling back to the default).
+export function resolveDemoCount(value) {
+  if (value === undefined || value === false) return null;
+  if (value === true) return DEFAULT_DEMO_COUNT;
+  const n = parseInt(value, 10);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_DEMO_COUNT;
+}
+
+// Resolve the effective tag: explicit flag wins, then env var, then default.
+export function resolveWpTag(override) {
+  return override || process.env.FORTYTWO_WP_TAG || DEFAULT_WP_TAG;
+}
+
+// Full image reference for display/logging.
+export function wpImage(tag) {
+  return `wordpress:${tag}`;
+}
+
+// The multisite constants block injected into wp-config.php (the {{MULTISITE_CONFIG}}
+// placeholder). Must only be written AFTER the network tables exist — see the
+// two-phase flow in commands/start.js.
+export function multisiteConfig(dom, { subdomains = false } = {}) {
+  return [
+    '/* Multisite */',
+    "define( 'WP_ALLOW_MULTISITE', true );",
+    "define( 'MULTISITE', true );",
+    `define( 'SUBDOMAIN_INSTALL', ${subdomains ? 'true' : 'false'} );`,
+    `define( 'DOMAIN_CURRENT_SITE', '${dom}' );`,
+    "define( 'PATH_CURRENT_SITE', '/' );",
+    "define( 'SITE_ID_CURRENT_SITE', 1 );",
+    "define( 'BLOG_ID_CURRENT_SITE', 1 );",
+  ].join('\n');
+}

package/src/lib/docker.js

@@ -0,0 +1,93 @@
+// Thin wrappers around the `docker` / `docker compose` CLIs using node:child_process.
+// Args are always passed as arrays (never through a shell), so project names and
+// WP-CLI arguments can't be reinterpreted by the shell.
+
+import { spawn } from 'node:child_process';
+
+// Run a command, streaming its stdio to the user. Resolves on exit 0, rejects otherwise.
+export function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit', ...opts });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`));
+    });
+  });
+}
+
+// Run a command with `input` piped to its stdin, streaming stdout/stderr to the
+// user. Used to feed a PHP script to `docker exec -i ... wp eval-file -`.
+export function runWithInput(cmd, args, input, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: ['pipe', 'inherit', 'inherit'], ...opts });
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`));
+    });
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
+// Run a command quietly and capture its output. Never rejects on a non-zero exit;
+// callers inspect `.code`. Rejects only if the binary can't be spawned at all.
+export function capture(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => (stdout += d));
+    child.stderr.on('data', (d) => (stderr += d));
+    child.on('error', reject);
+    child.on('close', (code) =>
+      resolve({ code, stdout: stdout.trim(), stderr: stderr.trim() }),
+    );
+  });
+}
+
+// `docker info` succeeds only when the daemon is reachable.
+export async function dockerIsRunning() {
+  try {
+    const { code } = await capture('docker', ['info']);
+    return code === 0;
+  } catch {
+    // docker binary not found
+    return false;
+  }
+}
+
+// True when a container matching the given name is currently running.
+export async function containerIsRunning(name) {
+  const { code, stdout } = await capture('docker', [
+    'ps',
+    '-q',
+    '-f',
+    `name=^${name}$`,
+  ]);
+  return code === 0 && stdout.length > 0;
+}
+
+// `docker compose -f <file> ...` (or, when cwd is set, `docker compose ...`).
+export function compose(args, opts = {}) {
+  return run('docker', ['compose', ...args], opts);
+}
+
+export function composeCapture(args, opts = {}) {
+  return capture('docker', ['compose', ...args], opts);
+}
+
+// `docker exec [-i] [-t] <container> <cmd...>`
+export function dockerExec(container, cmdArgs, { interactive = false } = {}) {
+  const flags = [];
+  if (interactive) {
+    flags.push('-i');
+    if (process.stdout.isTTY) flags.push('-t'); // -t only with a real TTY, so piping works
+  }
+  return run('docker', ['exec', ...flags, container, ...cmdArgs]);
+}
+
+export function dockerExecCapture(container, cmdArgs) {
+  return capture('docker', ['exec', container, ...cmdArgs]);
+}

package/src/lib/i18n.js

@@ -0,0 +1,64 @@
+// Tiny i18n layer. Ships English + Portuguese; locale is resolved once, from
+// (in priority order) an explicit override, the FORTYTWO_LANG env var, then the
+// usual locale env vars (LC_ALL / LC_MESSAGES / LANG / LANGUAGE). Anything that
+// looks like Portuguese ("pt", "pt_BR", "pt-PT", ...) selects Portuguese;
+// everything else falls back to English.
+
+import en from '../locales/en.js';
+import pt from '../locales/pt.js';
+
+const CATALOGS = { en, pt };
+const DEFAULT_LOCALE = 'en';
+
+let current = null;
+
+function normalize(tag) {
+  if (!tag) return null;
+  const lower = String(tag).toLowerCase();
+  if (lower.startsWith('pt')) return 'pt';
+  if (lower.startsWith('en')) return 'en';
+  return null;
+}
+
+function detectLocale(override) {
+  const candidates = [
+    override,
+    process.env.FORTYTWO_LANG,
+    process.env.LC_ALL,
+    process.env.LC_MESSAGES,
+    process.env.LANG,
+    process.env.LANGUAGE,
+  ];
+  for (const candidate of candidates) {
+    const locale = normalize(candidate);
+    if (locale) return locale;
+  }
+  return DEFAULT_LOCALE;
+}
+
+// Call once at startup (CLI passes the parsed --lang value, if any).
+export function setLocale(override) {
+  current = detectLocale(override);
+  return current;
+}
+
+export function getLocale() {
+  if (!current) current = detectLocale();
+  return current;
+}
+
+function interpolate(template, params) {
+  if (!params) return template;
+  return template.replace(/\$\{(\w+)\}/g, (match, key) =>
+    Object.prototype.hasOwnProperty.call(params, key) ? String(params[key]) : match,
+  );
+}
+
+// Translate a key. Falls back to English, then to the raw key, so a missing
+// translation degrades gracefully instead of throwing.
+export function t(key, params) {
+  const locale = getLocale();
+  const message =
+    CATALOGS[locale]?.[key] ?? CATALOGS[DEFAULT_LOCALE]?.[key] ?? key;
+  return interpolate(message, params);
+}

package/src/lib/log.js

@@ -0,0 +1,44 @@
+// Terminal output helpers — same look as 42script.sh's echo_step / echo_error.
+// Colors are emitted only when stdout is a TTY and NO_COLOR is unset.
+
+import { t } from './i18n.js';
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+const CODES = {
+  green: '\x1b[0;32m',
+  blue: '\x1b[0;34m',
+  yellow: '\x1b[1;33m',
+  red: '\x1b[0;31m',
+  reset: '\x1b[0m',
+};
+
+function paint(code, text) {
+  return useColor ? `${code}${text}${CODES.reset}` : text;
+}
+
+// "==> message" in blue arrow + green text (mirrors echo_step).
+export function step(message) {
+  const arrow = paint(CODES.blue, '==>');
+  console.log(`${arrow} ${paint(CODES.green, message)}`);
+}
+
+// "Error: message" in red (mirrors echo_error), printed to stderr.
+export function error(message) {
+  console.error(paint(CODES.red, `${t('err.prefix')}: ${message}`));
+}
+
+export function plain(message = '') {
+  console.log(message);
+}
+
+export function success(message) {
+  console.log(`\n🚀 ${paint(CODES.green, message)}`);
+}
+
+export const colors = {
+  green: (s) => paint(CODES.green, s),
+  blue: (s) => paint(CODES.blue, s),
+  yellow: (s) => paint(CODES.yellow, s),
+  red: (s) => paint(CODES.red, s),
+};

package/src/lib/naming.js

@@ -0,0 +1,44 @@
+// Project-name handling, ported 1:1 from 42script.sh, plus a validation guard.
+//
+//   bash: PROJECT_NAME="${PROJECT_NAME%.*}"   -> strip a trailing ".suffix"
+//   bash: DB_NAME=$(... | tr '-' '_')         -> hyphens become underscores
+//   bash: DOMAIN="${PROJECT_NAME}.localhost"
+
+import { t } from './i18n.js';
+
+// Remove the shortest trailing ".something", e.g. "jovempan.localhost" -> "jovempan".
+export function normalizeName(raw) {
+  return String(raw ?? '').replace(/\.[^.]*$/, '');
+}
+
+// MySQL database name and container suffix.
+export function dbName(name) {
+  return name.replace(/-/g, '_');
+}
+
+export function domain(name) {
+  return `${name}.localhost`;
+}
+
+export function containerName(db) {
+  return `wp_${db}`;
+}
+
+// Traefik router rule for a project. Subdomain multisite needs a wildcard host so
+// that sub-site hosts (<sub>.<domain>) route to the same container; otherwise an
+// exact Host() match is enough. Returned with literal backticks for the label;
+// the compose template wraps it in single quotes so the backslashes survive YAML.
+export function routerRule(dom, { subdomains = false } = {}) {
+  if (!subdomains) return `Host(\`${dom}\`)`;
+  const esc = dom.replace(/\./g, '\\.');
+  return `HostRegexp(\`^([a-z0-9-]+\\.)?${esc}$\`)`;
+}
+
+// Guard against shell/SQL/container-name injection in the original's interpolated
+// `CREATE DATABASE` and container names. Accepts simple slug characters only.
+export function validateName(name) {
+  if (!name || !/^[A-Za-z0-9_-]+$/.test(name)) {
+    throw new Error(t('name.invalid', { name }));
+  }
+  return name;
+}