bmweb-cli 0.1.3 → 0.1.6

package/README.md

@@ -315,7 +315,10 @@ cancels. The home starts with or without a cable.
 
 The TUI runs on the terminal's alternate screen (the buffer vim and htop
 use), so the shell's scrollback is never touched and quitting restores it;
-a screen redraws in place, only the lines that changed.
+a screen redraws in place, only the lines that changed. A viewer longer
+than the terminal (a fault protocol, a report) scrolls: Up/Down a line,
+PgUp/PgDn a page, Home/End to either end, with a line under it saying
+which rows are shown.
 
 Every dialog INPA opens is a prompt: a message waits for Enter, an input
 asks for the number (or hex, or text) within the declared range, the
@@ -350,6 +353,11 @@ tests drive the app's runtime against a fake car and a scripted terminal,
 with a module script written for the tests in INPA's language. The
 repository's `tools/check.sh` runs all of it.
 
+Set `BMWEB_VERBOSE=1` to see what the app's runtime logs: the wire trace
+the bus dumps after an error, each variant probe's verdict, the cable
+events. It goes to stderr; without it the runtime is silent and a command's
+output is only its own.
+
 ## License
 
 GPL-3.0, as the repository is. See `LICENSE`.

package/dist/bmweb.js

@@ -111,6 +111,7 @@ function formatCount(n) {
 import { readFileSync as readFileSync2 } from "node:fs";
 import { join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
+import { format, inspect } from "node:util";
 import { createContext, runInContext } from "node:vm";
 
 // src/runtime-files.json
@@ -284,14 +285,49 @@ function runtimeGlobals() {
   loadRuntime();
   return sandboxRef;
 }
+function runtimeConsole() {
+  const on = !!process.env.BMWEB_VERBOSE;
+  const say = (...a) => {
+    if (on) process.stderr.write(`${format(...a)}
+`);
+  };
+  const table = (rows) => {
+    if (on)
+      process.stderr.write(
+        `${inspect(rows, { depth: 3, maxArrayLength: 200, breakLength: 160 })}
+`
+      );
+  };
+  const noop = () => {
+  };
+  return {
+    log: say,
+    info: say,
+    warn: say,
+    error: say,
+    debug: say,
+    trace: say,
+    table,
+    group: say,
+    groupCollapsed: say,
+    groupEnd: noop,
+    time: noop,
+    timeEnd: noop,
+    assert: noop,
+    dir: table
+  };
+}
 function hostGlobals() {
   const noop = () => {
   };
   const sandbox = {
-    // the scripts test `typeof window` and read window.<x>; the context's own
-    // global stands in, as it does in the page (self: fflate's UMD attaches
-    // its global to `self` when there is no CommonJS `exports`)
-    console,
+    // the app's scripts talk to the browser console: the bus dumps its wire
+    // trace after an IFH error (console.table in a collapsed group), the
+    // variant resolver notes every probe's verdict, the bus reports the
+    // cable. In a terminal those are noise between a command's own lines
+    // (a scan's table had the trace printed through it), so they go to
+    // stderr only when BMWEB_VERBOSE is set, and never to stdout
+    console: runtimeConsole(),
     // timers.js's bmwSleep falls back to setTimeout where there is no
     // Worker; program.js schedules screen cycles and drains key presses
     // through setTimeout; activations.js defers a session end a microtask
@@ -814,6 +850,7 @@ import { createInterface } from "node:readline";
 
 // src/serial.ts
 import { readdirSync as readdirSync2 } from "node:fs";
+var RX_KICK_MS = 4;
 var PORT_PATTERNS = [
   /^cu\.usbserial/i,
   /^cu\.SLAB/i,
@@ -827,8 +864,12 @@ var NodeSerialPort = class {
   binding = null;
   /** chunks heard and not yet read */
   chunks = [];
-  /** the one read waiting for bytes, when the queue is empty */
-  waiter = null;
+  /** reads waiting for bytes, oldest first, when the queue is empty */
+  waiters = [];
+  /** the receive kick, running while a read waits (see startKick) */
+  kick = null;
+  /** a kick ioctl in flight, so they never pile up */
+  kicking = false;
   /** the lines as last set, so a partial setSignals keeps the others */
   lines = { dtr: false, rts: false, brk: false };
   /** the wire trace sink, when the CLI wants one */
@@ -864,23 +905,25 @@ var NodeSerialPort = class {
   async close() {
     const b = this.binding;
     this.binding = null;
-    if (this.waiter) {
-      const w = this.waiter;
-      this.waiter = null;
-      w({ value: void 0, done: true });
-    }
+    this.stopKick();
+    this.wakeAll();
     this.chunks = [];
     if (b) await b.close();
   }
+  /** Tell every waiting read the port is done, and forget them. */
+  wakeAll() {
+    const ws = this.waiters;
+    this.waiters = [];
+    for (const w of ws) w({ value: void 0, done: true });
+  }
   /**
    * Bytes the binding heard: to the waiting read, else queued.
    * @param chunk - the bytes
    */
   push(chunk) {
     if (!chunk.length) return;
-    if (this.waiter) {
-      const w = this.waiter;
-      this.waiter = null;
+    const w = this.waiters.shift();
+    if (w) {
       w({ value: chunk, done: false });
       return;
     }
@@ -916,19 +959,54 @@ var NodeSerialPort = class {
     if (next) return Promise.resolve({ value: next, done: false });
     if (!this.binding) return Promise.resolve({ value: void 0, done: true });
     return new Promise((resolve2) => {
-      this.waiter = resolve2;
+      this.waiters.push(resolve2);
+      this.startKick();
     });
   }
+  /**
+   * Make the driver deliver what it has heard.
+   *
+   * THE BUG THIS FIXES. On macOS the built-in FTDI driver does not wake the
+   * reader when bytes arrive: with a read armed and the process simply
+   * waiting, an ECU's answer sat in the driver until some OTHER call touched
+   * the device (the next write, a modem-line change, close), and only then
+   * came out -- measured on a real car as 0 bytes for the first exchange
+   * after open and every later exchange delivering the PREVIOUS one's bytes
+   * at its start. Polling the modem lines (a TIOCMGET, no wire traffic)
+   * every few milliseconds while a read waits makes each answer arrive
+   * within the poll interval, first exchange included. The interval never
+   * holds the process open and stops itself once no read is waiting.
+   */
+  startKick() {
+    if (this.kick) return;
+    const tick = () => {
+      const b = this.binding;
+      if (!b || !this.waiters.length) {
+        this.stopKick();
+        return;
+      }
+      if (this.kicking) return;
+      this.kicking = true;
+      b.get().catch(() => null).then(() => {
+        this.kicking = false;
+      });
+    };
+    this.kick = setInterval(tick, RX_KICK_MS);
+    if (typeof this.kick === "object" && "unref" in this.kick)
+      this.kick.unref();
+  }
+  /** Stop the receive kick. */
+  stopKick() {
+    if (!this.kick) return;
+    clearInterval(this.kick);
+    this.kick = null;
+  }
   /**
    * Cancel the reader: a waiting read is told `done`, buffered bytes go.
    */
   cancel() {
     this.chunks = [];
-    if (this.waiter) {
-      const w = this.waiter;
-      this.waiter = null;
-      w({ value: void 0, done: true });
-    }
+    this.wakeAll();
   }
   /**
    * Write bytes. Resolves when the OS has them, not when they have left the
@@ -1966,6 +2044,12 @@ var TuiUi = class {
   frame = [];
   /** a picker owns the keyboard: the program's key handler must stand back */
   modal = false;
+  /** the first line of the viewer shown (INPA's viewer scrolls; so does this) */
+  viewTop = 0;
+  /** the view the scroll position belongs to; a new view starts at the top */
+  viewShown = null;
+  /** how many viewer lines the last frame had room for */
+  viewRoom = 0;
   /** the terminal size the frame was drawn for; a change draws fresh */
   frameSize = "";
   leftResolve = null;
@@ -2380,6 +2464,32 @@ Save as [fault-memory.txt]: `);
   paint(p) {
     this.flush(this.frameLines(p));
   }
+  /**
+   * Scroll the viewer by a key: a line, a page, or to an end. Nothing
+   * happens without a viewer on screen.
+   * @param how - 'up' | 'down' | 'pageup' | 'pagedown' | 'home' | 'end'
+   * @returns whether the key was for the viewer
+   */
+  scrollView(how) {
+    const p = this.program;
+    if (!p || !p.view) return false;
+    const page = Math.max(1, this.viewRoom - 1);
+    const n = (p.view.lines || []).length;
+    const max = Math.max(0, n - this.viewRoom);
+    const jump = {
+      up: -1,
+      down: 1,
+      pageup: -page,
+      pagedown: page,
+      home: -n,
+      end: n
+    };
+    const by = jump[how];
+    if (by === void 0) return false;
+    this.viewTop = Math.max(0, Math.min(max, this.viewTop + by));
+    this.paint(p);
+    return true;
+  }
   /**
    * The frame as lines: title, rule, the view or the grid, a blank, the
    * key bar, then the status and progress lines. Cut to the terminal's
@@ -2392,16 +2502,34 @@ Save as [fault-memory.txt]: `);
     const w = this.term.columns;
     const title = `${p.ecu.label || p.ecu.sgbd}  ${p.ecu.sgbd}.prg  ${p.title || ""}`.trim();
     const head = [title, "-".repeat(Math.min(w, 78))];
-    let body = p.view ? [...p.view.lines || []] : this.gridLines(p);
     const tail = ["", ...this.keyLines(p), this.statusText, this.progressText];
     const room = Math.max(1, this.term.rows - 1 - head.length - tail.length);
-    if (body.length > room) body = body.filter((l, i) => l || body[i - 1]);
-    if (body.length > room) {
-      const hidden = body.length - (room - 1);
-      body = [
-        ...body.slice(0, room - 1),
-        `(${hidden} more rows: enlarge the terminal)`
-      ];
+    let body;
+    if (p.view) {
+      const lines = [...p.view.lines || []];
+      if (p.view !== this.viewShown) {
+        this.viewShown = p.view;
+        this.viewTop = 0;
+      }
+      const fits = lines.length <= room;
+      const window = fits ? room : room - 1;
+      this.viewRoom = window;
+      this.viewTop = Math.max(0, Math.min(this.viewTop, lines.length - window));
+      body = lines.slice(this.viewTop, this.viewTop + window);
+      if (!fits)
+        body.push(
+          `\x1B[2mrows ${this.viewTop + 1}-${this.viewTop + body.length} of ${lines.length}   \u2191\u2193 PgUp PgDn Home End scroll\x1B[0m`
+        );
+    } else {
+      body = this.gridLines(p);
+      if (body.length > room) body = body.filter((l, i) => l || body[i - 1]);
+      if (body.length > room) {
+        const hidden = body.length - (room - 1);
+        body = [
+          ...body.slice(0, room - 1),
+          `(${hidden} more rows: enlarge the terminal)`
+        ];
+      }
     }
     return [...head, ...body, ...tail].map(
       (l) => String(l).replace(/[\r\n]/g, " ").slice(0, w)
@@ -2581,6 +2709,7 @@ async function tuiCommand(chassis, sgbd, opts = {}) {
     let leaving = false;
     const unsubscribe = term.onKey((k) => {
       if (ui.modal) return;
+      if (ui.scrollView(k.name)) return;
       const what = keyToPress(k);
       if (what === null) return;
       if (what === "quit") {
@@ -2620,7 +2749,7 @@ async function tuiCommand(chassis, sgbd, opts = {}) {
 }
 
 // src/bmweb.ts
-var VERSION = true ? "0.1.3" : "0.0.0-dev";
+var VERSION = true ? "0.1.6" : "0.0.0-dev";
 var INCLUDE = {
   include: {
     kind: "list",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bmweb-cli",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "BMWeb's tools as a command line: read INPA .IPO scripts, compile .IPS sources, search the corpus job index, decode and diff shared Garage reports, and, over a K+DCAN cable, run jobs, whole-car scans and INPA screens in the terminal.",
   "license": "GPL-3.0-only",
   "type": "module",