@cryptiklemur/lattice 5.4.3 → 5.6.0

package/dist/server/features/brainstorm.js

@@ -0,0 +1,267 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, watch } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "../config.js";
+import { broadcast } from "../ws/broadcast.js";
+import { log } from "../logger.js";
+var activeBrainstorms = {};
+var watchers = [];
+var debounceTimers = {};
+function debounce(key, fn, ms) {
+    if (debounceTimers[key]) {
+        clearTimeout(debounceTimers[key]);
+    }
+    debounceTimers[key] = setTimeout(function () {
+        delete debounceTimers[key];
+        fn();
+    }, ms);
+}
+function getMostRecentSessionDir(brainstormDir) {
+    if (!existsSync(brainstormDir)) {
+        return null;
+    }
+    var entries = [];
+    try {
+        var names = readdirSync(brainstormDir);
+        for (var i = 0; i < names.length; i++) {
+            var fullPath = join(brainstormDir, names[i]);
+            try {
+                var stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    entries.push({ name: names[i], mtime: stat.mtimeMs });
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    if (entries.length === 0) {
+        return null;
+    }
+    entries.sort(function (a, b) {
+        return b.mtime - a.mtime;
+    });
+    return join(brainstormDir, entries[0].name);
+}
+function isWaitingFile(filename) {
+    return filename === "waiting.html" || filename.startsWith("waiting");
+}
+function handleContentFile(projectSlug, contentDir, sessionDir, filename) {
+    if (!filename.endsWith(".html")) {
+        return;
+    }
+    if (isWaitingFile(filename)) {
+        log.server("[brainstorm] waiting file detected for project %s", projectSlug);
+        delete activeBrainstorms[projectSlug];
+        broadcast({ type: "brainstorm:cleared" });
+        return;
+    }
+    var filePath = join(contentDir, filename);
+    if (!existsSync(filePath)) {
+        return;
+    }
+    var html;
+    try {
+        html = readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to read %s: %s", filePath, err);
+        return;
+    }
+    log.server("[brainstorm] broadcasting content %s for project %s", filename, projectSlug);
+    activeBrainstorms[projectSlug] = { html, filename, sessionDir };
+    broadcast({ type: "brainstorm:content", html, filename, sessionDir });
+}
+function handleStateFile(projectSlug, filename) {
+    if (filename === "server-stopped") {
+        log.server("[brainstorm] server-stopped detected for project %s", projectSlug);
+        delete activeBrainstorms[projectSlug];
+        broadcast({ type: "brainstorm:cleared" });
+    }
+}
+function watchSessionDir(projectSlug, sessionDir) {
+    var contentDir = join(sessionDir, "content");
+    var stateDir = join(sessionDir, "state");
+    if (!existsSync(contentDir)) {
+        mkdirSync(contentDir, { recursive: true });
+    }
+    if (!existsSync(stateDir)) {
+        mkdirSync(stateDir, { recursive: true });
+    }
+    var existingFiles = [];
+    try {
+        existingFiles = readdirSync(contentDir);
+    }
+    catch {
+        // ok
+    }
+    for (var i = 0; i < existingFiles.length; i++) {
+        var fname = existingFiles[i];
+        if (fname.endsWith(".html") && !isWaitingFile(fname)) {
+            handleContentFile(projectSlug, contentDir, sessionDir, fname);
+        }
+    }
+    try {
+        var contentWatcher = watch(contentDir, function (eventType, filename) {
+            if (!filename) {
+                return;
+            }
+            debounce("content:" + sessionDir + ":" + filename, function () {
+                handleContentFile(projectSlug, contentDir, sessionDir, filename);
+            }, 50);
+        });
+        watchers.push(contentWatcher);
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to watch content dir %s: %s", contentDir, err);
+    }
+    try {
+        var stateWatcher = watch(stateDir, function (eventType, filename) {
+            if (!filename) {
+                return;
+            }
+            debounce("state:" + sessionDir + ":" + filename, function () {
+                handleStateFile(projectSlug, filename);
+            }, 50);
+        });
+        watchers.push(stateWatcher);
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to watch state dir %s: %s", stateDir, err);
+    }
+}
+function watchBrainstormDir(projectSlug, brainstormDir) {
+    var recentSession = getMostRecentSessionDir(brainstormDir);
+    if (recentSession) {
+        watchSessionDir(projectSlug, recentSession);
+    }
+    try {
+        var dirWatcher = watch(brainstormDir, function (eventType, filename) {
+            if (!filename) {
+                return;
+            }
+            debounce("brainstorm:" + brainstormDir + ":" + filename, function () {
+                var candidate = join(brainstormDir, filename);
+                try {
+                    var stat = statSync(candidate);
+                    if (stat.isDirectory()) {
+                        log.server("[brainstorm] new session dir detected: %s", candidate);
+                        watchSessionDir(projectSlug, candidate);
+                    }
+                }
+                catch {
+                    // entry may have been removed
+                }
+            }, 50);
+        });
+        watchers.push(dirWatcher);
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to watch brainstorm dir %s: %s", brainstormDir, err);
+    }
+}
+function watchProjectRoot(projectSlug, projectPath) {
+    var superpowersDir = join(projectPath, ".superpowers");
+    var brainstormDir = join(superpowersDir, "brainstorm");
+    if (existsSync(brainstormDir)) {
+        watchBrainstormDir(projectSlug, brainstormDir);
+        return;
+    }
+    if (existsSync(superpowersDir)) {
+        watchForBrainstormDir(projectSlug, superpowersDir, brainstormDir);
+        return;
+    }
+    try {
+        var rootWatcher = watch(projectPath, function (eventType, filename) {
+            if (filename !== ".superpowers") {
+                return;
+            }
+            if (existsSync(superpowersDir)) {
+                rootWatcher.close();
+                watchForBrainstormDir(projectSlug, superpowersDir, brainstormDir);
+            }
+        });
+        watchers.push(rootWatcher);
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to watch project root %s: %s", projectPath, err);
+    }
+}
+function watchForBrainstormDir(projectSlug, superpowersDir, brainstormDir) {
+    if (existsSync(brainstormDir)) {
+        watchBrainstormDir(projectSlug, brainstormDir);
+        return;
+    }
+    try {
+        var spWatcher = watch(superpowersDir, function (eventType, filename) {
+            if (filename !== "brainstorm") {
+                return;
+            }
+            if (existsSync(brainstormDir)) {
+                spWatcher.close();
+                watchBrainstormDir(projectSlug, brainstormDir);
+            }
+        });
+        watchers.push(spWatcher);
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to watch .superpowers dir %s: %s", superpowersDir, err);
+    }
+}
+export function startBrainstormWatchers() {
+    var config = loadConfig();
+    var projects = config.projects;
+    for (var i = 0; i < projects.length; i++) {
+        var project = projects[i];
+        if (!project.path || !project.slug) {
+            continue;
+        }
+        if (!existsSync(project.path)) {
+            continue;
+        }
+        log.server("[brainstorm] setting up watcher for project %s at %s", project.slug, project.path);
+        watchProjectRoot(project.slug, project.path);
+    }
+}
+export function stopBrainstormWatchers() {
+    for (var i = 0; i < watchers.length; i++) {
+        try {
+            watchers[i].close();
+        }
+        catch {
+            // ignore
+        }
+    }
+    watchers = [];
+    activeBrainstorms = {};
+    var keys = Object.keys(debounceTimers);
+    for (var i = 0; i < keys.length; i++) {
+        clearTimeout(debounceTimers[keys[i]]);
+    }
+    debounceTimers = {};
+}
+export function getActiveBrainstorm(projectSlug) {
+    return activeBrainstorms[projectSlug] || null;
+}
+export function getAnyActiveBrainstorm() {
+    var keys = Object.keys(activeBrainstorms);
+    if (keys.length === 0)
+        return null;
+    return activeBrainstorms[keys[0]];
+}
+export function writeBrainstormEvent(sessionDir, event) {
+    var stateDir = join(sessionDir, "state");
+    if (!existsSync(stateDir)) {
+        mkdirSync(stateDir, { recursive: true });
+    }
+    var eventsFile = join(stateDir, "events");
+    try {
+        appendFileSync(eventsFile, JSON.stringify(event) + "\n", "utf-8");
+    }
+    catch (err) {
+        log.server("[brainstorm] failed to write event to %s: %s", eventsFile, err);
+    }
+}

package/dist/server/handlers/attachment.js

@@ -1,5 +1,10 @@
+import { createWriteStream, createReadStream } from "node:fs";
+import { unlink, mkdtemp } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { registerHandler } from "../ws/router.js";
 import { sendTo } from "../ws/broadcast.js";
+import { log } from "../logger.js";
 var MAX_ATTACHMENT_SIZE = 10 * 1024 * 1024;
 var stores = new Map();
 var completed = new Map();
@@ -21,22 +26,35 @@ function getClientCompleted(clientId) {
     }
     return store;
 }
-registerHandler("attachment", function (clientId, message) {
+async function cleanupPending(pending) {
+    try {
+        pending.writeStream.destroy();
+        await unlink(pending.tempPath).catch(function () { });
+        await unlink(pending.tempDir).catch(function () { });
+    }
+    catch { }
+}
+registerHandler("attachment", async function (clientId, message) {
     if (message.type === "attachment:chunk") {
         var msg = message;
         var store = getClientStore(clientId);
         var pending = store.get(msg.attachmentId);
         if (!pending) {
+            var tempDir = await mkdtemp(join(tmpdir(), "lattice-attach-"));
+            var tempPath = join(tempDir, "data.bin");
             pending = {
-                chunks: new Map(),
+                tempDir: tempDir,
+                tempPath: tempPath,
+                writeStream: createWriteStream(tempPath),
                 totalChunks: msg.totalChunks,
                 receivedCount: 0,
                 totalBytes: 0,
                 createdAt: Date.now(),
+                chunksSeen: new Set(),
             };
             store.set(msg.attachmentId, pending);
         }
-        if (pending.chunks.has(msg.chunkIndex)) {
+        if (pending.chunksSeen.has(msg.chunkIndex)) {
             sendTo(clientId, {
                 type: "attachment:error",
                 attachmentId: msg.attachmentId,
@@ -46,6 +64,7 @@ registerHandler("attachment", function (clientId, message) {
         }
         var chunkBuffer = Buffer.from(msg.data, "base64");
         if (pending.totalBytes + chunkBuffer.length > MAX_ATTACHMENT_SIZE) {
+            await cleanupPending(pending);
             store.delete(msg.attachmentId);
             sendTo(clientId, {
                 type: "attachment:error",
@@ -54,7 +73,8 @@ registerHandler("attachment", function (clientId, message) {
             });
             return;
         }
-        pending.chunks.set(msg.chunkIndex, chunkBuffer);
+        pending.writeStream.write(chunkBuffer);
+        pending.chunksSeen.add(msg.chunkIndex);
         pending.receivedCount++;
         pending.totalBytes += chunkBuffer.length;
         sendTo(clientId, {
@@ -85,36 +105,46 @@ registerHandler("attachment", function (clientId, message) {
             });
             return;
         }
-        var buffers = [];
-        for (var ci = 0; ci < completePending.totalChunks; ci++) {
-            var chunk = completePending.chunks.get(ci);
-            if (!chunk) {
-                sendTo(clientId, {
-                    type: "attachment:error",
-                    attachmentId: completeMsg.attachmentId,
-                    error: "Missing chunk at index " + ci,
-                });
-                return;
-            }
-            buffers.push(chunk);
+        await new Promise(function (resolve) {
+            completePending.writeStream.end(function () { resolve(); });
+        });
+        try {
+            var assembled = await readTempFile(completePending.tempPath);
+            var isText = completeMsg.attachmentType === "paste" || isTextMimeType(completeMsg.mimeType);
+            var content = isText ? assembled.toString("utf-8") : assembled.toString("base64");
+            var attachment = {
+                type: completeMsg.attachmentType,
+                name: completeMsg.name,
+                content,
+                mimeType: completeMsg.mimeType,
+                size: completeMsg.size,
+                lineCount: completeMsg.lineCount,
+            };
+            var finishedStore = getClientCompleted(clientId);
+            finishedStore.set(completeMsg.attachmentId, attachment);
+        }
+        catch (err) {
+            log.ws("Failed to read assembled attachment: %O", err);
+            sendTo(clientId, {
+                type: "attachment:error",
+                attachmentId: completeMsg.attachmentId,
+                error: "Failed to assemble attachment",
+            });
         }
-        var assembled = Buffer.concat(buffers);
-        var isText = completeMsg.attachmentType === "paste" || isTextMimeType(completeMsg.mimeType);
-        var content = isText ? assembled.toString("utf-8") : assembled.toString("base64");
-        var attachment = {
-            type: completeMsg.attachmentType,
-            name: completeMsg.name,
-            content,
-            mimeType: completeMsg.mimeType,
-            size: completeMsg.size,
-            lineCount: completeMsg.lineCount,
-        };
-        var finishedStore = getClientCompleted(clientId);
-        finishedStore.set(completeMsg.attachmentId, attachment);
+        await cleanupPending(completePending);
         completeStore.delete(completeMsg.attachmentId);
         return;
     }
 });
+function readTempFile(path) {
+    return new Promise(function (resolve, reject) {
+        var chunks = [];
+        var stream = createReadStream(path);
+        stream.on("data", function (chunk) { chunks.push(chunk); });
+        stream.on("end", function () { resolve(Buffer.concat(chunks)); });
+        stream.on("error", reject);
+    });
+}
 function isTextMimeType(mime) {
     if (mime.startsWith("text/"))
         return true;
@@ -142,6 +172,12 @@ export function getAttachments(clientId, ids) {
     return result;
 }
 export function cleanupClient(clientId) {
+    var clientStore = stores.get(clientId);
+    if (clientStore) {
+        for (var [, pending] of clientStore) {
+            void cleanupPending(pending);
+        }
+    }
     stores.delete(clientId);
     completed.delete(clientId);
 }
@@ -150,6 +186,7 @@ var ttlCleanupInterval = setInterval(function () {
     stores.forEach(function (store) {
         store.forEach(function (pending, id) {
             if (now - pending.createdAt > TTL_MS) {
+                void cleanupPending(pending);
                 store.delete(id);
             }
         });

package/dist/server/handlers/brainstorm.js

@@ -0,0 +1,33 @@
+import { registerHandler } from "../ws/router.js";
+import { sendTo } from "../ws/broadcast.js";
+import { getActiveBrainstorm, getAnyActiveBrainstorm, writeBrainstormEvent } from "../features/brainstorm.js";
+import { getActiveProjectForClient } from "./fs.js";
+registerHandler("brainstorm", function (clientId, message) {
+    if (message.type === "brainstorm:select") {
+        var selectMsg = message;
+        writeBrainstormEvent(selectMsg.sessionDir, {
+            type: "click",
+            choice: selectMsg.choice,
+            text: selectMsg.text,
+            timestamp: Date.now(),
+        });
+        return;
+    }
+    if (message.type === "brainstorm:status_request") {
+        var projectSlug = getActiveProjectForClient(clientId);
+        var active = projectSlug ? getActiveBrainstorm(projectSlug) : getAnyActiveBrainstorm();
+        if (active) {
+            sendTo(clientId, {
+                type: "brainstorm:status",
+                active: true,
+                html: active.html,
+                filename: active.filename,
+                sessionDir: active.sessionDir,
+            });
+        }
+        else {
+            sendTo(clientId, { type: "brainstorm:status", active: false });
+        }
+        return;
+    }
+});