bitwrench 2.0.15 → 2.0.17

package/src/cli/index.js

@@ -1,21 +1,27 @@
 /**
- * Bitwrench CLI - Main entry point
+ * bwcli — Main entry point for the bitwrench command-line tool
  * Arg parsing with util.parseArgs(), help, version, dispatch
+ *
+ * Subcommands:
+ *   bwcli <file> [options]       Convert a file to styled HTML
+ *   bwcli serve [dir] [options]  Start bwserve dev server
  */
 
 import { parseArgs } from 'node:util';
 import { VERSION } from '../version.js';
 import { convertFile } from './convert.js';
+import { runServe } from './serve.js';
 
 const USAGE = `
-bitwrench v${VERSION} — Document converter & static site generator
+bwcli v${VERSION} — bitwrench command-line tool
 
 Usage:
-  bitwrench <file> [options]       Convert a file to styled HTML
-  bitwrench --version              Print version
-  bitwrench --help                 Print this help
+  bwcli <file> [options]       Convert a file to styled HTML
+  bwcli serve [dir] [options]  Start bwserve development server
+  bwcli --version              Print version
+  bwcli --help                 Print this help
 
-Options:
+Convert options:
   -o, --output <file>    Output file path (default: input with .html extension)
   -c, --css <file>       Include external CSS file
   -t, --theme <name>     Theme preset (ocean, sunset, forest, slate) or hex colors ("#pri,#sec")
@@ -26,16 +32,26 @@ Options:
   -f, --favicon <path>   Favicon path or URL
       --highlight        Include highlight.js for syntax highlighting
   -v, --verbose          Verbose output
+
+Serve options:
+  -p, --port <number>    Port to listen on (default: 7902)
+  -t, --theme <name>     Theme preset or hex colors
+      --open             Open browser on start
+  -v, --verbose          Verbose output
+
+General:
   -h, --help             Print this help
       --version          Print version
 
 Examples:
-  bitwrench README.md                          Convert README.md to README.html
-  bitwrench README.md -o index.html            Specify output file
-  bitwrench README.md -o out.html --theme ocean  Apply ocean theme
-  bitwrench README.md -o out.html --standalone   Self-contained offline HTML
-  bitwrench README.md -o out.html --highlight    With syntax highlighting
-  bitwrench doc.md --theme "#336699,#cc6633"     Custom theme colors
+  bwcli README.md                          Convert README.md to README.html
+  bwcli README.md -o index.html            Specify output file
+  bwcli README.md -o out.html --theme ocean  Apply ocean theme
+  bwcli README.md -o out.html --standalone   Self-contained offline HTML
+  bwcli README.md -o out.html --highlight    With syntax highlighting
+  bwcli doc.md --theme "#336699,#cc6633"     Custom theme colors
+  bwcli serve                              Serve current directory on port 7902
+  bwcli serve ./site --port 8080           Serve ./site on port 8080
 `.trim();
 
 /**
@@ -43,6 +59,11 @@ Examples:
  * @param {string[]} argv - process.argv.slice(2)
  */
 export function run(argv) {
+    // Check for subcommand before parseArgs (subcommands have different options)
+    if (argv.length > 0 && argv[0] === 'serve') {
+        return runServe(argv.slice(1));
+    }
+
     let values, positionals;
 
     try {
@@ -69,13 +90,13 @@ export function run(argv) {
         positionals = result.positionals;
     } catch (err) {
         console.error(`Error: ${err.message}`);
-        console.error('Run "bitwrench --help" for usage.');
+        console.error('Run "bwcli --help" for usage.');
         process.exit(1);
     }
 
     // --version
     if (values.version) {
-        console.log(`bitwrench v${VERSION}`);
+        console.log(`bwcli v${VERSION}`);
         return;
     }
 
@@ -88,7 +109,7 @@ export function run(argv) {
     // No positional args → error
     if (positionals.length === 0) {
         console.error('Error: No input file specified.');
-        console.error('Run "bitwrench --help" for usage.');
+        console.error('Run "bwcli --help" for usage.');
         process.exit(1);
     }
 

package/src/cli/layout-default.js

@@ -1,6 +1,7 @@
 /**
  * Bitwrench CLI - Default page layout
- * Wraps converted content in a complete HTML document
+ * Wraps converted content in a complete HTML document.
+ * Delegates to bw.htmlPage() for document structure.
  */
 
 import bw from '../bitwrench.js';
@@ -77,7 +78,11 @@ const BASE_PAGE_CSS = `
 `;
 
 /**
- * Build a complete HTML page from content and options
+ * Build a complete HTML page from content and options.
+ * Delegates to bw.htmlPage() for document structure, adding CLI-specific
+ * concerns: .bw_cli_page wrapper, generator meta tag, highlight.js, and
+ * pre-resolved injection strings from inject.js.
+ *
  * @param {Object} opts
  * @param {string} opts.title - Page title
  * @param {string} opts.bodyHTML - Rendered HTML content for the body
@@ -99,44 +104,54 @@ export function makePageLayout(opts) {
         highlight = false
     } = opts;
 
-    const safeTitle = bw.escapeHTML(title);
-    const version = bw.version;
+    const version = bw.getVersion().version;
 
-    let faviconTag = '';
-    if (favicon) {
-        // Only escape quotes and angle brackets for attribute safety, not slashes
-        const safeFavicon = favicon.replace(/[&<>"']/g, c => ({
-            '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
-        })[c]);
-        faviconTag = `<link rel="icon" href="${safeFavicon}">`;
+    // Build extra <head> elements: generator meta, injection script, highlight.js CSS
+    const headElements = [];
+
+    // Generator meta tag (CLI-specific)
+    headElements.push({
+        t: 'meta', a: { name: 'generator', content: 'bitwrench v' + version }
+    });
+
+    // Injection script from inject.js (already pre-built HTML string)
+    if (headInjection) {
+        headElements.push(bw.raw(headInjection));
     }
 
-    let highlightHead = '';
-    let highlightBodyEnd = '';
+    // Highlight.js CSS
     if (highlight) {
-        highlightHead = '<link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11/build/styles/github.min.css">';
-        highlightBodyEnd = '<script src="https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11/build/highlight.min.js"></script>\n<script>hljs.highlightAll();</script>';
+        headElements.push({
+            t: 'link', a: {
+                rel: 'stylesheet',
+                href: 'https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11/build/styles/github.min.css'
+            }
+        });
     }
 
+    // Wrap body content in .bw_cli_page div (CLI-specific)
+    const wrappedBody = '<div class="bw_cli_page">\n' + bodyHTML + '\n</div>';
+
+    // Build body-end injection (highlight.js init)
+    let fullBodyEnd = bodyEndInjection || '';
+    if (highlight) {
+        fullBodyEnd += '<script src="https://cdn.jsdelivr.net/gh/highlightjs/cdn-release@11/build/highlight.min.js"></script>\n<script>hljs.highlightAll();</script>';
+    }
+
+    // Combine all CSS
     const allCSS = BASE_PAGE_CSS + (css ? '\n' + css : '');
 
-    return `<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<meta name="generator" content="bitwrench v${version}">
-<title>${safeTitle}</title>
-${faviconTag}${headInjection}${highlightHead}
-<style>${allCSS}</style>
-</head>
-<body>
-<div class="bw_cli_page">
-${bodyHTML}
-</div>
-${bodyEndInjection}${highlightBodyEnd}
-</body>
-</html>`;
+    // Use bw.htmlPage() with runtime:'none' since CLI handles injection itself
+    var page = bw.htmlPage({
+        title: title,
+        body: wrappedBody + (fullBodyEnd ? '\n' + fullBodyEnd : ''),
+        css: allCSS,
+        head: headElements,
+        favicon: favicon,
+        runtime: 'none'
+    });
+
+    return page;
 }
 
 export { BASE_PAGE_CSS };

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.17';
 export const VERSION_INFO = {
-  version: '2.0.15',
+  version: '2.0.17',
   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-13T23:15:10.823Z'
 };