lunel-cli 0.1.91 → 0.1.93

package/dist/index.js

@@ -70,6 +70,9 @@ let currentPrimaryGateway = DEFAULT_PROXY_URL;
 let activeGatewayUrl = DEFAULT_PROXY_URL;
 let shuttingDown = false;
 let activeV2Transport = null;
+const trackedEditorFiles = new Map();
+const trackedEditorDirectories = new Map();
+const pendingTrackedFileChecks = new Set();
 function logWithTimestamp(scope, message, fields) {
     if (!DEBUG_MODE)
         return;
@@ -493,6 +496,7 @@ async function handleFsWrite(payload) {
     const reqPath = payload.path;
     const content = payload.content;
     const encoding = payload.encoding || "utf8";
+    const source = typeof payload.source === "string" ? payload.source : null;
     if (!reqPath)
         throw Object.assign(new Error("path is required"), { code: "EINVAL" });
     if (typeof content !== "string")
@@ -506,6 +510,7 @@ async function handleFsWrite(payload) {
     else {
         await fs.writeFile(safePath, content, "utf-8");
     }
+    await noteTrackedFileWrite(reqPath, source);
     return { path: reqPath };
 }
 async function handleFsMkdir(payload) {
@@ -524,6 +529,7 @@ async function handleFsRm(payload) {
         throw Object.assign(new Error("path is required"), { code: "EINVAL" });
     const safePath = assertSafePath(reqPath);
     await fs.rm(safePath, { recursive, force: false });
+    deleteTrackedEditorFile(reqPath);
     return { path: reqPath };
 }
 async function handleFsMv(payload) {
@@ -536,6 +542,7 @@ async function handleFsMv(payload) {
     const safeFrom = assertSafePath(from);
     const safeTo = assertSafePath(to);
     await fs.rename(safeFrom, safeTo);
+    await renameTrackedEditorFile(from, to);
     return { from, to };
 }
 // Load gitignore patterns
@@ -943,6 +950,254 @@ function emitAppEvent(msg) {
         });
     }
 }
+function emitEditorFileChanged(requestPath, mtimeMs, size) {
+    logWithTimestamp("editor-watch", "emitting fileChanged", { path: requestPath, mtime: mtimeMs, size });
+    emitAppEvent({
+        v: 1,
+        id: `editor-change-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        ns: "editor",
+        action: "fileChanged",
+        payload: { path: requestPath, mtime: mtimeMs, size },
+    });
+}
+function emitEditorFileDeleted(requestPath) {
+    logWithTimestamp("editor-watch", "emitting fileDeleted", { path: requestPath });
+    emitAppEvent({
+        v: 1,
+        id: `editor-delete-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        ns: "editor",
+        action: "fileDeleted",
+        payload: { path: requestPath },
+    });
+}
+function releaseTrackedEditorDirectory(dirPath) {
+    const trackedDir = trackedEditorDirectories.get(dirPath);
+    if (!trackedDir || trackedDir.filePaths.size > 0) {
+        return;
+    }
+    trackedDir.watcher.close();
+    trackedEditorDirectories.delete(dirPath);
+}
+function queueTrackedEditorFileCheck(safePath) {
+    if (pendingTrackedFileChecks.has(safePath)) {
+        return;
+    }
+    pendingTrackedFileChecks.add(safePath);
+    void (async () => {
+        try {
+            const tracked = trackedEditorFiles.get(safePath);
+            if (!tracked) {
+                return;
+            }
+            logWithTimestamp("editor-watch", "checking tracked file", { path: tracked.requestPath });
+            let stat;
+            try {
+                stat = await fs.stat(tracked.safePath);
+            }
+            catch (error) {
+                const nodeError = error;
+                if (nodeError?.code === "ENOENT") {
+                    trackedEditorFiles.delete(tracked.safePath);
+                    const trackedDir = trackedEditorDirectories.get(tracked.dirPath);
+                    if (trackedDir) {
+                        trackedDir.filePaths.delete(tracked.safePath);
+                        releaseTrackedEditorDirectory(tracked.dirPath);
+                    }
+                    emitEditorFileDeleted(tracked.requestPath);
+                    return;
+                }
+                throw error;
+            }
+            if (!stat.isFile()) {
+                trackedEditorFiles.delete(tracked.safePath);
+                const trackedDir = trackedEditorDirectories.get(tracked.dirPath);
+                if (trackedDir) {
+                    trackedDir.filePaths.delete(tracked.safePath);
+                    releaseTrackedEditorDirectory(tracked.dirPath);
+                }
+                emitEditorFileDeleted(tracked.requestPath);
+                return;
+            }
+            const changed = tracked.lastMtimeMs !== stat.mtimeMs || tracked.lastSize !== stat.size;
+            logWithTimestamp("editor-watch", "stat compared", {
+                path: tracked.requestPath,
+                changed,
+                prevMtime: tracked.lastMtimeMs,
+                nextMtime: stat.mtimeMs,
+                prevSize: tracked.lastSize,
+                nextSize: stat.size,
+                suppressWatcherUntil: tracked.suppressWatcherUntil,
+            });
+            tracked.lastMtimeMs = stat.mtimeMs;
+            tracked.lastSize = stat.size;
+            if (!changed) {
+                return;
+            }
+            if (Date.now() <= tracked.suppressWatcherUntil) {
+                return;
+            }
+            emitEditorFileChanged(tracked.requestPath, stat.mtimeMs, stat.size);
+        }
+        catch (error) {
+            if (DEBUG_MODE) {
+                console.error("[editor-watch] file check failed:", error instanceof Error ? error.message : String(error));
+            }
+        }
+        finally {
+            pendingTrackedFileChecks.delete(safePath);
+        }
+    })();
+}
+function ensureTrackedEditorDirectory(dirPath) {
+    const existing = trackedEditorDirectories.get(dirPath);
+    if (existing) {
+        return existing;
+    }
+    const watcher = fssync.watch(dirPath, (_eventType, fileName) => {
+        const trackedDir = trackedEditorDirectories.get(dirPath);
+        if (!trackedDir) {
+            return;
+        }
+        const changedName = fileName == null ? null : String(fileName);
+        logWithTimestamp("editor-watch", "directory event", { dirPath, fileName: changedName });
+        if (!changedName) {
+            for (const safePath of trackedDir.filePaths) {
+                queueTrackedEditorFileCheck(safePath);
+            }
+            return;
+        }
+        for (const safePath of trackedDir.filePaths) {
+            const tracked = trackedEditorFiles.get(safePath);
+            if (tracked && tracked.baseName === changedName) {
+                queueTrackedEditorFileCheck(safePath);
+            }
+        }
+    });
+    watcher.on("error", (error) => {
+        if (DEBUG_MODE) {
+            console.error("[editor-watch] directory watcher error:", dirPath, error instanceof Error ? error.message : String(error));
+        }
+    });
+    const trackedDir = {
+        watcher,
+        filePaths: new Set(),
+    };
+    trackedEditorDirectories.set(dirPath, trackedDir);
+    return trackedDir;
+}
+async function trackEditorFile(requestPath) {
+    const safePath = assertSafePath(requestPath);
+    const stat = await fs.stat(safePath);
+    if (!stat.isFile()) {
+        throw Object.assign(new Error("Only files can be tracked by the editor"), { code: "EINVAL" });
+    }
+    const existing = trackedEditorFiles.get(safePath);
+    if (existing) {
+        existing.openCount += 1;
+        existing.requestPath = requestPath;
+        existing.lastMtimeMs = stat.mtimeMs;
+        existing.lastSize = stat.size;
+        logWithTimestamp("editor-watch", "increment tracked file", { path: requestPath, openCount: existing.openCount });
+        return { path: requestPath, tracked: true };
+    }
+    const dirPath = path.dirname(safePath);
+    const trackedDir = ensureTrackedEditorDirectory(dirPath);
+    trackedDir.filePaths.add(safePath);
+    trackedEditorFiles.set(safePath, {
+        requestPath,
+        safePath,
+        dirPath,
+        baseName: path.basename(safePath),
+        openCount: 1,
+        lastMtimeMs: stat.mtimeMs,
+        lastSize: stat.size,
+        suppressWatcherUntil: 0,
+    });
+    logWithTimestamp("editor-watch", "tracking file", { path: requestPath, dirPath, mtime: stat.mtimeMs, size: stat.size });
+    return { path: requestPath, tracked: true };
+}
+function untrackEditorFile(requestPath) {
+    const safePath = assertSafePath(requestPath);
+    const tracked = trackedEditorFiles.get(safePath);
+    if (!tracked) {
+        return { path: requestPath, tracked: false };
+    }
+    tracked.openCount -= 1;
+    logWithTimestamp("editor-watch", "decrement tracked file", { path: requestPath, openCount: tracked.openCount });
+    if (tracked.openCount > 0) {
+        return { path: requestPath, tracked: true };
+    }
+    trackedEditorFiles.delete(safePath);
+    const trackedDir = trackedEditorDirectories.get(tracked.dirPath);
+    if (trackedDir) {
+        trackedDir.filePaths.delete(safePath);
+        releaseTrackedEditorDirectory(tracked.dirPath);
+    }
+    return { path: requestPath, tracked: false };
+}
+async function renameTrackedEditorFile(fromPath, toPath) {
+    const safeFrom = assertSafePath(fromPath);
+    const safeTo = assertSafePath(toPath);
+    const tracked = trackedEditorFiles.get(safeFrom);
+    if (!tracked) {
+        return { from: fromPath, to: toPath, tracked: false };
+    }
+    logWithTimestamp("editor-watch", "renaming tracked file", { from: fromPath, to: toPath });
+    const fromDir = trackedEditorDirectories.get(tracked.dirPath);
+    if (fromDir) {
+        fromDir.filePaths.delete(tracked.safePath);
+        releaseTrackedEditorDirectory(tracked.dirPath);
+    }
+    trackedEditorFiles.delete(tracked.safePath);
+    const stat = await fs.stat(safeTo);
+    const nextDirPath = path.dirname(safeTo);
+    const nextDir = ensureTrackedEditorDirectory(nextDirPath);
+    nextDir.filePaths.add(safeTo);
+    tracked.requestPath = toPath;
+    tracked.safePath = safeTo;
+    tracked.dirPath = nextDirPath;
+    tracked.baseName = path.basename(safeTo);
+    tracked.lastMtimeMs = stat.mtimeMs;
+    tracked.lastSize = stat.size;
+    trackedEditorFiles.set(safeTo, tracked);
+    return { from: fromPath, to: toPath, tracked: true };
+}
+function deleteTrackedEditorFile(requestPath) {
+    const safePath = assertSafePath(requestPath);
+    const tracked = trackedEditorFiles.get(safePath);
+    if (!tracked) {
+        return { path: requestPath, tracked: false };
+    }
+    logWithTimestamp("editor-watch", "deleting tracked file", { path: requestPath });
+    trackedEditorFiles.delete(safePath);
+    const trackedDir = trackedEditorDirectories.get(tracked.dirPath);
+    if (trackedDir) {
+        trackedDir.filePaths.delete(safePath);
+        releaseTrackedEditorDirectory(tracked.dirPath);
+    }
+    return { path: requestPath, tracked: false };
+}
+async function noteTrackedFileWrite(requestPath, source) {
+    const safePath = assertSafePath(requestPath);
+    const tracked = trackedEditorFiles.get(safePath);
+    if (!tracked) {
+        return;
+    }
+    const stat = await fs.stat(safePath);
+    tracked.lastMtimeMs = stat.mtimeMs;
+    tracked.lastSize = stat.size;
+    tracked.suppressWatcherUntil = Date.now() + 1500;
+    logWithTimestamp("editor-watch", "tracked file write noted", {
+        path: tracked.requestPath,
+        source,
+        mtime: stat.mtimeMs,
+        size: stat.size,
+        suppressWatcherUntil: tracked.suppressWatcherUntil,
+    });
+    if (source !== "editor") {
+        emitEditorFileChanged(tracked.requestPath, stat.mtimeMs, stat.size);
+    }
+}
 let ensurePtyBinaryPromise = null;
 function normalizeJsonWithTrailingCommas(text) {
     return text.replace(/,\s*([}\]])/g, "$1");
@@ -1246,7 +1501,7 @@ function handleTerminalScroll(payload) {
 function handleSystemCapabilities() {
     return {
         version: VERSION,
-        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http", "ai", "proxy"],
+        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http", "ai", "proxy", "editor"],
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
@@ -2152,6 +2407,24 @@ async function processMessage(message) {
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }
                 break;
+            case "editor":
+                switch (action) {
+                    case "open":
+                        result = await trackEditorFile(payload.path);
+                        break;
+                    case "close":
+                        result = untrackEditorFile(payload.path);
+                        break;
+                    case "rename":
+                        result = await renameTrackedEditorFile(payload.from, payload.to);
+                        break;
+                    case "delete":
+                        result = deleteTrackedEditorFile(payload.path);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
             case "git":
                 switch (action) {
                     case "status":
@@ -2537,6 +2810,12 @@ function gracefulShutdown() {
     console.log("\nShutting down...");
     void aiManager?.destroy();
     stopPortSync();
+    for (const trackedDir of trackedEditorDirectories.values()) {
+        trackedDir.watcher.close();
+    }
+    trackedEditorDirectories.clear();
+    trackedEditorFiles.clear();
+    pendingTrackedFileChecks.clear();
     activeV2Transport?.close();
     activeV2Transport = null;
     if (ptyProcess) {

package/dist/transport/v2.d.ts

@@ -37,6 +37,7 @@ export declare class V2SessionTransport {
     private handleHandshakeFrame;
     private encryptEnvelope;
     private ensureKeyPair;
+    private resetPeerSession;
     private computeHandshakeAuth;
     private sendJsonFrame;
     private sendBinaryFrame;

package/dist/transport/v2.js

@@ -124,6 +124,7 @@ export class V2SessionTransport {
             if ("type" in raw) {
                 await this.options.handlers.onSystemMessage(raw);
                 if (raw.type === "peer_connected") {
+                    this.resetPeerSession();
                     await this.maybeStartHandshake();
                 }
                 return;
@@ -290,6 +291,16 @@ export class V2SessionTransport {
         };
         return this.keyPair;
     }
+    resetPeerSession() {
+        this.remotePublicKey = null;
+        this.sessionKeys = null;
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.state = "open";
+        }
+        else {
+            this.state = "idle";
+        }
+    }
     computeHandshakeAuth(phase, senderRole, peerPubkeyB64, nonce, boxed) {
         const authKey = sodium.crypto_generichash(sodium.crypto_auth_KEYBYTES, encodeUtf8(this.options.sessionCode), undefined);
         const parts = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.91",
+  "version": "0.1.93",
   "author": [
     {
       "name": "Soham Bharambe",