bitwrench 2.0.14 → 2.0.16

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

@@ -9,7 +9,7 @@ import bw from '../bitwrench.js';
  * Base page CSS for the CLI-generated pages
  */
 const BASE_PAGE_CSS = `
-.bw-cli-page {
+.bw_cli_page {
   max-width: 48rem;
   margin: 0 auto;
   padding: 2rem 1.5rem;
@@ -18,61 +18,61 @@ const BASE_PAGE_CSS = `
   line-height: 1.6;
   color: #333;
 }
-.bw-cli-page pre {
+.bw_cli_page pre {
   overflow-x: auto;
   padding: 1em;
   background: #f5f5f5;
   border-radius: 4px;
   font-size: 0.875em;
 }
-.bw-cli-page code {
+.bw_cli_page code {
   font-family: "SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", Menlo, Courier, monospace;
 }
-.bw-cli-page p code {
+.bw_cli_page p code {
   background: #f0f0f0;
   padding: 0.15em 0.3em;
   border-radius: 3px;
   font-size: 0.875em;
 }
-.bw-cli-page table {
+.bw_cli_page table {
   border-collapse: collapse;
   width: 100%;
   margin: 1em 0;
   overflow-x: auto;
   display: block;
 }
-.bw-cli-page th, .bw-cli-page td {
+.bw_cli_page th, .bw_cli_page td {
   border: 1px solid #ddd;
   padding: 0.5em 0.75em;
   text-align: left;
 }
-.bw-cli-page th {
+.bw_cli_page th {
   background: #f5f5f5;
   font-weight: 600;
 }
-.bw-cli-page blockquote {
+.bw_cli_page blockquote {
   border-left: 4px solid #ddd;
   margin-left: 0;
   padding-left: 1em;
   color: #666;
 }
-.bw-cli-page img {
+.bw_cli_page img {
   max-width: 100%;
   height: auto;
 }
-.bw-cli-page h1, .bw-cli-page h2, .bw-cli-page h3,
-.bw-cli-page h4, .bw-cli-page h5, .bw-cli-page h6 {
+.bw_cli_page h1, .bw_cli_page h2, .bw_cli_page h3,
+.bw_cli_page h4, .bw_cli_page h5, .bw_cli_page h6 {
   margin-top: 1.5em;
   margin-bottom: 0.5em;
   line-height: 1.25;
 }
-.bw-cli-page h1 { font-size: 2em; }
-.bw-cli-page h2 { font-size: 1.5em; border-bottom: 1px solid #eee; padding-bottom: 0.3em; }
-.bw-cli-page a { color: #0366d6; text-decoration: none; }
-.bw-cli-page a:hover { text-decoration: underline; }
-.bw-cli-page hr { border: none; border-top: 1px solid #eee; margin: 2em 0; }
+.bw_cli_page h1 { font-size: 2em; }
+.bw_cli_page h2 { font-size: 1.5em; border-bottom: 1px solid #eee; padding-bottom: 0.3em; }
+.bw_cli_page a { color: #0366d6; text-decoration: none; }
+.bw_cli_page a:hover { text-decoration: underline; }
+.bw_cli_page hr { border: none; border-top: 1px solid #eee; margin: 2em 0; }
 @media (max-width: 600px) {
-  .bw-cli-page { padding: 1rem; }
+  .bw_cli_page { padding: 1rem; }
 }
 `;
 
@@ -131,7 +131,7 @@ ${faviconTag}${headInjection}${highlightHead}
 <style>${allCSS}</style>
 </head>
 <body>
-<div class="bw-cli-page">
+<div class="bw_cli_page">
 ${bodyHTML}
 </div>
 ${bodyEndInjection}${highlightBodyEnd}

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.');
+    });
+}