vite-wp 0.1.8 → 0.1.9

package/README.md

@@ -2,22 +2,14 @@
 
 ViteWP is an Astro-first WordPress development framework.
 
-A ViteWP project **is** the local WordPress site: Composer installs WordPress, PHP runs WordPress, Astro renders the frontend, and one local URL serves admin, REST, media, previews, and Astro pages.
-
-```txt
-http://localhost:3000
-```
-
-PHP and Astro still run internally, but you normally only use the unified ViteWP URL.
+One entrypoint for everything you need, no fuzz and no magic.
 
 ## Requirements
 
 - Node.js 20+
 - PHP 8.2+
 - Composer
-- MySQL or MariaDB
-
-ViteWP is bring-your-own database. It does not start MySQL for you.
+- a MySQL or MariaDB server
 
 ## Get started
 
@@ -27,12 +19,11 @@ cd my-site
 npm init -y
 npx vite-wp init
 cp .env.example .env
-npm run dev
 ```
 
 `vite-wp init` creates the starter files, adds the needed package dependencies, and runs install.
 
-Edit `.env` with your database credentials, then open:
+Edit `.env` with your database credentials, run `npm run dev`, wait for the initial configuration and then open:
 
 ```txt
 http://localhost:3000
@@ -47,6 +38,8 @@ npm run dev      # Start the local ViteWP runtime
 npm run doctor   # Check PHP, Composer, WordPress, config, and environment
 npm run types    # Generate WordPress-derived TypeScript types
 npm run check    # Run Astro type checking
+npx vite-wp composer install  # Run Composer in the project
+npx vite-wp wp plugin list    # Run WP-CLI when installed
 ```
 
 For internal runtime diagnostics:
@@ -71,15 +64,15 @@ my-site/
   wordpress/
     public/              # Composer-installed WordPress core
     content/
-      mu-plugins/
-      themes/
+      mu-plugins/        # ViteWP bridge is generated here
+      themes/            # ViteWP placeholder theme is generated here
       plugins/
       uploads/
 ```
 
 ## Templates
 
-ViteWP ships default templates from the package. Create files in `src/templates` only when you want to override them. Project templates always win over package defaults.
+ViteWP ships default templates from the package. Create files in `src/templates` only when you want to override them.
 
 Examples:
 
@@ -106,10 +99,3 @@ const menu = await getLiveEntry('menus', { location: 'primary' });
 ```
 
 After `npm run dev` or `npm run check`, collection names and filters should have TypeScript completion.
-
-## Notes
-
-- WordPress core is installed into `wordpress/public` by Composer.
-- Do not commit `wordpress/public`, `.env`, `.vitewp`, or uploads.
-- The tiny placeholder theme exists only to keep WordPress admin happy.
-- Docker is optional, not required.

package/{starter → defaults}/wordpress/content/mu-plugins/vitewp-bridge.php

@@ -47,6 +47,24 @@ add_action('rest_api_init', function () {
         },
     ]);
 
+    register_rest_route('vitewp/v1', '/health', [
+        'methods' => WP_REST_Server::READABLE,
+        'permission_callback' => '__return_true',
+        'callback' => function () {
+            return [
+                'wordpressVersion' => get_bloginfo('version'),
+                'phpVersion' => PHP_VERSION,
+                'homeUrl' => home_url('/'),
+                'siteUrl' => site_url('/'),
+                'permalinkStructure' => (string) get_option('permalink_structure'),
+                'activeTheme' => get_stylesheet(),
+                'template' => get_template(),
+                'activePlugins' => array_values((array) get_option('active_plugins', [])),
+                'muPlugins' => array_values(array_keys(get_mu_plugins())),
+            ];
+        },
+    ]);
+
     register_rest_route('vitewp/v1', '/types', [
         'methods' => WP_REST_Server::READABLE,
         'permission_callback' => '__return_true',

package/dist/astro.js

@@ -5,7 +5,16 @@ export default function vitewp(_options = {}) {
     return {
         name: 'vitewp',
         hooks: {
-            'astro:config:setup': ({ command, config, injectRoute, addDevToolbarApp, logger }) => {
+            'astro:config:setup': ({ command, config, injectRoute, addDevToolbarApp, logger, updateConfig }) => {
+                if (isSourceIntegration()) {
+                    updateConfig({
+                        vite: {
+                            resolve: {
+                                alias: sourceAliases(),
+                            },
+                        },
+                    });
+                }
                 if (!hasProjectCatchAllRoute(fileURLToPath(config.root))) {
                     injectRoute({
                         pattern: '/[...slug]',
@@ -47,3 +56,24 @@ function getDevToolbarEntrypoint() {
     }
     return new URL('./dev-toolbar/vitewp-toolbar.js', import.meta.url);
 }
+function isSourceIntegration() {
+    return fileURLToPath(import.meta.url).endsWith('/src/astro.ts');
+}
+function sourceAliases() {
+    return [
+        alias('vite-wp/wordpress/templates', './wordpress/templates.ts'),
+        alias('vite-wp/wordpress/client', './wordpress/client.ts'),
+        alias('vite-wp/wordpress/menus', './wordpress/menus.ts'),
+        alias('vite-wp/wordpress/schemas', './wordpress/schemas.ts'),
+        alias('vite-wp/wordpress', './wordpress/index.ts'),
+        alias('vite-wp/content', './content.ts'),
+        alias('vite-wp/astro', './astro.ts'),
+        alias('vite-wp', './index.ts'),
+    ];
+}
+function alias(find, replacement) {
+    return {
+        find,
+        replacement: fileURLToPath(new URL(replacement, import.meta.url)),
+    };
+}

package/dist/cli.js

@@ -4,6 +4,8 @@ import { runDoctor } from './commands/doctor.js';
 import { runSmoke } from './commands/smoke.js';
 import { runTypes } from './commands/types.js';
 import { runInit } from './commands/init.js';
+import { runComposerCommand } from './commands/composer.js';
+import { runWpCommand } from './commands/wp.js';
 const command = process.argv[2] ?? 'help';
 switch (command) {
     case 'dev':
@@ -18,6 +20,12 @@ switch (command) {
     case 'types':
         await runTypes();
         break;
+    case 'composer':
+        await runComposerCommand();
+        break;
+    case 'wp':
+        await runWpCommand();
+        break;
     case 'smoke':
         await runSmoke();
         break;
@@ -36,6 +44,8 @@ function printHelp() {
   vite-wp dev       Start the local WordPress + Astro development runtime
   vite-wp doctor    Check the current project setup
   vite-wp types     Generate TypeScript types from WordPress metadata
+  vite-wp composer  Run Composer in the ViteWP project
+  vite-wp wp        Run WP-CLI for the local WordPress runtime
   vite-wp smoke     Verify the running ViteWP dev runtime
 
 Options:

package/dist/commands/composer.d.ts

@@ -0,0 +1 @@
+export declare function runComposerCommand(args?: string[]): Promise<void>;

package/dist/commands/composer.js

@@ -0,0 +1,13 @@
+import { loadViteWpConfig } from '../config.js';
+import { runComposer } from '../runtime/composer.js';
+export async function runComposerCommand(args = process.argv.slice(3)) {
+    const config = await loadViteWpConfig();
+    const composerArgs = args.length > 0 ? args : ['install'];
+    try {
+        await runComposer(config.root, composerArgs);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    }
+}

package/dist/commands/dev.js

@@ -20,16 +20,16 @@ export async function runDev() {
     console.log(`- templates: ${config.templates.directory}`);
     console.log(`- database: ${config.database.driver}://${config.database.user}@${config.database.host}:${config.database.port}/${config.database.name}`);
     console.log('');
-    const result = await runDoctorChecks(config);
-    if (result.errors > 0) {
-        console.log('');
-        console.log('Fix the errors above before starting the dev runtime.');
-        process.exitCode = 1;
-        return;
-    }
     try {
         await ensureComposerInstall(config);
         writeWordPressConfig(config);
+        const result = await runDoctorChecks(config, { live: false });
+        if (result.errors > 0) {
+            console.log('');
+            console.log('Fix the errors above before starting the dev runtime.');
+            process.exitCode = 1;
+            return;
+        }
         await stopAstroServer(config);
         config.dev.phpPort = await resolveInternalPort(config.dev.phpHost, config.dev.phpPort);
         config.dev.astroPort = await resolveInternalPort(config.dev.astroHost, config.dev.astroPort);

package/dist/commands/doctor.d.ts

@@ -1,6 +1,8 @@
 import { type LoadedViteWpConfig } from '../config.js';
 export declare function runDoctor(): Promise<void>;
-export declare function runDoctorChecks(config: LoadedViteWpConfig): Promise<{
+export declare function runDoctorChecks(config: LoadedViteWpConfig, options?: {
+    live?: boolean;
+}): Promise<{
     errors: number;
     warnings: number;
 }>;

package/dist/commands/doctor.js

@@ -9,7 +9,8 @@ export async function runDoctor() {
     const result = await runDoctorChecks(config);
     process.exitCode = result.errors > 0 ? 1 : 0;
 }
-export async function runDoctorChecks(config) {
+export async function runDoctorChecks(config, options = {}) {
+    const live = options.live ?? true;
     const checks = [];
     checks.push({
         status: config.configFile ? 'pass' : 'warn',
@@ -19,15 +20,23 @@ export async function runDoctorChecks(config) {
     checks.push(fileCheck(config.root, 'astro.config.mjs', 'Astro config'));
     checks.push(fileCheck(config.root, 'composer.json', 'Composer manifest'));
     checks.push(composerWordPressCheck(config.root, config.composer.wordpressPackage));
+    checks.push(composerInstallDirCheck(config));
     checks.push(fileCheck(config.root, 'composer.lock', 'Composer lockfile'));
+    checks.push(composerLockCheck(config.root, config.composer.wordpressPackage));
     checks.push(fileCheck(config.root, `${config.wordpress.docroot}/wp-settings.php`, 'Composer-installed WordPress core'));
     checks.push(fileCheck(config.root, `${config.wordpress.docroot}/wp-config.php`, 'Generated wp-config.php'));
+    checks.push(fileCheck(config.root, `${config.wordpress.contentDir}/mu-plugins/vitewp-bridge.php`, 'ViteWP bridge mu-plugin'));
     checks.push(fileCheck(config.root, `${config.wordpress.contentDir}/themes/vitewp/style.css`, 'ViteWP placeholder theme'));
-    checks.push(fileCheck(config.root, config.templates.directory, 'Template directory'));
+    checks.push(templateDirectoryCheck(config));
     checks.push(databaseConfigCheck(config));
     checks.push(await commandCheck('php', ['-v'], 'PHP runtime'));
     checks.push(await commandCheck('composer', ['--version'], 'Composer'));
     checks.push(gitignoreCheck(config.root, config.wordpress.docroot));
+    checks.push(runtimeFilesIgnoredCheck(config.root, config.wordpress.contentDir));
+    checks.push(...requiredPluginFileChecks(config));
+    if (live) {
+        checks.push(await wordpressHealthCheck(config));
+    }
     printChecks(checks);
     const errors = checks.filter((check) => check.status === 'fail').length;
     const warnings = checks.filter((check) => check.status === 'warn').length;
@@ -41,6 +50,16 @@ function fileCheck(root, relativePath, label) {
         ? { status: 'pass', label, detail: relativePath }
         : { status: 'warn', label, detail: `${relativePath} does not exist yet.` };
 }
+function templateDirectoryCheck(config) {
+    const directory = join(config.root, config.templates.directory);
+    return existsSync(directory)
+        ? { status: 'pass', label: 'Project template overrides', detail: config.templates.directory }
+        : {
+            status: 'pass',
+            label: 'Project template overrides',
+            detail: `${config.templates.directory} is optional; package defaults will be used.`,
+        };
+}
 async function commandCheck(command, args, label) {
     try {
         const { stdout, stderr } = await execFileAsync(command, args);
@@ -114,6 +133,74 @@ function composerWordPressCheck(root, wordpressPackage) {
         };
     }
 }
+function composerInstallDirCheck(config) {
+    const composerPath = join(config.root, 'composer.json');
+    if (!existsSync(composerPath)) {
+        return {
+            status: 'warn',
+            label: 'Composer WordPress install dir',
+            detail: 'composer.json does not exist yet.',
+        };
+    }
+    try {
+        const composer = JSON.parse(readFileSync(composerPath, 'utf8'));
+        const installDir = composer.extra?.['wordpress-install-dir'];
+        if (!installDir) {
+            return {
+                status: 'warn',
+                label: 'Composer WordPress install dir',
+                detail: 'extra.wordpress-install-dir is not set.',
+            };
+        }
+        return installDir === config.wordpress.docroot
+            ? { status: 'pass', label: 'Composer WordPress install dir', detail: installDir }
+            : {
+                status: 'fail',
+                label: 'Composer WordPress install dir',
+                detail: `${installDir} does not match config docroot ${config.wordpress.docroot}.`,
+            };
+    }
+    catch (error) {
+        return {
+            status: 'fail',
+            label: 'Composer WordPress install dir',
+            detail: error instanceof Error ? error.message : 'Could not parse composer.json.',
+        };
+    }
+}
+function composerLockCheck(root, wordpressPackage) {
+    const lockPath = join(root, 'composer.lock');
+    if (!existsSync(lockPath)) {
+        return {
+            status: 'warn',
+            label: 'Locked WordPress version',
+            detail: 'Run composer install to create composer.lock.',
+        };
+    }
+    try {
+        const lock = JSON.parse(readFileSync(lockPath, 'utf8'));
+        const wordpress = lock.packages?.find((pkg) => pkg.name === wordpressPackage);
+        if (!wordpress?.version) {
+            return {
+                status: 'fail',
+                label: 'Locked WordPress version',
+                detail: `${wordpressPackage} was not found in composer.lock.`,
+            };
+        }
+        return {
+            status: 'pass',
+            label: 'Locked WordPress version',
+            detail: `${wordpressPackage}@${wordpress.version}`,
+        };
+    }
+    catch (error) {
+        return {
+            status: 'fail',
+            label: 'Locked WordPress version',
+            detail: error instanceof Error ? error.message : 'Could not parse composer.lock.',
+        };
+    }
+}
 function gitignoreCheck(root, docroot) {
     const gitignorePath = join(root, '.gitignore');
     if (!existsSync(gitignorePath)) {
@@ -129,6 +216,72 @@ function gitignoreCheck(root, docroot) {
             detail: `Add ${normalizedDocroot} to .gitignore.`,
         };
 }
+function runtimeFilesIgnoredCheck(root, contentDir) {
+    const gitignorePath = join(root, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        return { status: 'warn', label: 'WordPress runtime files ignored', detail: '.gitignore is missing.' };
+    }
+    const gitignore = readFileSync(gitignorePath, 'utf8');
+    const required = [
+        `${contentDir}/uploads/`,
+        `${contentDir}/debug.log`,
+    ];
+    const missing = required.filter((entry) => !gitignore.includes(entry));
+    return missing.length === 0
+        ? { status: 'pass', label: 'WordPress runtime files ignored', detail: required.join(', ') }
+        : {
+            status: 'warn',
+            label: 'WordPress runtime files ignored',
+            detail: `Add ${missing.join(', ')} to .gitignore.`,
+        };
+}
+function requiredPluginFileChecks(config) {
+    return config.wordpress.requiredPlugins.map((plugin) => {
+        const directory = `${config.wordpress.contentDir}/plugins/${plugin}`;
+        return fileCheck(config.root, directory, `Required plugin files: ${plugin}`);
+    });
+}
+async function wordpressHealthCheck(config) {
+    const url = `${config.wordpress.url.replace(/\/$/, '')}/wp-json/vitewp/v1/health`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (!response.ok) {
+            return {
+                status: 'warn',
+                label: 'WordPress health endpoint',
+                detail: `${url} returned ${response.status}. Start vite-wp dev if the runtime is offline.`,
+            };
+        }
+        const health = await response.json();
+        const missingPlugins = config.wordpress.requiredPlugins.filter((plugin) => {
+            return !health.activePlugins?.some((active) => active === plugin || active.startsWith(`${plugin}/`));
+        });
+        if (missingPlugins.length > 0) {
+            return {
+                status: 'fail',
+                label: 'WordPress health endpoint',
+                detail: `Missing active plugin(s): ${missingPlugins.join(', ')}.`,
+            };
+        }
+        return {
+            status: 'pass',
+            label: 'WordPress health endpoint',
+            detail: `WP ${health.wordpressVersion ?? '?'} / PHP ${health.phpVersion ?? '?'} / theme ${health.activeTheme ?? '?'} / permalinks ${health.permalinkStructure || 'plain'}`,
+        };
+    }
+    catch {
+        return {
+            status: 'warn',
+            label: 'WordPress health endpoint',
+            detail: `Could not reach ${url}. Start vite-wp dev to run live health checks.`,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 function printChecks(checks) {
     console.log('ViteWP doctor');
     console.log('');

package/dist/commands/init.js

@@ -59,6 +59,8 @@ function updatePackageJson(root, packageRoot) {
     packageJson.scripts.dev ??= 'vite-wp dev';
     packageJson.scripts.doctor ??= 'vite-wp doctor';
     packageJson.scripts.types ??= 'vite-wp types';
+    packageJson.scripts.composer ??= 'vite-wp composer';
+    packageJson.scripts.wp ??= 'vite-wp wp';
     packageJson.scripts.check ??= 'astro check';
     packageJson.dependencies['vite-wp'] ??= `^${viteWp.version}`;
     packageJson.dependencies.astro ??= '^7.0.6';
@@ -91,6 +93,8 @@ dist-ssr/
 .vitewp/
 .astro/
 wordpress/public/
+wordpress/content/mu-plugins/vitewp-bridge.php
+wordpress/content/themes/vitewp/
 wordpress/content/uploads/
 wordpress/content/debug.log
 

package/dist/commands/wp.d.ts

@@ -0,0 +1 @@
+export declare function runWpCommand(args?: string[]): Promise<void>;

package/dist/commands/wp.js

@@ -0,0 +1,41 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { loadViteWpConfig } from '../config.js';
+export async function runWpCommand(args = process.argv.slice(3)) {
+    const config = await loadViteWpConfig();
+    const command = wpBinary(config);
+    if (!command) {
+        console.error('Could not find WP-CLI. Install it globally as `wp` or add it to Composer.');
+        process.exitCode = 1;
+        return;
+    }
+    const wpArgs = [
+        `--path=${config.wordpress.docroot}`,
+        `--url=${config.wordpress.url}`,
+        ...args,
+    ];
+    const code = await spawnWp(config, command, wpArgs);
+    process.exitCode = code;
+}
+function wpBinary(config) {
+    const local = join(config.root, 'vendor/bin/wp');
+    if (existsSync(local)) {
+        return local;
+    }
+    return process.platform === 'win32' ? 'wp.cmd' : 'wp';
+}
+function spawnWp(config, command, args) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: config.root,
+            stdio: 'inherit',
+            env: process.env,
+        });
+        child.once('exit', (code) => resolve(code ?? 1));
+        child.once('error', (error) => {
+            console.error(`Could not run WP-CLI (${command}). ${error.message}`);
+            resolve(1);
+        });
+    });
+}

package/dist/config.d.ts

@@ -14,6 +14,7 @@ export interface ViteWpConfig {
         url?: string;
         docroot?: string;
         contentDir?: string;
+        requiredPlugins?: string[];
     };
     composer?: {
         install?: boolean;
@@ -49,6 +50,7 @@ export interface LoadedViteWpConfig {
         url: string;
         docroot: string;
         contentDir: string;
+        requiredPlugins: string[];
     };
     composer: {
         install: boolean;

package/dist/config.js

@@ -37,6 +37,7 @@ export async function loadViteWpConfig(root = process.cwd()) {
             url: userConfig.wordpress?.url ?? 'http://localhost:3000',
             docroot: userConfig.wordpress?.docroot ?? 'wordpress/public',
             contentDir: userConfig.wordpress?.contentDir ?? 'wordpress/content',
+            requiredPlugins: userConfig.wordpress?.requiredPlugins ?? [],
         },
         composer: {
             install: userConfig.composer?.install ?? true,

package/dist/runtime/composer.d.ts

@@ -1,2 +1,3 @@
 import type { LoadedViteWpConfig } from '../config.js';
 export declare function ensureComposerInstall(config: LoadedViteWpConfig): Promise<void>;
+export declare function runComposer(cwd: string, args: string[]): Promise<void>;

package/dist/runtime/composer.js

@@ -7,19 +7,23 @@ export async function ensureComposerInstall(config) {
         return;
     }
     const lockfile = join(config.root, 'composer.lock');
+    const manifest = join(config.root, 'composer.json');
     const vendor = join(config.root, 'vendor');
     const wpSettings = join(config.root, config.wordpress.docroot, 'wp-settings.php');
+    if (!existsSync(manifest)) {
+        throw new Error('composer.json is missing. Run `vite-wp init` or add a Composer manifest before starting dev.');
+    }
     if (existsSync(lockfile) && existsSync(vendor) && existsSync(wpSettings)) {
         console.log('✓ Composer dependencies already installed');
         return;
     }
     console.log('Installing Composer dependencies...');
-    await runComposerInstall(config.root);
+    await runComposer(config.root, ['install']);
     console.log('✓ Composer dependencies ready');
 }
-function runComposerInstall(cwd) {
+export function runComposer(cwd, args) {
     return new Promise((resolve, reject) => {
-        const child = spawn('composer', ['install'], {
+        const child = spawn('composer', args, {
             cwd,
             stdio: 'inherit',
             env: { ...process.env, COMPOSER_ALLOW_SUPERUSER: process.env.COMPOSER_ALLOW_SUPERUSER ?? '1' },
@@ -29,8 +33,11 @@ function runComposerInstall(cwd) {
                 resolve();
             }
             else {
-                reject(new Error(`composer install failed with code ${code ?? 'unknown'}.`));
+                reject(new Error(`composer ${args.join(' ')} failed with code ${code ?? 'unknown'}.`));
             }
         });
+        child.once('error', (error) => {
+            reject(new Error(`Could not run composer. Is Composer installed?\n${error.message}`));
+        });
     });
 }

package/dist/runtime/wp-config.js

@@ -1,6 +1,7 @@
-import { mkdirSync, symlinkSync, writeFileSync, existsSync, lstatSync } from 'node:fs';
+import { cpSync, existsSync, lstatSync, mkdirSync, symlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { randomBytes } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
 export function writeWordPressConfig(config) {
     const docroot = resolve(config.root, config.wordpress.docroot);
     const contentDir = resolve(config.root, config.wordpress.contentDir);
@@ -10,6 +11,7 @@ export function writeWordPressConfig(config) {
     mkdirSync(join(contentDir, 'plugins'), { recursive: true });
     mkdirSync(join(contentDir, 'mu-plugins'), { recursive: true });
     mkdirSync(join(contentDir, 'uploads'), { recursive: true });
+    ensureDefaultContentFiles(contentDir);
     ensureContentSymlink(docroot, contentDir);
     writeFileSync(wpConfigPath, renderWpConfig(config, publicUrl, contentDir), 'utf8');
     console.log(`✓ wp-config.php generated at ${relative(config.root, wpConfigPath)}`);
@@ -80,3 +82,20 @@ function ensureContentSymlink(docroot, contentDir) {
     const target = relative(dirname(link), contentDir);
     symlinkSync(target, link, 'dir');
 }
+function ensureDefaultContentFiles(contentDir) {
+    const packageContentDir = resolve(dirname(fileURLToPath(import.meta.url)), '../../defaults/wordpress/content');
+    copyPackageFile(join(packageContentDir, 'mu-plugins/vitewp-bridge.php'), join(contentDir, 'mu-plugins/vitewp-bridge.php'));
+    copyIfMissing(join(packageContentDir, 'themes/vitewp'), join(contentDir, 'themes/vitewp'));
+}
+function copyPackageFile(source, destination) {
+    if (!existsSync(source))
+        return;
+    mkdirSync(dirname(destination), { recursive: true });
+    cpSync(source, destination);
+}
+function copyIfMissing(source, destination) {
+    if (existsSync(destination) || !existsSync(source))
+        return;
+    mkdirSync(dirname(destination), { recursive: true });
+    cpSync(source, destination, { recursive: true });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vite-wp",
   "private": false,
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "bin": {
     "vite-wp": "dist/cli.js"
@@ -43,6 +43,8 @@
   "scripts": {
     "dev": "tsx src/cli.ts dev",
     "doctor": "tsx src/cli.ts doctor",
+    "composer": "tsx src/cli.ts composer",
+    "wp": "tsx src/cli.ts wp",
     "build": "rm -rf dist && tsc",
     "prepack": "npm run build",
     "pack:dry": "npm pack --dry-run",