bitwrench 2.0.15 → 2.0.16

package/src/cli/serve.js

@@ -0,0 +1,325 @@
+/**
+ * bwcli serve — CLI subcommand for bwserve pipe server.
+ *
+ * Serves a directory of bitwrench pages and accepts protocol messages
+ * via an input HTTP port or stdin. Broadcasts messages to all connected
+ * browser tabs.
+ *
+ * Usage:
+ *   bwcli serve [dir] [--port N] [--listen N] [--stdin] [--theme name]
+ */
+
+import { parseArgs } from 'node:util';
+import { createServer } from 'node:http';
+import { createReadStream } from 'node:fs';
+import { VERSION } from '../version.js';
+
+var SERVE_USAGE = `
+bwcli serve v${VERSION} — Pipe server for browser UI
+
+Usage:
+  bwcli serve [dir] [options]
+
+Arguments:
+  dir                        Directory to serve static files from (default: .)
+
+Options:
+  -p, --port <number>        Browser-facing web port (default: 8080)
+  -l, --listen <number>      Input port for protocol messages (default: 9000)
+      --stdin                Read protocol messages from stdin (newline-delimited JSON)
+  -t, --theme <name>         Theme preset or hex colors ("#pri,#sec")
+      --title <string>       Page title (default: "bwcli serve")
+      --open                 Open browser on start
+  -v, --verbose              Verbose output
+  -h, --help                 Print this help
+
+Examples:
+  bwcli serve                             Serve . on :8080, listen on :9000
+  bwcli serve ./public --port 3000        Serve ./public on :3000
+  bwcli serve --stdin                     Read from pipe instead of input port
+  sensor-reader | bwcli serve --stdin     Pipe sensor data to browser
+  curl -X POST :9000 -d '{"type":"replace","target":"#app","node":{"t":"h1","c":"Hi"}}'
+`.trim();
+
+/**
+ * Parse a message string — supports both strict JSON and r-prefixed relaxed JSON.
+ * @param {string} str
+ * @returns {Object|null} parsed message or null on error
+ */
+function parseMessage(str) {
+    str = str.trim();
+    if (!str) return null;
+    try {
+        if (str.charAt(0) === 'r') {
+            return parseRelaxedJSON(str.slice(1));
+        }
+        return JSON.parse(str);
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Parse relaxed JSON (single-quoted strings, trailing commas).
+ * State machine — walks char by char.
+ */
+function parseRelaxedJSON(str) {
+    var out = [];
+    var i = 0;
+    var len = str.length;
+
+    while (i < len) {
+        var ch = str[i];
+
+        if (ch === "'") {
+            out.push('"');
+            i++;
+            while (i < len) {
+                var c = str[i];
+                if (c === '\\' && i + 1 < len) {
+                    var next = str[i + 1];
+                    if (next === "'") {
+                        out.push("'");
+                    } else {
+                        out.push('\\');
+                        out.push(next);
+                    }
+                    i += 2;
+                } else if (c === '"') {
+                    out.push('\\"');
+                    i++;
+                } else if (c === "'") {
+                    break;
+                } else {
+                    out.push(c);
+                    i++;
+                }
+            }
+            out.push('"');
+            i++;
+        } else if (ch === '"') {
+            out.push(ch);
+            i++;
+            while (i < len) {
+                var c2 = str[i];
+                if (c2 === '\\' && i + 1 < len) {
+                    out.push(c2);
+                    out.push(str[i + 1]);
+                    i += 2;
+                } else {
+                    out.push(c2);
+                    i++;
+                    if (c2 === '"') break;
+                }
+            }
+        } else if (ch === ',') {
+            var j = i + 1;
+            while (j < len && (str[j] === ' ' || str[j] === '\t' || str[j] === '\n' || str[j] === '\r')) j++;
+            if (j < len && (str[j] === '}' || str[j] === ']')) {
+                i++;
+            } else {
+                out.push(ch);
+                i++;
+            }
+        } else {
+            out.push(ch);
+            i++;
+        }
+    }
+
+    return JSON.parse(out.join(''));
+}
+
+/**
+ * Run the serve subcommand.
+ * @param {string[]} argv - arguments after "serve"
+ */
+export function runServe(argv) {
+    var values, positionals;
+
+    try {
+        var result = parseArgs({
+            args: argv,
+            strict: true,
+            allowPositionals: true,
+            options: {
+                port:    { type: 'string', short: 'p' },
+                listen:  { type: 'string', short: 'l' },
+                stdin:   { type: 'boolean' },
+                theme:   { type: 'string', short: 't' },
+                title:   { type: 'string' },
+                open:    { type: 'boolean' },
+                verbose: { type: 'boolean', short: 'v' },
+                help:    { type: 'boolean', short: 'h' }
+            }
+        });
+        values = result.values;
+        positionals = result.positionals;
+    } catch (err) {
+        console.error('Error: ' + err.message);
+        console.error('Run "bwcli serve --help" for usage.');
+        process.exit(1);
+    }
+
+    if (values.help) {
+        console.log(SERVE_USAGE);
+        return;
+    }
+
+    var dir = positionals[0] || '.';
+    var webPort = values.port ? parseInt(values.port, 10) : 8080;
+    var listenPort = values.listen ? parseInt(values.listen, 10) : 9000;
+    var useStdin = !!values.stdin;
+    var theme = values.theme || null;
+    var title = values.title || 'bwcli serve';
+    var verbose = !!values.verbose;
+
+    if (isNaN(webPort) || webPort < 1 || webPort > 65535) {
+        console.error('Error: --port must be a number between 1 and 65535.');
+        process.exit(1);
+    }
+    if (!useStdin && (isNaN(listenPort) || listenPort < 1 || listenPort > 65535)) {
+        console.error('Error: --listen must be a number between 1 and 65535.');
+        process.exit(1);
+    }
+
+    // Dynamic import of bwserve to avoid loading it at parse time
+    import('../../src/bwserve/index.js').then(function(bwserve) {
+        startServer(bwserve, {
+            dir: dir,
+            webPort: webPort,
+            listenPort: listenPort,
+            useStdin: useStdin,
+            theme: theme,
+            title: title,
+            verbose: verbose,
+            open: !!values.open
+        });
+    }).catch(function(err) {
+        console.error('Failed to load bwserve: ' + err.message);
+        process.exit(1);
+    });
+}
+
+/**
+ * Start the bwserve pipe server.
+ */
+function startServer(bwserve, opts) {
+    var app = bwserve.create({
+        port: opts.webPort,
+        title: opts.title,
+        static: opts.dir,
+        theme: opts.theme
+    });
+
+    // Register a passthrough page handler — just keeps clients alive
+    app.page('/', function(client) {
+        if (opts.verbose) {
+            console.error('[bwcli serve] Client connected: ' + client.id);
+        }
+        client.on('_disconnect', function() {
+            if (opts.verbose) {
+                console.error('[bwcli serve] Client disconnected: ' + client.id);
+            }
+        });
+    });
+
+    // Start web server
+    app.listen(function() {
+        console.error('bwcli serve v' + VERSION);
+        console.error('  Web server:  http://localhost:' + opts.webPort);
+        console.error('  Static dir:  ' + opts.dir);
+        if (opts.theme) console.error('  Theme:       ' + opts.theme);
+
+        if (opts.useStdin) {
+            console.error('  Input:       stdin (newline-delimited JSON)');
+            startStdinReader(app, opts.verbose);
+        } else {
+            console.error('  Input port:  http://localhost:' + opts.listenPort);
+            startInputServer(app, opts.listenPort, opts.verbose);
+        }
+
+        console.error('');
+        console.error('Ready. Send protocol messages to push UI to browsers.');
+
+        if (opts.open) {
+            import('node:child_process').then(function(cp) {
+                var url = 'http://localhost:' + opts.webPort;
+                var cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+                cp.exec(cmd + ' ' + url);
+            });
+        }
+    });
+}
+
+/**
+ * Start the input HTTP server for receiving protocol messages.
+ */
+function startInputServer(app, listenPort, verbose) {
+    var inputServer = createServer(function(req, res) {
+        if (req.method !== 'POST') {
+            res.writeHead(405, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Use POST' }));
+            return;
+        }
+
+        var body = '';
+        req.on('data', function(chunk) { body += chunk; });
+        req.on('end', function() {
+            var msg = parseMessage(body);
+            if (!msg) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid message' }));
+                return;
+            }
+
+            var count = app.broadcast(msg);
+            if (verbose) {
+                console.error('[input] ' + msg.type + ' -> ' + count + ' client(s)');
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, clients: count }));
+        });
+    });
+
+    inputServer.listen(listenPort);
+}
+
+/**
+ * Read protocol messages from stdin (newline-delimited).
+ */
+function startStdinReader(app, verbose) {
+    var buffer = '';
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', function(chunk) {
+        buffer += chunk;
+        var lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (!line) continue;
+
+            var msg = parseMessage(line);
+            if (!msg) {
+                if (verbose) console.error('[stdin] Parse error: ' + line.slice(0, 80));
+                continue;
+            }
+
+            var count = app.broadcast(msg);
+            if (verbose) {
+                console.error('[stdin] ' + msg.type + ' -> ' + count + ' client(s)');
+            }
+        }
+    });
+
+    process.stdin.on('end', function() {
+        // Flush remaining buffer
+        if (buffer.trim()) {
+            var msg = parseMessage(buffer.trim());
+            if (msg) app.broadcast(msg);
+        }
+        if (verbose) console.error('[stdin] Input stream closed. Server stays running.');
+    });
+}

package/src/version.js

@@ -3,14 +3,14 @@
  * DO NOT EDIT DIRECTLY - Use npm run generate-version
  */
 
-export const VERSION = '2.0.15';
+export const VERSION = '2.0.16';
 export const VERSION_INFO = {
-  version: '2.0.15',
+  version: '2.0.16',
   name: 'bitwrench',
   description: 'A library for javascript UI functions.',
   license: 'BSD-2-Clause',
   homepage: 'https://deftio.github.com/bitwrench/pages',
   repository: 'git+https://github.com/deftio/bitwrench.git',
   author: 'manu a. chatterjee <deftio@deftio.com> (https://deftio.com/)',
-  buildDate: '2026-03-10T09:08:17.015Z'
+  buildDate: '2026-03-12T08:05:52.043Z'
 };