lunel-cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,6 +1,267 @@
 #!/usr/bin/env node
+import { WebSocket } from "ws";
 import qrcode from "qrcode-terminal";
+import Ignore from "ignore";
+const ignore = Ignore.default;
+import * as fs from "fs/promises";
+import * as path from "path";
 const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://proxy-1.lunel.dev";
+// Root directory - sandbox all file operations to this
+const ROOT_DIR = process.cwd();
+// Validate and resolve path within sandbox
+function resolveSafePath(requestedPath) {
+    // Resolve the requested path relative to ROOT_DIR
+    const resolved = path.resolve(ROOT_DIR, requestedPath);
+    // Ensure the resolved path is within ROOT_DIR
+    if (!resolved.startsWith(ROOT_DIR)) {
+        return null;
+    }
+    return resolved;
+}
+// Handle ls command
+async function handleLs(requestedPath) {
+    const safePath = resolveSafePath(requestedPath);
+    if (!safePath) {
+        throw new Error("Access denied: path outside root directory");
+    }
+    const entries = await fs.readdir(safePath, { withFileTypes: true });
+    return entries.map((entry) => ({
+        name: entry.name,
+        type: entry.isDirectory() ? "directory" : "file",
+    }));
+}
+// Handle read command
+async function handleRead(requestedPath) {
+    const safePath = resolveSafePath(requestedPath);
+    if (!safePath) {
+        throw new Error("Access denied: path outside root directory");
+    }
+    const content = await fs.readFile(safePath, "utf-8");
+    return content;
+}
+// Handle write command
+async function handleWrite(requestedPath, content) {
+    const safePath = resolveSafePath(requestedPath);
+    if (!safePath) {
+        throw new Error("Access denied: path outside root directory");
+    }
+    // Ensure parent directory exists
+    const parentDir = path.dirname(safePath);
+    await fs.mkdir(parentDir, { recursive: true });
+    await fs.writeFile(safePath, content, "utf-8");
+}
+// Load gitignore patterns from a directory
+async function loadGitignore(dirPath) {
+    const ig = ignore();
+    // Always ignore .git directory
+    ig.add(".git");
+    try {
+        const gitignorePath = path.join(dirPath, ".gitignore");
+        const content = await fs.readFile(gitignorePath, "utf-8");
+        ig.add(content);
+    }
+    catch {
+        // No .gitignore file, that's fine
+    }
+    return ig;
+}
+// Handle grep command - search for pattern in files
+async function handleGrep(requestedPath, pattern, options = {}) {
+    const safePath = resolveSafePath(requestedPath);
+    if (!safePath) {
+        throw new Error("Access denied: path outside root directory");
+    }
+    const { caseSensitive = true, maxResults = 100 } = options;
+    const matches = [];
+    const regex = new RegExp(pattern, caseSensitive ? "g" : "gi");
+    // Load root gitignore
+    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), // Limit line length
+                    });
+                }
+                // Reset regex lastIndex for global flag
+                regex.lastIndex = 0;
+            }
+        }
+        catch {
+            // Skip files that can't be read (binary, permissions, etc.)
+        }
+    }
+    async function searchDir(dirPath, relativePath, ig) {
+        if (matches.length >= maxResults)
+            return;
+        // Check for local .gitignore and merge with parent
+        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) {
+            if (matches.length >= maxResults)
+                break;
+            const relPath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+            // Check if ignored by gitignore
+            // For directories, append / to match gitignore patterns correctly
+            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, requestedPath === "." ? "" : requestedPath, rootIgnore);
+    }
+    else {
+        await searchFile(safePath, requestedPath);
+    }
+    return matches;
+}
+// Handle replace command - find and replace in a file
+async function handleReplace(requestedPath, search, replace, options = {}) {
+    const safePath = resolveSafePath(requestedPath);
+    if (!safePath) {
+        throw new Error("Access denied: path outside root directory");
+    }
+    const { caseSensitive = true, replaceAll = true } = options;
+    const content = await fs.readFile(safePath, "utf-8");
+    const flags = replaceAll ? (caseSensitive ? "g" : "gi") : (caseSensitive ? "" : "i");
+    const regex = new RegExp(search.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+    // Count replacements
+    const matchCount = (content.match(regex) || []).length;
+    if (matchCount === 0) {
+        return { file: requestedPath, replacements: 0 };
+    }
+    const newContent = content.replace(regex, replace);
+    await fs.writeFile(safePath, newContent, "utf-8");
+    return { file: requestedPath, replacements: matchCount };
+}
+// Process incoming request from app
+async function processRequest(message) {
+    const { id, action, payload } = message;
+    try {
+        switch (action) {
+            case "ls": {
+                const reqPath = payload.path || ".";
+                const entries = await handleLs(reqPath);
+                return {
+                    id,
+                    type: "response",
+                    action: "ls",
+                    payload: { path: reqPath, entries },
+                };
+            }
+            case "read": {
+                const reqPath = payload.path;
+                if (!reqPath) {
+                    throw new Error("path is required");
+                }
+                const content = await handleRead(reqPath);
+                return {
+                    id,
+                    type: "response",
+                    action: "read",
+                    payload: { path: reqPath, content },
+                };
+            }
+            case "write": {
+                const reqPath = payload.path;
+                const content = payload.content;
+                if (!reqPath) {
+                    throw new Error("path is required");
+                }
+                if (typeof content !== "string") {
+                    throw new Error("content is required");
+                }
+                await handleWrite(reqPath, content);
+                return {
+                    id,
+                    type: "response",
+                    action: "write",
+                    payload: { path: reqPath, success: true },
+                };
+            }
+            case "grep": {
+                const reqPath = payload.path || ".";
+                const pattern = payload.pattern;
+                if (!pattern) {
+                    throw new Error("pattern is required");
+                }
+                const matches = await handleGrep(reqPath, pattern, {
+                    caseSensitive: payload.caseSensitive,
+                    maxResults: payload.maxResults,
+                });
+                return {
+                    id,
+                    type: "response",
+                    action: "grep",
+                    payload: { path: reqPath, pattern, matches },
+                };
+            }
+            case "replace": {
+                const reqPath = payload.path;
+                const search = payload.search;
+                const replaceWith = payload.replace;
+                if (!reqPath) {
+                    throw new Error("path is required");
+                }
+                if (!search) {
+                    throw new Error("search is required");
+                }
+                if (typeof replaceWith !== "string") {
+                    throw new Error("replace is required");
+                }
+                const result = await handleReplace(reqPath, search, replaceWith, {
+                    caseSensitive: payload.caseSensitive,
+                    replaceAll: payload.replaceAll,
+                });
+                return {
+                    id,
+                    type: "response",
+                    action: "replace",
+                    payload: { ...result },
+                };
+            }
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        return {
+            id,
+            type: "error",
+            action,
+            payload: {
+                code: error.code || "ERROR",
+                message: errorMessage,
+            },
+        };
+    }
+}
 async function createSession() {
     const response = await fetch(`${PROXY_URL}/v1/session`, {
         method: "POST",
@@ -19,14 +280,69 @@ function displayQR(code) {
     qrcode.generate(code, { small: true }, (qr) => {
         console.log(qr);
         console.log(`\n  Session code: ${code}\n`);
-        console.log("  Scan the QR code with the Lunel app to connect.\n");
+        console.log(`  Root directory: ${ROOT_DIR}\n`);
+        console.log("  Scan the QR code with the Lunel app to connect.");
+        console.log("  Press Ctrl+C to exit.\n");
+    });
+}
+function connectWebSocket(code) {
+    const wsUrl = PROXY_URL.replace(/^http/, "ws") + `/v1/ws/cli?code=${code}`;
+    console.log("Connecting to proxy...");
+    const ws = new WebSocket(wsUrl);
+    ws.on("open", () => {
+        console.log("Connected to proxy. Waiting for app...\n");
+    });
+    ws.on("message", async (data) => {
+        try {
+            const message = JSON.parse(data.toString());
+            // Handle system messages
+            if (message.type === "connected") {
+                return;
+            }
+            if (message.type === "peer_connected") {
+                console.log("App connected!\n");
+                return;
+            }
+            if (message.type === "peer_disconnected") {
+                console.log("App disconnected.\n");
+                return;
+            }
+            // Handle file operation requests
+            if (message.type === "request") {
+                const response = await processRequest(message);
+                ws.send(JSON.stringify(response));
+            }
+            // Handle proxy errors
+            if (message.type === "error" && !("action" in message)) {
+                console.error("Proxy error:", message.payload?.message);
+                return;
+            }
+        }
+        catch (error) {
+            console.error("Error processing message:", error);
+        }
+    });
+    ws.on("close", (code, reason) => {
+        console.log(`\nDisconnected from proxy (${code}: ${reason.toString()})`);
+        process.exit(0);
+    });
+    ws.on("error", (error) => {
+        console.error("WebSocket error:", error.message);
+    });
+    // Handle graceful shutdown
+    process.on("SIGINT", () => {
+        console.log("\nShutting down...");
+        ws.close();
+        process.exit(0);
     });
 }
 async function main() {
-    console.log("Connecting to Lunel...");
+    console.log("Lunel CLI");
+    console.log("=========\n");
     try {
         const code = await createSession();
         displayQR(code);
+        connectWebSocket(code);
     }
     catch (error) {
         if (error instanceof Error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -25,11 +25,14 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "qrcode-terminal": "^0.12.0"
+    "ignore": "^6.0.2",
+    "qrcode-terminal": "^0.12.0",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@types/qrcode-terminal": "^0.12.2",
+    "@types/ws": "^8.5.13",
     "typescript": "^5.0.0"
   },
   "engines": {