lunel-cli 0.1.35 → 0.1.38

package/dist/index.js

@@ -11,6 +11,7 @@ import * as os from "os";
 import { spawn, execSync, execFileSync } from "child_process";
 import { createServer, createConnection } from "net";
 import { createInterface } from "readline";
+import { simpleGit } from "simple-git";
 const DEFAULT_PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
 const MANAGER_URL = process.env.LUNEL_MANAGER_URL || "https://manager.lunel.dev";
 const CLI_ARGS = process.argv.slice(2);
@@ -22,6 +23,7 @@ const PTY_RELEASE_INFO_URL = process.env.LUNEL_PTY_INFO_URL ||
 const VERBOSE_AI_LOGS = process.env.LUNEL_DEBUG_AI === "1";
 // Root directory - sandbox all file operations to this
 const ROOT_DIR = process.cwd();
+const gitClient = simpleGit(ROOT_DIR);
 // Terminal sessions (managed by Rust PTY binary)
 const terminals = new Set();
 // PTY binary process
@@ -51,6 +53,7 @@ const PROXY_WS_CONNECT_RETRY_ATTEMPTS = 1;
 const PROXY_WS_RETRY_JITTER_MIN_MS = 200;
 const PROXY_WS_RETRY_JITTER_MAX_MS = 500;
 const PROXY_TUNNEL_LINGER_MS = 1_200;
+const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
 let portSyncTimer = null;
 let portScanInFlight = false;
 let lastDiscoveredPorts = [];
@@ -219,6 +222,21 @@ function assertSafePath(requestedPath) {
 // ============================================================================
 // File System Handlers
 // ============================================================================
+function isLikelyBinaryBuffer(buffer) {
+    if (buffer.length === 0)
+        return false;
+    if (buffer.includes(0x00))
+        return true;
+    let suspicious = 0;
+    for (let i = 0; i < buffer.length; i++) {
+        const byte = buffer[i];
+        const isPrintableAscii = byte >= 0x20 && byte <= 0x7e;
+        const isCommonControl = byte === 0x09 || byte === 0x0a || byte === 0x0d;
+        if (!isPrintableAscii && !isCommonControl)
+            suspicious++;
+    }
+    return suspicious / buffer.length > 0.3;
+}
 async function handleFsLs(payload) {
     const reqPath = payload.path || ".";
     const safePath = assertSafePath(reqPath);
@@ -257,6 +275,25 @@ async function handleFsStat(payload) {
         mtime: stat.mtimeMs,
         mode: stat.mode,
     };
+    if (stat.isFile()) {
+        try {
+            const fd = await fs.open(safePath, "r");
+            try {
+                const sampleSize = Math.min(stat.size, 8192);
+                const sample = Buffer.alloc(sampleSize);
+                if (sampleSize > 0) {
+                    await fd.read(sample, 0, sampleSize, 0);
+                }
+                result.isBinary = isLikelyBinaryBuffer(sample);
+            }
+            finally {
+                await fd.close();
+            }
+        }
+        catch {
+            // Keep stat resilient even if sampling fails
+        }
+    }
     return result;
 }
 async function handleFsRead(payload) {
@@ -267,8 +304,8 @@ async function handleFsRead(payload) {
     // Check if binary
     const stat = await fs.stat(safePath);
     const content = await fs.readFile(safePath);
-    // Try to detect if binary
-    const isBinary = content.includes(0x00);
+    // Detect if binary
+    const isBinary = isLikelyBinaryBuffer(content.subarray(0, 8192));
     if (isBinary) {
         return {
             path: reqPath,
@@ -569,6 +606,68 @@ async function handleGitLog(payload) {
     });
     return { commits };
 }
+async function handleGitCommitDetails(payload) {
+    const hash = payload.hash;
+    if (!hash)
+        throw Object.assign(new Error("hash is required"), { code: "EINVAL" });
+    try {
+        const logResult = await gitClient.log({
+            from: hash,
+            to: hash,
+            maxCount: 1,
+            format: {
+                fullHash: "%H",
+                message: "%s",
+                author: "%an",
+                timestamp: "%at",
+            },
+        });
+        const latest = logResult.latest;
+        if (!latest) {
+            throw Object.assign(new Error("Commit not found"), { code: "EGIT" });
+        }
+        const filesRaw = await gitClient.show(["--name-status", "--format=", hash]);
+        const files = filesRaw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const parts = line.split("\t");
+            const status = parts[0] || "?";
+            // Handles regular + rename/copy name-status output.
+            const path = parts[2] || parts[1] || "";
+            return { status, path };
+        })
+            .filter((entry) => !!entry.path);
+        const diff = await gitClient.show(["--patch", "--format=", hash]);
+        const fileDiffs = {};
+        const fileChunks = diff.split(/^diff --git /m).filter(Boolean);
+        for (const chunk of fileChunks) {
+            const patch = `diff --git ${chunk}`;
+            const firstLine = chunk.split(/\r?\n/, 1)[0] || "";
+            const match = firstLine.match(/^a\/(.+?) b\/(.+)$/);
+            if (match?.[2]) {
+                fileDiffs[match[2]] = patch;
+            }
+        }
+        return {
+            commit: {
+                hash: latest.fullHash.substring(0, 7),
+                fullHash: latest.fullHash,
+                message: latest.message,
+                author: latest.author,
+                date: parseInt(latest.timestamp, 10) * 1000,
+            },
+            files,
+            diff,
+            fileDiffs,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "git show failed";
+        throw Object.assign(new Error(message), { code: "EGIT" });
+    }
+}
 async function handleGitDiff(payload) {
     const filepath = payload.path;
     const staged = payload.staged === true;
@@ -1690,20 +1789,36 @@ async function scanDevPorts() {
     const openPorts = [];
     const checks = SCAN_PORTS.map((port) => {
         return new Promise((resolve) => {
-            const socket = createConnection({ port, host: "127.0.0.1" });
-            socket.setTimeout(200);
-            socket.on("connect", () => {
-                openPorts.push(port);
-                socket.destroy();
-                resolve();
-            });
-            socket.on("timeout", () => {
-                socket.destroy();
-                resolve();
-            });
-            socket.on("error", () => {
-                resolve();
-            });
+            let finished = false;
+            let pending = LOOPBACK_HOSTS.length;
+            for (const host of LOOPBACK_HOSTS) {
+                const socket = createConnection({ port, host });
+                socket.setTimeout(200);
+                socket.on("connect", () => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    openPorts.push(port);
+                    socket.destroy();
+                    resolve();
+                });
+                const onDone = () => {
+                    if (finished)
+                        return;
+                    pending -= 1;
+                    if (pending <= 0) {
+                        finished = true;
+                        resolve();
+                    }
+                };
+                socket.on("timeout", () => {
+                    socket.destroy();
+                    onDone();
+                });
+                socket.on("error", () => {
+                    onDone();
+                });
+            }
         });
     });
     await Promise.all(checks);
@@ -1765,23 +1880,47 @@ async function handleProxyConnect(payload) {
     if (getRemainingSetupMs() <= 0) {
         throw Object.assign(new Error("Tunnel setup timeout before start"), { code: "ETIMEOUT" });
     }
-    // 1. Open TCP connection to the local service
-    const tcpSocket = createConnection({ port, host: "127.0.0.1" });
-    const tcpConnectTimeoutMs = Math.min(CLI_LOCAL_TCP_CONNECT_TIMEOUT_MS, Math.max(250, getRemainingSetupMs()));
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            tcpSocket.destroy();
-            reject(Object.assign(new Error(`TCP connect timeout to localhost:${port}`), { code: "ETIMEOUT" }));
-        }, tcpConnectTimeoutMs);
-        tcpSocket.on("connect", () => {
-            clearTimeout(timeout);
-            resolve();
-        });
-        tcpSocket.on("error", (err) => {
-            clearTimeout(timeout);
-            reject(Object.assign(new Error(`TCP connect failed: ${err.message}`), { code: "ECONNREFUSED" }));
-        });
-    });
+    // 1. Open TCP connection to the local service (dual-stack localhost fallback)
+    let tcpSocket = null;
+    let tcpConnectError = null;
+    for (const host of LOOPBACK_HOSTS) {
+        const remainingMs = getRemainingSetupMs();
+        if (remainingMs <= 0) {
+            throw Object.assign(new Error("Tunnel setup timeout before local TCP connect"), { code: "ETIMEOUT" });
+        }
+        const tcpConnectTimeoutMs = Math.min(CLI_LOCAL_TCP_CONNECT_TIMEOUT_MS, Math.max(250, remainingMs));
+        const candidate = createConnection({ port, host });
+        try {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    candidate.destroy();
+                    reject(Object.assign(new Error(`TCP connect timeout to ${host}:${port}`), { code: "ETIMEOUT" }));
+                }, tcpConnectTimeoutMs);
+                candidate.on("connect", () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                candidate.on("error", (err) => {
+                    clearTimeout(timeout);
+                    reject(Object.assign(new Error(`TCP connect failed to ${host}:${port}: ${err.message}`), { code: "ECONNREFUSED" }));
+                });
+            });
+            tcpSocket = candidate;
+            break;
+        }
+        catch (error) {
+            tcpConnectError = error;
+            try {
+                candidate.destroy();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!tcpSocket) {
+        throw tcpConnectError || Object.assign(new Error(`TCP connect failed to localhost:${port}`), { code: "ECONNREFUSED" });
+    }
     // 2. Open proxy WebSocket to gateway
     const wsBase = activeGatewayUrl.replace(/^http/, "ws");
     const authQuery = currentSessionPassword
@@ -2069,6 +2208,9 @@ async function processMessage(message) {
                     case "log":
                         result = await handleGitLog(payload);
                         break;
+                    case "commitDetails":
+                        result = await handleGitCommitDetails(payload);
+                        break;
                     case "diff":
                         result = await handleGitDiff(payload);
                         break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.35",
+  "version": "0.1.38",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -14,7 +14,7 @@
   "license": "Functional Source License, Version 1.1, Apache 2.0 Future License",
   "type": "module",
   "bin": {
-    "lunel-cli": "./dist/index.js"
+    "lunel-cli": "dist/index.js"
   },
   "files": [
     "dist",
@@ -29,6 +29,7 @@
     "@opencode-ai/sdk": "^1.1.56",
     "ignore": "^6.0.2",
     "qrcode-terminal": "^0.12.0",
+    "simple-git": "^3.32.3",
     "ws": "^8.18.0"
   },
   "devDependencies": {