code-mon-config 1.0.7 → 1.0.8

package/index.js

@@ -9,6 +9,7 @@ const open = require("open");
 const WebSocket = require("ws");
 
 const app = express();
+
 app.use(cors());
 app.use(express.json());
 
@@ -16,162 +17,373 @@ const PORT = 3000;
 const ROOT = process.cwd();
 
 /* ---------------- PROCESS MANAGER ---------------- */
+
 let processes = {};
 let processId = 0;
 
+/* ---------------- SAFE PATH ---------------- */
+
+function safePath(filename) {
+
+  if (!filename) {
+    throw new Error("Filename required");
+  }
+
+  const resolved = path.join(ROOT, filename);
+
+  if (!resolved.startsWith(ROOT)) {
+    throw new Error("Invalid path");
+  }
+
+  return resolved;
+}
+
 /* ---------------- FILE TREE ---------------- */
+
 function getTree(dir, base = "") {
+
   let results = [];
   const list = fs.readdirSync(dir);
 
   list.forEach(file => {
+
     const full = path.join(dir, file);
     const rel = path.join(base, file);
     const stat = fs.statSync(full);
 
     if (stat.isDirectory()) {
+
       results.push(rel + "/");
       results = results.concat(getTree(full, rel));
+
     } else {
+
       results.push(rel);
+
     }
+
   });
 
   return results;
 }
 
 /* ---------------- FILE APIs ---------------- */
+
 app.get("/list", (req, res) => {
+
   try {
+
     const tree = getTree(ROOT);
-    res.json({ root: ROOT, files: tree });
+
+    res.json({
+      root: ROOT,
+      files: tree
+    });
+
   } catch (err) {
+
     res.json({ error: err.message });
+
   }
+
 });
 
+/* LOAD FILE */
+
 app.get("/load", (req, res) => {
-  const filename = req.query.filename;
-  const filePath = path.join(ROOT, filename);
 
-  if (!fs.existsSync(filePath)) return res.json({ error: "File not found" });
+  try {
+
+    const filename = req.query.filename;
+    const filePath = safePath(filename);
+
+    if (!fs.existsSync(filePath)) {
+      return res.json({ error: "File not found" });
+    }
+
+    const content = fs.readFileSync(filePath, "utf8");
+
+    res.json({ content });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
 
-  const content = fs.readFileSync(filePath, "utf8");
-  res.json({ content });
 });
 
+/* SAVE FILE */
+
 app.post("/save", (req, res) => {
-  const { filename, content } = req.body;
-  const filePath = path.join(ROOT, filename);
-  fs.writeFileSync(filePath, content || "");
-  res.json({ success: true });
+
+  try {
+
+    const { filename, content } = req.body;
+
+    const filePath = safePath(filename);
+
+    fs.writeFileSync(filePath, content || "");
+
+    res.json({ success: true });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
+
 });
 
+/* CREATE FILE */
+
 app.post("/create", (req, res) => {
-  const { filename } = req.body;
-  const filePath = path.join(ROOT, filename);
-  fs.writeFileSync(filePath, "");
-  res.json({ success: true });
+
+  try {
+
+    const { filename } = req.body;
+
+    const filePath = safePath(filename);
+
+    fs.writeFileSync(filePath, "");
+
+    res.json({ success: true });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
+
 });
 
+/* DELETE FILE */
+
 app.delete("/delete", (req, res) => {
-  const { filename } = req.body;
-  const filePath = path.join(ROOT, filename);
-  if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
-  res.json({ success: true });
+
+  try {
+
+    const { filename } = req.body;
+
+    const filePath = safePath(filename);
+
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+
+    res.json({ success: true });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
+
 });
 
 /* ---------------- EXECUTE COMMAND ---------------- */
+
 app.post("/execute", (req, res) => {
-  const { command } = req.body;
-  if (!command) return res.json({ error: "Command required" });
 
-  const parts = command.split(" ");
-  const proc = spawn(parts[0], parts.slice(1), { cwd: ROOT, shell: true });
-  const id = processId++;
-  processes[id] = proc;
+  try {
+
+    const { command } = req.body;
 
-  proc.stdout.on("data", data => console.log(`[${id}]`, data.toString()));
-  proc.stderr.on("data", data => console.error(`[${id}]`, data.toString()));
-  proc.on("close", code => {
-    delete processes[id];
-    console.log(`Process ${id} exited`);
-  });
+    if (!command) {
+      return res.json({ error: "Command required" });
+    }
+
+    const parts = command.split(" ");
+
+    const proc = spawn(parts[0], parts.slice(1), {
+      cwd: ROOT,
+      shell: true
+    });
+
+    const id = processId++;
+
+    processes[id] = proc;
+
+    proc.stdout.on("data", data => {
+      console.log(`[${id}]`, data.toString());
+    });
+
+    proc.stderr.on("data", data => {
+      console.error(`[${id}]`, data.toString());
+    });
+
+    proc.on("close", code => {
+
+      delete processes[id];
+
+      console.log(`Process ${id} exited`);
+
+    });
+
+    res.json({
+      success: true,
+      processId: id
+    });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
 
-  res.json({ success: true, processId: id });
 });
 
 /* ---------------- PROCESS LIST ---------------- */
+
 app.get("/processes", (req, res) => {
-  const list = Object.keys(processes).map(id => ({ id }));
+
+  const list = Object.keys(processes).map(id => ({
+    id
+  }));
+
   res.json(list);
+
 });
 
 /* ---------------- STOP PROCESS ---------------- */
+
 app.post("/stop-process", (req, res) => {
-  const { id } = req.body;
-  if (!processes[id]) return res.json({ error: "Process not found" });
 
-  processes[id].kill();
-  delete processes[id];
+  try {
+
+    const { id } = req.body;
+
+    if (!processes[id]) {
+      return res.json({ error: "Process not found" });
+    }
+
+    processes[id].kill();
+
+    delete processes[id];
+
+    res.json({
+      success: true,
+      message: "Process stopped"
+    });
+
+  } catch (err) {
+
+    res.json({ error: err.message });
+
+  }
 
-  res.json({ success: true, message: "Process stopped" });
 });
 
 /* ---------------- EXTENSION LOADER ---------------- */
-const EXT_DIR = path.join(__dirname, "extensions");
-if (fs.existsSync(EXT_DIR)) {
-  fs.readdirSync(EXT_DIR).forEach(file => {
+
+const EXTENSIONS_DIR = path.join(ROOT, "extensions");
+
+if (fs.existsSync(EXTENSIONS_DIR)) {
+
+  fs.readdirSync(EXTENSIONS_DIR).forEach(file => {
+
     if (file.endsWith(".js")) {
+
       try {
-        require(path.join(EXT_DIR, file))({ app, ROOT, spawn, processes });
+
+        require(path.join(EXTENSIONS_DIR, file))({
+          app,
+          ROOT,
+          spawn,
+          processes
+        });
+
         console.log(`🔌 Loaded extension: ${file}`);
-      } catch (e) {
-        console.error(`❌ Failed to load extension ${file}:`, e);
+
+      } catch (err) {
+
+        console.log(`❌ Failed to load extension: ${file}`);
+
       }
+
     }
+
   });
+
 }
 
 /* ---------------- START SERVER ---------------- */
+
 const server = app.listen(PORT, async () => {
-  console.log("\n🚀 Code Mon Config Starting...");
+
+  console.log("\n🚀 Code Mon Config Starting...\n");
+
   console.log("📂 Connected Folder:", ROOT);
+
   console.log("\n✅ Your terminal has been connected with Code Mon Code Space\n");
 
-  const url = `http://localhost:${PORT}`;
+  const url = "http://localhost:3000";
+
   console.log("🌐 Opening:", url);
-  try { await open(url); } catch { console.log("Open manually:", url); }
+
+  try {
+
+    await open(url);
+
+  } catch {
+
+    console.log("Open manually:", url);
+
+  }
+
 });
 
 /* ---------------- WEBSOCKET TERMINAL ---------------- */
+
 const wss = new WebSocket.Server({ server });
 
 wss.on("connection", ws => {
+
   console.log("🟢 Terminal connected");
 
   let proc;
+
   ws.on("message", msg => {
+
     const command = msg.toString();
 
     if (!proc) {
-      proc = spawn(command, { cwd: ROOT, shell: true });
 
-      proc.stdout.on("data", data => ws.send(data.toString()));
-      proc.stderr.on("data", data => ws.send(data.toString()));
+      proc = spawn(command, {
+        cwd: ROOT,
+        shell: true
+      });
+
+      proc.stdout.on("data", data => {
+        ws.send(data.toString());
+      });
+
+      proc.stderr.on("data", data => {
+        ws.send(data.toString());
+      });
 
       proc.on("close", code => {
+
         ws.send(`\nProcess exited with code ${code}\n`);
+
         proc = null;
+
       });
 
     } else {
-      proc.stdin.write(command + "\n"); // support multi-step input
+
+      proc.stdin.write(command + "\n");
+
     }
+
   });
 
   ws.on("close", () => {
+
     if (proc) proc.kill();
+
     console.log("🔴 Terminal disconnected");
+
   });
+
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-mon-config",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Code Mon Code Space CLI with plugin/extension system",
   "main": "index.js",
   "bin": {