@andrian.yablonskyy/thub-coordinator 1.0.26 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andrian.yablonskyy/thub-coordinator",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "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

@@ -1,6 +1,6 @@
 #log-viewer {
   font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  font-size: 0.8125rem;
+  font-size: 0.75rem;
   white-space: pre-wrap;
   word-break: break-all;
 }
@@ -39,19 +39,12 @@
   text-align: left;
 }
 
-/* Resource card (views/mixins/resource.pug): 30% wider than Bootstrap's
-   default 500px modal. Only applies from 576px up, like Bootstrap's own
-   width — below that the modal fills the screen as before. */
-.modal.thub-resource-card {
-  --bs-modal-width: calc(500px * 1.3);
-}
-
 /* A status badge inside a page heading (e.g. the job page's state): badges
    are 0.75em of their parent, which in an h4 makes them oversized — keep
    it close to the badges in tables, centered on the heading text. */
 .thub-heading-badge {
-  font-size: 0.55em;
-  vertical-align: middle;
+  font-size: 0.6rem;
+  vertical-align: super;
 }
 
 /* Toast text (layout.pug): "\n" in a flash message is a line break, and a
@@ -61,3 +54,7 @@
   overflow-wrap: anywhere;
   min-width: 0;
 }
+
+.resource-capabilities {
+  font-size: 0.75rem;
+}

package/public/js/confirm.js

@@ -47,7 +47,16 @@
     field('ok').className = `btn btn-${tone}`;
     field('ok').textContent = form.dataset.confirmOk || 'Confirm';
     field('dismiss').textContent = form.dataset.confirmDismiss || 'Cancel';
-    modal.show();
+    // Asked from inside another modal (e.g. the resource card): close that
+    // one first — Bootstrap doesn't stack modals.
+    const host = form.closest('.modal.show');
+    if (host && host !== modalEl){
+      host.addEventListener('hidden.bs.modal', () => modal.show(), { once: true });
+      bootstrap.Modal.getInstance(host)?.hide();
+    }
+    else {
+      modal.show();
+    }
   });
 
   field('ok').addEventListener('click', () => {

package/src/api/admin.js

@@ -51,6 +51,28 @@ function createAdminRouter({ services }){
     res.status(204).end();
   });
 
+  // Reboot a Client's host now (its running job is canceled first).
+  router.post('/resources/:id/reboot', (req, res, next) => {
+    try {
+      const { resource, canceledJob } = services.jobs.requestReboot(req.params.id);
+      res.json({ id: resource.id, rebooting: true, canceledJob });
+    }
+    catch (err){
+      next(err);
+    }
+  });
+
+  // Scheduled host reboot: { cron } (5-field, host local time; "" clears).
+  router.post('/resources/:id/reboot-schedule', (req, res, next) => {
+    try {
+      const r = services.registry.setRebootSchedule(req.params.id, req.body?.cron ?? '');
+      res.json({ id: r.id, rebootSchedule: r.reboot_schedule, applied: r.reboot_schedule_applied });
+    }
+    catch (err){
+      next(err);
+    }
+  });
+
   router.post('/resources/:id/maintenance', (req, res, next) => {
     try {
       const resource = services.registry.setMaintenance(req.params.id, !!req.body.enabled);

package/src/api/resource.js

@@ -84,7 +84,7 @@ function createResourceRouter({ services, config }){
 
   router.post('/resources/:id/heartbeat', auth, requireOwnResource, (req, res, next) => {
     try {
-      const { state, activeJobId, localLock, metrics, addresses, hostUptimeSec, activity } = req.body;
+      const { state, activeJobId, localLock, metrics, addresses, hostUptimeSec, activity, rebootSchedule } = req.body;
       services.registry.heartbeat(req.params.id, {
         state,
         activeJobId,
@@ -94,7 +94,8 @@ function createResourceRouter({ services, config }){
         remoteAddr: req.ip,
         clientVersion: appVersion(req, 'client'),
         hostUptimeSec,
-        activity
+        activity,
+        rebootSchedule
       });
       const commands = services.commands.drain(req.params.id),
         // Repeated on every heartbeat until the Client reports the new
@@ -103,6 +104,11 @@ function createResourceRouter({ services, config }){
       if (updateTo){
         commands.push({ command: 'self-update', version: updateTo });
       }
+      // Also repeated until the Client reports applying it (README §10).
+      const reboot = services.registry.pendingRebootSchedule(req.params.id);
+      if (reboot){
+        commands.push({ command: 'set-reboot-schedule', cron: reboot.cron });
+      }
       // 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/017_add_reboot_schedule.sql

@@ -0,0 +1,7 @@
+-- Scheduled host reboot per Client (README §10): a 5-field cron expression
+-- in the Client host's local time, set on the resource card. `reboot_schedule`
+-- is what an admin saved; `reboot_schedule_applied` what the Client last
+-- reported applying — while they differ, every heartbeat reply carries a
+-- set-reboot-schedule command (api/resource.js). NULL = no scheduled reboot.
+ALTER TABLE resources ADD COLUMN reboot_schedule TEXT;
+ALTER TABLE resources ADD COLUMN reboot_schedule_applied TEXT;

package/src/dev/virtual.js

@@ -0,0 +1,286 @@
+/**
+ * @file        packages/coordinator/src/dev/virtual.js
+ * @description DEV mode only (DEV_MODE=1 with THUB_BOOTSTRAP_ADMIN_PASSWORD): a virtual agent, virtual Clients that
+ *              heartbeat and run assigned jobs in-process, and a seeded job history — for working on the dashboard
+ *              without real hardware (README §13.1)
+ *
+ * @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';
+
+const { JOB_STATES, ACTIVE_JOB_STATES } = require('@andrian.yablonskyy/thub-common'),
+  { hashToken } = require('../services/tokens'),
+  { version } = require('../../package.json');
+
+// Fixed, so `thub --token <it>` works against a dev Coordinator without
+// copying a fresh token each time. Only ever created in DEV mode.
+const DEV_AGENT_NAME = 'virtual-agent',
+  DEV_AGENT_TOKEN = 'agt_dev-virtual-agent-token',
+  VIRTUAL_CLIENTS = [
+    {
+      clientId: 'virtual-client-sw-01',
+      name: 'virtual-sw-01',
+      type: 'sw',
+      labels: ['virtual', 'emulator'],
+      capabilities: {
+        sw: { image: 'dut-emulator:dev', registry: null, allowDockerHub: true, allowJobImages: true, cpus: 2, memory: '2g' }
+      },
+      address: '10.0.0.41'
+    },
+    {
+      clientId: 'virtual-client-hw-01',
+      name: 'virtual-hw-01',
+      type: 'hw',
+      labels: ['virtual', 'board:nucleo-f401re', 'uart', 'stlink'],
+      capabilities: {
+        hw: {
+          stlinks: [{ path: '/dev/thub/dut1-stlink', index: 1, serial: '066DFF485457725187092834', present: true }],
+          uarts: [{ path: '/dev/thub/dut1-uart', index: 1, baudRate: 115200, present: true }],
+          usbs: [{ path: '/dev/thub/dut1-usb', index: 1, present: false }],
+          relays: [{ channel: 0, baseUrl: 'http://localhost:3000' }],
+          power: { method: 'relay' }
+        }
+      },
+      address: '10.0.0.42'
+    }
+  ],
+  // Seeded history: [daysAgo, source, target type, final state, duration s, user].
+  HISTORY = [
+    [6.8, 'ci', 'hw', 'PASSED', 412, null],
+    [6.1, 'cli', 'sw', 'FAILED', 95, 'alice'],
+    [5.4, 'ci', 'sw', 'PASSED', 188, null],
+    [4.9, 'ci', 'hw', 'ERROR', 31, null],
+    [4.2, 'cli', 'hw', 'PASSED', 640, 'bob'],
+    [3.6, 'ci', 'sw', 'TIMEOUT', 1800, null],
+    [2.7, 'cli', 'sw', 'CANCELED', 44, 'alice'],
+    [2.1, 'ci', 'hw', 'PASSED', 377, null],
+    [1.3, 'ci', 'sw', 'FAILED', 152, null],
+    [0.8, 'cli', 'hw', 'LOST', 260, 'bob'],
+    [0.4, 'ci', 'sw', 'PASSED', 201, null],
+    [0.1, 'cli', 'sw', 'PASSED', 73, 'alice']
+  ],
+  LOG_SCRIPT = [
+    ['runner', 'downloading app.bin (virtual)'],
+    ['runner', 'cloning yourorg/firmware-tests at main (virtual)'],
+    ['flash', 'st-flash write app.bin 0x08000000 ... done (virtual)'],
+    ['uart', '[BOOT] app v1.4.0-dev'],
+    ['uart', '[INIT] peripherals ok'],
+    ['runner', 'running: sh -c "./ci/run.sh"'],
+    ['runner', 'test_boot ............ ok'],
+    ['runner', 'test_uart_echo ....... ok'],
+    ['runner', 'test_flash_crc ....... ok'],
+    ['runner', 'test_power_cycle ..... ok']
+  ],
+
+  spec = (type, user, extra = {}) => ({
+    target: { type, labels: ['virtual'] },
+    command: './ci/run.sh',
+    downloads: [{ url: 'https://artifactory.example.com/fw-local/app/1.4.0-dev/app.bin' }],
+    ...(type === 'sw' ? { image: 'alpine:3.20' } : {}),
+    git: { url: 'https://github.com/yourorg/firmware-tests.git', ref: 'main', depth: 1 },
+    ...(user ? { user } : {}),
+    meta: { repo: 'yourorg/firmware', branch: 'main', virtual: true },
+    ...extra
+  });
+
+function isDevMode(env = process.env){
+  return env.DEV_MODE === '1' && Boolean(env.THUB_BOOTSTRAP_ADMIN_PASSWORD);
+}
+
+// The virtual agent, with its fixed token (re-applied if revoked or changed).
+function ensureAgent(services){
+  const { db } = services,
+    existing = db.prepare('SELECT * FROM agents WHERE name = ?').get(DEV_AGENT_NAME);
+  if (existing){
+    db.prepare('UPDATE agents SET token_hash = ?, revoked_at = NULL WHERE id = ?').run(hashToken(DEV_AGENT_TOKEN), existing.id);
+    return existing.id;
+  }
+  const id = 'agt_dev-virtual-agent';
+  db.prepare('INSERT INTO agents (id, name, kind, token_hash, created_at) VALUES (?, ?, ?, ?, ?)').run(
+    id, DEV_AGENT_NAME, 'cli', hashToken(DEV_AGENT_TOKEN), new Date().toISOString()
+  );
+  services.agents.touchLastUsed(id, version);
+  return id;
+}
+
+// A week of finished jobs in every final state, on the virtual Clients —
+// only into an empty jobs table, so restarts don't pile them up.
+function seedHistory(services, agentId, resourceIds){
+  const { db, jobs, logs } = services;
+  if (db.prepare('SELECT COUNT(*) AS n FROM jobs').get().n > 0){
+    return 0;
+  }
+  for (const [daysAgo, source, type, state, durationSec, user]of HISTORY){
+    const job = jobs.create({ agentId, source, spec: spec(type, user) }),
+      created = Date.now() - daysAgo * 86400000,
+      started = created + 20000,
+      finished = started + durationSec * 1000,
+      ran = state !== 'CANCELED' || durationSec > 0,
+      failed = state === 'FAILED' ? 2 : 0;
+    db.prepare(
+      `UPDATE jobs SET state = ?, resource_id = ?, created_at = ?, assigned_at = ?, started_at = ?, finished_at = ?,
+         duration_sec = ?, exit_code = ?, summary = ?, message = ? WHERE id = ?`
+    ).run(
+      state,
+      resourceIds[type],
+      new Date(created).toISOString(),
+      new Date(created + 5000).toISOString(),
+      ran ? new Date(started).toISOString() : null,
+      new Date(finished).toISOString(),
+      ran ? durationSec : null,
+      { PASSED: 0, FAILED: 1 }[state] ?? null,
+      JSON.stringify(['PASSED', 'FAILED'].includes(state)
+        ? { total: 12, passed: 12 - failed, failed, skipped: 0 }
+        : { error: `virtual ${state.toLowerCase()}` }),
+      { TIMEOUT: 'Job exceeded its timeout', LOST: 'Resource stopped heartbeating', ERROR: 'Flashing failed (virtual)' }[state] || null,
+      job.id
+    );
+    logs.appendBatch(job.id, LOG_SCRIPT.slice(0, state === 'PASSED' ? LOG_SCRIPT.length : 6).map(([stream, line], i) => ({
+      ts: new Date(started + i * 1000).toISOString(), stream, line
+    })));
+  }
+  return HISTORY.length;
+}
+
+// Virtual Clients, run in-process: they heartbeat like real ones (so they
+// stay IDLE instead of going OUT_OF_SERVICE) and play out any job the
+// scheduler assigns them — accept, PREPARING, RUNNING with streamed log
+// lines, then a PASSED (mostly) or FAILED result — through the same
+// services the Client API uses, so SSE, durations and artifacts all work.
+function startVirtualClients(services, config){
+  const { registry, jobs, logs, bus } = services,
+    intervalMs = config.heartbeat.intervalSec * 1000,
+    clients = new Map(); // resourceId -> { def, activity, running }
+
+  for (const def of VIRTUAL_CLIENTS){
+    const { resourceId } = registry.registerAuto({
+      clientId: def.clientId,
+      name: def.name,
+      type: def.type,
+      labels: def.labels,
+      hostInfo: { hostname: `${def.name}.virtual`, platform: 'linux', addresses: [{ iface: 'eth0', address: def.address, family: 'IPv4' }], timeZone: 'UTC' },
+      capabilities: { ...def.capabilities, rebootSupported: false },
+      remoteAddr: '127.0.0.1',
+      clientVersion: version
+    });
+    clients.set(resourceId, { def, activity: { state: 'idle', jobId: null, since: Date.now() }, running: null });
+  }
+
+  const bootedAt = Date.now() - 3 * 86400000;
+  function heartbeat(resourceId){
+    const c = clients.get(resourceId),
+      busy = Boolean(c.running);
+    registry.heartbeat(resourceId, {
+      state: busy ? 'busy' : 'idle',
+      activeJobId: c.running,
+      localLock: false,
+      addresses: [{ iface: 'eth0', address: c.def.address, family: 'IPv4' }],
+      remoteAddr: '127.0.0.1',
+      clientVersion: version,
+      hostUptimeSec: Math.round((Date.now() - bootedAt) / 1000),
+      activity: { state: c.activity.state, jobId: c.activity.jobId, durationSec: Math.round((Date.now() - c.activity.since) / 1000) },
+      rebootSchedule: registry.get(resourceId)?.reboot_schedule || null // "applies" whatever is saved
+    });
+    services.commands.drain(resourceId); // nothing real to act on
+  }
+
+  const beat = () => {
+      for (const resourceId of clients.keys()){
+        try {
+          heartbeat(resourceId);
+        }
+        catch (err){
+          console.error(`DEV virtual client heartbeat: ${err.message}`);
+        }
+      }
+    },
+    timer = setInterval(beat, intervalMs);
+  timer.unref?.();
+  beat();
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+    stillActive = (jobId) => ACTIVE_JOB_STATES.has(jobs.get(jobId)?.state);
+
+  async function run(resourceId, jobId){
+    const c = clients.get(resourceId);
+    c.running = jobId;
+    c.activity = { state: 'job', jobId, since: Date.now() };
+    try {
+      await sleep(800);
+      if (!stillActive(jobId)){
+        return;
+      }
+      jobs.setState(jobId, JOB_STATES.PREPARING);
+      logs.appendBatch(jobId, [{ stream: 'runner', line: `(virtual client ${c.def.name}) preparing` }]);
+      await sleep(1500);
+      if (!stillActive(jobId)){
+        return;
+      }
+      jobs.setState(jobId, JOB_STATES.RUNNING);
+      for (const [stream, line]of LOG_SCRIPT){
+        await sleep(600 + Math.random() * 900);
+        if (!stillActive(jobId)){
+          return; // canceled meanwhile
+        }
+        logs.appendBatch(jobId, [{ stream, line }]);
+      }
+      const failed = Math.random() < 0.2 ? 1 : 0;
+      jobs.applyResult(jobId, resourceId, {
+        state: failed ? JOB_STATES.FAILED : JOB_STATES.PASSED,
+        exitCode: failed,
+        summary: { total: 4, passed: 4 - failed, failed, skipped: 0 }
+      });
+    }
+    catch (err){
+      console.error(`DEV virtual client ${c.def.name}: ${err.message}`);
+    }
+    finally {
+      c.running = null;
+      c.activity = { state: 'idle', jobId: null, since: Date.now() };
+      heartbeat(resourceId);
+    }
+  }
+
+  bus.on('job.assigned', ({ jobId, resourceId }) => {
+    if (clients.has(resourceId)){
+      run(resourceId, jobId);
+    }
+  });
+
+  return {
+    resourceIds: Object.fromEntries([...clients].map(([id, c]) => [c.def.type, id])),
+    stop: () => clearInterval(timer)
+  };
+}
+
+// Entry point from server.js. Returns null outside DEV mode.
+function startDevMode(services, config, env = process.env){
+  if (!isDevMode(env)){
+    return null;
+  }
+  const agentId = ensureAgent(services),
+    virtual = startVirtualClients(services, config),
+    seeded = seedHistory(services, agentId, virtual.resourceIds);
+  // A few live ones for the virtual Clients to pick up right away.
+  if (seeded){
+    for (const [type, user]of [['sw', 'alice'], ['hw', null], ['sw', 'bob']]){
+      services.jobs.create({ agentId, source: 'cli', spec: spec(type, user) });
+    }
+  }
+  console.warn(
+    '*** DEV MODE (DEV_MODE=1): virtual Clients virtual-sw-01 / virtual-hw-01 are running in-process' +
+      `${seeded ? `, and ${seeded} past jobs + 3 live ones were seeded` : ''}.\n` +
+      `*** Virtual agent token: ${DEV_AGENT_TOKEN}\n` +
+      `***   e.g. thub --url ${config.publicUrl} --token ${DEV_AGENT_TOKEN} run --type sw --docker-image alpine --command 'uname -a'`
+  );
+  return virtual;
+}
+
+module.exports = { startDevMode, isDevMode, DEV_AGENT_TOKEN };

package/src/server.js

@@ -35,6 +35,7 @@ const path = require('node:path'),
   { createCommandsService } = require('./services/commands'),
   { createRetentionService } = require('./services/retention'),
   { createCleanupService } = require('./services/cleanup'),
+  { startDevMode } = require('./dev/virtual'),
   { createUpdatesService } = require('./services/updates'),
 
   { createAgentRouter } = require('./api/agent'),
@@ -154,6 +155,9 @@ function start(configPath){
     app = createApp(config, services);
 
   ensureBootstrapAdmin(services);
+  // DEV_MODE=1 plus THUB_BOOTSTRAP_ADMIN_PASSWORD only: virtual agent,
+  // Clients and jobs to work on the dashboard with (src/dev/virtual.js).
+  services.dev = startDevMode(services, config);
 
   const server = app.listen(config.port, config.host, () => {
     console.log(`Config: ${config.configPath || '(built-in defaults)'}; data: ${config.dataDir}`);

package/src/services/jobs.js

@@ -13,7 +13,7 @@
 
 'use strict';
 
-const { validateJobSpec, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES } = require('@andrian.yablonskyy/thub-common'),
+const { validateJobSpec, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES, RESOURCE_STATES } = require('@andrian.yablonskyy/thub-common'),
   { paginate } = require('./list-prefs');
 
 function rowToJob(row){
@@ -145,22 +145,15 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
       spec.target.client = resource.id;
     }
 
-    // A job-supplied Docker image or command needs a Client that opted in —
-    // say which, rather than the generic "no resource can satisfy".
-    const needs = { jobImage: Boolean(spec.firmware.image), jobCommand: Boolean(spec.tests.command) },
+    // A job-supplied Docker image needs an SW Client that opted in — say so,
+    // rather than the generic "no resource can satisfy".
+    const needs = { jobImage: Boolean(spec.image) },
       { type, labels, group, client } = spec.target;
-    if ((needs.jobImage || needs.jobCommand) && registry.everSatisfiable(type, labels, group, client) &&
-      !registry.everSatisfiable(type, labels, group, client, needs)){
-      const missing = [
-        needs.jobImage && !registry.everSatisfiable(type, labels, group, client, { jobImage: true }) &&
-          `job-supplied Docker images (${spec.firmware.image}) — "sw": { "allowJobImages": true }`,
-        needs.jobCommand && !registry.everSatisfiable(type, labels, group, client, { jobCommand: true }) &&
-          'job-supplied commands (--run) — "allowJobCommands": true'
-      ].filter(Boolean);
+    if (needs.jobImage && registry.everSatisfiable(type, labels, group, client) && !registry.everSatisfiable(type, labels, group, client, needs)){
       throw Object.assign(
         new Error(
-          `No matching Client runs ${missing.length ? missing.join(', nor ') : 'both a job-supplied Docker image and command together'}` +
-            ' — enable it in a Client\'s config'
+          `No matching SW Client runs job-supplied Docker images (${spec.image}) — enable it on a Client ` +
+            'with "sw": { "allowJobImages": true } in its config'
         ),
         { status: 422 }
       );
@@ -263,7 +256,8 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
   }
 
   // Agent: POST /jobs/:id/cancel
-  function cancel(id, { agentId, isAdmin }){
+  // `reason`: shown as the job's message (e.g. "Canceled: user reboot request").
+  function cancel(id, { agentId, isAdmin, reason }){
     const job = get(id);
     if (!job){
       throw Object.assign(new Error('Unknown job'), { status: 404 });
@@ -278,7 +272,35 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
     if (job.resource_id){
       bus.emit('command', { resourceId: job.resource_id, command: 'cancel-job', jobId: id });
     }
-    return setState(id, JOB_STATES.CANCELED);
+    return setState(id, JOB_STATES.CANCELED, reason ? { message: reason } : {});
+  }
+
+  // Admin "Reboot" on a Client (resource card): its running job is canceled
+  // first (the host is going down anyway), then a `reboot` command goes out
+  // with its next heartbeat — the Client reboots the host through its root
+  // reboot helper once nothing on it is busy. Refused for a Client that's
+  // offline (it would reboot whenever it next reconnects) or can't reboot.
+  function requestReboot(resourceId, { by } = {}){
+    const r = registry.get(resourceId);
+    if (!r){
+      throw Object.assign(new Error('Unknown resource'), { status: 404 });
+    }
+    if (r.status === RESOURCE_STATES.OUT_OF_SERVICE || !r.last_heartbeat_at){
+      throw Object.assign(new Error(`${r.name} is offline — it can only be rebooted while it's connected`), { status: 409 });
+    }
+    if (r.capabilities?.rebootSupported === false){
+      throw Object.assign(
+        new Error(`${r.name}'s host has no reboot helper — reinstall the Client as root (sudo npm i -g @andrian.yablonskyy/thub-client)`),
+        { status: 409 }
+      );
+    }
+    const job = activeForResource(resourceId);
+    if (job){
+      cancel(job.id, { isAdmin: true, reason: 'Canceled: user reboot request' });
+    }
+    bus.emit('command', { resourceId, command: 'reboot', reason: `user reboot request${by ? ` by ${by}` : ''}` });
+    events.record('resource', resourceId, 'resource.reboot_requested', { by, canceledJob: job?.id || null });
+    return { resource: r, canceledJob: job?.id || null };
   }
 
   // Queued jobs pinned to a resource (`target.client`) can never run once it's
@@ -493,6 +515,7 @@ function createJobsService(db, { bus, events, registry, artifacts, config }){
     setState,
     cancel,
     cancelPinnedTo,
+    requestReboot,
     removeResource,
     completeRemoval,
     activeForResource,

package/src/services/registry.js

@@ -14,7 +14,7 @@
 'use strict';
 
 const { v4: uuid } = require('uuid'),
-  { RESOURCE_STATES, BUSY_SOURCES, ACTIVE_JOB_STATES, compareVersions } = require('@andrian.yablonskyy/thub-common'),
+  { RESOURCE_STATES, BUSY_SOURCES, ACTIVE_JOB_STATES, compareVersions, parseCron } = require('@andrian.yablonskyy/thub-common'),
   { generateToken, hashToken } = require('./tokens');
 
 function rowToResource(row){
@@ -67,13 +67,19 @@ const MAX_DEVICES = 8,
     present: typeof d?.present === 'boolean' ? d.present : null
   });
 
-// Plus `allowJobCommands` (either type): runs a job's own `tests.command`.
 function sanitizeCapabilities(caps){
   if (!caps || typeof caps !== 'object'){
     return null;
   }
   const typed = sanitizeTypedCapabilities(caps);
-  return typed ? { ...typed, allowJobCommands: caps.allowJobCommands === true } : null;
+  return typed
+    ? {
+      ...typed,
+      // Whether the host has the root reboot helper (thub-client-reboot.path)
+      // a scheduled reboot needs; unknown (null) for older Clients.
+      rebootSupported: typeof caps.rebootSupported === 'boolean' ? caps.rebootSupported : null
+    }
+    : null;
 }
 
 function sanitizeTypedCapabilities(caps){
@@ -109,7 +115,7 @@ function sanitizeTypedCapabilities(caps){
 // Heartbeat durations (README §10) arrive as seconds relative to "now" on
 // the Client and are anchored to the Coordinator's clock here. Anything
 // negative, non-numeric or over ~10 years is ignored.
-const ACTIVITY_STATES = new Set(['idle', 'job', 'locked', 'update-hold']),
+const ACTIVITY_STATES = new Set(['idle', 'job', 'locked', 'update-hold', 'reboot-hold']),
   MAX_DURATION_SEC = 10 * 365 * 86400;
 
 function secondsAgo(now, sec){
@@ -184,7 +190,12 @@ function createRegistryService(db, { bus, events }){
   function registerAuto({ clientId, name, type, labels = [], groups = [], hostInfo, capabilities, remoteAddr, clientVersion = null }){
     const resourceToken = generateToken('res'),
       remote = normalizeRemoteAddr(remoteAddr);
-    hostInfo = { ...(hostInfo || {}), addresses: sanitizeAddresses(hostInfo?.addresses) || [] };
+    hostInfo = {
+      ...(hostInfo || {}),
+      addresses: sanitizeAddresses(hostInfo?.addresses) || [],
+      // The host's own IANA zone — a scheduled reboot's cron runs in it.
+      timeZone: typeof hostInfo?.timeZone === 'string' && /^[A-Za-z0-9_+/-]{1,64}$/.test(hostInfo.timeZone) ? hostInfo.timeZone : null
+    };
     const caps = sanitizeCapabilities(capabilities),
       capsJson = caps ? JSON.stringify(caps) : null;
     let existing = getByClientId(clientId);
@@ -296,7 +307,7 @@ function createRegistryService(db, { bus, events }){
   // Reconcile status from a heartbeat's self-reported state (§5.1).
   function heartbeat(
     resourceId,
-    { state, activeJobId, localLock, metrics, addresses, remoteAddr, clientVersion = null, hostUptimeSec, activity } = {}
+    { state, activeJobId, localLock, metrics, addresses, remoteAddr, clientVersion = null, hostUptimeSec, activity, rebootSchedule } = {}
   ){
     const resource = get(resourceId);
     if (!resource){
@@ -329,6 +340,15 @@ function createRegistryService(db, { bus, events }){
       busyReason = null;
     }
 
+    // The reboot schedule the Client applies (null: none); older Clients
+    // don't report one at all — then leave what's stored.
+    if (rebootSchedule !== undefined){
+      db.prepare('UPDATE resources SET reboot_schedule_applied = ? WHERE id = ?').run(
+        typeof rebootSchedule === 'string' && rebootSchedule ? rebootSchedule.slice(0, 200) : null,
+        resourceId
+      );
+    }
+
     const now = Date.now(),
       cleanActivity = sanitizeActivity(now, activity),
 
@@ -476,14 +496,12 @@ function createRegistryService(db, { bus, events }){
   }
 
   // `needs`: what a job brings that a Client must have opted in to run —
-  // jobImage (firmware.image; sw.allowJobImages) and jobCommand
-  // (tests.command; allowJobCommands).
+  // jobImage (the job's own Docker image; sw.allowJobImages).
   function matchesTarget(r, labels, groupId, resourceId, needs = {}){
     return labels.every((l) => r.labels.includes(l)) &&
       (!groupId || r.group_ids.includes(groupId)) &&
       (!resourceId || r.id === resourceId) &&
-      (!needs.jobImage || r.capabilities?.sw?.allowJobImages === true) &&
-      (!needs.jobCommand || r.capabilities?.allowJobCommands === true);
+      (!needs.jobImage || r.capabilities?.sw?.allowJobImages === true);
   }
 
   // Admin: remove a resource from the registry (dashboard "Remove"). Refused
@@ -521,6 +539,37 @@ function createRegistryService(db, { bus, events }){
     return db.prepare('SELECT * FROM resources WHERE remove_requested_at IS NOT NULL').all().map(rowToResource);
   }
 
+  // Scheduled host reboot (resource card): a cron expression, validated
+  // here; '' or null clears it. Delivered on the Client's next heartbeat.
+  function setRebootSchedule(resourceId, cron, { by } = {}){
+    const r = get(resourceId);
+    if (!r){
+      throw Object.assign(new Error('Unknown resource'), { status: 404 });
+    }
+    const text = typeof cron === 'string' ? cron.trim().replace(/\s+/g, ' ') : '';
+    if (text){
+      try {
+        parseCron(text);
+      }
+      catch (err){
+        throw Object.assign(new Error(`Invalid reboot schedule "${text}": ${err.message}`), { status: 400 });
+      }
+    }
+    db.prepare('UPDATE resources SET reboot_schedule = ? WHERE id = ?').run(text || null, resourceId);
+    events.record('resource', resourceId, 'resource.reboot_schedule', { cron: text || null, by });
+    return get(resourceId);
+  }
+
+  // What a heartbeat reply must tell the Client, if its applied schedule
+  // isn't the saved one: { cron } (null = clear). Repeated until it reports it.
+  function pendingRebootSchedule(resourceId){
+    const r = get(resourceId);
+    if (!r || (r.reboot_schedule || null) === (r.reboot_schedule_applied || null)){
+      return null;
+    }
+    return { cron: r.reboot_schedule || null };
+  }
+
   function findIdleCandidates(type, labels, groupId, resourceId, needs){
     const rows = db
       .prepare('SELECT * FROM resources WHERE status = ? AND type = ? AND remove_requested_at IS NULL')
@@ -552,6 +601,8 @@ function createRegistryService(db, { bus, events }){
     pendingUpdate,
     assignToJob,
     remove,
+    setRebootSchedule,
+    pendingRebootSchedule,
     requestRemoval,
     pendingRemovals,
     findIdleCandidates,

package/src/services/scheduler.js

@@ -17,7 +17,7 @@ const { JOB_STATES, BUSY_SOURCES } = require('@andrian.yablonskyy/thub-common');
 
 // What a job needs a Client to have opted in to (registry matchesTarget).
 function jobNeeds(spec){
-  return { jobImage: Boolean(spec.firmware?.image), jobCommand: Boolean(spec.tests?.command) };
+  return { jobImage: Boolean(spec.image) };
 }
 
 function rowToJob(row){

package/src/web/routes.js

@@ -21,7 +21,8 @@ const fs = require('node:fs'),
   { requireAdminSession, requireAdminRole } = require('../auth'),
   { attachJobStream } = require('../api/sse'),
   {
-    RESOURCE_STATES, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES, isNewer, compareVersions, formatDateTime, parseDateTime
+    RESOURCE_STATES, JOB_STATES, ACTIVE_JOB_STATES, TERMINAL_JOB_STATES, isNewer, compareVersions, formatDateTime, parseDateTime,
+    nextCronRun
   } = require('@andrian.yablonskyy/thub-common'),
   { retentionCutoff, JOB_RETENTION } = require('../services/cleanup'),
   listPrefs = require('../services/list-prefs');
@@ -152,6 +153,8 @@ function createWebRouter({ services, config }){
       ];
     }
     res.locals.isNewer = isNewer;
+    res.locals.nextCronRun = nextCronRun;
+    res.locals.formatDateTime = formatDateTime;
     res.locals.currentPath = req.originalUrl;
     if (req.session){
       req.session.flash = [];
@@ -365,6 +368,10 @@ function createWebRouter({ services, config }){
         services.commands.push(r.id, { command: 'unlock' });
         flash(req, 'warning', `Releasing the local lock on ${r.name} (on its next heartbeat).`);
       }
+      else if (activity === 'reboot-hold'){
+        services.commands.push(r.id, { command: 'cancel-reboot' });
+        flash(req, 'warning', `Canceling the scheduled reboot of ${r.name}'s host (on its next heartbeat).`);
+      }
       else if (activity === 'update-hold'){
         services.commands.push(r.id, { command: 'cancel-update' });
         if (r.update_to){
@@ -375,7 +382,7 @@ function createWebRouter({ services, config }){
       else {
         flash(req, 'info', `${r.name} isn't doing anything to cancel.`);
       }
-      if (!job && ['locked', 'update-hold'].includes(activity)){
+      if (!job && ['locked', 'update-hold', 'reboot-hold'].includes(activity)){
         services.events.record('resource', r.id, 'resource.activity_canceled', { activity, by: req.session.user.username });
       }
     }
@@ -405,6 +412,35 @@ function createWebRouter({ services, config }){
     res.redirect(returnTo(req, '/resources'));
   });
 
+  // Reboot now (resource card footer): cancels a running job, then the
+  // Client reboots its host on its next heartbeat (jobs.requestReboot).
+  router.post('/resources/:id/reboot', requireAdminRole, (req, res) => {
+    try {
+      const { resource: r, canceledJob } = services.jobs.requestReboot(req.params.id, { by: req.session.user.username });
+      flash(req, 'warning', `Rebooting ${r.name}'s host on its next heartbeat.` + (canceledJob ? `\nCanceled its running job ${canceledJob}.` : ''));
+    }
+    catch (err){
+      flash(req, 'danger', err.message);
+    }
+    res.redirect(returnTo(req, '/resources'));
+  });
+
+  // Scheduled host reboot (resource card): save a cron expression, or clear
+  // it; the Client applies it on its next heartbeat.
+  router.post('/resources/:id/reboot-schedule', requireAdminRole, (req, res) => {
+    try {
+      const cron = req.body.clear === '1' ? '' : req.body.cron,
+        r = services.registry.setRebootSchedule(req.params.id, cron, { by: req.session.user.username });
+      flash(req, 'success', r.reboot_schedule
+        ? `Reboot schedule for ${r.name} saved: ${r.reboot_schedule}.\nThe Client applies it on its next heartbeat.`
+        : `Scheduled reboot for ${r.name} cleared.\nThe Client applies it on its next heartbeat.`);
+    }
+    catch (err){
+      flash(req, 'danger', err.message);
+    }
+    res.redirect(returnTo(req, '/resources'));
+  });
+
   router.post('/resources/:id/rotate-token', requireAdminRole, (req, res) => {
     const { generateToken, hashToken } = require('../services/tokens');
     const token = generateToken('res');

package/test/cleanup.test.js

@@ -55,7 +55,7 @@ function setup(jobRetention = 'forever'){
 
   // A job that finished at `finishedAt` (or is still queued, if null), with a log line.
   function job(finishedAt){
-    const spec = { target: { type: 'sw' }, firmware: { url: 'https://x/a' }, tests: { url: 'https://x/t' } },
+    const spec = { target: { type: 'sw' }, command: './run.sh' },
       j = jobs.create({ agentId: agent.id, source: 'cli', spec });
     db.prepare('INSERT INTO job_logs (job_id, seq, ts, stream, line) VALUES (?, 1, ?, \'runner\', ?)').run(j.id, NOW.toISOString(), 'x'.repeat(2000));
     if (finishedAt){

package/test/dev-mode.test.js

@@ -0,0 +1,63 @@
+/**
+ * @file        packages/coordinator/test/dev-mode.test.js
+ * @description Tests: DEV mode (virtual agent, Clients and jobs) — only with DEV_MODE=1 and a bootstrap password
+ *
+ * @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';
+
+const test = require('node:test'),
+  assert = require('node:assert/strict'),
+  fs = require('node:fs'),
+  os = require('node:os'),
+  path = require('node:path'),
+  { loadConfig } = require('../src/config'),
+  { buildServices } = require('../src/server'),
+  { startDevMode, isDevMode, DEV_AGENT_TOKEN } = require('../src/dev/virtual'),
+  { hashToken } = require('../src/services/tokens');
+
+test('DEV mode needs both DEV_MODE=1 and THUB_BOOTSTRAP_ADMIN_PASSWORD', () => {
+  assert.equal(isDevMode({ DEV_MODE: '1', THUB_BOOTSTRAP_ADMIN_PASSWORD: 'pw' }), true);
+  assert.equal(isDevMode({ DEV_MODE: '1' }), false);
+  assert.equal(isDevMode({ THUB_BOOTSTRAP_ADMIN_PASSWORD: 'pw' }), false);
+  assert.equal(isDevMode({ DEV_MODE: 'true', THUB_BOOTSTRAP_ADMIN_PASSWORD: 'pw' }), false);
+});
+
+test('seeds a virtual agent, virtual Clients and jobs once; nothing outside DEV mode', (t) => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'thub-dev-')),
+    file = path.join(dir, 'coordinator.json');
+  fs.writeFileSync(file, JSON.stringify({ dataDir: path.join(dir, 'data'), updates: { checkIntervalMin: 0 } }));
+  const config = loadConfig(file),
+    services = buildServices(config),
+    count = (table) => services.db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n,
+    warn = t.mock.method(console, 'warn', () => {});
+
+  assert.equal(startDevMode(services, config, {}), null);
+  assert.equal(count('agents') + count('resources') + count('jobs'), 0);
+
+  const env = { DEV_MODE: '1', THUB_BOOTSTRAP_ADMIN_PASSWORD: 'pw' },
+    first = startDevMode(services, config, env);
+  t.after(() => first.stop());
+  assert.equal(services.agents.getByTokenHash(hashToken(DEV_AGENT_TOKEN)).name, 'virtual-agent');
+  assert.deepEqual(services.registry.list().map((r) => r.name).sort(), ['virtual-hw-01', 'virtual-sw-01']);
+  const jobs = count('jobs'),
+    states = new Set(services.db.prepare('SELECT state FROM jobs').all().map((r) => r.state));
+  assert.equal(jobs, 15);
+  for (const s of ['PASSED', 'FAILED', 'ERROR', 'TIMEOUT', 'CANCELED', 'LOST', 'QUEUED']){
+    assert.ok(states.has(s), s);
+  }
+
+  const second = startDevMode(services, config, env); // a restart
+  t.after(() => second.stop());
+  assert.equal(count('jobs'), jobs);
+  assert.equal(count('agents'), 1);
+  assert.equal(count('resources'), 2);
+  assert.equal(warn.mock.callCount(), 2);
+});

package/test/list-prefs.test.js

@@ -74,7 +74,7 @@ test('jobs.page sorts and pages in SQL, with empty values last', () => {
       jobs.create({
         agentId: agent.id,
         source: 'cli',
-        spec: { target: { type: 'sw' }, firmware: { url: 'https://x/a' }, tests: { url: 'https://x/t' }, ...(user ? { user } : {}) }
+        spec: { target: { type: 'sw' }, command: './run.sh', ...(user ? { user } : {}) }
       }).id),
 
     byUser = (dir) => jobs.page({ sort: 'user', dir, size: 'all' }).rows.map((j) => j.spec.user ?? null);

package/test/scheduler.test.js

@@ -57,7 +57,7 @@ function buildTestServices(overrides = {}){
     jobs = createJobsService(db, { bus, events, registry, artifacts, config }),
     scheduler = createScheduler(db, { bus, events, registry, config }),
     heartbeatMonitor = createHeartbeatMonitor(db, { bus, events, registry, jobs, config });
-  return { db, registry, agents, groups, artifacts, jobs, scheduler, heartbeatMonitor, artifactsDir };
+  return { db, bus, registry, agents, groups, artifacts, jobs, scheduler, heartbeatMonitor, artifactsDir };
 }
 
 function registerResource(registry, { name, type, labels = [], groups = [], clientId } = {}){
@@ -68,8 +68,7 @@ function registerResource(registry, { name, type, labels = [], groups = [], clie
 function makeSpec(overrides = {}){
   return {
     target: { type: 'sw', labels: [] },
-    firmware: { url: 'https://x/app.bin' },
-    tests: { url: 'https://x/tests.tar.gz' },
+    command: './run.sh',
     ...overrides
   };
 }
@@ -528,7 +527,7 @@ test('a removed Client re-registers as a fresh resource under the same name', ()
 test('a job-supplied Docker image only goes to SW Clients that allow it; otherwise 422', () => {
   const { registry, agents, jobs, scheduler } = buildTestServices(),
     { agent } = agents.create({ name: 'dev', kind: 'cli' }),
-    imageJob = { target: { type: 'sw', labels: [] }, firmware: { image: 'alpine' }, tests: { url: 'https://x/t.tar.gz' } },
+    imageJob = { target: { type: 'sw', labels: [] }, image: 'alpine', command: './run.sh' },
     strict = registerResource(registry, { name: 'sw-strict', type: 'sw' });
   registry.heartbeat(strict.id, { state: 'idle' });
 
@@ -544,25 +543,79 @@ test('a job-supplied Docker image only goes to SW Clients that allow it; otherwi
 
   const fileJob = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec() });
   scheduler.runPass();
-  assert.equal(jobs.get(fileJob.id).resource_id, strict.id); // firmware URLs still go anywhere
+  assert.equal(jobs.get(fileJob.id).resource_id, strict.id); // jobs without an image still go anywhere
 });
 
-test('a job-supplied command only goes to Clients with allowJobCommands; otherwise 422 naming it', () => {
+test('every job carries its command and runs on any matching Client; an old-Agent spec is refused', () => {
   const { registry, agents, jobs, scheduler } = buildTestServices(),
     { agent } = agents.create({ name: 'dev', kind: 'cli' }),
-    commandJob = makeSpec({ tests: { url: 'https://x/t.tar.gz', command: 'make test' } }),
-    plain = registerResource(registry, { name: 'sw-plain', type: 'sw' });
-  registry.heartbeat(plain.id, { state: 'idle' });
+    r = registerResource(registry, { name: 'sw-any', type: 'sw' });
+  registry.heartbeat(r.id, { state: 'idle' });
 
-  assert.throws(() => jobs.create({ agentId: agent.id, source: 'cli', spec: commandJob }), /allowJobCommands/);
+  const job = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec({ command: 'make test', args: ['-j4'] }) });
+  scheduler.runPass();
+  assert.equal(jobs.get(job.id).resource_id, r.id);
+  assert.equal(jobs.get(job.id).spec.command, 'make test');
 
-  const { resourceId } = registry.registerAuto({
-    clientId: 'c-cmd', name: 'sw-cmd', type: 'sw', labels: [], capabilities: { sw: { image: 'emu' }, allowJobCommands: true }
-  });
-  registry.heartbeat(resourceId, { state: 'idle' });
-  const job = jobs.create({ agentId: agent.id, source: 'cli', spec: commandJob });
+  assert.throws(
+    () => jobs.create({ agentId: agent.id, source: 'cli', spec: { target: { type: 'sw' }, firmware: { url: 'https://x/a' }, tests: { url: 'https://x/t' } } }),
+    /older Agent.*--command/
+  );
+  assert.throws(() => jobs.create({ agentId: agent.id, source: 'cli', spec: { target: { type: 'sw' } } }), /command/);
+});
+
+test('reboot schedule: validated, then resent on heartbeats until the Client reports applying it', () => {
+  const { registry } = buildTestServices(),
+    r = registerResource(registry, { name: 'lab-reboot', type: 'sw' });
+
+  assert.throws(() => registry.setRebootSchedule(r.id, '61 3 * * *'), /Invalid reboot schedule.*minute: 61/);
+  assert.equal(registry.pendingRebootSchedule(r.id), null); // nothing set, nothing applied
+
+  registry.setRebootSchedule(r.id, '  30   3 * * sun ');
+  assert.deepEqual(registry.pendingRebootSchedule(r.id), { cron: '30 3 * * sun' });
+  registry.heartbeat(r.id, { state: 'idle' }); // an older Client: reports nothing
+  assert.deepEqual(registry.pendingRebootSchedule(r.id), { cron: '30 3 * * sun' });
+  registry.heartbeat(r.id, { state: 'idle', rebootSchedule: '30 3 * * sun' });
+  assert.equal(registry.pendingRebootSchedule(r.id), null);
+
+  registry.setRebootSchedule(r.id, '');
+  assert.deepEqual(registry.pendingRebootSchedule(r.id), { cron: null }); // tell it to clear
+  registry.heartbeat(r.id, { state: 'idle', rebootSchedule: null });
+  assert.equal(registry.pendingRebootSchedule(r.id), null);
+});
+
+test('reboot now: refused offline or without a helper; cancels a running job first, then sends reboot', () => {
+  const { bus, registry, agents, jobs, scheduler } = buildTestServices(),
+    { agent } = agents.create({ name: 'dev', kind: 'cli' }),
+    reg = (name, rebootSupported) => registry.get(registry.registerAuto({
+      clientId: `c-${name}`, name, type: 'sw', labels: [], capabilities: { sw: { image: 'emu' }, rebootSupported }
+    }).resourceId),
+    offline = reg('rb-offline', true),
+    noHelper = reg('rb-nohelper', false),
+    idle = reg('rb-idle', true),
+    busy = reg('rb-busy', true),
+    commands = [];
+  for (const r of [noHelper, idle, busy]){
+    registry.heartbeat(r.id, { state: 'idle' });
+  }
+  bus.on('command', (c) => commands.push(c));
+
+  assert.throws(() => jobs.requestReboot(offline.id), /offline/);
+  assert.throws(() => jobs.requestReboot(noHelper.id), /no reboot helper/);
+
+  assert.equal(jobs.requestReboot(idle.id).canceledJob, null);
+  assert.deepEqual(commands.map((c) => [c.resourceId, c.command]), [[idle.id, 'reboot']]);
+  commands.length = 0;
+
+  const job = jobs.create({ agentId: agent.id, source: 'cli', spec: makeSpec({ target: { type: 'sw', client: busy.id } }) });
   scheduler.runPass();
-  assert.equal(jobs.get(job.id).resource_id, resourceId);
+  jobs.setState(job.id, JOB_STATES.RUNNING);
+  assert.equal(jobs.requestReboot(busy.id, { by: 'admin' }).canceledJob, job.id);
+  assert.deepEqual(commands.map((c) => c.command), ['cancel-job', 'reboot']); // same heartbeat reply, in order
+  assert.equal(commands[1].reason, 'user reboot request by admin');
+  const after = jobs.get(job.id);
+  assert.equal(after.state, JOB_STATES.CANCELED);
+  assert.equal(after.message, 'Canceled: user reboot request');
 });
 
 test('a resource can belong to several groups at once', () => {

package/views/jobs/show.pug

@@ -41,9 +41,6 @@ block content
       dt.col-sm-2 Message
       dd.col-sm-10= job.message
 
-  h2.h6.mt-4 Log
-  +logViewer(job.id, jobActive)
-
   h2.h6.mt-4#artifacts Artifacts
   if artifacts.length
     ul.list-group
@@ -53,3 +50,6 @@ block content
           a(href=a.url) download
   else
     p.text-body-secondary No artifacts yet.
+
+  h2.h6.mt-4 Log
+  +logViewer(job.id, jobActive)

package/views/mixins/resource.pug

@@ -180,7 +180,7 @@ mixin capabilitiesList(caps)
 mixin uptimeRows(r, returnTo)
   - const stale = r.status === 'OUT_OF_SERVICE' && r.last_heartbeat_at
   - const ref = stale ? new Date(r.last_heartbeat_at).getTime() : Date.now()
-  - const activityLabel = { idle: 'Idle', job: 'Running job', locked: 'Locked locally', 'update-hold': 'Holding for self-update' }
+  - const activityLabel = { idle: 'Idle', job: 'Running job', locked: 'Locked locally', 'update-hold': 'Holding for self-update', 'reboot-hold': 'Holding for scheduled reboot' }
   dt.col-sm-4 Host uptime
   dd.col-sm-8
     if r.host_booted_at
@@ -205,12 +205,80 @@ mixin uptimeRows(r, returnTo)
     if user.role === 'admin'
       +cancelActivityButton(r, returnTo)
 
+//- Scheduled host reboot (cron, in the Client host's local time): what's
+//- saved, when it next fires, whether the Client has applied it, and — for
+//- admins — an editor. Saved here, applied on the Client's next heartbeat.
+mixin rebootScheduleRow(r, returnTo)
+  - const tz = r.host_info && r.host_info.timeZone
+  - const caps = r.capabilities || {}
+  - const pending = (r.reboot_schedule || null) !== (r.reboot_schedule_applied || null)
+  - let next = null
+  - try { next = r.reboot_schedule && tz ? nextCronRun(r.reboot_schedule, new Date(), { timeZone: tz }) : null } catch (e) { next = null }
+  dt.col-sm-4 Scheduled reboot
+  dd.col-sm-8
+    if r.reboot_schedule
+      code= r.reboot_schedule
+      if next
+        span.text-body-secondary.small.ms-2(
+          data-bs-toggle="tooltip"
+          data-bs-title=`${formatDateTime(next, { timeZone: tz })} host time (${tz}); shown here in your time zone`
+        )= `next ${fmtDate(next)}`
+      else if !tz
+        span.text-body-secondary.small.ms-2(
+          data-bs-toggle="tooltip"
+          data-bs-title="The Client runs it in its host's local time; this Client is too old to report its time zone"
+        ) host local time
+    else
+      span.text-body-secondary none
+    if pending
+      span.badge.text-bg-warning.ms-2(
+        data-bs-toggle="tooltip"
+        data-bs-title="Saved — the Client applies it on its next heartbeat"
+      ) not applied yet
+    if caps.rebootSupported === false
+      span.badge.text-bg-danger.ms-2(
+        data-bs-toggle="tooltip"
+        data-bs-title="This host has no reboot helper (thub-client-reboot.path), so the schedule can't reboot it — reinstall the Client as root: sudo npm i -g @andrian.yablonskyy/thub-client"
+      ) can't reboot
+    if user.role === 'admin'
+      form.d-flex.gap-1.mt-1(
+        method="post"
+        action=`/resources/${r.id}/reboot-schedule`
+        data-confirm=`Reboot the host of ${r.name} on this schedule? It reboots the whole host — every Client instance on it. Running jobs finish first: new ones wait, for up to 2 h, and otherwise that time is skipped.`
+        data-confirm-title="Schedule host reboots?"
+        data-confirm-ok="Save schedule"
+        data-confirm-tone="warning"
+      )
+        input(type="hidden" name="returnTo" value=returnTo)
+        input.form-control.form-control-sm.font-monospace(
+          type="text"
+          name="cron"
+          value=r.reboot_schedule || ''
+          placeholder="30 3 * * sun"
+          aria-label=`Reboot schedule for ${r.name} (cron)`
+          required
+        )
+        button.btn.btn-sm.btn-outline-primary(type="submit") Save
+      if r.reboot_schedule
+        form.d-inline(method="post" action=`/resources/${r.id}/reboot-schedule`)
+          input(type="hidden" name="returnTo" value=returnTo)
+          input(type="hidden" name="clear" value="1")
+          button.btn.btn-sm.btn-link.p-0.small(type="submit") Clear schedule
+      .form-text
+        | cron: minute hour day month weekday, in the host's local time#{tz ? ` (${tz})` : ''} — e.g.
+        |
+        code 30 3 * * sun
+        |  (Sundays 03:30) or
+        |
+        code 0 4 * * *
+        | . Reboots the whole host.
+
 //- Cancel the Client's current job or local lock — icon only, on the card's
 //- Task / status line, and only while there's one. A self-update hold is
 //- canceled from the version line instead (+versionWithUpdate).
 mixin cancelActivityButton(r, returnTo)
   - const state = r.activity && r.activity.state
-  - const what = r.activeJob ? `job ${r.activeJob.id}` : state === 'locked' ? 'the local lock' : null
+  - const what = r.activeJob ? `job ${r.activeJob.id}` : state === 'locked' ? 'the local lock' : state === 'reboot-hold' ? 'the scheduled reboot' : null
   if what
     form.d-inline.ms-2(
       method="post"
@@ -234,60 +302,123 @@ mixin resourceCard(r, groupsById, returnTo)
   - const local = ((r.host_info && r.host_info.addresses) || []).filter((a) => !isLoopback(a.address))
   - const external = r.remote_addr && !isLoopback(r.remote_addr) ? r.remote_addr : null
   .modal.fade.thub-resource-card(id=`resource-card-${r.id}` tabindex="-1" aria-labelledby=`resource-card-${r.id}-title` aria-hidden="true")
-    .modal-dialog.modal-dialog-centered
+    .modal-dialog.modal-dialog-centered.modal-lg
       .modal-content
         .modal-header
           h5.modal-title(id=`resource-card-${r.id}-title`)= r.name
           button.btn-close(type="button" data-bs-dismiss="modal" aria-label="Close")
-        .modal-body
-          dl.row.mb-0
-            dt.col-sm-4 Name
-            dd.col-sm-8= r.name
-            dt.col-sm-4 Type
-            dd.col-sm-8.text-uppercase= r.type
-            dt.col-sm-4 Status
-            dd.col-sm-8: +resourceBadge(r.status, r.remove_requested_at)
-            +uptimeRows(r, returnTo)
-            dt.col-sm-4 Client version
-            dd.col-sm-8: +versionWithUpdate(r.client_version, updates.latest.client, r.update_to, `/resources/${r.id}/update`, returnTo, true, r.activity && r.activity.state === 'update-hold')
-            dt.col-sm-4 IP addresses
-            dd.col-sm-8
-              if !local.length && !external
-                span.text-body-secondary —
-              ul.list-unstyled.mb-0
-                each a in local
-                  li
-                    code= a.address
-                    span.text-body-secondary.small.ms-2= a.iface ? `${a.iface} · ${a.family}` : a.family
-                if external
-                  li
-                    code= external
-                    span.text-body-secondary.small.ms-2(
-                      data-bs-toggle="tooltip"
-                      data-bs-title="The address the Coordinator last saw this Client connect from"
-                    ) external
-            dt.col-sm-4 Capabilities
-            dd.col-sm-8
-              +capabilitiesList(r.capabilities)
-            dt.col-sm-4 Labels
-            dd.col-sm-8
-              if r.labels.length
-                each l in r.labels
-                  span.badge.text-bg-light.border.me-1= l
-              else
-                span.text-body-secondary —
-            dt.col-sm-4 Groups
-            dd.col-sm-8
-              if r.group_ids.length
-                each gid in r.group_ids
-                  span.badge.text-bg-info.me-1(data-bs-toggle="tooltip" data-bs-title=gid)= groupsById[gid] ? groupsById[gid].name : `(unknown: ${gid})`
-              else
-                span.text-body-secondary —
-            dt.col-sm-4 Busy source / reason
-            dd.col-sm-8= r.busy_source ? `${r.busy_source}${r.busy_reason ? ' — ' + r.busy_reason : ''}` : '—'
-            dt.col-sm-4 Last heartbeat
-            dd.col-sm-8= fmtDate(r.last_heartbeat_at, 'never')
-            if user.role === 'admin'
-              dt.col-sm-4 Actions
-              dd.col-sm-8.mb-0
-                +resourceActions(r, returnTo)
+        .modal-body.pt-2
+          //- Details: what the Client is and reports. Config: settings sent
+          //- to it (today the scheduled reboot); read-only for viewers.
+          ul.nav.nav-tabs.mb-3(role="tablist")
+            li.nav-item(role="presentation")
+              button.nav-link.active(
+                id=`rc-${r.id}-details-tab`
+                type="button"
+                role="tab"
+                data-bs-toggle="tab"
+                data-bs-target=`#rc-${r.id}-details`
+                aria-controls=`rc-${r.id}-details`
+                aria-selected="true"
+              ) Details
+            li.nav-item(role="presentation")
+              button.nav-link(
+                id=`rc-${r.id}-config-tab`
+                type="button"
+                role="tab"
+                data-bs-toggle="tab"
+                data-bs-target=`#rc-${r.id}-config`
+                aria-controls=`rc-${r.id}-config`
+                aria-selected="false"
+              ) Config
+          .tab-content
+            .tab-pane.fade.show.active(id=`rc-${r.id}-details` role="tabpanel" aria-labelledby=`rc-${r.id}-details-tab` tabindex="0")
+              +resourceDetails(r, groupsById, returnTo, local, external)
+            .tab-pane.fade(id=`rc-${r.id}-config` role="tabpanel" aria-labelledby=`rc-${r.id}-config-tab` tabindex="0")
+              dl.row.mb-0
+                +rebootScheduleRow(r, returnTo)
+        if user.role === 'admin'
+          .modal-footer
+            +rebootButton(r, returnTo)
+
+//- Reboot the Client's host now (card footer): confirmed first — naming the
+//- job that gets canceled, if one is running — then sent with the Client's
+//- next heartbeat. Disabled while it's offline or has no reboot helper.
+mixin rebootButton(r, returnTo)
+  - const offline = r.status === 'OUT_OF_SERVICE' || !r.last_heartbeat_at
+  - const unsupported = r.capabilities && r.capabilities.rebootSupported === false
+  - const why = offline ? 'Offline — a Client can only be rebooted while connected' : unsupported ? "This host has no reboot helper — reinstall the Client as root" : null
+  if why
+    span.d-inline-block(tabindex="0" data-bs-toggle="tooltip" data-bs-title=why)
+      button.btn.btn-outline-danger(type="button" disabled style="pointer-events: none;")
+        i.bi.bi-bootstrap-reboot.me-1
+        | Reboot
+  else
+    form(
+      method="post"
+      action=`/resources/${r.id}/reboot`
+      data-confirm=r.activeJob
+        ? `${r.name} is running job ${r.activeJob.id}. Rebooting cancels that job (reason: user reboot request), then reboots the host on the Client's next heartbeat. Every Client instance on that host goes down with it.`
+        : `Reboot the host of ${r.name}? It reboots on the Client's next heartbeat, once nothing on the host is busy. Every Client instance on that host goes down with it.`
+      data-confirm-title=r.activeJob ? `Cancel job ${r.activeJob.id} and reboot?` : `Reboot ${r.name}?`
+      data-confirm-ok=r.activeJob ? 'Cancel job and reboot' : 'Reboot'
+      data-confirm-dismiss="Don't reboot"
+    )
+      input(type="hidden" name="returnTo" value=returnTo)
+      button.btn.btn-outline-danger(type="submit")
+        i.bi.bi-bootstrap-reboot.me-1
+        | Reboot
+
+//- The resource card's Details tab.
+mixin resourceDetails(r, groupsById, returnTo, local, external)
+  dl.row.mb-0
+    dt.col-sm-4 Name
+    dd.col-sm-8= r.name
+    dt.col-sm-4 Type
+    dd.col-sm-8.text-uppercase= r.type
+    dt.col-sm-4 Status
+    dd.col-sm-8: +resourceBadge(r.status, r.remove_requested_at)
+    +uptimeRows(r, returnTo)
+    dt.col-sm-4 Client version
+    dd.col-sm-8: +versionWithUpdate(r.client_version, updates.latest.client, r.update_to, `/resources/${r.id}/update`, returnTo, true, r.activity && r.activity.state === 'update-hold')
+    dt.col-sm-4 IP addresses
+    dd.col-sm-8
+      if !local.length && !external
+        span.text-body-secondary —
+      ul.list-unstyled.mb-0
+        each a in local
+          li
+            code= a.address
+            span.text-body-secondary.small.ms-2= a.iface ? `${a.iface} · ${a.family}` : a.family
+        if external
+          li
+            code= external
+            span.text-body-secondary.small.ms-2(
+              data-bs-toggle="tooltip"
+              data-bs-title="The address the Coordinator last saw this Client connect from"
+            ) external
+    dt.col-sm-4 Capabilities
+    dd.col-sm-8.resource-capabilities
+      +capabilitiesList(r.capabilities)
+    dt.col-sm-4 Labels
+    dd.col-sm-8
+      if r.labels.length
+        each l in r.labels
+          span.badge.text-bg-light.border.me-1= l
+      else
+        span.text-body-secondary —
+    dt.col-sm-4 Groups
+    dd.col-sm-8
+      if r.group_ids.length
+        each gid in r.group_ids
+          span.badge.text-bg-info.me-1(data-bs-toggle="tooltip" data-bs-title=gid)= groupsById[gid] ? groupsById[gid].name : `(unknown: ${gid})`
+      else
+        span.text-body-secondary —
+    dt.col-sm-4 Busy source / reason
+    dd.col-sm-8= r.busy_source ? `${r.busy_source}${r.busy_reason ? ' — ' + r.busy_reason : ''}` : '—'
+    dt.col-sm-4 Last heartbeat
+    dd.col-sm-8= fmtDate(r.last_heartbeat_at, 'never')
+    if user.role === 'admin'
+      dt.col-sm-4 Actions
+      dd.col-sm-8.mb-0
+        +resourceActions(r, returnTo)