@veloxts/cli 0.6.106 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @veloxts/cli
 
+## 0.7.0
+
+### Minor Changes
+
+- chore(deps): update Prisma from 7.3.0 to 7.4.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @veloxts/auth@0.7.0
+  - @veloxts/core@0.7.0
+  - @veloxts/orm@0.7.0
+  - @veloxts/router@0.7.0
+  - @veloxts/validation@0.7.0
+
+## 0.6.107
+
+### Patch Changes
+
+- feat(cli): add workspace monorepo support for `velox dev`
+- Updated dependencies
+  - @veloxts/auth@0.6.107
+  - @veloxts/core@0.6.107
+  - @veloxts/orm@0.6.107
+  - @veloxts/router@0.6.107
+  - @veloxts/validation@0.6.107
+
 ## 0.6.106
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @veloxts/cli
 
-> **Early Access (v0.6.x)**
+> **Early Access (v0.7.x)**
 
 Command-line interface for VeloxTS Framework - provides development server with HMR, migration commands, and code generators. Learn more at [@veloxts/velox](https://www.npmjs.com/package/@veloxts/velox).
 

package/dist/commands/dev.js

@@ -7,12 +7,13 @@
  * Use --no-hmr for legacy tsx watch mode with full process restarts.
  */
 import { spawn } from 'node:child_process';
+import path from 'node:path';
 import * as p from '@clack/prompts';
 import { Command } from 'commander';
 import pc from 'picocolors';
 import { buildWatchArgs, runHMRServer } from '../dev/index.js';
 import { error, formatCommand, formatPath, info, instruction, printBanner, success, } from '../utils/output.js';
-import { detectProjectType, findEntryPoint, isVeloxProject, validateEntryPath, } from '../utils/paths.js';
+import { detectProjectType, discoverEntryPoints, findApiPackageRoot, findEntryPoint, findWebPackageRoot, isVeloxProject, isWorkspaceRoot, validateEntryPath, } from '../utils/paths.js';
 /**
  * Create the dev command
  */
@@ -28,6 +29,7 @@ export function createDevCommand(version) {
         .option('--no-hmr', 'Disable HMR and use legacy tsx watch mode')
         .option('-v, --verbose', 'Show detailed timing and reload information', false)
         .option('-d, --debug', 'Enable debug logging and request tracing', false)
+        .option('--all', 'Start both API and Web dev servers (workspace monorepos)', false)
         .action(async (options) => {
         await runDevServer(options, version);
     });
@@ -89,15 +91,38 @@ async function runVinxiServer(options, version) {
         }
     });
 }
+/**
+ * Spawn the web dev server in a workspace monorepo.
+ * Runs `pnpm dev` inside apps/web/ with inherited stdio.
+ * Returns the child process for lifecycle management.
+ */
+function spawnWebDevServer(webRoot) {
+    info(`Starting web dev server in ${formatPath(webRoot)}`);
+    console.log(`  ${pc.dim('Running pnpm dev in apps/web/')}`);
+    console.log('');
+    return spawn('pnpm', ['dev'], {
+        stdio: 'inherit',
+        cwd: webRoot,
+        env: { ...process.env, NODE_ENV: 'development' },
+    });
+}
 /**
  * Run the development server
  */
 async function runDevServer(options, version) {
+    const cwd = process.cwd();
     const s = p.spinner();
     try {
-        // Check if we're in a VeloxTS project
+        // Check if we're in a VeloxTS project (also check workspace subpackages)
         s.start('Checking project...');
-        const isVelox = await isVeloxProject();
+        let isVelox = await isVeloxProject(cwd);
+        // In a workspace root, @veloxts deps live in subpackages, not root
+        if (!isVelox && isWorkspaceRoot(cwd)) {
+            const apiRoot = findApiPackageRoot(cwd);
+            if (apiRoot) {
+                isVelox = await isVeloxProject(apiRoot);
+            }
+        }
         if (!isVelox) {
             s.stop('Project check failed');
             error('This does not appear to be a VeloxTS project.');
@@ -105,7 +130,7 @@ async function runDevServer(options, version) {
             process.exit(1);
         }
         // Detect project type (API-only vs Vinxi/RSC)
-        const projectType = await detectProjectType();
+        const projectType = await detectProjectType(cwd);
         if (projectType.isVinxi) {
             s.stop('Vinxi project detected');
             success('Detected VeloxTS full-stack project (RSC + Vinxi)');
@@ -119,7 +144,7 @@ async function runDevServer(options, version) {
             // User specified an entry point - validate it
             s.start('Validating entry point...');
             try {
-                entryPoint = validateEntryPath(options.entry);
+                entryPoint = validateEntryPath(options.entry, cwd);
                 s.stop(`Entry point: ${formatPath(entryPoint)}`);
             }
             catch (err) {
@@ -129,18 +154,54 @@ async function runDevServer(options, version) {
             }
         }
         else {
-            // Auto-detect entry point
+            // Auto-detect entry point (workspace-aware via findEntryPoint)
             s.start('Detecting entry point...');
-            const detected = findEntryPoint();
-            if (!detected) {
-                s.stop('Entry point not found');
-                error('Could not find application entry point.');
-                instruction('Try specifying the entry point with --entry flag:');
-                console.log(`  ${formatCommand('velox dev --entry src/index.ts')}`);
-                process.exit(1);
+            const detected = findEntryPoint(cwd);
+            if (detected) {
+                entryPoint = detected;
+                s.stop(`Entry point: ${formatPath(entryPoint)}`);
             }
-            entryPoint = detected;
-            s.stop(`Entry point: ${formatPath(entryPoint)}`);
+            else {
+                // Auto-detection failed — discover possible entry points and let user pick
+                const candidates = discoverEntryPoints(cwd);
+                if (candidates.length > 0) {
+                    s.stop('Multiple possible entry points found');
+                    const selected = await p.select({
+                        message: 'Select the entry point for your application',
+                        options: candidates.map((c) => ({
+                            value: c.absolute,
+                            label: c.relative,
+                        })),
+                    });
+                    if (p.isCancel(selected)) {
+                        p.cancel('Operation cancelled.');
+                        process.exit(0);
+                    }
+                    try {
+                        entryPoint = validateEntryPath(String(selected), cwd);
+                    }
+                    catch (err) {
+                        error(err instanceof Error ? err.message : 'Invalid entry point');
+                        process.exit(1);
+                    }
+                    success(`Using ${formatPath(entryPoint)}`);
+                }
+                else {
+                    s.stop('Entry point not found');
+                    error('Could not find any application entry point.');
+                    instruction('Create src/index.ts or specify one with --entry:');
+                    console.log(`  ${formatCommand('velox dev --entry src/index.ts')}`);
+                    process.exit(1);
+                }
+            }
+        }
+        // Determine the working directory for the child process.
+        // In a workspace monorepo, the API server needs to run from apps/api/
+        // so that dotenv/config loads apps/api/.env and Prisma finds its config.
+        const apiRoot = findApiPackageRoot(cwd);
+        const apiProcessCwd = apiRoot ?? cwd;
+        if (apiRoot) {
+            info(`Workspace detected — API root: ${formatPath(apiRoot)}`);
         }
         // Validate port and host
         const port = options.port || '3030';
@@ -173,6 +234,49 @@ async function runDevServer(options, version) {
         };
         const clearScreen = options.clear !== false;
         const verbose = options.verbose ?? false;
+        // --all: also start the web dev server in parallel
+        let webProcess = null;
+        let isShuttingDown = false;
+        if (options.all) {
+            // If we're in a subpackage (e.g., apps/api/), search from the parent workspace root
+            let webSearchRoot = cwd;
+            if (!isWorkspaceRoot(cwd)) {
+                const parentDir = path.dirname(cwd);
+                if (isWorkspaceRoot(parentDir)) {
+                    webSearchRoot = parentDir;
+                }
+                const grandparentDir = path.dirname(parentDir);
+                if (!isWorkspaceRoot(parentDir) && isWorkspaceRoot(grandparentDir)) {
+                    webSearchRoot = grandparentDir;
+                }
+            }
+            const webRoot = findWebPackageRoot(webSearchRoot);
+            if (webRoot) {
+                webProcess = spawnWebDevServer(webRoot);
+                webProcess.on('error', (err) => {
+                    error(`Web dev server failed: ${err.message}`);
+                });
+                webProcess.on('exit', (code) => {
+                    if (!isShuttingDown && code !== 0) {
+                        console.log(pc.yellow(`  Web dev server exited with code ${code}`));
+                        console.log(pc.dim('  API server continues running.'));
+                    }
+                });
+            }
+            else {
+                info('No web package found — starting API only.');
+            }
+        }
+        // Ensure the web process is cleaned up on exit (covers both HMR and legacy paths).
+        // The 'exit' handler runs synchronously when process.exit() is called,
+        // so SIGTERM is the best we can do (no async waiting).
+        if (webProcess) {
+            process.on('exit', () => {
+                if (webProcess && !webProcess.killed) {
+                    webProcess.kill('SIGTERM');
+                }
+            });
+        }
         // HMR is the default mode
         // Use --no-hmr for legacy tsx watch mode
         if (options.hmr !== false) {
@@ -185,6 +289,7 @@ async function runDevServer(options, version) {
                 verbose,
                 debug,
                 clearOnRestart: clearScreen,
+                cwd: apiProcessCwd,
             });
             return; // HMR runner handles its own lifecycle
         }
@@ -202,19 +307,21 @@ async function runDevServer(options, version) {
         const devProcess = spawn('npx', watchArgs, {
             stdio: 'inherit',
             env,
+            cwd: apiProcessCwd,
         });
         // Handle process termination
-        let isShuttingDown = false;
         const shutdown = (signal) => {
             if (isShuttingDown)
                 return;
             isShuttingDown = true;
             console.log(`\n\n${pc.yellow('⚠')} ${pc.dim(`Received ${signal}, shutting down gracefully...`)}`);
             devProcess.kill('SIGTERM');
+            webProcess?.kill('SIGTERM');
             // Force kill after 5 seconds if process doesn't exit
             const forceKillTimeout = setTimeout(() => {
                 console.log(pc.red('✗ Force killing process...'));
                 devProcess.kill('SIGKILL');
+                webProcess?.kill('SIGKILL');
                 process.exit(1);
             }, 5000);
             devProcess.on('exit', () => {

package/dist/dev/hmr-runner.d.ts

@@ -24,6 +24,8 @@ export interface HMRRunnerOptions {
     readonly debug?: boolean;
     /** Clear console on full restart */
     readonly clearOnRestart?: boolean;
+    /** Working directory for the child process (defaults to process.cwd()) */
+    readonly cwd?: string;
 }
 /**
  * HMR Runner manages a Node.js process with hot-hook enabled
@@ -99,7 +101,7 @@ export declare class HMRRunner {
      */
     private setupSignalHandlers;
     /**
-     * Get basename from file path
+     * Get basename from file path (cross-platform)
      */
     private getBasename;
 }

package/dist/dev/hmr-runner.js

@@ -8,6 +8,7 @@
  */
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
+import { basename } from 'node:path';
 import pc from 'picocolors';
 // Resolve hot-hook from CLI's node_modules, not from user's project
 const require = createRequire(import.meta.url);
@@ -185,7 +186,7 @@ export class HMRRunner {
         this.child = spawn('node', ['--import=tsx', `--import=${hotHookRegisterPath}`, this.options.entry], {
             stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
             env,
-            cwd: process.cwd(),
+            cwd: this.options.cwd ?? process.cwd(),
         });
         // Set up IPC message handler
         this.child.on('message', (message) => this.handleIPCMessage(message));
@@ -379,18 +380,17 @@ export class HMRRunner {
             console.log(pc.dim('Development server stopped.'));
             process.exit(0);
         };
-        process.on('SIGINT', () => shutdown('SIGINT'));
-        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        process.once('SIGINT', () => shutdown('SIGINT'));
+        process.once('SIGTERM', () => shutdown('SIGTERM'));
     }
     // --------------------------------------------------------------------------
     // Private: Utilities
     // --------------------------------------------------------------------------
     /**
-     * Get basename from file path
+     * Get basename from file path (cross-platform)
      */
     getBasename(filePath) {
-        const parts = filePath.split('/');
-        return parts[parts.length - 1] || filePath;
+        return basename(filePath);
     }
 }
 // ============================================================================

package/dist/utils/paths.d.ts

@@ -3,9 +3,46 @@
  */
 /**
  * Find the project entry point
- * Looks for common entry points in order of preference
+ * Looks for common entry points in order of preference.
+ * If nothing is found in cwd and cwd is a workspace root,
+ * also searches inside the API package (apps/api/).
  */
 export declare function findEntryPoint(cwd?: string): string | null;
+/**
+ * Check if a directory is a pnpm/npm/yarn workspace root.
+ * Looks for pnpm-workspace.yaml or "workspaces" in package.json.
+ */
+export declare function isWorkspaceRoot(cwd: string): boolean;
+/**
+ * Find the API package root in a workspace monorepo.
+ *
+ * 1. Checks if cwd is a workspace root
+ * 2. Looks for apps/api/package.json with @veloxts/* deps
+ * 3. Falls back to scanning apps/* for any package with @veloxts/* deps
+ *
+ * Returns the absolute path to the API package root, or null.
+ */
+export declare function findApiPackageRoot(cwd?: string): string | null;
+/**
+ * Find the Web package root in a workspace monorepo.
+ *
+ * Looks for apps/web/package.json with vite, @veloxts/web, or react in deps.
+ *
+ * Returns the absolute path to the Web package root, or null.
+ */
+export declare function findWebPackageRoot(cwd?: string): string | null;
+/**
+ * Discover potential entry point files in the project.
+ *
+ * Scans cwd and, in workspaces, each apps/* subpackage for TypeScript files
+ * that look like entry points (index.ts, main.ts, server.ts, app.ts in src/ or root).
+ *
+ * Returns paths relative to cwd for display, paired with absolute paths.
+ */
+export declare function discoverEntryPoints(cwd?: string): Array<{
+    absolute: string;
+    relative: string;
+}>;
 /**
  * Check if a file exists at the given path
  */

package/dist/utils/paths.js

@@ -1,23 +1,193 @@
 /**
  * Path utilities for finding project files
  */
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+/** Common entry point file names, ordered by preference */
+const ENTRY_POINT_PATTERNS = [
+    'src/index.ts',
+    'src/main.ts',
+    'src/app.ts',
+    'src/server.ts',
+    'index.ts',
+    'main.ts',
+    'app.ts',
+    'server.ts',
+];
+/** Default workspace subdirectory names */
+const WORKSPACE_DIRS = {
+    APPS: 'apps',
+    API: 'api',
+    WEB: 'web',
+};
+/** Directories excluded from the API package fallback scan */
+const NON_API_PACKAGES = ['web', 'docs', 'landing'];
 /**
  * Find the project entry point
- * Looks for common entry points in order of preference
+ * Looks for common entry points in order of preference.
+ * If nothing is found in cwd and cwd is a workspace root,
+ * also searches inside the API package (apps/api/).
  */
 export function findEntryPoint(cwd = process.cwd()) {
-    const candidates = ['src/index.ts', 'src/main.ts', 'src/app.ts', 'index.ts', 'main.ts'];
-    for (const candidate of candidates) {
+    // 1. Try flat candidates in cwd (preserves existing behavior)
+    for (const candidate of ENTRY_POINT_PATTERNS) {
         const fullPath = path.join(cwd, candidate);
         if (existsSync(fullPath)) {
             return fullPath;
         }
     }
+    // 2. If workspace detected, search inside the API package root
+    const apiRoot = findApiPackageRoot(cwd);
+    if (apiRoot) {
+        for (const candidate of ENTRY_POINT_PATTERNS) {
+            const fullPath = path.join(apiRoot, candidate);
+            if (existsSync(fullPath)) {
+                return fullPath;
+            }
+        }
+    }
     return null;
 }
+/**
+ * Check if a directory is a pnpm/npm/yarn workspace root.
+ * Looks for pnpm-workspace.yaml or "workspaces" in package.json.
+ */
+export function isWorkspaceRoot(cwd) {
+    // Check pnpm-workspace.yaml
+    if (existsSync(path.join(cwd, 'pnpm-workspace.yaml'))) {
+        return true;
+    }
+    // Check package.json "workspaces" field (npm/yarn)
+    const pkgPath = path.join(cwd, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            if (pkg.workspaces) {
+                return true;
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    return false;
+}
+/**
+ * Check if a package.json has @veloxts/* dependencies
+ */
+function hasVeloxDeps(pkgJsonPath) {
+    try {
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return Object.keys(deps).some((dep) => dep.startsWith('@veloxts/'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find the API package root in a workspace monorepo.
+ *
+ * 1. Checks if cwd is a workspace root
+ * 2. Looks for apps/api/package.json with @veloxts/* deps
+ * 3. Falls back to scanning apps/* for any package with @veloxts/* deps
+ *
+ * Returns the absolute path to the API package root, or null.
+ */
+export function findApiPackageRoot(cwd = process.cwd()) {
+    if (!isWorkspaceRoot(cwd)) {
+        return null;
+    }
+    // Primary: apps/api/
+    const primaryApiDir = path.join(cwd, WORKSPACE_DIRS.APPS, WORKSPACE_DIRS.API);
+    const primaryApiPkg = path.join(primaryApiDir, 'package.json');
+    if (existsSync(primaryApiPkg) && hasVeloxDeps(primaryApiPkg)) {
+        return primaryApiDir;
+    }
+    // Fallback: scan apps/*/package.json for first package with @veloxts/* deps
+    const appsDir = path.join(cwd, WORKSPACE_DIRS.APPS);
+    if (existsSync(appsDir)) {
+        try {
+            const entries = readdirSync(appsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && !NON_API_PACKAGES.includes(entry.name)) {
+                    const pkgPath = path.join(appsDir, entry.name, 'package.json');
+                    if (existsSync(pkgPath) && hasVeloxDeps(pkgPath)) {
+                        return path.join(appsDir, entry.name);
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore scan errors
+        }
+    }
+    return null;
+}
+/**
+ * Find the Web package root in a workspace monorepo.
+ *
+ * Looks for apps/web/package.json with vite, @veloxts/web, or react in deps.
+ *
+ * Returns the absolute path to the Web package root, or null.
+ */
+export function findWebPackageRoot(cwd = process.cwd()) {
+    if (!isWorkspaceRoot(cwd)) {
+        return null;
+    }
+    const webDir = path.join(cwd, WORKSPACE_DIRS.APPS, WORKSPACE_DIRS.WEB);
+    const webPkgPath = path.join(webDir, 'package.json');
+    if (!existsSync(webPkgPath)) {
+        return null;
+    }
+    try {
+        const pkg = JSON.parse(readFileSync(webPkgPath, 'utf-8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const webMarkers = ['vite', '@veloxts/web', 'react', 'next', 'vinxi'];
+        if (webMarkers.some((marker) => marker in deps)) {
+            return webDir;
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return null;
+}
+/**
+ * Discover potential entry point files in the project.
+ *
+ * Scans cwd and, in workspaces, each apps/* subpackage for TypeScript files
+ * that look like entry points (index.ts, main.ts, server.ts, app.ts in src/ or root).
+ *
+ * Returns paths relative to cwd for display, paired with absolute paths.
+ */
+export function discoverEntryPoints(cwd = process.cwd()) {
+    const results = [];
+    const seen = new Set();
+    const scanDir = (dir) => {
+        for (const candidate of ENTRY_POINT_PATTERNS) {
+            const fullPath = path.normalize(path.join(dir, candidate));
+            if (existsSync(fullPath) && !seen.has(fullPath)) {
+                seen.add(fullPath);
+                results.push({
+                    absolute: fullPath,
+                    relative: path.relative(cwd, fullPath),
+                });
+            }
+        }
+    };
+    // Scan cwd itself
+    scanDir(cwd);
+    // In workspaces, scan the detected API package root (not all apps/*)
+    if (isWorkspaceRoot(cwd)) {
+        const apiRoot = findApiPackageRoot(cwd);
+        if (apiRoot && apiRoot !== cwd) {
+            scanDir(apiRoot);
+        }
+    }
+    return results;
+}
 /**
  * Check if a file exists at the given path
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/cli",
-  "version": "0.6.106",
+  "version": "0.7.0",
   "description": "Developer tooling and CLI commands for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -41,17 +41,17 @@
     "pluralize": "8.0.0",
     "tsx": "4.21.0",
     "yaml": "2.8.2",
-    "@veloxts/core": "0.6.106",
-    "@veloxts/auth": "0.6.106",
-    "@veloxts/orm": "0.6.106",
-    "@veloxts/validation": "0.6.106",
-    "@veloxts/router": "0.6.106"
+    "@veloxts/core": "0.7.0",
+    "@veloxts/orm": "0.7.0",
+    "@veloxts/auth": "0.7.0",
+    "@veloxts/router": "0.7.0",
+    "@veloxts/validation": "0.7.0"
   },
   "peerDependencies": {
     "@prisma/client": ">=7.0.0"
   },
   "devDependencies": {
-    "@prisma/client": "7.3.0",
+    "@prisma/client": "7.4.0",
     "@types/node": "25.1.0",
     "@types/pg": "8.16.0",
     "@types/pluralize": "0.0.33",