create-vitnode-app 1.2.0-canary.5 → 1.2.0-canary.51

package/dist/src/create/create-package-json.js

@@ -1,63 +1,254 @@
 import { readFile, writeFile } from 'fs/promises';
-import { join } from 'path';
-export const createPackageJSON = async ({ appName, packageManager, root, eslint, }) => {
-    const pkg = JSON.parse(await readFile(join(__dirname, '..', 'package.json'), 'utf-8'));
-    const packageJson = {
-        name: appName,
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { getAvailablePackageManagers } from '../helpers/get-available-package-managers.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export const createPackageJSON = async ({ appName, packageManager, root, eslint, docker, mode, monorepo, }) => {
+    const availablePackageManagers = await getAvailablePackageManagers();
+    const pkg = JSON.parse(await readFile(join(__dirname, '..', '..', '..', 'package.json'), 'utf-8'));
+    const pkgVitNodeVersion = `^${pkg.version}`;
+    const monorepoStructure = {
+        api: join(root, 'apps', 'api'),
+        web: join(root, 'apps', 'web'),
+    };
+    if (mode === 'apiMonorepo' || monorepo) {
+        const rootPackageJson = {
+            name: appName,
+            private: true,
+            scripts: {
+                'db:migrate': 'turbo db:migrate',
+                'db:push': 'turbo db:push',
+                init: 'turbo init',
+                dev: 'turbo dev',
+                build: 'turbo build',
+                start: 'turbo start',
+                ...(eslint
+                    ? {
+                        lint: 'eslint .',
+                        'lint:fix': 'eslint . --fix',
+                    }
+                    : {}),
+                ...(docker
+                    ? {
+                        'docker:dev': `docker compose -f ./docker-compose.yml -p ${appName}-vitnode-dev up -d`,
+                    }
+                    : {}),
+            },
+            devDependencies: {
+                '@types/node': '^24',
+                '@vitnode/eslint-config': pkgVitNodeVersion,
+                ...(eslint
+                    ? {
+                        'prettier-plugin-tailwindcss': '^0.6.14',
+                        prettier: '^3.6.2',
+                    }
+                    : {}),
+                turbo: '^2.5.5',
+                typescript: '^5.8.3',
+                zod: '^4.0.5',
+            },
+            packageManager: `${packageManager}@${availablePackageManagers[packageManager]}`,
+            workspaces: ['apps/*', 'plugins/*'],
+        };
+        await writeFile(join(root, 'package.json'), JSON.stringify(rootPackageJson, null, 2));
+    }
+    const apiPackageJson = {
+        name: mode === 'apiMonorepo' || monorepo ? 'api' : appName,
         version: '0.1.0',
         private: true,
         type: 'module',
         scripts: {
-            'drizzle-kit': 'drizzle-kit',
-            'db:push': 'drizzle-kit push',
-            'db:migrate': 'drizzle-kit up && drizzle-kit generate && drizzle-kit migrate',
-            dev: 'vitnode init && next dev --turbopack',
-            build: 'next build --turbopack',
-            start: 'next start',
+            'db:push': 'vitnode push',
+            'db:migrate': 'vitnode migrate',
+            init: 'vitnode init --api',
+            ...(packageManager === 'bun'
+                ? {
+                    dev: 'vitnode init --api && bun run --hot src/index.ts',
+                    start: 'NODE_ENV=production bun run src/index.ts',
+                }
+                : {
+                    dev: 'vitnode init --api && tsx watch src/index.ts',
+                    build: 'tsc && tsc-alias -p tsconfig.json',
+                    start: 'node dist/index.js',
+                }),
             ...(eslint
                 ? {
                     lint: 'eslint .',
                     'lint:fix': 'eslint . --fix',
                 }
                 : {}),
+            ...(docker && mode === 'onlyApi'
+                ? {
+                    'docker:dev': `docker compose -f ./docker-compose.yml -p ${appName}-vitnode-dev up -d`,
+                }
+                : {}),
+            'drizzle-kit': 'drizzle-kit',
         },
         dependencies: {
-            '@hono/zod-openapi': '^0.19.8',
-            '@hono/zod-validator': '^0.7.0',
-            '@hookform/resolvers': '^5.0.1',
-            '@react-email/components': '^0.0.41',
-            '@vitnode/core': `^${pkg.version}`,
-            'babel-plugin-react-compiler': '19.1.0-rc.2',
-            'drizzle-kit': '^0.31.1',
-            'drizzle-orm': '^0.44.1',
-            hono: '^4.7.10',
-            'lucide-react': '^0.511.0',
-            next: '^15.3.3',
-            'next-intl': '^4.1.0',
-            react: '^19.1.0',
-            'react-dom': '^19.1.0',
-            'react-hook-form': '^7.56.4',
-            sonner: '^2.0.3',
-            zod: '^3.25.42',
+            '@hono/zod-openapi': '^1.0.2',
+            '@hono/zod-validator': '^0.7.2',
+            '@react-email/components': '^0.3.2',
+            '@vitnode/core': pkgVitNodeVersion,
+            'drizzle-kit': '^0.31.3',
+            'drizzle-orm': '^0.44.3',
+            hono: '^4.8.5',
+            'next-intl': '^4.3.1',
+            react: '^19.1',
+            'react-dom': '^19.1',
+            zod: '^4.0.5',
         },
         devDependencies: {
-            '@tailwindcss/postcss': '^4.1.8',
-            '@types/node': '^22.15.29',
-            '@types/react': '^19.1.6',
-            '@types/react-dom': '^19.1.5',
+            '@hono/node-server': '^1.17.1',
+            ...(packageManager === 'bun'
+                ? {
+                    '@types/bun': 'latest',
+                }
+                : {}),
+            '@types/node': '^24',
+            '@types/react': '^19.1',
+            '@types/react-dom': '^19.1',
+            '@vitnode/eslint-config': pkgVitNodeVersion,
+            dotenv: '^17.2.0',
             ...(eslint
                 ? {
-                    eslint: '^9.27.0',
-                    'eslint-config-typescript-vitnode': `^${pkg.version}`,
-                    prettier: '^3.5.3',
+                    eslint: '^9.31.0',
+                    ...(mode === 'onlyApi'
+                        ? {
+                            'prettier-plugin-tailwindcss': '^0.6.14',
+                            prettier: '^3.6.2',
+                        }
+                        : {}),
                 }
                 : {}),
-            'react-email': '^4.0.15',
-            tailwindcss: '^4.1.8',
-            'tw-animate-css': '^1.3.2',
+            'react-email': '^4.2.3',
+            'tsc-alias': '^1.8.16',
+            tsx: '^4.20.3',
             typescript: '^5.8.3',
         },
-        packageManager,
     };
-    await writeFile(join(root, 'apps', 'frontend', 'package.json'), JSON.stringify(packageJson, null, 2));
+    if (mode === 'singleApp') {
+        const packageJson = {
+            name: monorepo ? 'web' : appName,
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+            scripts: {
+                'db:push': 'vitnode push',
+                'db:migrate': 'vitnode migrate',
+                init: 'vitnode init',
+                dev: 'vitnode init && next dev --turbopack',
+                build: 'next build',
+                start: 'next start',
+                ...(eslint
+                    ? {
+                        lint: 'eslint .',
+                        'lint:fix': 'eslint . --fix',
+                    }
+                    : {}),
+                ...(docker
+                    ? {
+                        'docker:dev': `docker compose -f ./docker-compose.yml -p ${appName}-vitnode-dev up -d`,
+                    }
+                    : {}),
+                'drizzle-kit': 'drizzle-kit',
+            },
+            dependencies: {
+                '@hono/zod-openapi': '^1.0.2',
+                '@hono/zod-validator': '^0.7.2',
+                '@hookform/resolvers': '^5.1.1',
+                '@react-email/components': '^0.3.2',
+                '@vitnode/core': pkgVitNodeVersion,
+                'babel-plugin-react-compiler': '19.1.0-rc.2',
+                'drizzle-kit': '^0.31.4',
+                'drizzle-orm': '^0.44.3',
+                hono: '^4.8.5',
+                'lucide-react': '^0.525.0',
+                next: '^15.4.2',
+                'next-intl': '^4.3.4',
+                react: '^19.1',
+                'react-dom': '^19.1',
+                'react-hook-form': '^7.60.0',
+                sonner: '^2.0.6',
+                zod: '^4.0.5',
+            },
+            devDependencies: {
+                '@tailwindcss/postcss': '^4.1.11',
+                '@types/node': '^24',
+                '@types/react': '^19.1',
+                '@types/react-dom': '^19.1',
+                '@vitnode/eslint-config': pkgVitNodeVersion,
+                ...(eslint
+                    ? {
+                        eslint: '^9.31.0',
+                        'prettier-plugin-tailwindcss': '^0.6.14',
+                        prettier: '^3.6.2',
+                    }
+                    : {}),
+                'react-email': '^4.2.3',
+                turbo: '^2.5.5',
+                tailwindcss: '^4.1.11',
+                'tw-animate-css': '^1.3.5',
+                typescript: '^5.8.3',
+            },
+            packageManager: `${packageManager}@${availablePackageManagers[packageManager]}`,
+        };
+        await writeFile(join(monorepo ? monorepoStructure.web : root, 'package.json'), JSON.stringify(packageJson, null, 2));
+    }
+    else if (mode === 'apiMonorepo') {
+        await writeFile(join(root, 'apps', 'api', 'package.json'), JSON.stringify(apiPackageJson, null, 2));
+        const webPackageJson = {
+            name: 'web',
+            version: '0.1.0',
+            private: true,
+            type: 'module',
+            scripts: {
+                init: 'vitnode init --web',
+                dev: 'vitnode init --web && next dev --turbopack',
+                build: 'next build',
+                start: 'next start',
+                ...(eslint
+                    ? {
+                        lint: 'eslint .',
+                        'lint:fix': 'eslint . --fix',
+                    }
+                    : {}),
+            },
+            dependencies: {
+                '@vitnode/core': pkgVitNodeVersion,
+                'babel-plugin-react-compiler': '19.1.0-rc.2',
+                'lucide-react': '^0.525.0',
+                next: '^15.4.2',
+                'next-intl': '^4.3.4',
+                react: '^19.1',
+                'react-dom': '^19.1',
+                'react-hook-form': '^7.60.0',
+                sonner: '^2.0.6',
+            },
+            devDependencies: {
+                '@hookform/resolvers': '^5.1.1',
+                '@tailwindcss/postcss': '^4.1.11',
+                '@types/mdx': '^2.0.13',
+                '@types/node': '^24',
+                '@types/react': '^19.1',
+                '@types/react-dom': '^19.1',
+                '@vitnode/eslint-config': pkgVitNodeVersion,
+                'class-variance-authority': '^0.7.1',
+                ...(eslint
+                    ? {
+                        eslint: '^9.31.0',
+                    }
+                    : {}),
+                postcss: '^8.5.6',
+                tailwindcss: '^4.1.11',
+                'tw-animate-css': '^1.3.5',
+                typescript: '^5.8.3',
+                zod: '^4.0.5',
+            },
+        };
+        await writeFile(join(root, 'apps', 'web', 'package.json'), JSON.stringify(webPackageJson, null, 2));
+    }
+    else if (mode === 'onlyApi') {
+        await writeFile(join(monorepo ? monorepoStructure.api : root, 'package.json'), JSON.stringify(apiPackageJson, null, 2));
+    }
 };

package/dist/src/create/create-vitnode.js

@@ -1,14 +1,14 @@
-import { randomBytes } from 'crypto';
 import { existsSync } from 'fs';
-import { copyFile, cp, mkdir, readFile, writeFile } from 'fs/promises';
+import { copyFile, cp, mkdir, readFile, rename, writeFile } from 'fs/promises';
 import ora from 'ora';
 import { dirname, join } from 'path';
 import color from 'picocolors';
 import { fileURLToPath } from 'url';
+import { generateMigrationsVitnode, initFilesVitnode, } from '../helpers/init-vitnode.js';
 import { installDependencies } from '../helpers/install-dependencies.js';
 import { isFolderEmpty } from '../helpers/is-folder-empty.js';
 import { createPackageJSON } from './create-package-json.js';
-export const createVitNode = async ({ root, appName, packageManager, eslint, install, }) => {
+export const createVitNode = async ({ root, appName, packageManager, eslint, install, docker, mode, monorepo, }) => {
     const spinner = ora(`Creating a new VitNode app in ${color.green(root)}. Using ${color.green(packageManager)}...`).start();
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = dirname(__filename);
@@ -21,32 +21,165 @@ export const createVitNode = async ({ root, appName, packageManager, eslint, ins
     if (!isFolderEmpty(root, appName)) {
         process.exit(1);
     }
+    const monorepoStructure = {
+        api: join(root, 'apps', 'api'),
+        web: join(root, 'apps', 'web'),
+    };
+    spinner.text = 'Preparing the project structure...';
+    if (monorepo || mode === 'apiMonorepo') {
+        const dirsToCreate = [];
+        if (mode === 'apiMonorepo' || (monorepo && mode === 'onlyApi')) {
+            dirsToCreate.push(monorepoStructure.api);
+        }
+        if (mode === 'apiMonorepo' || (monorepo && mode === 'singleApp')) {
+            dirsToCreate.push(monorepoStructure.web);
+        }
+        await Promise.all(dirsToCreate.map(async (dir) => mkdir(dir, { recursive: true })));
+    }
     spinner.text = 'Copying files...';
-    await cp(join(templatePath, 'root'), root, {
+    await cp(join(templatePath, '.vscode'), join(root, '.vscode'), {
         recursive: true,
     });
+    if (mode === 'singleApp') {
+        await Promise.all([
+            cp(join(templatePath, 'root'), monorepo ? monorepoStructure.web : root, {
+                recursive: true,
+            }),
+            cp(join(templatePath, 'api-single-app'), monorepo ? monorepoStructure.web : root, {
+                recursive: true,
+            }),
+        ]);
+    }
+    else if (mode === 'apiMonorepo') {
+        await Promise.all([
+            cp(join(templatePath, 'root'), monorepoStructure.web, {
+                recursive: true,
+            }),
+            cp(join(templatePath, 'api'), monorepoStructure.api, {
+                recursive: true,
+            }),
+        ]);
+        if (packageManager === 'bun') {
+            await cp(join(templatePath, 'api-bun'), monorepoStructure.api, {
+                recursive: true,
+            });
+        }
+    }
+    else if (mode === 'onlyApi') {
+        await cp(join(templatePath, 'api'), monorepo ? monorepoStructure.api : root, {
+            recursive: true,
+        });
+        if (packageManager === 'bun') {
+            await cp(join(templatePath, 'api-bun'), monorepo ? monorepoStructure.api : root, {
+                recursive: true,
+            });
+        }
+    }
+    if (mode === 'apiMonorepo' || monorepo) {
+        await cp(join(templatePath, 'monorepo'), root, {
+            recursive: true,
+        });
+    }
     if (eslint) {
         spinner.text = 'Copying eslint files...';
         await cp(join(templatePath, 'eslint'), root, {
             recursive: true,
         });
     }
+    spinner.text = 'Renaming special files...';
+    await rename(join(root, '.gitignore_template'), join(root, '.gitignore'));
+    if (mode === 'apiMonorepo' || monorepo) {
+        if (existsSync(join(monorepoStructure.api, '.gitignore_template'))) {
+            await rename(join(monorepoStructure.api, '.gitignore_template'), join(monorepoStructure.api, '.gitignore'));
+        }
+        if (existsSync(join(monorepoStructure.web, '.gitignore_template'))) {
+            await rename(join(monorepoStructure.web, '.gitignore_template'), join(monorepoStructure.web, '.gitignore'));
+        }
+    }
     spinner.text = 'Creating package.json...';
     await createPackageJSON({
         root,
         appName,
         packageManager,
         eslint,
+        docker,
+        mode,
+        monorepo,
     });
-    spinner.text = 'Changing .env file...';
-    await copyFile(join(root, '.env.template'), join(root, '.env'));
-    const envPath = join(root, '.env');
-    const newEnv = (await readFile(envPath, 'utf-8')).replace('LOGIN_TOKEN_SECRET=vitnode_secret', `LOGIN_TOKEN_SECRET=${randomBytes(32).toString('hex')}`);
-    await writeFile(envPath, newEnv);
+    if ((mode === 'apiMonorepo' || monorepo) && packageManager === 'pnpm') {
+        spinner.text = 'Creating pnpm-workspace.yaml...';
+        const pnpmWorkspaceContent = `packages:\n  - 'apps/*'\n  - 'plugins/*'\n`;
+        await writeFile(join(root, 'pnpm-workspace.yaml'), pnpmWorkspaceContent);
+    }
+    if (docker) {
+        spinner.text = 'Copying docker files...';
+        await copyFile(join(templatePath, 'docker', 'docker-compose.yml'), join(root, 'docker-compose.yml'));
+        const dockerComposePath = join(root, 'docker-compose.yml');
+        const dockerComposeContent = await readFile(dockerComposePath, 'utf-8');
+        const updatedContent = dockerComposeContent.replace(/vitnode_postgres_dev/g, `${appName}_vitnode_postgres_dev`);
+        await writeFile(dockerComposePath, updatedContent);
+    }
+    spinner.text = 'Updating VitNode paths...';
+    if ((mode === 'apiMonorepo' || monorepo) &&
+        packageManager !== 'pnpm' &&
+        mode !== 'onlyApi') {
+        const globalCssPath = join(monorepoStructure.web, 'src', 'app', 'global.css');
+        const globalCssContent = await readFile(globalCssPath, 'utf-8');
+        const updatedGlobalCssContent = globalCssContent.replaceAll('@source "../../node_modules/@vitnode/', '@source "../../../../node_modules/@vitnode/');
+        await writeFile(globalCssPath, updatedGlobalCssContent);
+    }
+    if (mode === 'apiMonorepo') {
+        spinner.text = 'Setting up environment variables...';
+        const envExamplePath = join(monorepoStructure.web, '.env.example');
+        if (existsSync(envExamplePath)) {
+            await rename(envExamplePath, join(monorepoStructure.web, '.env'));
+        }
+    }
     if (install) {
         spinner.text = 'Installing dependencies...';
         await installDependencies({
             packageManager,
+            cwd: root,
+        });
+        spinner.text = 'Initializing VitNode files...';
+        if (mode === 'apiMonorepo') {
+            await Promise.all([
+                initFilesVitnode({
+                    packageManager,
+                    cwd: monorepoStructure.web,
+                    flag: 'web',
+                }),
+                initFilesVitnode({
+                    packageManager,
+                    cwd: monorepoStructure.api,
+                    flag: 'api',
+                }),
+                initFilesVitnode({
+                    packageManager,
+                    cwd: root,
+                }),
+            ]);
+        }
+        else {
+            initFilesVitnode({
+                packageManager,
+                cwd: root,
+            });
+        }
+        spinner.text = 'Generating migrations...';
+        let migrationsCwd;
+        if (mode === 'apiMonorepo' || (monorepo && mode !== 'singleApp')) {
+            migrationsCwd = monorepoStructure.api;
+        }
+        else if (mode === 'singleApp' && monorepo) {
+            migrationsCwd = monorepoStructure.web;
+        }
+        else {
+            migrationsCwd = root;
+        }
+        generateMigrationsVitnode({
+            packageManager,
+            cwd: migrationsCwd,
         });
     }
     spinner.succeed(`${color.green('Success!')} Created ${color.cyan(appName)} at ${color.cyan(root)}`);

package/dist/src/helpers/init-vitnode.js

@@ -0,0 +1,21 @@
+import { spawn } from 'child_process';
+export const initFilesVitnode = ({ packageManager: pm, cwd, flag, }) => {
+    const packageManager = pm.split('@')[0];
+    const args = [
+        'vitnode',
+        'prepare-plugins',
+        flag ? `--${flag}` : '',
+    ];
+    spawn(packageManager, args, {
+        cwd,
+        shell: true,
+    });
+};
+export const generateMigrationsVitnode = ({ packageManager: pm, cwd, }) => {
+    const packageManager = pm.split('@')[0];
+    const args = ['vitnode', 'migrate', '--generate'];
+    spawn(packageManager, args, {
+        cwd,
+        shell: true,
+    });
+};

package/dist/src/helpers/install-dependencies.js

@@ -1,17 +1,21 @@
 import { spawn } from 'child_process';
 import color from 'picocolors';
 import { getOnline } from './is-online.js';
-export const installDependencies = async ({ packageManager: pm, }) => {
+export const installDependencies = async ({ packageManager: pm, cwd, }) => {
     const packageManager = pm.split('@')[0];
     const isOnline = await getOnline();
-    const args = packageManager === 'npm' ? ['install', '--force'] : ['install'];
+    const args = ['install'];
     if (!isOnline) {
         console.log(color.yellow('You appear to be offline.\nFalling back to the local cache.'));
         args.push('--offline');
     }
     return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
         const child = spawn(packageManager, args, {
-            stdio: 'ignore',
+            stdio: 'pipe',
+            cwd,
+            shell: true,
             env: {
                 ...process.env,
                 ADBLOCK: '1',
@@ -19,12 +23,46 @@ export const installDependencies = async ({ packageManager: pm, }) => {
                 DISABLE_OPENCOLLECTIVE: '1',
             },
         });
+        child.stdout?.on('data', (data) => {
+            const output = data.toString();
+            stdout += output;
+        });
+        child.stderr?.on('data', (data) => {
+            const output = data.toString();
+            stderr += output;
+        });
         child.on('close', code => {
             if (code !== 0) {
-                reject({ command: `${packageManager} ${args.join(' ')}` });
+                console.error(color.red(`\n❌ Installation failed with exit code: ${code}`));
+                if (stderr) {
+                    console.error(color.red('Error output:'));
+                    console.error(stderr);
+                }
+                if (stdout) {
+                    console.log(color.yellow('Standard output:'));
+                    console.log(stdout);
+                }
+                if (stderr.includes('ENOTFOUND') || stderr.includes('network')) {
+                    console.error(color.yellow('💡 Network error detected. Please check your internet connection.'));
+                }
+                else if (stderr.includes('EACCES') ||
+                    stderr.includes('permission denied')) {
+                    console.error(color.yellow('💡 Permission error detected. Try running with elevated privileges or check file permissions.'));
+                }
+                else if (stderr.includes('ENOSPC')) {
+                    console.error(color.yellow('💡 Disk space error detected. Please free up some disk space.'));
+                }
+                else if (stderr.includes('ERR_PNPM_PEER_DEP_ISSUES')) {
+                    console.error(color.yellow('💡 Peer dependency issues detected. Consider using --force flag or resolve conflicts manually.'));
+                }
+                reject(new Error(`Failed to install dependencies using ${packageManager}. Exit code: ${code}\n${stderr || stdout}`));
                 return;
             }
             resolve();
         });
+        child.on('error', error => {
+            console.error(color.red(`❌ Failed to start ${packageManager}:`), error.message);
+            reject(new Error(`Failed to start ${packageManager}: ${error.message}`));
+        });
     });
 };

package/dist/src/helpers/is-online.js

@@ -32,7 +32,7 @@ function getProxy() {
         const httpsProxy = execSync('npm config get https-proxy').toString().trim();
         return httpsProxy !== 'null' ? httpsProxy : undefined;
     }
-    catch (_) {
+    catch {
         return;
     }
 }

package/dist/src/helpers/is-writeable.js

@@ -5,7 +5,7 @@ export async function isWriteable(directory) {
         await access(directory, W_OK);
         return true;
     }
-    catch (_) {
+    catch {
         return false;
     }
 }

package/dist/src/index.js

@@ -26,7 +26,7 @@ process.on('uncaughtException', (error) => {
 const init = async () => {
     let projectPath = '';
     const program = new Command()
-        .version(packageJson.version)
+        .version(packageJson.version ?? '0.1.0')
         .argument('[project-directory]')
         .usage(`${color.green('[project-directory]')} [options]`)
         .action(name => {
@@ -36,6 +36,9 @@ const init = async () => {
     program.option('--eslint', 'Initialize with eslint config.');
     program.option('--skip-install', 'Skip installing packages after initializing the project.');
     program.option('--plugin', 'Enable plugin mode.');
+    program.addOption(new Option('--mode <mode>', 'What type of app do you want to create?').choices(['singleApp', 'apiMonorepo', 'onlyApi']));
+    program.option('--monorepo', 'Create project with monorepo structure.');
+    program.option('--docker', 'Initialize with Docker support.');
     program.parse(process.argv);
     const opts = program.opts();
     if (opts.plugin) {

package/dist/src/prepare/prepare.js

@@ -6,7 +6,7 @@ const prepare = async () => {
     if (!existsSync(toRootPath)) {
         await mkdir(toRootPath);
     }
-    const fromRootPath = join(process.cwd(), '..', '..', 'apps', 'web');
+    const fromRootPath = join(process.cwd(), '..', '..', 'apps', 'docs');
     if (!existsSync(fromRootPath)) {
         console.error(`\x1b[31mThe path ${fromRootPath} does not exist. Please check the directory structure.\x1b[0m`);
         process.exit(1);