@codenotch/codenotch.cli 1.0.33 → 1.0.35

package/src/utils/ServeUtils.ts

@@ -1,175 +0,0 @@
-import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import { join, resolve } from 'path';
-import ConsoleUtils from './ConsoleUtils';
-
-export interface IServeOptions {
-    port?: number;
-    index?: string;
-}
-export default abstract class ServeUtils {
-    static async serveApp(directory: string, options: IServeOptions) {
-        const port = options.port || 5000;
-        const isAbsolutePath = directory && (directory.startsWith('/') || directory.match(/^[a-zA-Z]:\\/));
-        const targetDir = resolve(isAbsolutePath ? directory : join(process.cwd(), directory));
-        const indexPath = resolve(targetDir, options.index || 'index.html');
-
-        if (!existsSync(targetDir)) {
-            console.log(chalk.red(`Error: Target directory not found (${targetDir})`));
-            process.exit(1);
-        }
-
-        if (!existsSync(indexPath)) {
-            console.log(chalk.red(`Error: Index file not found (${indexPath})`));
-            process.exit(1);
-        }
-
-        const envVariables = this.getEnvVariables(resolve(targetDir, '.env'));
-        const aumlObject = this.getAumlVariables(resolve(targetDir, 'auml.json'));
-        console.log(chalk.green('Starting production server...'));
-        console.log(chalk.blue(`Server: http://localhost:${port}`));
-        console.log(chalk.yellow('Using built-in static file server with custom endpoint\n'));
-
-        await this.startExpressServer(targetDir, indexPath, {
-            port: port,
-            envVariables: envVariables,
-            auml: aumlObject
-        });
-    }
-
-    private static getAumlVariables(aumlPath: string): any {
-        if (existsSync(aumlPath)) {
-            console.log(chalk.green(`Loaded auml variables from "${aumlPath}":`));
-            try{
-                let json = readFileSync(aumlPath, 'utf8');
-                return JSON.parse(json);
-            }
-            catch(error){
-                console.log(chalk.red(`Error parsing auml file: ${error}`));
-            }
-        }
-        else {
-            console.log(chalk.yellow(`Warning: No .auml file found. Auml variables will not be loaded.`));
-        }
-        return undefined;
-    }
-    private static getEnvVariables(envPath: string): { name: string, value: string }[] {
-        let envVariables: { name: string, value: string }[] = [];
-        if (existsSync(envPath)) {
-            let envContent = readFileSync(envPath, 'utf8');
-            envContent.split('\n').forEach(line => {
-                let [key, value] = line.split('=');
-                if (key && value) {
-                    envVariables.push({ name: key.trim(), value: value.trim() });
-                }
-            });
-            console.log(chalk.green(`Loaded environment variables from "${envPath}":`));
-            envVariables.forEach(env => {
-                console.log(chalk.blue(`- ${env.name}=${env.value}`));
-            });
-        }
-        else {
-            console.log(chalk.yellow(`Warning: No .env file found. Environment variables will not be loaded.`));
-        }
-        return envVariables;
-    }
-
-    private static async startExpressServer(targetDir: string, indexPath: string, options: {
-        port: number;
-        envVariables: { name: string, value: string }[];
-        auml: any;
-    }){
-
-        // Express server
-        try {
-            const express = await import('express');
-            const app = express.default();
-
-            // Serve static files
-            app.use(express.static(targetDir));
-
-            app.get('/api/env', (req, res) => {
-                let envData: { [key: string]: string } = {};
-                options.envVariables.forEach(env => {
-                    envData[env.name] = env.value;
-                });
-                if(options.auml && Object.keys(options.auml).length > 0){
-                    for(let key of Object.keys(options.auml)){
-                        envData[`GLOBAL.${key}`] = JSON.stringify(options.auml[key]);
-                    }
-                }
-                res.json(envData);
-            });
-
-            // Fallback to index.html for SPA - handle all unmatched routes
-            app.use((req, res, next) => {
-                // Skip fallback for static files (images, favicons, etc.)
-                const staticFileExtensions = ['.ico', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.css', '.js', '.map', '.txt', '.xml', '.json'];
-                const hasStaticExtension = staticFileExtensions.some(ext => req.path.toLowerCase().endsWith(ext));
-
-                // Only serve index.html for GET requests that aren't API calls or static files
-                if (req.method === 'GET' && !req.path.startsWith('/api/') && !hasStaticExtension) {
-                    console.log(chalk.gray(`Serving fallback for: ${req.path}`));
-
-                    // Use a more robust approach for sending files with special characters
-                    try {
-                        res.sendFile(indexPath, {
-                            maxAge: 0,
-                            etag: false
-                        }, (err) => {
-                            if (err) {
-                                console.error(chalk.red(`Error serving ${indexPath}: ${err.message}`));
-                                if (!res.headersSent) {
-                                    res.status(404).send('Page not found');
-                                }
-                            }
-                        });
-                    } catch (error) {
-                        console.error(chalk.red(`Catch error: ${error}`));
-                        if (!res.headersSent) {
-                            res.status(500).send('Internal Server Error');
-                        }
-                    }
-                } else {
-                    // For static files that don't exist, return 404 directly
-                    if (hasStaticExtension) {
-                        res.status(404).send('File not found');
-                    } else {
-                        next();
-                    }
-                }
-            });
-
-            const server = app.listen(options.port, () => {
-                console.log(chalk.green(`Server running on http://localhost:${options.port}`) + ConsoleUtils.proposeOpenUri('Open in browser?', `http://localhost:${options.port}`));
-            });
-
-            const killServer = () => {
-                console.log(chalk.yellow('\nStopping server...'));
-
-                // Force exit graceful shutdown takes too long
-                const forceExit = setTimeout(() => {
-                    console.log(chalk.red('Force stopping server...'));
-                    process.exit(0);
-                }, 500);
-
-                server.close(() => {
-                    clearTimeout(forceExit);
-                    process.exit(0);
-                });
-
-                // For Node.js 18.02+ - close all connections immediately
-                if (typeof server.closeAllConnections === 'function') {
-                    server.closeAllConnections();
-                }
-            };
-
-            process.on('SIGINT', () => killServer());
-            process.on('SIGTERM', () => killServer());
-
-        } catch (error) {
-            console.log(chalk.red(`Error starting server: ${error}`));
-            process.exit(1);
-        }
-    }
-}

package/src/utils/ShellUtils.ts

@@ -1,26 +0,0 @@
-import chalk from 'chalk';
-import { exec } from 'child_process';
-
-export default abstract class ShellUtils{
-    public static async exec(location: string, command: string, info?: string, silent: boolean = false): Promise<void> {
-        
-        if(info)
-            console.log(info + "...");
-        await new Promise((resolve, reject) => {
-            exec(command, { cwd: location }, (error: any, stdout: any, stderr: any) => {
-                if (error) {
-                    if (!silent) {
-                        console.error(`Error while ${info}: ${error}`);
-                    }
-                    reject(error);
-                } else {
-                    if (!silent) {
-                        console.log(stdout);
-                        console.error(stderr);
-                    }
-                    resolve(null);
-                }
-            });
-        });
-    }
-}

package/src/utils/StringUtils.ts

@@ -1,80 +0,0 @@
-
-import { platform } from 'os';
-
-export default abstract class StringUtils {
-
-    static firstUpper(str: string): string {
-        if (str.trim() === '')
-            return str;
-
-        return `${str[0].toUpperCase()}${str.substring(1)}`;
-    }
-    public static toRelativePath(path: string, parentPath: string): string {
-        path = path.replaceAll("\\", "/");
-        parentPath = parentPath.replaceAll("\\", "/");
-
-        path = path.replace(parentPath, '');
-
-        if (path.startsWith("/")) {
-            path = path.substring(1);
-        }
-
-        return path;
-    }
-
-    static getNameWithoutExtention(filename: string): string {
-        filename = this.getFilenameFromUri(filename);
-
-        if (!filename.includes('.')) {
-            return filename;
-        }
-
-        let ind = filename.lastIndexOf('.');
-        return filename.substring(0, ind);
-    }
-
-    static getFilenameFromUri(uri: string): string {
-        uri = uri.replaceAll('\\', '/');
-        return uri.includes('/') ? uri.split('/').pop()! : uri;
-    }
-
-    static getFolder(path: string): string {
-        path = path.replaceAll("/", "\\");
-        if (path.includes('\\') === false) {
-            return '';
-        }
-
-        path = path.substring(0, path.lastIndexOf("\\"));
-        path = this.normalizePath(path);
-        return path;
-    }
-
-    static normalizePath(path: string): string {
-        if (typeof path !== 'string' || path.trim() === '') {   
-            return '';
-        }
-
-        if (platform() === 'win32') {
-            path = path.replaceAll("/", '\\');
-        }
-        else {
-            path = path.replaceAll('\\', '/');
-        }
-        return path;
-    }
-
-    static async sha256(message: string): Promise<string> {
-        // encode as UTF-8
-        const msgBuffer = new TextEncoder().encode(message);
-
-        // hash the message
-        const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
-
-        // convert ArrayBuffer to Array
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-
-        // convert bytes to hex string                  
-        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-        return hashHex;
-    }
-}

package/tsconfig.json

@@ -1,35 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "allowImportingTsExtensions": false,
-    "noEmitOnError": true,
-    "pretty": true,
-    "lib": ["ES2022"],
-    "types": ["node"]
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts",
-    "**/*.spec.ts"
-  ],
-  "ts-node": {
-    "esm": true,
-    "experimentalSpecifierResolution": "node"
-  }
-}