lunel-cli 0.1.99 → 0.1.101

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { WebSocket } from "ws";
 import qrcode from "qrcode-terminal";
+import shell from "shelljs";
 import { createAiManager } from "./ai/index.js";
 import { V2SessionTransport } from "./transport/v2.js";
 import Ignore from "ignore";
@@ -566,64 +567,82 @@ async function handleFsGrep(payload) {
         throw Object.assign(new Error("pattern is required"), { code: "EINVAL" });
     const safePath = assertSafePath(reqPath);
     const matches = [];
-    const regex = new RegExp(pattern, caseSensitive ? "g" : "gi");
+    let regex;
+    try {
+        regex = new RegExp(pattern, caseSensitive ? "g" : "gi");
+    }
+    catch {
+        throw Object.assign(new Error("pattern must be a valid regular expression"), { code: "EINVAL" });
+    }
     const rootIgnore = await loadGitignore(ROOT_DIR);
-    async function searchFile(filePath, relativePath) {
-        if (matches.length >= maxResults)
-            return;
-        try {
-            const content = await fs.readFile(filePath, "utf-8");
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
-                if (regex.test(lines[i])) {
-                    matches.push({
-                        file: relativePath,
-                        line: i + 1,
-                        content: lines[i].substring(0, 500),
-                    });
+    const previousSilent = shell.config.silent;
+    shell.config.silent = true;
+    try {
+        async function searchFile(filePath, relativePath) {
+            if (matches.length >= maxResults)
+                return;
+            try {
+                const grepResult = shell.grep(regex, filePath);
+                if (grepResult.code !== 0 || !grepResult.stdout.trim()) {
+                    regex.lastIndex = 0;
+                    return;
                 }
+                const content = await fs.readFile(filePath, "utf-8");
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length && matches.length < maxResults; i++) {
+                    if (regex.test(lines[i])) {
+                        matches.push({
+                            file: relativePath,
+                            line: i + 1,
+                            content: lines[i].substring(0, 500),
+                        });
+                    }
+                    regex.lastIndex = 0;
+                }
+            }
+            catch {
                 regex.lastIndex = 0;
             }
         }
-        catch {
-            // Skip unreadable files
-        }
-    }
-    async function searchDir(dirPath, relativePath, ig) {
-        if (matches.length >= maxResults)
-            return;
-        const localIgnore = ignore().add(ig);
-        try {
-            const localGitignorePath = path.join(dirPath, ".gitignore");
-            const content = await fs.readFile(localGitignorePath, "utf-8");
-            localIgnore.add(content);
-        }
-        catch {
-            // No local .gitignore
-        }
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
+        async function searchDir(dirPath, relativePath, ig) {
             if (matches.length >= maxResults)
-                break;
-            const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-            const checkPath = entry.isDirectory() ? `${relPath}/` : relPath;
-            if (localIgnore.ignores(checkPath))
-                continue;
-            const fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                await searchDir(fullPath, relPath, localIgnore);
+                return;
+            const localIgnore = ignore().add(ig);
+            try {
+                const localGitignorePath = path.join(dirPath, ".gitignore");
+                const content = await fs.readFile(localGitignorePath, "utf-8");
+                localIgnore.add(content);
+            }
+            catch {
+                // No local .gitignore
             }
-            else if (entry.isFile()) {
-                await searchFile(fullPath, relPath);
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (matches.length >= maxResults)
+                    break;
+                const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+                const checkPath = entry.isDirectory() ? `${relPath}/` : relPath;
+                if (localIgnore.ignores(checkPath))
+                    continue;
+                const fullPath = path.join(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    await searchDir(fullPath, relPath, localIgnore);
+                }
+                else if (entry.isFile()) {
+                    await searchFile(fullPath, relPath);
+                }
             }
         }
+        const stat = await fs.stat(safePath);
+        if (stat.isDirectory()) {
+            await searchDir(safePath, reqPath === "." ? "" : reqPath, rootIgnore);
+        }
+        else {
+            await searchFile(safePath, reqPath);
+        }
     }
-    const stat = await fs.stat(safePath);
-    if (stat.isDirectory()) {
-        await searchDir(safePath, reqPath === "." ? "" : reqPath, rootIgnore);
-    }
-    else {
-        await searchFile(safePath, reqPath);
+    finally {
+        shell.config.silent = previousSilent;
     }
     return { matches };
 }
@@ -1525,7 +1544,7 @@ function handleProcessesList() {
     }
     return { processes: result };
 }
-function handleProcessesSpawn(payload) {
+async function handleProcessesSpawn(payload) {
     const command = payload.command;
     const args = payload.args || [];
     const cwd = payload.cwd;
@@ -1539,7 +1558,31 @@ function handleProcessesSpawn(payload) {
         stdio: ["pipe", "pipe", "pipe"],
         shell: false,
     });
-    const pid = proc.pid;
+    const pid = await new Promise((resolve, reject) => {
+        let settled = false;
+        const handleSpawn = () => {
+            if (settled)
+                return;
+            settled = true;
+            proc.removeListener("error", handleError);
+            if (!proc.pid) {
+                reject(Object.assign(new Error(`Failed to spawn "${command}"`), { code: "ERROR" }));
+                return;
+            }
+            resolve(proc.pid);
+        };
+        const handleError = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            proc.removeListener("spawn", handleSpawn);
+            reject(Object.assign(new Error(err.message || `Failed to spawn "${command}"`), {
+                code: err.code || "ERROR",
+            }));
+        };
+        proc.once("spawn", handleSpawn);
+        proc.once("error", handleError);
+    });
     const channel = `proc-${pid}`;
     const managedProc = {
         pid,
@@ -1569,6 +1612,17 @@ function handleProcessesSpawn(payload) {
     };
     proc.stdout?.on("data", sendOutput("stdout"));
     proc.stderr?.on("data", sendOutput("stderr"));
+    proc.on("error", (err) => {
+        const message = err.message || `Process "${command}" failed`;
+        processOutputBuffers.set(channel, (processOutputBuffers.get(channel) || "") + `${message}\n`);
+        emitAppEvent({
+            v: 1,
+            id: `evt-${Date.now()}`,
+            ns: "processes",
+            action: "output",
+            payload: { pid, channel, stream: "stderr", data: `${message}\n` },
+        });
+    });
     proc.on("close", (code, signal) => {
         const msg = {
             v: 1,
@@ -2565,7 +2619,7 @@ async function processMessage(message) {
                         result = handleProcessesList();
                         break;
                     case "spawn":
-                        result = handleProcessesSpawn(payload);
+                        result = await handleProcessesSpawn(payload);
                         break;
                     case "kill":
                         result = handleProcessesKill(payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.99",
+  "version": "0.1.101",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -30,12 +30,14 @@
     "ignore": "^6.0.2",
     "libsodium-wrappers": "^0.7.15",
     "qrcode-terminal": "^0.12.0",
+    "shelljs": "^0.10.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/minimatch": "^5.1.2",
     "@types/node": "^20.0.0",
     "@types/qrcode-terminal": "^0.12.2",
+    "@types/shelljs": "^0.10.0",
     "@types/ws": "^8.5.13",
     "typescript": "^5.0.0"
   },