Skip to content

An agentic skills framework & software development methodology that works.

Add HTTP server, WebSocket handling, and file watching to server.js

Jesse Vincent8d9b94eb8d07
diff --git a/skills/brainstorming/scripts/server.js b/skills/brainstorming/scripts/server.js
index 9bdd71f55..8a8cc5a2b 100644
--- a/skills/brainstorming/scripts/server.js
+++ b/skills/brainstorming/scripts/server.js
@@ -1,4 +1,9 @@
const crypto = require('crypto');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+// ========== WebSocket Protocol (RFC 6455) ==========
const OPCODES = { TEXT: 0x01, CLOSE: 0x08, PING: 0x09, PONG: 0x0A };
const WS_MAGIC = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
@@ -66,4 +71,230 @@ function decodeFrame(buffer) {
return { opcode, payload: data, bytesConsumed: totalLen };
}
+// ========== Configuration ==========
+
+const PORT = process.env.BRAINSTORM_PORT || (49152 + Math.floor(Math.random() * 16383));
+const HOST = process.env.BRAINSTORM_HOST || '127.0.0.1';
+const URL_HOST = process.env.BRAINSTORM_URL_HOST || (HOST === '127.0.0.1' ? 'localhost' : HOST);
+const SCREEN_DIR = process.env.BRAINSTORM_DIR || '/tmp/brainstorm';
+
+const MIME_TYPES = {
+ '.html': 'text/html', '.css': 'text/css', '.js': 'application/javascript',
+ '.json': 'application/json', '.png': 'image/png', '.jpg': 'image/jpeg',
+ '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml'
+};
+
+// ========== Templates and Constants ==========
+
+const WAITING_PAGE = `<!DOCTYPE html>
+<html>
+<head><title>Brainstorm Companion</title>
+<style>body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
+h1 { color: #333; } p { color: #666; }</style>
+</head>
+<body><h1>Brainstorm Companion</h1>
+<p>Waiting for Claude to push a screen...</p></body></html>`;
+
+const frameTemplate = fs.readFileSync(path.join(__dirname, 'frame-template.html'), 'utf-8');
+const helperScript = fs.readFileSync(path.join(__dirname, 'helper.js'), 'utf-8');
+const helperInjection = '<script>\n' + helperScript + '\n</script>';
+
+// ========== Helper Functions ==========
+
+function isFullDocument(html) {
+ const trimmed = html.trimStart().toLowerCase();
+ return trimmed.startsWith('<!doctype') || trimmed.startsWith('<html');
+}
+
+function wrapInFrame(content) {
+ return frameTemplate.replace('<!-- CONTENT -->', content);
+}
+
+function getNewestScreen() {
+ const files = fs.readdirSync(SCREEN_DIR)
+ .filter(f => f.endsWith('.html'))
+ .map(f => {
+ const fp = path.join(SCREEN_DIR, f);
+ return { path: fp, mtime: fs.statSync(fp).mtime.getTime() };
+ })
+ .sort((a, b) => b.mtime - a.mtime);
+ return files.length > 0 ? files[0].path : null;
+}
+
+// ========== HTTP Request Handler ==========
+
+function handleRequest(req, res) {
+ if (req.method === 'GET' && req.url === '/') {
+ const screenFile = getNewestScreen();
+ let html = screenFile
+ ? (raw => isFullDocument(raw) ? raw : wrapInFrame(raw))(fs.readFileSync(screenFile, 'utf-8'))
+ : WAITING_PAGE;
+
+ if (html.includes('</body>')) {
+ html = html.replace('</body>', helperInjection + '\n</body>');
+ } else {
+ html += helperInjection;
+ }
+
+ res.writeHead(200, { 'Content-Type': 'text/html' });
+ res.end(html);
+ } else if (req.method === 'GET' && req.url.startsWith('/files/')) {
+ const fileName = req.url.slice(7);
+ const filePath = path.join(SCREEN_DIR, path.basename(fileName));
+ if (!fs.existsSync(filePath)) {
+ res.writeHead(404);
+ res.end('Not found');
+ return;
+ }
+ const ext = path.extname(filePath).toLowerCase();
+ const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+ res.writeHead(200, { 'Content-Type': contentType });
+ res.end(fs.readFileSync(filePath));
+ } else {
+ res.writeHead(404);
+ res.end('Not found');
+ }
+}
+
+// ========== WebSocket Connection Handling ==========
+
+const clients = new Set();
+
+function handleUpgrade(req, socket) {
+ const key = req.headers['sec-websocket-key'];
+ if (!key) { socket.destroy(); return; }
+
+ const accept = computeAcceptKey(key);
+ socket.write(
+ 'HTTP/1.1 101 Switching Protocols\r\n' +
+ 'Upgrade: websocket\r\n' +
+ 'Connection: Upgrade\r\n' +
+ 'Sec-WebSocket-Accept: ' + accept + '\r\n\r\n'
+ );
+
+ let buffer = Buffer.alloc(0);
+ clients.add(socket);
+
+ socket.on('data', (chunk) => {
+ buffer = Buffer.concat([buffer, chunk]);
+ while (buffer.length > 0) {
+ let result;
+ try {
+ result = decodeFrame(buffer);
+ } catch (e) {
+ socket.end(encodeFrame(OPCODES.CLOSE, Buffer.alloc(0)));
+ clients.delete(socket);
+ return;
+ }
+ if (!result) break;
+ buffer = buffer.slice(result.bytesConsumed);
+
+ switch (result.opcode) {
+ case OPCODES.TEXT:
+ handleMessage(result.payload.toString());
+ break;
+ case OPCODES.CLOSE:
+ socket.end(encodeFrame(OPCODES.CLOSE, Buffer.alloc(0)));
+ clients.delete(socket);
+ return;
+ case OPCODES.PING:
+ socket.write(encodeFrame(OPCODES.PONG, result.payload));
+ break;
+ case OPCODES.PONG:
+ break;
+ default: {
+ const closeBuf = Buffer.alloc(2);
+ closeBuf.writeUInt16BE(1003);
+ socket.end(encodeFrame(OPCODES.CLOSE, closeBuf));
+ clients.delete(socket);
+ return;
+ }
+ }
+ }
+ });
+
+ socket.on('close', () => clients.delete(socket));
+ socket.on('error', () => clients.delete(socket));
+}
+
+function handleMessage(text) {
+ let event;
+ try {
+ event = JSON.parse(text);
+ } catch (e) {
+ console.error('Failed to parse WebSocket message:', e.message);
+ return;
+ }
+ console.log(JSON.stringify({ source: 'user-event', ...event }));
+ if (event.choice) {
+ const eventsFile = path.join(SCREEN_DIR, '.events');
+ fs.appendFileSync(eventsFile, JSON.stringify(event) + '\n');
+ }
+}
+
+function broadcast(msg) {
+ const frame = encodeFrame(OPCODES.TEXT, Buffer.from(JSON.stringify(msg)));
+ for (const socket of clients) {
+ try { socket.write(frame); } catch (e) { clients.delete(socket); }
+ }
+}
+
+// ========== File Watching ==========
+
+const debounceTimers = new Map();
+
+// ========== Server Startup ==========
+
+function startServer() {
+ if (!fs.existsSync(SCREEN_DIR)) fs.mkdirSync(SCREEN_DIR, { recursive: true });
+
+ // Track known files to distinguish new screens from updates.
+ // macOS fs.watch reports 'rename' for both new files and overwrites,
+ // so we can't rely on eventType alone.
+ const knownFiles = new Set(
+ fs.readdirSync(SCREEN_DIR).filter(f => f.endsWith('.html'))
+ );
+
+ const server = http.createServer(handleRequest);
+ server.on('upgrade', handleUpgrade);
+
+ const watcher = fs.watch(SCREEN_DIR, (eventType, filename) => {
+ if (!filename || !filename.endsWith('.html')) return;
+
+ if (debounceTimers.has(filename)) clearTimeout(debounceTimers.get(filename));
+ debounceTimers.set(filename, setTimeout(() => {
+ debounceTimers.delete(filename);
+ const filePath = path.join(SCREEN_DIR, filename);
+
+ if (!fs.existsSync(filePath)) return; // file was deleted
+
+ if (!knownFiles.has(filename)) {
+ knownFiles.add(filename);
+ const eventsFile = path.join(SCREEN_DIR, '.events');
+ if (fs.existsSync(eventsFile)) fs.unlinkSync(eventsFile);
+ console.log(JSON.stringify({ type: 'screen-added', file: filePath }));
+ } else {
+ console.log(JSON.stringify({ type: 'screen-updated', file: filePath }));
+ }
+
+ broadcast({ type: 'reload' });
+ }, 100));
+ });
+ watcher.on('error', (err) => console.error('fs.watch error:', err.message));
+
+ server.listen(PORT, HOST, () => {
+ const info = JSON.stringify({
+ type: 'server-started', port: Number(PORT), host: HOST,
+ url_host: URL_HOST, url: 'http://' + URL_HOST + ':' + PORT,
+ screen_dir: SCREEN_DIR
+ });
+ console.log(info);
+ fs.writeFileSync(path.join(SCREEN_DIR, '.server-info'), info + '\n');
+ });
+}
+
+if (require.main === module) {
+ startServer();
+}
+
module.exports = { computeAcceptKey, encodeFrame, decodeFrame, OPCODES };