monorepotime 1.0.0

package/dist/index.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpServer = exports.io = exports.app = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const path_1 = __importDefault(require("path"));
+const apiroute_1 = __importDefault(require("apiroute"));
+const config_1 = __importDefault(require("config"));
+const open_1 = __importDefault(require("open"));
+const http_1 = require("http");
+const socket_io_1 = require("socket.io");
+//routers
+const scanworkspace_1 = __importDefault(require("./routes/scanworkspace"));
+const runcmddev_1 = __importDefault(require("./routes/runcmddev"));
+const stopcmd_1 = __importDefault(require("./routes/stopcmd"));
+const listworkspacedirs_1 = __importDefault(require("./routes/listworkspacedirs"));
+const newworkspace_1 = __importDefault(require("./routes/newworkspace"));
+const interactiveTerminal_1 = __importStar(require("./routes/interactiveTerminal"));
+const updateworkspace_1 = __importDefault(require("./routes/updateworkspace"));
+const vscodeHideShow_1 = __importDefault(require("./routes/vscodeHideShow"));
+const rootPath_1 = __importDefault(require("./routes/rootPath"));
+const scafoldrepo_1 = __importDefault(require("./routes/scafoldrepo"));
+const turborepoexist_1 = __importDefault(require("./routes/turborepoexist"));
+const app = (0, express_1.default)();
+exports.app = app;
+const port = config_1.default.apiPort;
+app.use((0, cors_1.default)({
+    origin: true,
+    credentials: true,
+}));
+app.use(express_1.default.static('public'));
+app.use(express_1.default.json());
+// Serve frontend static files
+//routes=======================================================================
+app.use("/" + apiroute_1.default.scanWorkspace, scanworkspace_1.default);
+app.use("/" + apiroute_1.default.stopProcess, stopcmd_1.default);
+app.use("/" + apiroute_1.default.listWorkspacesDir, listworkspacedirs_1.default);
+app.use("/" + apiroute_1.default.newWorkspace, newworkspace_1.default);
+app.use("/" + apiroute_1.default.interactvTerminal, interactiveTerminal_1.default);
+app.use("/" + apiroute_1.default.updateWorkspace, updateworkspace_1.default);
+app.use("/" + apiroute_1.default.hideShowFileFolder, vscodeHideShow_1.default);
+app.use("/" + apiroute_1.default.getRootPath, rootPath_1.default);
+app.use("/" + apiroute_1.default.scaffoldRepo, scafoldrepo_1.default);
+app.use("/" + apiroute_1.default.turborepoExist, turborepoexist_1.default);
+// Serve frontend static files==================================================
+const frontendPath = path_1.default.join(__dirname, '../public');
+app.use(express_1.default.static(frontendPath));
+app.get('*', (req, res) => {
+    res.sendFile(path_1.default.join(frontendPath, 'index.html'));
+});
+// Socket.IO Setup ============================================================
+const httpServer = (0, http_1.createServer)(app);
+exports.httpServer = httpServer;
+const io = new socket_io_1.Server(httpServer, {
+    cors: {
+        origin: "*",
+        methods: ["GET", "POST"],
+    },
+    transports: ['websocket', 'polling']
+});
+exports.io = io;
+(0, runcmddev_1.default)(io);
+(0, interactiveTerminal_1.interactiveTerminalSocket)(io);
+//=============================================================================
+httpServer.listen(port, () => {
+    console.log(`Server running at http://localhost:${port}`);
+    (0, open_1.default)(`http://localhost:${port}`);
+});
+exports.default = app;

package/dist/routes/_temp.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const router = (0, express_1.Router)();
+router.get("/", async (req, res) => {
+    console.log('called');
+    res.send("Hello World!");
+});
+exports.default = router;

package/dist/routes/interactiveTerminal.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactiveTerminalSocket = interactiveTerminalSocket;
+const express_1 = require("express");
+const child_process_1 = require("child_process");
+const router = (0, express_1.Router)();
+// Keep the router for potential future HTTP endpoints, though we primarily use sockets now
+router.get("/", async (req, res) => {
+    res.send("Interactive Terminal Route");
+});
+exports.default = router;
+// Map to store active terminal processes for each socket
+const activeTerminals = new Map();
+function interactiveTerminalSocket(io) {
+    io.on('connection', (socket) => {
+        socket.on('terminal:start', (data) => {
+            const { path, command } = data;
+            if (activeTerminals.has(socket.id)) {
+                const oldChild = activeTerminals.get(socket.id);
+                if (oldChild) {
+                    // Remove all listeners to prevent 'exit' or 'data' events from the old process
+                    // interfering with the new one or sending confusing logs.
+                    oldChild.removeAllListeners();
+                    oldChild.stdout?.removeAllListeners();
+                    oldChild.stderr?.removeAllListeners();
+                    oldChild.kill();
+                    activeTerminals.delete(socket.id);
+                    socket.emit('terminal:log', '\r\n\x1b[33m[System] Previous command terminated.\x1b[0m\r\n');
+                }
+            }
+            try {
+                const env = { ...process.env };
+                delete env.CI;
+                env.TERM = 'xterm-256color';
+                env.FORCE_COLOR = '1';
+                // Use PROMPT_COMMAND to force the PS1 prompt. 
+                // This overrides any PS1 set by .bashrc which is sourced by the interactive shell.
+                // Format: [PATH] /current/path (newline) $ 
+                // \033[34m = Blue, \033[32m = Green, \033[0m = Reset
+                // We use \033 (octal) which is standard for bash PS1.
+                env.PROMPT_COMMAND = 'export PS1="\\[\\033[34m\\][PATH] \\[\\033[32m\\]\\w\\[\\033[0m\\]\\n$ ";';
+                let child;
+                if (process.platform === 'win32') {
+                    // Windows does not support the python pty module.
+                    // We fall back to standard spawn with shell: true.
+                    // Interactivity might be limited (arrow keys might not work in some apps),
+                    // but standard input/output should function.
+                    socket.emit('terminal:log', '\x1b[33m[System] Windows detected. Running in compatible mode (limited interactivity).\x1b[0m\r\n');
+                    const baseCMD = command.split(" ")[0];
+                    const args = command.split(" ").slice(1);
+                    child = (0, child_process_1.spawn)(baseCMD, args, {
+                        cwd: path,
+                        env: env,
+                        shell: true,
+                        stdio: ['pipe', 'pipe', 'pipe']
+                    });
+                }
+                else {
+                    // Linux/Mac: Use Python PTY bridge for full interactivity
+                    env.CMD = command;
+                    const pythonScript = `
+import pty, sys, os
+
+try:
+    cmd = os.environ.get('CMD')
+    if not cmd:
+        sys.exit(1)
+
+    # pty.spawn(argv) executes argv and connects stdin/stdout to pty
+    status = pty.spawn(['/bin/bash', '-c', 'stty cols 80 rows 24; ' + cmd])
+
+    if os.WIFEXITED(status):
+        sys.exit(os.WEXITSTATUS(status))
+    else:
+        sys.exit(1)
+except ImportError:
+    sys.exit(127) # Return special code if pty module missing (unlikely on unix)
+except Exception as e:
+    sys.exit(1)
+`;
+                    child = (0, child_process_1.spawn)('python3', ['-u', '-c', pythonScript], {
+                        cwd: path,
+                        env: env,
+                        stdio: ['pipe', 'pipe', 'pipe']
+                    });
+                }
+                activeTerminals.set(socket.id, child);
+                child.stdout?.on('data', (chunk) => {
+                    socket.emit('terminal:log', chunk.toString());
+                });
+                child.stderr?.on('data', (chunk) => {
+                    socket.emit('terminal:log', chunk.toString());
+                });
+                child.on('error', (err) => {
+                    if (err.code === 'ENOENT' && process.platform !== 'win32') {
+                        socket.emit('terminal:error', '\r\n\x1b[31mError: Python3 is required for interactive mode on Linux/Mac but was not found.\x1b[0m');
+                    }
+                    else {
+                        socket.emit('terminal:error', `Failed to start command: ${err.message}`);
+                    }
+                    cleanup(socket.id);
+                });
+                child.on('exit', (code) => {
+                    // Check for our custom "Python missing pty" code or general failure logic
+                    if (code === 127 && process.platform !== 'win32') {
+                        socket.emit('terminal:error', '\r\n\x1b[31mError: Python PTY module issue.\x1b[0m');
+                    }
+                    else if (code !== 0) {
+                        socket.emit('terminal:error', `\r\nProcess exited with code ${code}`);
+                    }
+                    else {
+                        //socket.emit('terminal:log', `\r\nProcess finished successfully.`);
+                    }
+                    socket.emit('terminal:exit', code);
+                    cleanup(socket.id);
+                });
+            }
+            catch (error) {
+                socket.emit('terminal:error', `Error handling command: ${error.message}`);
+                cleanup(socket.id);
+            }
+        });
+        socket.on('terminal:input', (input) => {
+            const child = activeTerminals.get(socket.id);
+            if (child && child.stdin) {
+                // With PTY bridge, we send raw input. PTY handles newlines/signals.
+                child.stdin.write(input);
+            }
+        });
+        socket.on('disconnect', () => {
+            const child = activeTerminals.get(socket.id);
+            if (child) {
+                // Remove listeners so we don't try to emit 'exit' or 'error' to a disconnected socket
+                child.removeAllListeners();
+                child.stdout?.removeAllListeners();
+                child.stderr?.removeAllListeners();
+                child.kill(); // Kill the process if client disconnects
+                activeTerminals.delete(socket.id);
+            }
+        });
+        function cleanup(socketId) {
+            activeTerminals.delete(socketId);
+        }
+    });
+}

package/dist/routes/listworkspacedirs.js

@@ -0,0 +1,107 @@
+"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 START_DIR = process.cwd();
+// Find the monorepo root (where package.json with "workspaces" is defined)
+// If not found, default to START_DIR
+const findRoot = async (dir) => {
+    const pkgPath = path_1.default.join(dir, 'package.json');
+    if (await fs_extra_1.default.pathExists(pkgPath)) {
+        try {
+            const pkg = await fs_extra_1.default.readJSON(pkgPath);
+            // If "workspaces" is defined, we assume this is the root
+            if (pkg.workspaces) {
+                return dir;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const parent = path_1.default.dirname(dir);
+    if (parent === dir)
+        return START_DIR;
+    return findRoot(parent);
+};
+router.get("/", async (req, res) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    try {
+        const rootPath = await findRoot(START_DIR);
+        const pkgPath = path_1.default.join(rootPath, 'package.json');
+        let workspaceDirs = [];
+        let foundWorkspaces = false;
+        // 1. Try to read "workspaces" from package.json
+        if (await fs_extra_1.default.pathExists(pkgPath)) {
+            const pkg = await fs_extra_1.default.readJSON(pkgPath);
+            let globs = [];
+            if (pkg.workspaces) {
+                if (Array.isArray(pkg.workspaces)) {
+                    globs = pkg.workspaces;
+                }
+                else if (pkg.workspaces.packages && Array.isArray(pkg.workspaces.packages)) {
+                    globs = pkg.workspaces.packages;
+                }
+            }
+            if (globs.length > 0) {
+                foundWorkspaces = true;
+                const uniqueDirs = new Set();
+                for (const pattern of globs) {
+                    // Pattern examples: "apps/*", "packages/*", "libs/my-lib"
+                    // We want the top-level folder, e.g. "apps", "packages", "libs"
+                    const parts = pattern.split('/');
+                    if (parts.length > 0) {
+                        const topLevel = parts[0];
+                        // filter out if the pattern was just "*" (unlikely but possible) or empty
+                        if (topLevel && topLevel !== '*') {
+                            uniqueDirs.add(topLevel);
+                        }
+                    }
+                }
+                for (const dirName of uniqueDirs) {
+                    const fullPath = path_1.default.join(rootPath, dirName);
+                    if (await fs_extra_1.default.pathExists(fullPath)) {
+                        workspaceDirs.push({
+                            label: dirName,
+                            path: fullPath
+                        });
+                    }
+                }
+            }
+        }
+        // 2. If no workspaces defined, fallback to scanning root
+        if (!foundWorkspaces) {
+            const items = await fs_extra_1.default.readdir(rootPath, { withFileTypes: true });
+            workspaceDirs = items
+                .filter(item => item.isDirectory())
+                .filter(item => {
+                const name = item.name;
+                // Exclude node_modules
+                if (name === 'node_modules')
+                    return false;
+                // Exclude hidden fs (start with .)
+                if (name.startsWith('.'))
+                    return false;
+                // Exclude folders starting with _
+                if (name.startsWith('_'))
+                    return false;
+                return true;
+            })
+                .map(item => ({
+                label: item.name,
+                path: path_1.default.join(rootPath, item.name)
+            }));
+        }
+        return res.json(workspaceDirs);
+    }
+    catch (e) {
+        console.error("Error listing workspaces:", e);
+        res.status(500).json({ error: e.message });
+    }
+});
+exports.default = router;

package/dist/routes/newworkspace.js

@@ -0,0 +1,43 @@
+"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 reqBody = req.body;
+        const targetPath = reqBody.path;
+        if (!targetPath) {
+            return res.status(400).json({ error: "Path is required" });
+        }
+        await fs_extra_1.default.ensureDir(targetPath);
+        const packageJson = {
+            name: reqBody.name || path_1.default.basename(targetPath),
+            version: "1.0.0",
+            description: reqBody.description || "",
+            fontawesomeIcon: reqBody.fontawesomeIcon || "",
+            scripts: {
+                dev: reqBody.devCommand || "",
+                start: reqBody.startCommand || undefined,
+                stop: reqBody.stopCommand || undefined,
+                build: reqBody.buildCommand || undefined,
+                clean: reqBody.cleanCommand || undefined,
+                lint: reqBody.lintCommand || undefined,
+                test: reqBody.testCommand || undefined
+            }
+        };
+        Object.keys(packageJson.scripts).forEach(key => packageJson.scripts[key] === undefined && delete packageJson.scripts[key]);
+        await fs_extra_1.default.writeJSON(path_1.default.join(targetPath, "package.json"), packageJson, { spaces: 2 });
+        res.json({ message: "Workspace created successfully", path: targetPath });
+    }
+    catch (e) {
+        console.error("Error creating workspace:", e);
+        res.status(500).json({ error: e.message });
+    }
+});
+exports.default = router;

package/dist/routes/rootPath.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROOT = void 0;
+exports.findMonorepoRoot = findMonorepoRoot;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+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;
+}
+exports.ROOT = findMonorepoRoot(START_DIR);
+const route = (0, express_1.Router)();
+route.get("/", async (req, res) => {
+    res.json({ path: exports.ROOT });
+});
+exports.default = route;

package/dist/routes/runcmddev.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sockets = exports.activeProcesses = void 0;
+exports.default = runCmdDevSocket;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+exports.activeProcesses = new Map();
+exports.sockets = new Map();
+function runCmdDevSocket(io) {
+    io.on('connection', (socket) => {
+        socket.on('run', (data) => {
+            exports.sockets.set(data.workspace.name, socket);
+            try {
+                handleOnRun(socket, data);
+            }
+            catch (error) {
+                socket.emit('error', {
+                    message: error
+                });
+            }
+        });
+    });
+}
+async function handleOnRun(socket, data) {
+    const { workspace, runas } = data;
+    if (exports.activeProcesses.has(workspace.name))
+        return socket.emit("log", "Attached to already running process...");
+    const commandToRun = runas === "dev" ? workspace.devCommand : workspace.startCommand;
+    if (!commandToRun)
+        throw new Error("No command to run");
+    const baseCMD = commandToRun.split(" ")[0];
+    const args = commandToRun.split(" ").slice(1);
+    socket.emit('log', chalk_1.default.green(`${data.workspace.path}: ${commandToRun}`));
+    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'
+    });
+    exports.activeProcesses.set(workspace.name, child);
+    child.on('error', (error) => {
+        socket.emit('error', error.message);
+    });
+    child.stdout.on('data', (data) => {
+        socket.emit('log', data.toString());
+    });
+    child.stderr.on('data', (data) => {
+        socket.emit('error', data.toString());
+    });
+    child.on('exit', (code) => {
+        socket.emit('exit', `Process exited with code ${code}`);
+    });
+}

package/dist/routes/scafoldrepo.js

@@ -0,0 +1,156 @@
+"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 child_process_1 = require("child_process");
+const rootPath_1 = require("./rootPath");
+const router = (0, express_1.Router)();
+router.get("/", async (req, res) => {
+    try {
+        const packageJsonPath = path_1.default.join(rootPath_1.ROOT, "package.json");
+        const turboJsonPath = path_1.default.join(rootPath_1.ROOT, "turbo.json");
+        // 1. Read package.json
+        if (!fs_extra_1.default.existsSync(packageJsonPath)) {
+            res.status(400).json({ error: "package.json not found in root" });
+            return; // Stop execution
+        }
+        const pkg = fs_extra_1.default.readJsonSync(packageJsonPath);
+        let pkgChanged = false;
+        // 2. Check Workspaces
+        if (!pkg.workspaces) {
+            pkg.workspaces = ["apps/*", "packages/*"];
+            pkgChanged = true;
+        }
+        // 3. Save package.json if workspaces changed (before install)
+        if (pkgChanged) {
+            fs_extra_1.default.writeJsonSync(packageJsonPath, pkg, { spaces: 2 });
+        }
+        // 4. Create directories
+        await fs_extra_1.default.ensureDir(path_1.default.join(rootPath_1.ROOT, 'apps'));
+        await fs_extra_1.default.ensureDir(path_1.default.join(rootPath_1.ROOT, 'packages'));
+        // 4.1 Create monorepotime.json if not exists
+        const monorepoTimePath = path_1.default.join(rootPath_1.ROOT, "monorepotime.json");
+        if (!fs_extra_1.default.existsSync(monorepoTimePath)) {
+            const defaultMonorepoTime = [
+                {
+                    "category": "Internal CRUD Test",
+                    "devurl": "http://localhost:3200",
+                    "produrl": "http://superhost:3200",
+                    "items": [
+                        {
+                            "label": "Ping the Tool Server",
+                            "route": "/pingme",
+                            "methods": "GET",
+                            "description": "Ping the tool server to check if it is running.",
+                            "sampleInput": "{}",
+                            "suggested": [],
+                            "expectedOutcome": "# You should see the word \"pong\" as a message \n\n{\n  \"message\": \"pong\"\n}",
+                            "availableFor": "public"
+                        },
+                        {
+                            "label": "Check Post",
+                            "route": "/pingpost",
+                            "methods": "POST",
+                            "description": "Send a POST request to check if it sending correctly",
+                            "sampleInput": "{\n   \"data\": \"test\",\n   \"message\": \"test\"\n}",
+                            "suggested": [
+                                {
+                                    "name": "Customer Data",
+                                    "urlparams": "",
+                                    "content": "{\n    \"name\": \"Demo Customer\",\n    \"email\": \"CusRaRa@customer.com\",\n    \"phone1\": \"123456789\",\n    \"phone2\": \"987654321\",\n    \"city\": \"randomw1\",\n    \"state\": \"ultra state\",\n    \"zip\": \"12345\",\n    \"country\": \"mega country\",\n    \"icon\": \"test icon\",\n    \"gender\": \"female\",\n    \"delivery_notes\": \"Make sure that it is packed correctly\"\n}"
+                                }
+                            ],
+                            "expectedOutcome": "# Note \nYou should see the mirror of your inputs",
+                            "availableFor": "public"
+                        },
+                        {
+                            "label": "Check Stream",
+                            "route": "/pingstream",
+                            "methods": "STREAM",
+                            "description": "Send a stream request to check if it sending correctly",
+                            "sampleInput": "{ }",
+                            "suggested": [
+                                {
+                                    "name": "I Wandered Lonely as a Cloud",
+                                    "urlparams": "?poem=I%20Wandered%20Lonely%20as%20a%20Cloud",
+                                    "content": "{}"
+                                },
+                                {
+                                    "name": "The Sun Has Long Been Set",
+                                    "urlparams": "?poem=The%20Sun%20Has%20Long%20Been%20Set",
+                                    "content": "{}"
+                                }
+                            ],
+                            "expectedOutcome": "# Note \nYou should see the stream of words",
+                            "availableFor": "public"
+                        }
+                    ]
+                }
+            ];
+            fs_extra_1.default.writeJsonSync(monorepoTimePath, defaultMonorepoTime, { spaces: 4 });
+        }
+        // 5. Create turbo.json if not exists
+        if (!fs_extra_1.default.existsSync(turboJsonPath) || !pkg.devDependencies?.turbo) {
+            if (!fs_extra_1.default.existsSync(turboJsonPath)) {
+                const defaultTurbo = {
+                    "$schema": "https://turbo.build/schema.json",
+                    "pipeline": {
+                        "build": {
+                            "outputs": ["dist/**", ".next/**"]
+                        },
+                        "lint": {}
+                    }
+                };
+                fs_extra_1.default.writeJsonSync(turboJsonPath, defaultTurbo, { spaces: 2 });
+            }
+            // 6. Commands
+            // Check if turbo is in devDependencies
+            const hasTurbo = pkg.devDependencies && pkg.devDependencies.turbo;
+            if (!hasTurbo) {
+                // installing turbo will install deps
+                await runCommand("npm install turbo -D", rootPath_1.ROOT);
+            }
+            else {
+                // just install to ensure workspaces are linked
+                await runCommand("npm install", rootPath_1.ROOT);
+            }
+        }
+        else {
+            // If everything existed, user requested "then npm install" implies we might still want to ensure state?
+            // But the prompt says: "if so [missing turbo.json or turbo dep], then ... then npm install".
+            // It also says "if the root package.json has no 'workspaces'... then npm install".
+            // To be safe, let's run npm install if we changed workspaces OR if we entered the 'turbo missing' block.
+            if (pkgChanged) {
+                await runCommand("npm install", rootPath_1.ROOT);
+            }
+        }
+        res.json({ success: true, message: "Scaffolding complete" });
+    }
+    catch (error) {
+        console.error("Scaffolding error:", error);
+        res.status(500).json({
+            error: "Failed to scaffold",
+            details: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+function runCommand(cmd, cwd) {
+    console.log(`Running: ${cmd} in ${cwd}`);
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(cmd, { cwd }, (error, stdout, stderr) => {
+            if (error) {
+                console.error("Exec error:", stderr);
+                reject(error);
+            }
+            else {
+                console.log(stdout); // Log output
+                resolve();
+            }
+        });
+    });
+}
+exports.default = router;