bitwrench 2.0.17 → 2.0.19

package/src/cli/serve.js

@@ -5,6 +5,10 @@
  * via an input HTTP port or stdin. Broadcasts messages to all connected
  * browser tabs.
  *
+ * The input HTTP port also supports interactive commands: POST a JSON
+ * object with a `command` field and receive the result as the HTTP
+ * response. This is the programmatic equivalent of bwcli attach's REPL.
+ *
  * Usage:
  *   bwcli serve [dir] [--port N] [--listen N] [--stdin] [--theme name]
  */
@@ -29,6 +33,7 @@ Options:
       --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")
+      --allow-exec           Enable exec messages (runs JS in browser, use for dev only)
       --open                 Open browser on start
   -v, --verbose              Verbose output
   -h, --help                 Print this help
@@ -39,6 +44,8 @@ Examples:
   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"}}'
+  curl -X POST :9000 -d '{"command":"query","code":"document.title"}'
+  curl -X POST :9000 -d '{"command":"clients"}'
 `.trim();
 
 /**
@@ -130,11 +137,151 @@ function parseRelaxedJSON(str) {
     return JSON.parse(out.join(''));
 }
 
+// Required fields per command (async commands also listed)
+var _COMMAND_REQUIRED = {
+    query:    ['code'],
+    screenshot: [],
+    tree:     [],
+    mount:    ['selector', 'factory'],
+    exec:     ['code'],
+    render:   ['selector', 'taco'],
+    patch:    ['id'],
+    listen:   ['selector', 'event'],
+    unlisten: ['selector', 'event'],
+    clients:  []
+};
+
+// Commands that return a result via promise
+var _ASYNC_COMMANDS = { query: 1, screenshot: 1, tree: 1, mount: 1 };
+
+/**
+ * Handle an interactive command from the listen port.
+ *
+ * @param {Object} msg - Parsed message with `command` field
+ * @param {Object} app - BwServeApp instance (has _clients Map)
+ * @param {boolean} verbose - Log details to stderr
+ * @returns {Promise<Object>} Response object ({ok, result, clientId} or {error})
+ */
+function handleCommand(msg, app, verbose) {
+    var cmd = msg.command;
+
+    // clients: no client needed
+    if (cmd === 'clients') {
+        var ids = [];
+        for (var entry of app._clients) {
+            if (entry[1] && entry[1].client) ids.push(entry[0]);
+        }
+        return Promise.resolve({ ok: true, clients: ids });
+    }
+
+    // Validate command name
+    if (!_COMMAND_REQUIRED.hasOwnProperty(cmd)) {
+        return Promise.resolve({ error: 'Unknown command: ' + cmd });
+    }
+
+    // Validate required fields
+    var required = _COMMAND_REQUIRED[cmd];
+    for (var k = 0; k < required.length; k++) {
+        if (msg[required[k]] === undefined) {
+            return Promise.resolve({ error: 'Missing required field: ' + required[k] });
+        }
+    }
+
+    // Select client
+    var client = null;
+    var clientId = null;
+
+    if (msg.clientId) {
+        var record = app._clients.get(msg.clientId);
+        if (record && record.client) {
+            client = record.client;
+            clientId = msg.clientId;
+        } else {
+            return Promise.resolve({ error: 'Client not found: ' + msg.clientId });
+        }
+    } else {
+        // Pick first connected client
+        for (var pair of app._clients) {
+            if (pair[1] && pair[1].client && !pair[1].client._closed) {
+                client = pair[1].client;
+                clientId = pair[0];
+                break;
+            }
+        }
+    }
+
+    if (!client) {
+        return Promise.resolve({ error: 'No clients connected' });
+    }
+
+    var timeout = msg.timeout;
+
+    if (verbose) {
+        console.error('[command] ' + cmd + ' -> client ' + clientId);
+    }
+
+    // Dispatch
+    try {
+        switch (cmd) {
+            case 'query':
+                return client.query(msg.code, { timeout: timeout || 5000 }).then(function(result) {
+                    return { ok: true, result: result, clientId: clientId };
+                });
+
+            case 'screenshot':
+                return client.screenshot(msg.selector || 'body', { timeout: timeout || 10000 }).then(function(result) {
+                    // Convert Buffer to base64 for JSON response
+                    var data = result && result.data ? result.data.toString('base64') : null;
+                    return { ok: true, result: { data: data, width: result.width, height: result.height, format: result.format }, clientId: clientId };
+                });
+
+            case 'tree':
+                var pend = client._pend(timeout || 10000);
+                client.call('_bw_tree', {
+                    selector: msg.selector || 'body',
+                    depth: msg.depth || 3,
+                    requestId: pend.requestId
+                });
+                return pend.promise.then(function(result) {
+                    return { ok: true, result: result, clientId: clientId };
+                });
+
+            case 'mount':
+                return client.mount(msg.selector, msg.factory, msg.props || {}, { timeout: timeout || 10000 }).then(function(result) {
+                    return { ok: true, result: result, clientId: clientId };
+                });
+
+            case 'exec':
+                client.exec(msg.code);
+                return Promise.resolve({ ok: true, clientId: clientId });
+
+            case 'render':
+                client.render(msg.selector, msg.taco);
+                return Promise.resolve({ ok: true, clientId: clientId });
+
+            case 'patch':
+                client.patch(msg.id, msg.content, msg.attr);
+                return Promise.resolve({ ok: true, clientId: clientId });
+
+            case 'listen':
+                client.call('_bw_listen', { selector: msg.selector, event: msg.event });
+                return Promise.resolve({ ok: true, clientId: clientId });
+
+            case 'unlisten':
+                client.call('_bw_unlisten', { selector: msg.selector, event: msg.event });
+                return Promise.resolve({ ok: true, clientId: clientId });
+        }
+    } catch (err) {
+        return Promise.resolve({ error: err.message });
+    }
+}
+
 /**
  * Run the serve subcommand.
  * @param {string[]} argv - arguments after "serve"
+ * @param {object} [ioOpts] - optional overrides for testing
  */
-export function runServe(argv) {
+export function runServe(argv, ioOpts) {
     var values, positionals;
 
     try {
@@ -148,6 +295,7 @@ export function runServe(argv) {
                 stdin:   { type: 'boolean' },
                 theme:   { type: 'string', short: 't' },
                 title:   { type: 'string' },
+                'allow-exec': { type: 'boolean' },
                 open:    { type: 'boolean' },
                 verbose: { type: 'boolean', short: 'v' },
                 help:    { type: 'boolean', short: 'h' }
@@ -184,7 +332,9 @@ export function runServe(argv) {
     }
 
     // Dynamic import of bwserve to avoid loading it at parse time
-    import('../../src/bwserve/index.js').then(function(bwserve) {
+    var io = ioOpts || {};
+    var importPath = io._importPath || '../../src/bwserve/index.js';
+    var importPromise = import(importPath).then(function(bwserve) {
         startServer(bwserve, {
             dir: dir,
             webPort: webPort,
@@ -193,12 +343,15 @@ export function runServe(argv) {
             theme: theme,
             title: title,
             verbose: verbose,
-            open: !!values.open
+            open: !!values.open,
+            allowExec: !!values['allow-exec']
         });
     }).catch(function(err) {
         console.error('Failed to load bwserve: ' + err.message);
         process.exit(1);
     });
+
+    return importPromise;
 }
 
 /**
@@ -209,7 +362,8 @@ function startServer(bwserve, opts) {
         port: opts.webPort,
         title: opts.title,
         static: opts.dir,
-        theme: opts.theme
+        theme: opts.theme,
+        allowExec: opts.allowExec
     });
 
     // Register a passthrough page handler — just keeps clients alive
@@ -253,7 +407,11 @@ function startServer(bwserve, opts) {
 }
 
 /**
- * Start the input HTTP server for receiving protocol messages.
+ * Start the input HTTP server for receiving protocol messages and interactive commands.
+ *
+ * Messages with a `command` field are treated as interactive commands --
+ * routed to a specific client and the result returned in the HTTP response.
+ * Messages with a `type` field (no `command`) are broadcast to all clients.
  */
 function startInputServer(app, listenPort, verbose) {
     var inputServer = createServer(function(req, res) {
@@ -273,6 +431,25 @@ function startInputServer(app, listenPort, verbose) {
                 return;
             }
 
+            // Interactive command path
+            if (msg.command) {
+                handleCommand(msg, app, verbose).then(function(result) {
+                    var status = result.error ? 400 : 200;
+                    // Unknown command and client-not-found get 400; timeout also 400
+                    res.writeHead(status, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(result));
+                }).catch(function(err) {
+                    var errMsg = err && err.message ? err.message : String(err);
+                    if (verbose) {
+                        console.error('[command] error: ' + errMsg);
+                    }
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: errMsg }));
+                });
+                return;
+            }
+
+            // Broadcast path (existing behavior)
             var count = app.broadcast(msg);
             if (verbose) {
                 console.error('[input] ' + msg.type + ' -> ' + count + ' client(s)');
@@ -323,3 +500,6 @@ function startStdinReader(app, verbose) {
         if (verbose) console.error('[stdin] Input stream closed. Server stays running.');
     });
 }
+
+// Export private functions for testability
+export { parseMessage, parseRelaxedJSON, startServer, startInputServer, startStdinReader, handleCommand };

package/src/generate-css.js

@@ -8,16 +8,23 @@ import { getAllStyles, getStructuralStyles, generateThemedCSS,
 import { derivePalette } from './bitwrench-color-utils.js';
 import fs from 'fs';
 import path from 'path';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
 
 // Convert styles object to CSS string
 function stylesToCSS(styles) {
   let css = `/**
- * Bitwrench v2 CSS
- * Class-based styles to prevent framework collisions
- * Generated from bitwrench-styles.js
+ * bitwrench.css v${pkg.version} — AUTO-GENERATED, DO NOT EDIT
+ *
+ * Generated by src/generate-css.js from bitwrench-styles.js
+ * This is a static snapshot of what bw.loadStyles() produces
+ * at runtime. Use one or the other, not both.
+ *
+ * To regenerate: npm run build:css
+ * ${pkg.homepage}
  */
 
-/* Base styles with .bw namespace */
 `;
 
   // Process each style rule