monorepotime 1.0.0

package/dist/routes/scanworkspace.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const express_1 = require("express");
+const START_DIR = process.cwd();
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path_1.default.dirname(dir)) {
+        const pkgPath = path_1.default.join(dir, "package.json");
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = fs_extra_1.default.readJsonSync(pkgPath);
+                if (pkg.workspaces) {
+                    return dir;
+                }
+            }
+            catch (e) {
+                // Ignore errors
+            }
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    return startDir;
+}
+const ROOT = findMonorepoRoot(START_DIR);
+const route = (0, express_1.Router)();
+const IGNORE = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.turbo/**",
+    "**/.next/**",
+    "**/.vercel/**",
+    "**/.cache/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/out/**",
+    "**/coverage/**",
+];
+/**
+ * Safe JSON reader
+ */
+async function readJSON(file) {
+    try {
+        return await fs_extra_1.default.readJSON(file);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Checks if folder has package.json with dev or start
+ */
+async function isRunnableProject(dir) {
+    const pkgPath = path_1.default.join(dir, "package.json");
+    if (!(await fs_extra_1.default.pathExists(pkgPath)))
+        return false;
+    const pkg = await readJSON(pkgPath);
+    if (!pkg?.scripts)
+        return false;
+    //even if the dev script or start script is empty as long it exist
+    //it is considred as runnable
+    if (pkg.scripts.dev != typeof null || pkg.scripts.start != typeof null) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Expand workspace globs like "apps/*"
+ */
+async function resolveWorkspaceDirs(workspaces) {
+    return (0, fast_glob_1.default)(workspaces.map(w => w.replace(/\/$/, "") + "/"), {
+        cwd: ROOT,
+        onlyDirectories: true,
+        absolute: true,
+        ignore: IGNORE,
+    });
+}
+/**
+ * Scan workspaces
+ */
+async function scanWorkspaces(rootPkg) {
+    let patterns = [];
+    if (Array.isArray(rootPkg.workspaces)) {
+        patterns = rootPkg.workspaces;
+    }
+    else if (rootPkg.workspaces?.packages) {
+        patterns = rootPkg.workspaces.packages;
+    }
+    if (!patterns.length)
+        return [];
+    const dirs = await resolveWorkspaceDirs(patterns);
+    const results = new Set();
+    for (const dir of dirs) {
+        if (await isRunnableProject(dir)) {
+            results.add(path_1.default.resolve(dir));
+        }
+    }
+    return [...results];
+}
+/**
+ * Deep scan fallback
+ */
+async function scanRecursively() {
+    const pkgFiles = await (0, fast_glob_1.default)("**/package.json", {
+        cwd: ROOT,
+        absolute: true,
+        ignore: IGNORE,
+    });
+    const results = new Set();
+    for (const pkgFile of pkgFiles) {
+        const dir = path_1.default.dirname(pkgFile);
+        if (await isRunnableProject(dir)) {
+            results.add(path_1.default.resolve(dir));
+        }
+    }
+    return [...results];
+}
+/**
+ * Route
+ */
+route.get("/", async (req, res) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    try {
+        const rootPkgPath = path_1.default.join(ROOT, "package.json");
+        const rootPkg = await readJSON(rootPkgPath);
+        let projects = [];
+        if (rootPkg?.workspaces) {
+            projects = await scanWorkspaces(rootPkg);
+        }
+        else {
+            projects = await scanRecursively();
+        }
+        const projectInfos = (await Promise.all(projects.map(async (p) => {
+            const pkgPath = path_1.default.join(p, "package.json");
+            const pkg = await readJSON(pkgPath);
+            if (!pkg)
+                return null;
+            return {
+                name: pkg.name || path_1.default.basename(p),
+                path: p,
+                fontawesomeIcon: (pkg.fontawesomeIcon != typeof null) ? pkg.fontawesomeIcon : null,
+                description: (pkg.description != typeof null) ? pkg.description : null,
+                devCommand: (pkg.scripts.dev != typeof null) ? pkg.scripts.dev : null,
+                startCommand: (pkg.scripts.start != typeof null) ? pkg.scripts.start : null,
+                stopCommand: (pkg.scripts.stop != typeof null) ? pkg.scripts.stop : null,
+                buildCommand: (pkg.scripts.build != typeof null) ? pkg.scripts.build : null,
+                cleanCommand: (pkg.scripts.clean != typeof null) ? pkg.scripts.clean : null,
+                lintCommand: (pkg.scripts.lint != typeof null) ? pkg.scripts.lint : null,
+                testCommand: (pkg.scripts.test != typeof null) ? pkg.scripts.test : null,
+            };
+        }))).filter(Boolean); // Filter out any failed reads
+        res.json({
+            root: ROOT,
+            count: projectInfos.length,
+            workspace: projectInfos,
+        });
+    }
+    catch (err) {
+        res.status(500).json({ error: err.message });
+    }
+});
+exports.default = route;

package/dist/routes/stopcmd.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const runcmddev_1 = require("./runcmddev");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const router = (0, express_1.Router)();
+router.post("/", async (req, res) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    try {
+        const body = req.body;
+        const workspace = body.workspace;
+        if (!workspace) {
+            return res.status(400).json({ error: "No workspace provided" });
+        }
+        const currentSocket = runcmddev_1.sockets.get(workspace.name);
+        const currentProcess = runcmddev_1.activeProcesses.get(workspace.name);
+        // 1. Kill the Active Process
+        if (currentProcess) {
+            currentSocket?.emit('log', chalk_1.default.yellow("Stopping active process..."));
+            if (currentProcess.pid) {
+                if (process.platform !== 'win32') {
+                    await cleanupProcessPorts(currentProcess.pid, currentSocket);
+                }
+            }
+            await new Promise((resolve) => {
+                let resolved = false;
+                const safeResolve = () => {
+                    if (!resolved) {
+                        resolved = true;
+                        resolve();
+                    }
+                };
+                // Timeout safety: Proceed after 5s if process hangs
+                const timer = setTimeout(() => {
+                    console.log(`Process stop timed out for ${workspace.name}`);
+                    safeResolve();
+                }, 5000);
+                currentProcess.once('exit', () => {
+                    clearTimeout(timer);
+                    safeResolve();
+                });
+                if (currentProcess.pid) {
+                    try {
+                        if (process.platform !== 'win32') {
+                            process.kill(-currentProcess.pid, 'SIGINT');
+                        }
+                        else {
+                            currentProcess.kill();
+                        }
+                    }
+                    catch (error) {
+                        if (error.code === 'ESRCH') {
+                            // Process already dead
+                            clearTimeout(timer);
+                            safeResolve();
+                        }
+                        else {
+                            console.error(`Failed to kill process: ${error.message}`);
+                            // Don't resolve here, wait for timeout or natural exit if signal worked partially
+                        }
+                    }
+                }
+                else {
+                    safeResolve();
+                }
+            });
+            runcmddev_1.activeProcesses.delete(workspace.name);
+        }
+        else {
+            currentSocket?.emit('log', chalk_1.default.yellow("No active process found to stop."));
+        }
+        // 3. Execute Stop Command (if any)
+        const commandToRun = workspace.stopCommand;
+        if (commandToRun) {
+            currentSocket?.emit('log', chalk_1.default.green(`Running stop command: ${commandToRun}`));
+            const baseCMD = commandToRun.split(" ")[0];
+            const args = commandToRun.split(" ").slice(1);
+            const child = (0, child_process_1.spawn)(baseCMD, args, {
+                cwd: workspace.path,
+                env: {
+                    ...process.env,
+                    TERM: 'dumb',
+                    FORCE_COLOR: '1',
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: true,
+                detached: process.platform !== 'win32'
+            });
+            child.stdout.on('data', (data) => {
+                currentSocket?.emit('log', data.toString());
+            });
+            child.stderr.on('data', (data) => {
+                currentSocket?.emit('error', data.toString());
+            });
+            child.on('close', (code) => {
+                currentSocket?.emit('log', chalk_1.default.green(`Stop command finished with code ${code}`));
+                currentSocket?.emit('exit', 'Process stopped');
+                // We keep the socket open or let client disconnect
+            });
+        }
+        else {
+            currentSocket?.emit('log', "Process stopped (no stop command defined).");
+            currentSocket?.emit('exit', 'Process stopped');
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        res.end();
+    }
+    catch (e) {
+        console.error("Error in stopcmd:", e);
+        res.status(500).json({ error: e.message });
+    }
+});
+exports.default = router;
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+async function getProcessTreePids(rootPid) {
+    try {
+        // getting all processes with ppid
+        const { stdout } = await execAsync('ps -e -o pid,ppid --no-headers');
+        const pids = new Set();
+        pids.add(rootPid);
+        const tree = new Map();
+        const lines = stdout.trim().split('\n');
+        for (const line of lines) {
+            const parts = line.trim().split(/\s+/);
+            if (parts.length >= 2) {
+                const pid = parseInt(parts[0], 10);
+                const ppid = parseInt(parts[1], 10);
+                if (!tree.has(ppid))
+                    tree.set(ppid, []);
+                tree.get(ppid)?.push(pid);
+            }
+        }
+        const queue = [rootPid];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const children = tree.get(current);
+            if (children) {
+                for (const child of children) {
+                    pids.add(child);
+                    queue.push(child);
+                }
+            }
+        }
+        return Array.from(pids);
+    }
+    catch (e) {
+        console.error("Error building process tree:", e);
+        return [rootPid];
+    }
+}
+async function cleanupProcessPorts(rootPid, socket) {
+    try {
+        const pids = await getProcessTreePids(rootPid);
+        // lsof output format "-F pn":
+        // p1234
+        // n*:3000
+        const { stdout } = await execAsync('lsof -P -n -iTCP -sTCP:LISTEN -F pn');
+        const lines = stdout.trim().split('\n');
+        let currentPid = -1;
+        const pidPorts = new Map();
+        for (const line of lines) {
+            const type = line[0];
+            const content = line.substring(1);
+            if (type === 'p') {
+                currentPid = parseInt(content, 10);
+            }
+            else if (type === 'n' && currentPid !== -1) {
+                const match = content.match(/:(\d+)$/);
+                if (match) {
+                    const port = match[1];
+                    // Only check if this port belongs to one of our tree PIDs
+                    if (!pidPorts.has(currentPid))
+                        pidPorts.set(currentPid, []);
+                    pidPorts.get(currentPid)?.push(port);
+                }
+            }
+        }
+        for (const pid of pids) {
+            if (pidPorts.has(pid)) {
+                const ports = pidPorts.get(pid);
+                if (ports) {
+                    for (const port of ports) {
+                        socket?.emit('log', chalk_1.default.yellow(`Detected active port ${port} on PID ${pid}. Killing port...`));
+                        try {
+                            await execAsync(`npx -y kill-port ${port}`);
+                        }
+                        catch (err) {
+                            socket?.emit('log', chalk_1.default.red(`Failed to kill port ${port}: ${err.message}`));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        // If lsof fails (e.g. no permissions or no ports open), just ignore
+    }
+}

package/dist/routes/turborepoexist.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const rootPath_1 = require("./rootPath");
+const router = (0, express_1.Router)();
+router.get("/", async (req, res) => {
+    try {
+        let isExist = true;
+        const turboJsonPath = path_1.default.join(rootPath_1.ROOT, 'turbo.json');
+        const turboExists = fs_1.default.existsSync(turboJsonPath);
+        if (!turboExists) {
+            isExist = false;
+        }
+        const monorepoJsonPath = path_1.default.join(rootPath_1.ROOT, 'monorepotime.json');
+        const monorepoExists = fs_1.default.existsSync(monorepoJsonPath);
+        if (!monorepoExists) {
+            isExist = false;
+        }
+        res.json({ exists: isExist });
+    }
+    catch (error) {
+        console.error("Error checking turbo.json:", error);
+        res.status(500).json({ error: "Internal server error", exists: false });
+    }
+});
+exports.default = router;

package/dist/routes/updateworkspace.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const router = (0, express_1.Router)();
+router.post("/", async (req, res) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    try {
+        const workspace = req.body;
+        if (!workspace || !workspace.path) {
+            res.status(400).send({ error: "Invalid workspace data" });
+            return;
+        }
+        const packageJsonPath = path_1.default.join(workspace.path, 'package.json');
+        if (!fs_extra_1.default.existsSync(packageJsonPath)) {
+            res.status(404).send({ error: "package.json not found in workspace path" });
+            return;
+        }
+        const packageJson = await fs_extra_1.default.readJson(packageJsonPath);
+        if (workspace.name)
+            packageJson.name = workspace.name;
+        if (workspace.description != typeof null)
+            packageJson.description = workspace.description;
+        if (workspace.devCommand != typeof null)
+            packageJson.scripts.dev = workspace.devCommand;
+        if (workspace.startCommand != typeof null)
+            packageJson.scripts.start = workspace.startCommand;
+        if (workspace.buildCommand != typeof null)
+            packageJson.scripts.build = workspace.buildCommand;
+        if (workspace.testCommand != typeof null)
+            packageJson.scripts.test = workspace.testCommand;
+        if (workspace.lintCommand != typeof null)
+            packageJson.scripts.lint = workspace.lintCommand;
+        if (workspace.stopCommand != typeof null)
+            packageJson.scripts.stop = workspace.stopCommand;
+        if (workspace.cleanCommand != typeof null)
+            packageJson.scripts.clean = workspace.cleanCommand;
+        await fs_extra_1.default.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+        res.send({ success: true, message: "Workspace updated successfully" });
+    }
+    catch (error) {
+        console.error("Update workspace error:", error);
+        res.status(500).send({ error: error.message });
+    }
+});
+exports.default = router;

package/dist/routes/vscodeHideShow.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const router = (0, express_1.Router)();
+const EXCLUDE_PATTERNS = {
+    "**/node_modules": true,
+    "**/.git": true,
+    "**/.gitignore": true,
+    "**/.turbo": true,
+    "**/dist": true,
+    "**/_tool": true,
+    "**/package-lock.json": true,
+    "**/Dockerfile": true,
+    "**/docker-compose.yml": true,
+    "**/.dockerignore": true,
+    "**/turbo.json": true,
+    "**/nodemon.json": true,
+    "**/temp.md": true,
+    "**/*postcss*": true,
+    "**/*tailwind*": true,
+    "**/*tsconfig*": true,
+    "**/*eslint*": true,
+    "**/*prettier*": true,
+    "**/*vite*": true,
+    "_temp": true,
+    ".gitignore": true,
+    ".vscode": true,
+    "package.json": true,
+    "README.md": true,
+    ".github": true,
+    ".buildkite": true,
+    ".circleci": true,
+    ".gitlab-ci.yml": true,
+    ".travis.yml": true,
+    "out": true
+};
+const EXCLUDE_PATTERNS_DEFAULT = {
+    "**/.git": true,
+    ".vscode": true,
+    ".turbo": true,
+};
+const START_DIR = process.cwd();
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    while (dir !== path_1.default.dirname(dir)) {
+        const pkgPath = path_1.default.join(dir, "package.json");
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            try {
+                const pkg = fs_extra_1.default.readJsonSync(pkgPath);
+                // heuristic: if it has workspaces or if it is the top with .git
+                // But simpler: just look for package.json that seems to be the root. 
+                // Or if we are in a monorepo, the one with 'workspaces'. 
+                // If not a monorepo, maybe just the one with .vscode?
+                // Let's stick to the scanworkspace logic: look for workspaces.
+                // If not found, maybe fall back to just the CWD if we assume the user runs it from root.
+                if (pkg.workspaces) {
+                    return dir;
+                }
+            }
+            catch (e) {
+                // Ignore errors
+            }
+        }
+        // Also check for .vscode folder as a strong indicator of "root" for this context
+        if (fs_extra_1.default.existsSync(path_1.default.join(dir, ".vscode"))) {
+            return dir;
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    return startDir;
+}
+const ROOT = findMonorepoRoot(START_DIR);
+const getSettingsPath = () => {
+    return path_1.default.join(ROOT, '.vscode/settings.json');
+};
+const ensureSettingsFile = async () => {
+    const settingsPath = getSettingsPath();
+    const dir = path_1.default.dirname(settingsPath);
+    await fs_extra_1.default.ensureDir(dir);
+    if (!await fs_extra_1.default.pathExists(settingsPath)) {
+        await fs_extra_1.default.writeJson(settingsPath, { "files.exclude": {} }, { spaces: 4 });
+    }
+};
+/**
+ * POST /
+ * Body: { hide: boolean, pathInclude?: string[] }
+ * Updates files.exclude in settings.json
+ */
+router.post("/", async (req, res) => {
+    try {
+        const { hide, pathInclude } = req.body;
+        await ensureSettingsFile();
+        const settingsPath = getSettingsPath();
+        const settings = await fs_extra_1.default.readJson(settingsPath);
+        // We will reconstruct files.exclude based on the logic
+        // 1. Start with valid defaults
+        const newExcludes = { ...EXCLUDE_PATTERNS_DEFAULT };
+        if (hide) {
+            // 2a. If hide is true, add the standard patterns
+            Object.assign(newExcludes, EXCLUDE_PATTERNS);
+            // 2b. Add the specific paths from pathInclude (converted to relative)
+            if (Array.isArray(pathInclude)) {
+                pathInclude.forEach(p => {
+                    // Ensure path is relative to the workspace ROOT
+                    const relativePath = path_1.default.relative(ROOT, p);
+                    if (relativePath && !relativePath.startsWith('..') && !path_1.default.isAbsolute(relativePath)) {
+                        newExcludes[relativePath] = true;
+                    }
+                });
+            }
+        }
+        // 3. If hide is false, we strictly return the defaults (which we already initialized in step 1).
+        // This effectively "shows all files" (removes other exclusions) except the defaults.
+        // Update the settings object
+        settings['files.exclude'] = newExcludes;
+        await fs_extra_1.default.writeJson(settingsPath, settings, { spaces: 4 });
+        res.json({ success: true, isHidden: hide });
+    }
+    catch (error) {
+        console.error("Error updating VSCode settings:", error);
+        res.status(500).json({ error: 'Failed to update VSCode settings' });
+    }
+});
+exports.default = router;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "monorepotime",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "dev": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "stop": "npx -y kill-port 3000",
+    "copy-frontend": "rm -rf public && mkdir -p public && cp -r ../web/dist/* public/"
+  },
+  "dependencies": {
+    "apiroute": "*",
+    "chalk": "^4.1.2",
+    "config": "*",
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "fast-glob": "^3.3.3",
+    "fs-extra": "^11.3.3",
+    "open": "^11.0.0",
+    "socket.io": "^4.8.3",
+    "types": "*"
+  },
+  "keywords": [],
+  "author": "Anghelo Amir",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^24.10.4",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  },
+
+  "bin": {
+    "monorepotime": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "public"
+  ]
+}