sitevision-cli 0.0.0

package/dist/utils/webpack-runner.js

@@ -0,0 +1,313 @@
+/**
+ * Webpack Runner
+ *
+ * Handles webpack compilation for Sitevision apps.
+ * Dynamically loads webpack from the target project's node_modules.
+ */
+import path from 'path';
+import fs from 'fs';
+import { createRequire } from 'module';
+import { EventEmitter } from 'events';
+import { copyChunksToResources } from './zip.js';
+// =============================================================================
+// WEBPACK RUNNER CLASS
+// =============================================================================
+/**
+ * Events emitted by WebpackRunner:
+ * - 'compile': Emitted when compilation starts
+ * - 'done': Emitted when compilation completes successfully
+ * - 'error': Emitted when compilation fails
+ * - 'warning': Emitted when compilation has warnings
+ */
+export class WebpackRunner extends EventEmitter {
+    constructor(projectRoot, options) {
+        super();
+        Object.defineProperty(this, "projectRoot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: projectRoot
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "webpack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "compiler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "watcher", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Initialize webpack by loading it from the project's node_modules
+     */
+    async initialize() {
+        if (this.webpack) {
+            return;
+        }
+        // Load webpack from project's node_modules
+        const webpackPath = path.join(this.projectRoot, 'node_modules', 'webpack');
+        if (!fs.existsSync(webpackPath)) {
+            throw new Error('webpack not found in project. Make sure webpack is installed: npm install webpack');
+        }
+        try {
+            // Use createRequire to load webpack (CommonJS module) from the project
+            const require = createRequire(path.join(this.projectRoot, 'package.json'));
+            this.webpack = require('webpack');
+        }
+        catch (error) {
+            throw new Error(`Failed to load webpack: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Load webpack config from project
+        await this.loadConfig();
+    }
+    /**
+     * Load webpack configuration from the project
+     */
+    async loadConfig() {
+        // Try to find webpack config in standard locations
+        // Project-specific configs take priority, fall back to @sitevision/sitevision-scripts
+        const configPaths = [
+            path.join(this.projectRoot, 'webpack.config.js'),
+            path.join(this.projectRoot, 'webpack.config.mjs'),
+            path.join(this.projectRoot, 'config', 'webpack', 'webpack.config.js'),
+            path.join(this.projectRoot, 'node_modules', '@sitevision', 'sitevision-scripts', 'config', 'webpack', 'webpack.config.js'),
+        ];
+        let configPath = null;
+        for (const p of configPaths) {
+            if (fs.existsSync(p)) {
+                configPath = p;
+                break;
+            }
+        }
+        if (!configPath) {
+            throw new Error('webpack.config.js not found. Make sure your project has a webpack configuration.');
+        }
+        try {
+            const configModule = await import(configPath);
+            const configFactory = configModule.default || configModule;
+            // If it's a function, call it with options
+            if (typeof configFactory === 'function') {
+                this.config = configFactory({
+                    dev: this.options.mode === 'development',
+                    cssPrefix: this.options.cssPrefix || '',
+                    restApp: this.options.restApp || false,
+                });
+            }
+            else {
+                this.config = configFactory;
+            }
+            // Override mode
+            this.config.mode = this.options.mode === 'development' ? 'development' : 'production';
+        }
+        catch (error) {
+            throw new Error(`Failed to load webpack config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Convert webpack stats to BuildResult
+     */
+    statsToResult(stats) {
+        const json = stats.toJson();
+        return {
+            success: !stats.hasErrors(),
+            outputPath: this.config?.output?.path,
+            errors: json.errors?.map((e) => e.message) || [],
+            warnings: json.warnings?.map((w) => w.message) || [],
+            stats: {
+                time: json.time || 0,
+                hash: json.hash || '',
+                assets: json.assets?.map((a) => a.name) || [],
+            },
+        };
+    }
+    /**
+     * Run a single webpack build
+     */
+    async run() {
+        await this.initialize();
+        if (!this.webpack || !this.config) {
+            throw new Error('Webpack not initialized');
+        }
+        return new Promise((resolve, reject) => {
+            this.emit('compile');
+            this.compiler = this.webpack(this.config);
+            this.compiler.run((err, stats) => {
+                if (err) {
+                    this.emit('error', err);
+                    reject(err);
+                    return;
+                }
+                if (!stats) {
+                    const error = new Error('No stats returned from webpack');
+                    this.emit('error', error);
+                    reject(error);
+                    return;
+                }
+                const result = this.statsToResult(stats);
+                // Copy chunks to resources if build succeeded
+                if (result.success && this.config?.output?.path) {
+                    try {
+                        copyChunksToResources(this.config.output.path);
+                    }
+                    catch (chunkError) {
+                        // Non-fatal, just log
+                        console.warn('Warning: Failed to copy chunks:', chunkError);
+                    }
+                }
+                if (stats.hasErrors()) {
+                    this.emit('error', new Error(stats.toString({ colors: false })));
+                }
+                else if (stats.hasWarnings()) {
+                    this.emit('warning', stats.toString({ colors: false }));
+                }
+                this.emit('done', result);
+                resolve(result);
+            });
+        });
+    }
+    /**
+     * Start webpack in watch mode
+     *
+     * @param callback - Called after each compilation
+     */
+    async watch(callback) {
+        await this.initialize();
+        if (!this.webpack || !this.config) {
+            throw new Error('Webpack not initialized');
+        }
+        return new Promise((resolve) => {
+            this.compiler = this.webpack(this.config);
+            this.watcher = this.compiler.watch({
+                aggregateTimeout: 300,
+                ignored: ['**/dist/**', '**/build/**', '**/node_modules/**'],
+            }, (err, stats) => {
+                if (err) {
+                    this.emit('error', err);
+                    callback?.({
+                        success: false,
+                        errors: [err.message],
+                    });
+                    return;
+                }
+                if (!stats) {
+                    return;
+                }
+                const result = this.statsToResult(stats);
+                // Copy chunks to resources if build succeeded
+                if (result.success && this.config?.output?.path) {
+                    try {
+                        copyChunksToResources(this.config.output.path);
+                    }
+                    catch (chunkError) {
+                        console.warn('Warning: Failed to copy chunks:', chunkError);
+                    }
+                }
+                if (stats.hasErrors()) {
+                    this.emit('error', new Error(stats.toString({ colors: false })));
+                }
+                else if (stats.hasWarnings()) {
+                    this.emit('warning', stats.toString({ colors: false }));
+                }
+                this.emit('done', result);
+                callback?.(result);
+            });
+            // Resolve immediately - watch continues in background
+            resolve();
+        });
+    }
+    /**
+     * Stop watching and close the compiler
+     */
+    async close() {
+        return new Promise((resolve) => {
+            if (this.watcher) {
+                this.watcher.close(() => {
+                    this.watcher = null;
+                    this.compiler = null;
+                    resolve();
+                });
+            }
+            else if (this.compiler) {
+                this.compiler.close(() => {
+                    this.compiler = null;
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    /**
+     * Check if webpack is available in the project
+     */
+    static isWebpackAvailable(projectRoot) {
+        const webpackPath = path.join(projectRoot, 'node_modules', 'webpack');
+        return fs.existsSync(webpackPath);
+    }
+    /**
+     * Get the webpack version from the project
+     */
+    static getWebpackVersion(projectRoot) {
+        try {
+            const packageJsonPath = path.join(projectRoot, 'node_modules', 'webpack', 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+                return packageJson.version;
+            }
+        }
+        catch {
+            // Ignore errors
+        }
+        return null;
+    }
+}
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Run a single webpack build
+ *
+ * @param projectRoot - Project root directory
+ * @param options - Build options
+ * @returns Build result
+ */
+export async function runWebpackBuild(projectRoot, options) {
+    const runner = new WebpackRunner(projectRoot, options);
+    return runner.run();
+}
+/**
+ * Start webpack in watch mode
+ *
+ * @param projectRoot - Project root directory
+ * @param options - Build options
+ * @param callback - Called after each compilation
+ * @returns WebpackRunner instance (call .close() to stop)
+ */
+export async function startWebpackWatch(projectRoot, options, callback) {
+    const runner = new WebpackRunner(projectRoot, options);
+    await runner.watch(callback);
+    return runner;
+}

package/dist/utils/zip.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Zip Utilities
+ *
+ * Handles creating zip archives for Sitevision app distribution.
+ * Also handles webpack chunk organization.
+ */
+/**
+ * Create a zip archive of a directory
+ *
+ * Uses the system `zip` command for cross-platform compatibility.
+ * Falls back to a basic implementation if zip is not available.
+ *
+ * @param sourceDir - Directory to zip
+ * @param outputPath - Path for the output zip file
+ * @returns Promise resolving to the output path
+ */
+export declare function createZip(sourceDir: string, outputPath: string): Promise<string>;
+/**
+ * Create a zip of the build directory for deployment
+ *
+ * @param projectRoot - Project root directory
+ * @param manifest - App manifest for naming
+ * @returns Path to the created zip file
+ */
+export declare function createBuildZip(projectRoot: string, appId: string): Promise<string>;
+/**
+ * Copy webpack chunks to the resource directory
+ *
+ * Webpack outputs chunk files (chunk-*.js) in the build directory.
+ * These need to be moved to a resource/ subdirectory for Sitevision.
+ *
+ * @param buildDir - The build directory containing webpack output
+ */
+export declare function copyChunksToResources(buildDir: string): void;
+/**
+ * Copy static files to build directory
+ *
+ * @param projectRoot - Project root directory
+ */
+export declare function copyStaticToBuild(projectRoot: string): void;
+/**
+ * Copy source files to build directory (for non-bundled apps)
+ *
+ * @param projectRoot - Project root directory
+ */
+export declare function copySrcToBuild(projectRoot: string): void;
+/**
+ * Clean the build directory
+ *
+ * @param projectRoot - Project root directory
+ */
+export declare function cleanBuild(projectRoot: string): void;
+/**
+ * Check if a zip file exists
+ */
+export declare function zipExists(zipPath: string): boolean;
+/**
+ * Get zip file size in bytes
+ */
+export declare function getZipSize(zipPath: string): number;
+/**
+ * Format file size for display
+ */
+export declare function formatFileSize(bytes: number): string;

package/dist/utils/zip.js

@@ -0,0 +1,246 @@
+/**
+ * Zip Utilities
+ *
+ * Handles creating zip archives for Sitevision app distribution.
+ * Also handles webpack chunk organization.
+ */
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { ensureDistDir } from './project-detection.js';
+// =============================================================================
+// ZIP CREATION
+// =============================================================================
+/**
+ * Create a zip archive of a directory
+ *
+ * Uses the system `zip` command for cross-platform compatibility.
+ * Falls back to a basic implementation if zip is not available.
+ *
+ * @param sourceDir - Directory to zip
+ * @param outputPath - Path for the output zip file
+ * @returns Promise resolving to the output path
+ */
+export async function createZip(sourceDir, outputPath) {
+    // Ensure the output directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    // Remove existing zip if present
+    if (fs.existsSync(outputPath)) {
+        fs.unlinkSync(outputPath);
+    }
+    return new Promise((resolve, reject) => {
+        // Try using system zip command (works on macOS, Linux, and Windows with Git Bash)
+        const zipProcess = spawn('zip', ['-r', outputPath, '.'], {
+            cwd: sourceDir,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        zipProcess.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        zipProcess.on('error', (error) => {
+            // If zip command not found, try alternative methods
+            if (error.code === 'ENOENT') {
+                // Fall back to tar on systems without zip
+                createZipWithTar(sourceDir, outputPath)
+                    .then(resolve)
+                    .catch(reject);
+            }
+            else {
+                reject(new Error(`Zip process error: ${error.message}`));
+            }
+        });
+        zipProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(outputPath);
+            }
+            else {
+                reject(new Error(`Zip failed with code ${code}: ${stderr}`));
+            }
+        });
+    });
+}
+/**
+ * Fallback: Create zip using tar (converts to zip format)
+ * This is a fallback for systems without the zip command.
+ */
+async function createZipWithTar(sourceDir, outputPath) {
+    // On Windows without zip, we might need to use PowerShell
+    const isWindows = process.platform === 'win32';
+    if (isWindows) {
+        return createZipWithPowerShell(sourceDir, outputPath);
+    }
+    // On Unix without zip, this is unlikely but we'll throw an error
+    throw new Error('zip command not found. Please install zip: apt-get install zip (Linux) or brew install zip (macOS)');
+}
+/**
+ * Create zip using PowerShell on Windows
+ */
+async function createZipWithPowerShell(sourceDir, outputPath) {
+    return new Promise((resolve, reject) => {
+        const absoluteSourceDir = path.resolve(sourceDir);
+        const absoluteOutputPath = path.resolve(outputPath);
+        const command = `Compress-Archive -Path "${absoluteSourceDir}\\*" -DestinationPath "${absoluteOutputPath}" -Force`;
+        const psProcess = spawn('powershell', ['-Command', command], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        psProcess.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        psProcess.on('error', (error) => {
+            reject(new Error(`PowerShell error: ${error.message}`));
+        });
+        psProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve(absoluteOutputPath);
+            }
+            else {
+                reject(new Error(`PowerShell zip failed with code ${code}: ${stderr}`));
+            }
+        });
+    });
+}
+/**
+ * Create a zip of the build directory for deployment
+ *
+ * @param projectRoot - Project root directory
+ * @param manifest - App manifest for naming
+ * @returns Path to the created zip file
+ */
+export async function createBuildZip(projectRoot, appId) {
+    const buildDir = path.join(projectRoot, 'build');
+    const distDir = ensureDistDir(projectRoot);
+    const zipPath = path.join(distDir, `${appId}.zip`);
+    if (!fs.existsSync(buildDir)) {
+        throw new Error(`Build directory not found: ${buildDir}. Run build first.`);
+    }
+    return createZip(buildDir, zipPath);
+}
+// =============================================================================
+// WEBPACK CHUNK UTILITIES
+// =============================================================================
+/**
+ * Copy webpack chunks to the resource directory
+ *
+ * Webpack outputs chunk files (chunk-*.js) in the build directory.
+ * These need to be moved to a resource/ subdirectory for Sitevision.
+ *
+ * @param buildDir - The build directory containing webpack output
+ */
+export function copyChunksToResources(buildDir) {
+    const resourceDir = path.join(buildDir, 'resource');
+    // Create resource directory if it doesn't exist
+    if (!fs.existsSync(resourceDir)) {
+        fs.mkdirSync(resourceDir, { recursive: true });
+    }
+    // Find and move chunk files
+    const files = fs.readdirSync(buildDir);
+    const chunkPattern = /^chunk-.*\.js$/;
+    for (const file of files) {
+        if (chunkPattern.test(file)) {
+            const sourcePath = path.join(buildDir, file);
+            const destPath = path.join(resourceDir, file);
+            // Move file (copy then delete)
+            fs.copyFileSync(sourcePath, destPath);
+            fs.unlinkSync(sourcePath);
+        }
+    }
+}
+/**
+ * Copy static files to build directory
+ *
+ * @param projectRoot - Project root directory
+ */
+export function copyStaticToBuild(projectRoot) {
+    const staticDir = path.join(projectRoot, 'static');
+    const buildDir = path.join(projectRoot, 'build');
+    if (!fs.existsSync(staticDir)) {
+        return;
+    }
+    // Ensure build directory exists
+    if (!fs.existsSync(buildDir)) {
+        fs.mkdirSync(buildDir, { recursive: true });
+    }
+    // Copy static directory contents to build
+    copyDirRecursive(staticDir, buildDir);
+}
+/**
+ * Copy source files to build directory (for non-bundled apps)
+ *
+ * @param projectRoot - Project root directory
+ */
+export function copySrcToBuild(projectRoot) {
+    const srcDir = path.join(projectRoot, 'src');
+    const buildDir = path.join(projectRoot, 'build');
+    if (!fs.existsSync(srcDir)) {
+        return;
+    }
+    // Ensure build directory exists
+    if (!fs.existsSync(buildDir)) {
+        fs.mkdirSync(buildDir, { recursive: true });
+    }
+    // Copy src directory contents to build
+    copyDirRecursive(srcDir, buildDir);
+}
+/**
+ * Recursively copy a directory
+ */
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest)) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Clean the build directory
+ *
+ * @param projectRoot - Project root directory
+ */
+export function cleanBuild(projectRoot) {
+    const buildDir = path.join(projectRoot, 'build');
+    if (fs.existsSync(buildDir)) {
+        fs.rmSync(buildDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Check if a zip file exists
+ */
+export function zipExists(zipPath) {
+    return fs.existsSync(zipPath);
+}
+/**
+ * Get zip file size in bytes
+ */
+export function getZipSize(zipPath) {
+    if (!fs.existsSync(zipPath)) {
+        return 0;
+    }
+    const stats = fs.statSync(zipPath);
+    return stats.size;
+}
+/**
+ * Format file size for display
+ */
+export function formatFileSize(bytes) {
+    if (bytes === 0) {
+        return '0 B';
+    }
+    const units = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const size = bytes / Math.pow(1024, i);
+    return `${size.toFixed(i > 0 ? 2 : 0)} ${units[i]}`;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+	"name": "sitevision-cli",
+	"version": "0.0.0",
+	"license": "MIT",
+	"bin": {
+		"svc": "dist/cli.js"
+	},
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"test": "prettier --check . && xo && ava"
+	},
+	"files": [
+		"dist"
+	],
+	"dependencies": {
+		"ink": "^6.6.0",
+		"ink-spinner": "^5.0.0",
+		"meow": "^11.0.0",
+		"react": "^19.2.3"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/node": "^25.0.3",
+		"@types/react": "^19.2.7",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.53.1"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
+}