bmweb-cli 0.1.0

package/runtime/screens/ipo-runtime/translate-sets.js

@@ -0,0 +1,130 @@
+/**
+ * @file ENGLISH FOR WHAT A JOB RETURNS. The script reads F_ORT_TEXT,
+ * F_SYMPTOM_TEXT, F_READY_TEXT... and glues them into its own lines before
+ * it paints, so by paint time there is one string nobody can split; the swap
+ * has to happen on the result values as they are fed to the VM. Exact
+ * dictionary lookups only (phraseText: the fault phrase tables and the
+ * generated fault-location dictionary), plus the fault-code lookup the fault
+ * screen uses for a location whose text has no entry but whose number the
+ * ECU's own codespace knows. A string without an entry is fed exactly as the
+ * ECU sent it; Original mode feeds everything untouched. Captions the .IPO
+ * prints itself are not this: irLabel handles those at paint.
+ */
+
+/** A P-code text: "P1128 " + the fault location + " - " + the fault type. */
+const IPO_PCODE_RE = /^(P[0-9A-F]{4}\s+)([\s\S]*)$/i;
+
+/** The result keys of a fault's freeze-frame (Umwelt) labels and values. */
+const IPO_ENV_TEXT_KEY_RE = /^F_(UW|FF)\d*_TEXT$/;
+const IPO_ENV_VALUE_KEY_RE = /^F_(UW|FF)\d*_WERT$/;
+
+/** The result keys of a fault's P-code text. */
+const IPO_PCODE_KEY_RE = /^F_PCODE7?_TEXT$/;
+
+/**
+ * Whether fed results are translated: the dictionaries are loaded and the
+ * language setting is not Original.
+ * @returns {boolean}
+ */
+function ipoTranslating() {
+  return (
+    typeof phraseText === 'function' &&
+    typeof lang === 'function' &&
+    lang() !== 'orig'
+  );
+}
+
+/**
+ * F_ORT_TEXT: the phrase dictionary, else the code. The code is the one the
+ * text leads with ("27DA BSD-Generator", kept as a prefix because the ECU
+ * wrote it there) or F_HEX_CODE, else the 16-bit F_ORT_NR when a codespace
+ * knows it whole (a DTC, not a location+detail word). The ECU's own
+ * codespace outranks the flat DB: 27C3 is the oil-level sensor on the E46
+ * MS45 and something else elsewhere.
+ * @param {Record<string, string>} set - the result set the text belongs to
+ * @param {string} text - the F_ORT_TEXT value
+ * @param {string} sgbd - the SGBD that answered (its codespace)
+ * @returns {string}
+ */
+function ipoLocationText(set, text, sgbd) {
+  const hit = phraseText(text);
+  if (hit !== text) return hit;
+  const own = typeof scopedFaultDb === 'function' ? scopedFaultDb(sgbd) : null;
+  const flat = (typeof window !== 'undefined' && window.BMW_FAULT_DB) || null;
+  if (!own && !flat) return text;
+  const codes = [];
+  const led =
+    typeof bmwCode === 'function' ? bmwCode(text, set.F_HEX_CODE) : null;
+  if (led) codes.push({ code: led, flatOk: true });
+  const full = typeof ortNrFull === 'function' ? ortNrFull(set.F_ORT_NR) : null;
+  if (full) codes.push({ code: full, flatOk: !own });
+  for (const { code, flatOk } of codes) {
+    const name = (own && own[code]) || (flatOk && flat && flat[code]) || null;
+    if (!name) continue;
+    return new RegExp(`^${code}\\b`, 'i').test(String(text).trim())
+      ? `${code} ${name}`
+      : name;
+  }
+  return text;
+}
+
+/**
+ * F_PCODE_TEXT, translated part by part: the code prefix is kept, the fault
+ * location (FO) and the fault type (FA) are each a dictionary string of
+ * their own; a part with no entry stays German.
+ * @param {string} v - the value
+ * @returns {string}
+ */
+function ipoPcodeText(v) {
+  const whole = phraseText(v);
+  if (whole !== v) return whole;
+  const m = String(v).match(IPO_PCODE_RE);
+  const code = m ? m[1] : '';
+  const rest = m ? m[2] : String(v);
+  const parts = rest.split(' - ');
+  if (parts.length < 2) return v;
+  const en = parts.map((x) => phraseText(x.trim()));
+  if (en.every((x, i) => x === parts[i].trim())) return v;
+  return code + en.join(' - ');
+}
+
+/**
+ * Freeze-frame (Umwelt) labels and their enum values have their own curated
+ * dictionary (envLabel over envmap.js): "(Motor) - Öltemperatur" -> "Engine
+ * oil temperature", "0 ES - Motor steht" -> "0 ES - engine stopped".
+ * @param {string} v - the value
+ * @returns {string}
+ */
+function ipoEnvText(v) {
+  const e = typeof envLabel === 'function' ? envLabel(v) : v;
+  return e !== v ? e : phraseText(v);
+}
+
+/**
+ * One result set with its *_TEXT strings in English where a dictionary
+ * carries them; every other value, and every string without an entry, as
+ * sent. A new object: the wire's answer is not rewritten in place.
+ * @param {Record<string, *>} set - a result set
+ * @param {string} sgbd - the SGBD that answered
+ * @returns {Record<string, *>}
+ */
+function ipoTranslateSet(set, sgbd) {
+  const out = {};
+  for (const [k, v] of Object.entries(set || {})) {
+    let t = v;
+    if (typeof v === 'string') {
+      if (k === 'F_ORT_TEXT') t = ipoLocationText(set, v, sgbd);
+      else if (IPO_PCODE_KEY_RE.test(k)) t = ipoPcodeText(v);
+      else if (IPO_ENV_TEXT_KEY_RE.test(k)) t = ipoEnvText(v);
+      else if (IPO_ENV_VALUE_KEY_RE.test(k) && /[A-Za-z]/.test(v))
+        t = ipoEnvText(v); // an enum value, not a number
+      else if (/_TEXT$/.test(k)) t = ipoEnvText(v); // MESSWERTBLOCK rows carry FUMWELTTEXTE labels
+    }
+    out[k] = t;
+  }
+  return out;
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { ipoTranslating, ipoTranslateSet };
+}

package/runtime/screens/ipo-runtime/ui.js

@@ -0,0 +1,249 @@
+/**
+ * @file The UI adapter: maps the program's state onto the app's grammar --
+ * the F-key bar, a title, the painted grid (INPA mode) or per-LINE rows
+ * (modern), the app's own dialogs for INPA's prompts, and the status line.
+ */
+
+/**
+ * The Back action for a menu without its own F10 (kind 'back' answers Esc).
+ * @param {() => void} fn - what Back does
+ * @returns {object} an action-bar entry
+ */
+/**
+ * The caption over the key bar: the running script's menu title
+ * (setmenutitle), the way INPA shows it; empty restores "Select menu".
+ * @param {string} title
+ * @returns {void}
+ */
+function ipoSetKeysCaption(title) {
+  if (typeof document === 'undefined') return;
+  const st = document.documentElement.style;
+  if (title && title.trim())
+    st.setProperty('--fkeys-caption', JSON.stringify(title));
+  else st.removeProperty('--fkeys-caption');
+}
+
+function ipoBackAction(fn) {
+  return { key: 'Escape', keyLabel: 'Esc', label: 'Back', kind: 'back', fn };
+}
+
+/**
+ * Build the UI adapter for a module's container.
+ * @param {object} ecu - the module (sgbd, label, chassis)
+ * @param {HTMLElement} container - where the view is drawn
+ * @param {() => void} back - leave the module view
+ * @returns {IpoUi}
+ */
+function ipoMakeUi(ecu, container, back) {
+  const inpa = typeof inpaMode === 'function' && inpaMode();
+  let gridEl = null,
+    statusEl = null,
+    machineEl = null;
+  /** INPA's progress window while a body has one open (progressDialog) */
+  let progress = null;
+  /** the viewopen file currently in the DOM (paint keeps it across cycles) */
+  let paintedView = null;
+
+  const build = () => {
+    container.className = inpa ? 'ipo-view ipo-inpa' : 'ipo-view results-panel';
+    container.innerHTML =
+      `<div class="ipo-screen"></div>` +
+      `<div class="ipo-machine" hidden></div>` +
+      `<div class="ipo-status mono"></div>`;
+    gridEl = container.querySelector('.ipo-screen');
+    machineEl = container.querySelector('.ipo-machine');
+    statusEl = container.querySelector('.ipo-status');
+  };
+  build();
+
+  /**
+   * The F-key bar: the script's plain keys, its shifted bank, and the
+   * script's own F10 as Back (kind 'back' answers Esc too). Only a menu
+   * WITHOUT one gets the app's Esc Back -- adding it beside an F10 spilled
+   * it into the first empty slot, and SM46's captionless F3 (read coding
+   * data) read "Back".
+   * @param {IpoProgram} p - the program
+   * @returns {void}
+   */
+  const renderKeys = (p) => {
+    const shown = (it) => !it.hidden || !!it.legendLabel;
+    const plain = p.items.filter((it) => !it.shift && shown(it));
+    const shifted = p.items.filter((it) => it.shift && shown(it));
+    const asAction = (it) => {
+      const n = it.shift ? it.nr - IPO_SHIFT_BASE : it.nr;
+      return {
+        key: n === 20 ? null : String(n % 10),
+        keyLabel: it.shift ? `⇧F${it.nr - IPO_SHIFT_BASE}` : `F${it.nr}`,
+        label: ipoKeyLabel(p, it),
+        kind: it.nr === IPO_BACK_KEY ? 'back' : undefined,
+        fn: () => p.press(it.nr),
+      };
+    };
+    const acts = plain.map(asAction);
+    if (!plain.some((it) => it.nr === IPO_BACK_KEY)) {
+      acts.push(ipoBackAction(() => p.back()));
+    }
+    const put = () =>
+      setActions(acts, shifted.length ? shifted.map(asAction) : undefined);
+    if (typeof setActions === 'function') {
+      if (typeof keepActivationsDuring === 'function')
+        keepActivationsDuring(put);
+      else put();
+    }
+    ipoSetKeysCaption(ipoText(p.title || ''));
+    if (machineEl) machineEl.hidden = true;
+  };
+
+  /** @type {IpoUi} */
+  const ui = {
+    // the bus's worker-backed timer: a hidden tab's setTimeout is throttled
+    // to once a second, which stretched every scripted wait and screen tick
+    sleep: (ms) =>
+      typeof bmwSleep === 'function'
+        ? bmwSleep(ms)
+        : new Promise((r) => setTimeout(r, ms)),
+    loadExec: async (sgbd) => {
+      try {
+        return typeof irLiveExec === 'function' ? await irLiveExec(sgbd) : null;
+      } catch (e) {
+        return null;
+      }
+    },
+    route: (p) => {
+      if (typeof routeSetCar === 'function' && ecu.chassis && ecu.sgbd) {
+        const rootMenu = p.rootMenu || (p.rootMenu = p.menu);
+        routeSetCar(ecu.chassis, ecu.sgbd, p.menu === rootMenu ? null : p.menu);
+      }
+    },
+    status: (p, text) => {
+      if (statusEl) statusEl.textContent = text;
+      sbLeft.textContent = `${(p.ecu || ecu).sgbd}.prg · ${p.menu || ''} · ${text}`;
+    },
+    error: (p, text) => {
+      if (statusEl) statusEl.textContent = `error: ${text}`;
+      sbLeft.textContent = `${ecu.sgbd}.prg · ${text}`;
+    },
+    message: (title, body) =>
+      messageDialog({
+        title: esc(ipoText(title)),
+        body: esc(ipoText(body || '')),
+      }),
+    askInput: (step, label) => irAskInput(step, label),
+    confirmKey: (p, it, jobs, writes) =>
+      confirmDialog({
+        title: `${esc(ipoKeyLabel(p, it))} on ${esc(ecu.label)}?`,
+        body:
+          `Runs INPA's own key script live; it can send ` +
+          `<span class="mono">${jobs.map(esc).join(' · ')}</span>.` +
+          `<br><br>The argument is computed by the script, exactly as INPA ` +
+          `computes it.`,
+        confirmLabel: 'Run',
+        danger: writes.length > 0,
+      }),
+    confirmWrite: (p, job, arg, ctx) =>
+      confirmDialog({
+        title: `Send ${esc(job)} on ${esc(ecu.label)}?`,
+        body:
+          `The ${esc(ctx && ctx.label ? ctx.label : 'script')} wants to send ` +
+          `<span class="mono">${esc(job)}${arg ? ' ' + esc(arg) : ''}</span>` +
+          ` to the module.` +
+          (ctx && String(ctx.scope || '').startsWith('screen:')
+            ? ` This screen sends it on every refresh; confirming allows it ` +
+              `for as long as the screen is open.`
+            : ''),
+        confirmLabel: 'Send',
+        danger: true,
+      }),
+    pickComponent: (p, step) => ipoPickComponent(p, step),
+    // BMWeb's own picker (the home script): the host's lists in a dialog
+    pickHome: (p, step) => ipoPickHome(p, step),
+    // INPA's save-as dialog: the browser's own picker where it has one
+    // (Chrome, Edge), else a name for a download
+    saveFile: (p, step) => ipoSaveFilePick(p, step),
+    writeFile: (p, picked, lines) => ipoSaveFileWrite(picked, lines),
+    pickLines: (p, names, multiple, current, hints) =>
+      ipoPickLines(names, multiple, current, hints),
+    // INPA's printscreen: the module view as a clean sheet (print.js)
+    printScreen: (p) => ipoPrintScreen(p, p.ecu || ecu, inpa),
+    resolveScriptEcu: (from, script, exec) =>
+      // the home script names a module by its SGBD after a chassis pick:
+      // that module is the car's own record, not a wire-resolved variant
+      from && from.sgbd === IPO_HOME_SGBD
+        ? ipoHomeEcuFor(from, script)
+        : ipoResolveScriptEcu(from, script, exec),
+    machineTick: (p, step, guards) => ipoMachineTick(machineEl, step, guards),
+    // INPA's progress window: a popup with the title, the line the script
+    // wrote last (the module it is asking right now) and Cancel, which ends
+    // the body between two jobs
+    userbox: (p, box) => {
+      if (!box) {
+        if (progress) progress.close();
+        progress = null;
+        return;
+      }
+      const lines = box.lines || [];
+      const text = lines.length ? ipoText(lines[lines.length - 1]) : '';
+      if (!progress) {
+        progress = progressDialog({
+          title: esc(ipoText(box.title || '')),
+          text,
+          onCancel: () => {
+            progress = null;
+            p.cancel();
+          },
+        });
+      } else {
+        progress.update(text);
+      }
+    },
+    renderKeys,
+    paint: (p) => {
+      if (!gridEl) return;
+      ipoSetKeysCaption(ipoText(p.title || ''));
+      // viewopen: INPA's viewer window with the file the script wrote. The
+      // menu's screen cycle keeps painting behind it; the same file stays
+      // in the DOM so the reader's scroll position survives each cycle.
+      if (p.view) {
+        if (p.view !== paintedView) {
+          paintedView = p.view;
+          if (p.view.report && typeof ipoProtocolRender === 'function') {
+            const drawn = p.view;
+            // the whole-car read is finished: show what each fault captured,
+            // then offer to keep the report. Deferred until the renderer has
+            // built the rows and the bar these attach to.
+            Promise.resolve(ipoProtocolRender(gridEl, p)).then(async () => {
+              if (p.view !== drawn) return;
+              if (typeof garageAttachEnv === 'function')
+                await garageAttachEnv(gridEl, drawn.report, {
+                  screensFor:
+                    typeof garageScreensFor === 'function'
+                      ? garageScreensFor
+                      : null,
+                });
+              if (p.view === drawn && typeof garageOfferSave === 'function')
+                garageOfferSave(gridEl, drawn, p.ecu);
+            });
+          } else {
+            gridEl.innerHTML = `<pre class="ipo-protocol mono">${esc(
+              (p.view.lines || []).join('\n')
+            )}</pre>`;
+          }
+        }
+        return;
+      }
+      paintedView = null;
+      if (inpa) ipoPaintGrid(gridEl, p);
+      else ipoPaintLines(gridEl, p);
+    },
+    left: () => {
+      ipoSetKeysCaption('');
+      ipoProgramLeft();
+      if (typeof back === 'function') back();
+    },
+  };
+  return ui;
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = { ipoBackAction, ipoMakeUi };
+}

package/runtime/screens/ipo-runtime/wire-policy.js

@@ -0,0 +1,113 @@
+/**
+ * @file The runtime's wire policy: which SGBD a script's job goes to, and
+ * which jobs are a USER ACTION that must be confirmed before they are sent.
+ *
+ * SAFETY. Confirm before any key whose body can send a job the write
+ * classifier flags; a screen's own writes are confirmed once per screen.
+ * Release on leave is the script's own Back ITEM (that is how INPA releases
+ * what it energised) plus `inpaexit` on module exit; the Back job is also
+ * registered with registerMenuLeave so a route change still sends it. Reads
+ * never prompt. Jobs go to the SGBD the car identified.
+ */
+
+/**
+ * The session plumbing INPA sends without asking anyone: the write
+ * classifier is default-deny (it guards the raw job route, where an unknown
+ * name must never reach the car unasked), and inside a running script most
+ * of what it flags is the session INITIALISIERUNG, the DIAGNOSE_AUFRECHT
+ * keep-alive, the closing DIAGNOSE_ENDE -- prompting for each turns opening
+ * a module into a wall of dialogs. What is worth confirming is an ACTUATOR
+ * COMMAND: a job that energises something, writes, resets or clears -- what
+ * INPA itself warns about. So the script's own plumbing goes silently and
+ * everything else the classifier flags still asks (an unknown write stays
+ * guarded).
+ * @type {RegExp}
+ */
+const IPO_PLUMBING =
+  /^(INITIALISIERUNG|IDENT|IDENT_\w+|INFO|DIAGNOSE_(AUFRECHT|ENDE|MODE)|ENDE)$/i;
+
+/** a group SGBD's name: D_ + the diagnostic address or a family (D_MOTOR) */
+const IPO_GROUP_SGBD_RE = /^d_[a-z0-9_]+$/;
+
+/**
+ * The wire target for a job the script addresses. The script's own variable
+ * holds INPA's dispatch LIST ("IHKA46,IHKA46_2,IHKA46_3") until inpainit
+ * stores the resolved variant; the car's identified SGBD is what we talk to.
+ * A script that names ANOTHER shipped module explicitly (a DME screen asking
+ * the EGS) keeps that name.
+ * @param {object} ecu - the module ({sgbd, _sgbdBase, _ipoKnownSgbds})
+ * @param {string|null} sgbd - the SGBD the script named
+ * @returns {string} the SGBD to send to, lower-case
+ */
+function ipoWireTarget(ecu, sgbd) {
+  const mine = String((ecu && ecu.sgbd) || '').toLowerCase();
+  const s = String(sgbd || '')
+    .toLowerCase()
+    .trim();
+  if (!s || s.includes(',') || s === mine) return mine;
+  const base = String((ecu && ecu._sgbdBase) || '').toLowerCase();
+  if (s === base) return mine;
+  const known = ecu && ecu._ipoKnownSgbds;
+  if (known && known.has(s)) return s;
+  // a group SGBD (D_0044, D_MOTOR): a script addresses a module by its group
+  // and lets EDIABAS find the variant on the wire -- the whole-vehicle
+  // scripts do it for every module, a module's script for its own startup
+  // (IHKA46 goes through D_005B) or a neighbour (GS30 asks D_0044). The
+  // shim's run route resolves the group the same way EDIABAS does and
+  // caches the answer, so the group stays the target (api-router.js).
+  if (IPO_GROUP_SGBD_RE.test(s)) return s;
+  return mine;
+}
+
+/**
+ * Does sending this job need the user's confirmation: a write by the
+ * classifier's verdict that is not the script's own session plumbing.
+ * @param {string|null|undefined} job - job name
+ * @returns {boolean}
+ */
+function ipoNeedsConfirm(job) {
+  const n = String(job || '').trim();
+  if (!n) return false;
+  if (typeof isWriteJob === 'function' && !isWriteJob(n)) return false;
+  if (IPO_PLUMBING.test(n)) return false;
+  return true;
+}
+
+/**
+ * Writes that change the module for good, whatever the setting says: coding,
+ * flashing, EEPROM/adaptation writes, resets, clears. An actuator drive is
+ * not one of these (STEUERN_*, START_/STOP_*, AKTIVIER*): it energises a
+ * component for the moment and releases when the key or screen is left.
+ * @type {RegExp}
+ */
+const IPO_PERMANENT_WRITE_RE = new RegExp(
+  '(SCHREIB|LOESCH|FLASH|PROGRAMMIER|RESET|CODIER|WRITE|DOWNLOAD|UPLOAD' +
+    '|ABGLEICH|ADAPTION|ANLERN|TEACH|CLEAR|SETZEN|(?:\\b|_)SET(?:\\b|_)|EINSTELL|TILGUNG' +
+    '|AUTHENTIS|SLEEP|WAKEUP|POWER_?DOWN)',
+  'i'
+);
+
+/**
+ * Does this write still ask, given Settings 'confirmActuators'? "Send
+ * immediately (like INPA)" turns the prompt off for actuator drives only; a
+ * permanent write asks whatever the setting says (the README's promise).
+ * @param {string} job - job name
+ * @returns {boolean} true when the prompt must be shown
+ */
+function ipoConfirmWanted(job) {
+  const n = String(job || '').trim();
+  if (IPO_PERMANENT_WRITE_RE.test(n)) return true;
+  if (typeof Settings === 'undefined' || !Settings || !Settings.get)
+    return true;
+  return Settings.get('confirmActuators', 'on') !== 'off';
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    IPO_PLUMBING,
+    IPO_PERMANENT_WRITE_RE,
+    ipoWireTarget,
+    ipoNeedsConfirm,
+    ipoConfirmWanted,
+  };
+}