@andrian.yablonskyy/thub-coordinator 1.0.29 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrian.yablonskyy/thub-coordinator",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "description": "TestHub Coordinator — job queue, resource registry, scheduler, heartbeat monitor, log/artifact store and web dashboard",
   "main": "src/server.js",
   "engines": {

package/public/css/thub.css

@@ -58,3 +58,43 @@
 .resource-capabilities {
   font-size: 0.75rem;
 }
+
+/* An overlay inside a modal (e.g. "Import to config"'s review note on the
+   resource card, public/js/usb-import.js) — Bootstrap doesn't stack modals. */
+.thub-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 10;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1rem;
+  background: rgba(0, 0, 0, 0.45);
+  border-radius: inherit;
+}
+
+.thub-overlay > .card {
+  max-width: 34rem;
+  max-height: 100%;
+  overflow: auto;
+}
+
+/* The client details modal has up to 7 tabs (Details, the config tabs,
+   Connected USB devices) — tighter padding keeps them on one row, ⚠ icons
+   included, at the modal-lg width. */
+.thub-resource-card .nav-tabs .nav-link {
+  padding: 0.45rem 0.65rem;
+}
+
+/* Bootstrap hides inactive tab panes only as direct children of
+   .tab-content (`.tab-content > .tab-pane`). The client details modal's
+   capability tabs sit inside their shared <form>/<fieldset> (one Save for
+   all of them), so without this the inactive ones merely fade out and still
+   take up space, pushing the active tab's fields down. */
+.tab-content .tab-pane[data-config-pane] {
+  display: none;
+}
+
+.tab-content .tab-pane[data-config-pane].active {
+  display: block;
+}

package/public/js/client-config.js

@@ -0,0 +1,117 @@
+/**
+ * @file        packages/coordinator/public/js/client-config.js
+ * @description Dashboard: the resource card's Capabilities form — add/remove device rows, and turn the form into
+ *              the Client's hw/sw config section (JSON) on Save
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+(function (){
+  const val = (root, f) => root.querySelector(`[data-f="${f}"]`),
+    text = (root, f) => (val(root, f)?.value || '').trim(),
+    num = (root, f) => (text(root, f) === '' ? undefined : Number(text(root, f))),
+    // Only set keys: an empty field means "not configured", not "".
+    compact = (obj) => Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined && v !== '')),
+    device = (value) => (/^\d+$/.test(value) ? { index: Number(value) } : { path: value });
+
+  function rows(form, kind){
+    return [...form.querySelectorAll(`[data-table="${kind}"] tbody [data-row]`)].map((tr) => {
+      if (kind === 'relays'){
+        return compact({ channel: num(tr, 'channel'), baseUrl: text(tr, 'baseUrl') });
+      }
+      let extra = {};
+      try {
+        extra = JSON.parse(tr.dataset.extra || '{}');
+      }
+      catch {
+        extra = {};
+      }
+      return compact({
+        ...extra,
+        ...device(text(tr, 'device')),
+        serial: text(tr, 'serial'),
+        baudRate: num(tr, 'baudRate'),
+        devpath: text(tr, 'devpath')
+      });
+    });
+  }
+
+  function sectionFrom(form){
+    if (form.dataset.clientConfig === 'sw'){
+      return compact({
+        image: text(form, 'image'),
+        registry: text(form, 'registry'),
+        cpus: num(form, 'cpus'),
+        memory: text(form, 'memory'),
+        cmd: text(form, 'cmd') ? text(form, 'cmd').split(/\s+/) : undefined,
+        allowDockerHub: val(form, 'allowDockerHub').checked,
+        allowJobImages: val(form, 'allowJobImages').checked
+      });
+    }
+    const power = form.querySelector('[data-power]'),
+      method = text(power, 'method');
+    return {
+      stlinks: rows(form, 'stlinks'),
+      uarts: rows(form, 'uarts'),
+      usbs: rows(form, 'usbs'),
+      relays: rows(form, 'relays'),
+      power: method ? compact({ method, hub: text(power, 'hub'), port: num(power, 'port'), baseUrl: text(power, 'baseUrl') }) : null
+    };
+  }
+
+  // ⚠ on each config tab whose fields differ from what was loaded. A pane's
+  // state: its field values (rows included) plus the hidden per-row extras.
+  function paneState(pane){
+    const fields = [...pane.querySelectorAll('input, select, textarea')].filter((i) => i.type !== 'hidden')
+        .map((i) => (i.type === 'checkbox' ? i.checked : i.value)),
+      extras = [...pane.querySelectorAll('tr[data-row]')].map((tr) => tr.dataset.extra || '');
+    return JSON.stringify([fields, extras]);
+  }
+
+  document.querySelectorAll('[data-config-root]').forEach((root) => {
+    const panes = [...root.querySelectorAll('[data-config-pane]')],
+      loaded = new Map(panes.map((pane) => [pane, paneState(pane)]));
+    function update(){
+      for (const pane of panes){
+        root.querySelector(`[data-config-tab="${pane.dataset.configPane}"] [data-dirty-icon]`)
+          ?.classList.toggle('d-none', paneState(pane) === loaded.get(pane));
+      }
+    }
+    for (const type of ['input', 'change', 'thub:changed']){
+      root.addEventListener(type, update);
+    }
+  });
+
+  document.querySelectorAll('form[data-client-config]').forEach((form) => {
+    form.addEventListener('click', (e) => {
+      const add = e.target.closest('[data-add-row]'),
+        remove = e.target.closest('[data-remove-row]');
+      if (add){
+        const kind = add.dataset.addRow,
+          tbody = form.querySelector(`[data-table="${kind}"] tbody`);
+        if (tbody.children.length >= 8){
+          return; // the Client takes at most 8 of each
+        }
+        tbody.appendChild(form.querySelector(`template[data-template="${kind}"]`).content.cloneNode(true));
+        form.dispatchEvent(new Event('thub:changed', { bubbles: true }));
+      }
+      else if (remove){
+        remove.closest('tr').remove();
+        form.dispatchEvent(new Event('thub:changed', { bubbles: true }));
+      }
+    });
+    // Before confirm.js (capture phase), so the JSON is in place whatever
+    // it decides; a bad number etc. is reported by the server on Save.
+    form.addEventListener('submit', () => {
+      form.querySelector('input[name="config"]').value = JSON.stringify(sectionFrom(form));
+    }, true);
+  });
+})();

package/public/js/usb-import.js

@@ -0,0 +1,169 @@
+/**
+ * @file        packages/coordinator/public/js/usb-import.js
+ * @description Dashboard: "Import to config" on the resource card's Connected USB devices tab — updates the Config
+ *              sub-tabs' device lists from the last `lsusb -tvv`, opens the first changed one, and asks to verify
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+(function (){
+  const { parseLsusbTree, classifyDevices } = window.thubUsbParse,
+    TITLES = { stlinks: 'ST-Link', uarts: 'UART', usbs: 'DUT USB' },
+    MAX_INDEX = 8,
+
+    el = (tag, attrs = {}, ...children) => {
+      const node = document.createElement(tag);
+      for (const [k, v]of Object.entries(attrs)){
+        if (k === 'class'){
+          node.className = v;
+        }
+        else {
+          node.setAttribute(k, v);
+        }
+      }
+      for (const c of children){
+        node.append(c);
+      }
+      return node;
+    };
+
+  // Updates one device table from the scan, keeping what's stable:
+  //   - a row already there for a scanned port (same udev devpath) keeps its
+  //     Device — so its /dev/thub/dut<N>-… symlink, and anything using it,
+  //     don't move — and what the scan can't know (serial, baud rate, extras);
+  //   - a newly found device gets the lowest free udev index;
+  //   - a row with no devpath (an explicit /dev path set by hand) stays;
+  //   - a row for a port that's not in the scan any more is removed.
+  // Returns { rows: [{ devpath, device, isNew, label, id }], removed: [ports] }.
+  function fillTable(form, kind, devices){
+    const tbody = form.querySelector(`[data-table="${kind}"] tbody`),
+      template = form.querySelector(`template[data-template="${kind}"]`),
+      rows = [...tbody.querySelectorAll('tr')].map((tr) => ({
+        tr,
+        devpath: tr.querySelector('[data-f="devpath"]')?.value.trim() || '',
+        device: tr.querySelector('[data-f="device"]')?.value.trim() || ''
+      })),
+      byPort = new Map(rows.filter((r) => r.devpath).map((r) => [r.devpath, r])),
+      manual = rows.filter((r) => !r.devpath),
+      scanned = new Set(devices.map((d) => d.devpath)),
+      used = new Set([...manual, ...rows.filter((r) => scanned.has(r.devpath))].map((r) => r.device)),
+      nextIndex = () => {
+        for (let i = 1; i <= MAX_INDEX; i++){
+          if (!used.has(String(i))){
+            used.add(String(i));
+            return String(i);
+          }
+        }
+        return '';
+      },
+      result = [],
+
+      updated = devices.map((d) => {
+        const old = byPort.get(d.devpath),
+          tr = old ? old.tr : template.content.firstElementChild.cloneNode(true);
+        let extra = {};
+        try {
+          extra = JSON.parse(tr.dataset.extra || '{}');
+        }
+        catch {
+          extra = {};
+        }
+        delete extra.vendorId;
+        delete extra.productId;
+        if (d.vendorId){
+          Object.assign(extra, { vendorId: d.vendorId, productId: d.productId });
+        }
+        tr.dataset.extra = JSON.stringify(extra);
+        const device = old ? old.device : nextIndex();
+        tr.querySelector('[data-f="device"]').value = device;
+        tr.querySelector('[data-f="devpath"]').value = d.devpath;
+        result.push({ devpath: d.devpath, device, isNew: !old, label: d.label, id: d.id });
+        return tr;
+      });
+    tbody.replaceChildren(...updated, ...manual.map((r) => r.tr));
+    return { rows: result, removed: rows.filter((r) => r.devpath && !scanned.has(r.devpath)).map((r) => r.devpath) };
+  }
+
+  function overlay(modal, { total, skipped, changes }){
+    const content = modal.querySelector('.modal-content'),
+      body = el('div', { class: 'card-body small' });
+    body.append(el('p', {}, total
+      ? 'The ST-Link, UART and DUT USB tabs were updated from the last lsusb -tvv scan (⚠ marks what changed). Nothing is saved yet: ' +
+        'check them, set what the scan can\'t know (e.g. UART baud rates), then press Save capabilities.'
+      : 'The scan has no device a HW Client uses (ST-Link, USB-serial adapter, STM32 COM port), so nothing was changed.'));
+    for (const [kind, change]of Object.entries(changes)){
+      if (!change.rows.length && !change.removed.length){
+        continue;
+      }
+      body.append(el('strong', {}, `${TITLES[kind]} (${change.rows.length})`));
+      body.append(el('ul', { class: 'mb-2' },
+        ...change.rows.map((row) => el('li', {}, `Device ${row.device || '?'} ← port `, el('code', {}, row.devpath), ` ${row.label} (${row.id}) `,
+          el('span', { class: `badge ${row.isNew ? 'text-bg-primary' : 'text-bg-secondary'}` }, row.isNew ? 'new' : 'already configured'))),
+        ...change.removed.map((port) => el('li', { class: 'text-warning-emphasis' }, 'Removed: port ', el('code', {}, port), ' — not in the scan'))));
+    }
+    if (changes.stlinks?.rows.length){
+      body.append(el('p', { class: 'text-body-secondary mb-2' },
+        'ST-Link serials aren\'t in lsusb -tvv: the Client looks them up from each probe\'s udev symlink.'));
+    }
+    if (skipped.length){
+      body.append(el('details', {}, el('summary', {}, `Not imported (${skipped.length})`),
+        el('ul', { class: 'mb-0' }, ...skipped.map((d) =>
+          el('li', {}, `${d.name || d.id} (${d.id}${d.devpath ? `, port ${d.devpath}` : ''}) — ${d.reason}`)))));
+    }
+    const close = el('button', { type: 'button', class: 'btn btn-primary btn-sm' }, total ? 'Review configuration' : 'OK'),
+      card = el('div', { class: 'card shadow', role: 'alertdialog', 'aria-modal': 'true', 'aria-labelledby': 'thub-import-title' },
+        el('div', { class: 'card-header fw-semibold', id: 'thub-import-title' }, total ? 'Verify the imported configuration' : 'Nothing to import'),
+        body,
+        el('div', { class: 'card-footer text-end' }, close)),
+      layer = el('div', { class: 'thub-overlay' }, card);
+    content.style.position = 'relative';
+    content.appendChild(layer);
+    // Esc closes the note, not the whole resource card behind it.
+    const onKey = (e) => {
+        if (e.key === 'Escape'){
+          e.stopPropagation();
+          e.preventDefault();
+          dismiss();
+        }
+      },
+      dismiss = () => {
+        layer.remove();
+        modal.removeEventListener('keydown', onKey, true);
+      };
+    modal.addEventListener('keydown', onKey, true);
+    close.addEventListener('click', dismiss);
+    modal.addEventListener('hidden.bs.modal', dismiss, { once: true });
+    close.focus();
+  }
+
+  document.querySelectorAll('[data-usb-import]').forEach((button) => {
+    button.addEventListener('click', () => {
+      const pane = button.closest('[data-usb-scan]'),
+        modal = button.closest('.modal'),
+        form = modal.querySelector('form[data-client-config="hw"]');
+      if (!form){
+        return;
+      }
+      const { lists, skipped } = classifyDevices(parseLsusbTree(pane.querySelector('[data-usb-output]').textContent)),
+        total = Object.values(lists).reduce((n, l) => n + l.length, 0),
+        changes = total ? Object.fromEntries(Object.entries(lists).map(([kind, devices]) => [kind, fillTable(form, kind, devices)])) : {};
+      if (total){
+        form.dispatchEvent(new Event('thub:changed', { bubbles: true })); // ⚠ on what changed
+        // Open the first config tab the import changed (else ST-Link).
+        const root = form.closest('[data-config-root]'),
+          changed = ['stlinks', 'uarts', 'usbs'].find((k) =>
+            !root.querySelector(`[data-config-tab="${k}"] [data-dirty-icon]`).classList.contains('d-none')) || 'stlinks';
+        bootstrap.Tab.getOrCreateInstance(root.querySelector(`[data-config-tab="${changed}"]`)).show();
+      }
+      overlay(modal, { total, skipped, changes });
+    });
+  });
+})();

package/public/js/usb-parse.js

@@ -0,0 +1,114 @@
+/**
+ * @file        packages/coordinator/public/js/usb-parse.js
+ * @description Parses `lsusb -tvv` output into USB devices and sorts the ones a HW Client can use into its config
+ *              lists (ST-Links, UARTs, DUT USB) — for "Import to config" on the resource card; also loadable in Node
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+(function (root){
+  // vendor:product -> the Client config list it belongs in. The first id of
+  // each list is the Client's own default (udev.js), which needs no
+  // vendorId/productId on the row.
+  const KNOWN = {
+      '0483:3748': { kind: 'stlinks', label: 'ST-Link/V2' },
+      '0483:374b': { kind: 'stlinks', label: 'ST-Link/V2-1' },
+      '0483:374e': { kind: 'stlinks', label: 'STLINK-V3' },
+      '0483:374f': { kind: 'stlinks', label: 'STLINK-V3' },
+      '0483:3753': { kind: 'stlinks', label: 'STLINK-V3' },
+      '0483:3754': { kind: 'stlinks', label: 'STLINK-V3' },
+      '0403:6001': { kind: 'uarts', label: 'FTDI FT232R' },
+      '0403:6015': { kind: 'uarts', label: 'FTDI FT-X' },
+      '0403:6010': { kind: 'uarts', label: 'FTDI FT2232' },
+      '0403:6014': { kind: 'uarts', label: 'FTDI FT232H' },
+      '10c4:ea60': { kind: 'uarts', label: 'Silicon Labs CP210x' },
+      '1a86:7523': { kind: 'uarts', label: 'CH340' },
+      '067b:2303': { kind: 'uarts', label: 'Prolific PL2303' },
+      '0483:5740': { kind: 'usbs', label: 'STM32 Virtual COM Port (DUT USB)' }
+    },
+    DEFAULT_IDS = { stlinks: '0483:3748', uarts: '0403:6001', usbs: '0483:5740' },
+    MAX_PER_KIND = 8;
+
+  // Devices from `lsusb -tvv`: one per /sys path (interfaces of the same
+  // device repeat it), root hubs included, each as
+  // { id, vendorId, productId, name, driver, sysPath, devpath }. `devpath`
+  // is what udev calls ATTR{devpath}: the port path after "<bus>-".
+  function parseLsusbTree(text){
+    const devices = new Map();
+    let current = null;
+    for (const line of String(text || '').split('\n')){
+      if (/^\s*(\/:|\|__)\s/.test(line)){
+        current = { driver: (/Driver=([^,]*)/.exec(line) || [])[1] || '' };
+        continue;
+      }
+      if (!current){
+        continue;
+      }
+      const id = /^\s*ID ([0-9a-fA-F]{4}):([0-9a-fA-F]{4})\s*(.*)$/.exec(line);
+      if (id){
+        Object.assign(current, { vendorId: id[1].toLowerCase(), productId: id[2].toLowerCase(), name: id[3].trim() });
+        current.id = `${current.vendorId}:${current.productId}`;
+        continue;
+      }
+      const sys = /\/sys\/bus\/usb\/devices\/([^\s]+)/.exec(line);
+      if (sys && current.id){
+        const sysPath = sys[1],
+          port = /^\d+-([\d.]+)$/.exec(sysPath);
+        if (!devices.has(sysPath)){
+          devices.set(sysPath, { ...current, sysPath, devpath: port ? port[1] : null });
+        }
+        current = null;
+      }
+    }
+    return [...devices.values()];
+  }
+
+  // { lists: { stlinks, uarts, usbs }, skipped } — the devices a HW Client
+  // can use, in port order, each { devpath, id, label, name, driver,
+  // vendorId?, productId? } (ids only when not the list's default), at most
+  // 8 per list (the rest skipped too).
+  function classifyDevices(devices){
+    const lists = { stlinks: [], uarts: [], usbs: [] },
+      skipped = [],
+      byPort = [...devices].sort((a, b) => (a.devpath || '').localeCompare(b.devpath || '', undefined, { numeric: true }));
+    for (const d of byPort){
+      const known = KNOWN[d.id];
+      if (!d.devpath){
+        skipped.push({ ...d, reason: 'root hub' });
+      }
+      else if (!known){
+        skipped.push({ ...d, reason: /hub/i.test(d.name) || d.driver.startsWith('hub') ? 'hub' : 'not a device the Client uses' });
+      }
+      else if (lists[known.kind].length >= MAX_PER_KIND){
+        skipped.push({ ...d, reason: `more than ${MAX_PER_KIND} ${known.kind}` });
+      }
+      else {
+        lists[known.kind].push({
+          devpath: d.devpath,
+          id: d.id,
+          label: known.label,
+          name: d.name,
+          driver: d.driver,
+          ...(d.id === DEFAULT_IDS[known.kind] ? {} : { vendorId: d.vendorId, productId: d.productId })
+        });
+      }
+    }
+    return { lists, skipped };
+  }
+
+  const api = { parseLsusbTree, classifyDevices, KNOWN_USB_DEVICES: KNOWN };
+  if (typeof module !== 'undefined' && module.exports){
+    module.exports = api;
+  }
+  else {
+    root.thubUsbParse = api;
+  }
+})(typeof window !== 'undefined' ? window : globalThis);

package/public/js/usb-scan.js

@@ -0,0 +1,99 @@
+/**
+ * @file        packages/coordinator/public/js/usb-scan.js
+ * @description Dashboard: the resource card's "Connected USB devices" tab — Refresh asks the Client for `lsusb`,
+ *              then polls until its answer arrives and shows it in place
+ *
+ * @author      Andrian Yablonskyy
+ * @copyright   Copyright (c) 2026 Andrian Yablonskyy. All rights reserved.
+ *
+ * This file is part of TestHub and is proprietary and confidential.
+ * Unauthorized copying, modification, distribution, or use of this file,
+ * via any medium, is strictly prohibited without prior written permission
+ * from AdSystem.PRO.
+ */
+
+'use strict';
+
+(function (){
+  const POLL_MS = 2000,
+    // The Client answers on its next heartbeat (10 s by default); no answer
+    // by then means it's too old to know scan-usb, or went away.
+    GIVE_UP_MS = 60_000;
+
+  document.querySelectorAll('[data-usb-scan]').forEach((pane) => {
+    const url = pane.dataset.usbScan,
+      button = pane.querySelector('[data-usb-refresh]'),
+      status = pane.querySelector('[data-usb-status]'),
+      errorBox = pane.querySelector('[data-usb-error]'),
+      output = pane.querySelector('[data-usb-output]');
+    let timer = null;
+
+    function show(view){
+      if (view.scan){
+        status.textContent = `lsusb -tvv at ${view.scan.atText}`;
+        errorBox.textContent = view.scan.error || '';
+        errorBox.classList.toggle('d-none', !view.scan.error);
+        output.textContent = view.scan.output || '';
+        output.classList.toggle('d-none', !view.scan.output);
+        const importButton = pane.querySelector('[data-usb-import]');
+        if (importButton){
+          importButton.disabled = !view.scan.output;
+        }
+      }
+    }
+
+    function waiting(on){
+      if (button){
+        button.disabled = on;
+        button.querySelector('i').className = on ? 'spinner-border spinner-border-sm me-1' : 'bi bi-arrow-clockwise me-1';
+      }
+      if (on){
+        status.textContent = 'Waiting for the Client to run lsusb -tvv (its next heartbeat)…';
+      }
+    }
+
+    function poll(requestedAt){
+      clearTimeout(timer);
+      timer = setTimeout(async () => {
+        try {
+          const view = await (await fetch(url, { cache: 'no-store', headers: { Accept: 'application/json' } })).json();
+          if (!view.pending && view.scan && view.scan.at >= requestedAt){
+            waiting(false);
+            return show(view);
+          }
+        }
+        catch {
+          // network blip: keep polling
+        }
+        if (Date.now() - Date.parse(requestedAt) > GIVE_UP_MS){
+          waiting(false);
+          status.textContent = 'No answer from the Client — it may be too old to scan USB devices, or offline. Try again later.';
+          return;
+        }
+        poll(requestedAt);
+      }, POLL_MS);
+    }
+
+    button?.addEventListener('click', async () => {
+      waiting(true);
+      try {
+        const res = await fetch(url, { method: 'POST', headers: { Accept: 'application/json' } }),
+          view = await res.json();
+        if (!res.ok){
+          throw new Error(view.error || `HTTP ${res.status}`);
+        }
+        poll(view.requestedAt);
+      }
+      catch (err){
+        waiting(false);
+        status.textContent = `Couldn't ask the Client: ${err.message}`;
+      }
+    });
+
+    // A request still pending when the page loaded (e.g. after a reload).
+    if (pane.dataset.pending && pane.dataset.requestedAt){
+      waiting(true);
+      poll(pane.dataset.requestedAt);
+    }
+  });
+})();

package/src/api/admin.js

@@ -51,6 +51,28 @@ function createAdminRouter({ services }){
     res.status(204).end();
   });
 
+  // Rename a Client: { name } ("" = back to its own name).
+  router.post('/resources/:id/rename', (req, res, next) => {
+    try {
+      const r = services.registry.rename(req.params.id, req.body?.name);
+      res.json({ id: r.id, name: r.name, nameOverride: r.name_override, clientName: r.reported_name });
+    }
+    catch (err){
+      next(err);
+    }
+  });
+
+  // A Client's capabilities (its hw or sw config section): { config }.
+  router.post('/resources/:id/config', (req, res, next) => {
+    try {
+      const r = services.registry.setClientConfig(req.params.id, req.body?.config);
+      res.json({ id: r.id, revision: r.config_revision, applied: r.config_applied_revision });
+    }
+    catch (err){
+      next(err);
+    }
+  });
+
   // Reboot a Client's host now (its running job is canceled first).
   router.post('/resources/:id/reboot', (req, res, next) => {
     try {

package/src/api/resource.js

@@ -51,7 +51,7 @@ function createResourceRouter({ services, config }){
   // the resource by name (see registry.registerAuto).
   router.post('/resources/register', requireJoinKey(config), (req, res, next) => {
     try {
-      const { clientId, name, type, labels, groups, hostInfo, capabilities } = req.body;
+      const { clientId, name, type, labels, groups, hostInfo, capabilities, config: clientConfig } = req.body;
       if (!clientId){
         return res.status(400).json({ error: 'clientId is required (persisted in the Client\'s .client-id file)' });
       }
@@ -66,6 +66,7 @@ function createResourceRouter({ services, config }){
         groups: groups || [],
         hostInfo,
         capabilities,
+        config: clientConfig,
         remoteAddr: req.ip,
         clientVersion: appVersion(req, 'client')
       });
@@ -82,9 +83,15 @@ function createResourceRouter({ services, config }){
   // matching happens (see the same note in api/agent.js).
   const auth = requireRole('resource');
 
+  // The Client's `lsusb` output for a scan-usb command (README §10).
+  router.post('/resources/:id/usb-scan', auth, requireOwnResource, (req, res) => {
+    const stored = services.registry.storeUsbScan(req.params.id, req.body || {});
+    res.status(stored ? 204 : 409).end();
+  });
+
   router.post('/resources/:id/heartbeat', auth, requireOwnResource, (req, res, next) => {
     try {
-      const { state, activeJobId, localLock, metrics, addresses, hostUptimeSec, activity, rebootSchedule } = req.body;
+      const { state, activeJobId, localLock, metrics, addresses, hostUptimeSec, activity, rebootSchedule, configRevision, configError } = req.body;
       services.registry.heartbeat(req.params.id, {
         state,
         activeJobId,
@@ -95,7 +102,9 @@ function createResourceRouter({ services, config }){
         clientVersion: appVersion(req, 'client'),
         hostUptimeSec,
         activity,
-        rebootSchedule
+        rebootSchedule,
+        configRevision,
+        configError
       });
       const commands = services.commands.drain(req.params.id),
         // Repeated on every heartbeat until the Client reports the new
@@ -109,6 +118,11 @@ function createResourceRouter({ services, config }){
       if (reboot){
         commands.push({ command: 'set-reboot-schedule', cron: reboot.cron });
       }
+      // Capabilities saved on the Config tab — likewise until applied.
+      const pendingConfig = services.registry.pendingConfig(req.params.id);
+      if (pendingConfig){
+        commands.push({ command: 'set-config', ...pendingConfig });
+      }
       // Removal pending (jobs.removeResource): once the Client reports its
       // job stopped, finish it. This response still goes out; the next
       // heartbeat gets 401, the token being gone with the resource.

package/src/db/migrations/018_add_client_config.sql

@@ -0,0 +1,12 @@
+-- Client capabilities edited from the dashboard (README §10, resource card
+-- Config tab). `client_config` is the editable part of the Client's config
+-- (its hw or sw section, secrets excluded) as it last reported it at
+-- registration; `config_desired` is what an admin saved, at
+-- `config_revision`. While the Client reports an older applied revision
+-- (`config_applied_revision`), every heartbeat reply carries a set-config
+-- command. `config_error` is why it last refused one (NULL: none).
+ALTER TABLE resources ADD COLUMN client_config TEXT;
+ALTER TABLE resources ADD COLUMN config_desired TEXT;
+ALTER TABLE resources ADD COLUMN config_revision INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE resources ADD COLUMN config_applied_revision INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE resources ADD COLUMN config_error TEXT;

package/src/db/migrations/019_add_name_override.sql

@@ -0,0 +1,7 @@
+-- Renaming a Client from the dashboard (README §10): `name_override` is the
+-- name an admin gave it, which registrations keep using (a Client presents
+-- its own name — config `name` or systemd instance — on every start, which
+-- would otherwise undo the rename). `reported_name` is that own name, shown
+-- as a hint and restored by clearing the override. NULL: no override.
+ALTER TABLE resources ADD COLUMN name_override TEXT;
+ALTER TABLE resources ADD COLUMN reported_name TEXT;

package/src/db/migrations/020_add_usb_scan.sql

@@ -0,0 +1,8 @@
+-- "Connected USB devices" (resource card tab, README §10): the Client runs
+-- `lsusb` only when an admin presses Refresh — a scan-usb command with its
+-- next heartbeat — and posts the output back. `usb_scan` is the last result
+-- (JSON {output, error, at}); `usb_scan_requested_at`/`_request_id` the
+-- pending request, so the tab can tell a fresh result from an old one.
+ALTER TABLE resources ADD COLUMN usb_scan TEXT;
+ALTER TABLE resources ADD COLUMN usb_scan_requested_at TEXT;
+ALTER TABLE resources ADD COLUMN usb_scan_request_id TEXT;