@thinremote/thinr-cli 1.3.4 → 1.4.0

package/lib/mcp/tools-exec.js

@@ -1,17 +1,21 @@
 // @ts-check
-import { getMonitoringData } from '../monitoring.js';
-import { inputError } from '../errors.js';
-import { BYTES, TIMEOUTS } from '../constants.js';
+import { filterActiveDevices, getDevices } from '@thinger-io/cli-core/devices';
+import { getProduct, getProducts } from '@thinger-io/cli-core/product';
+import { runPool } from '@thinger-io/cli-core/concurrency';
+import { inputError } from '@thinger-io/cli-core/errors';
+import { TIMEOUTS } from '../constants.js';
+import { createDeviceAPI } from '../device-api.js';
+import { runProductFanOut } from '../product-orchestrator.js';
 import { getAPI } from './helpers.js';
 
-async function toolExec(args) {
-    const { api } = getAPI(args.device_id, args.user);
-    // Default guards against hung commands locking the session; callers
-    // override for known-long operations. Knob lives in lib/constants.js.
-    const timeout =
-        Number.isFinite(args.timeout) && args.timeout > 0
-            ? args.timeout
-            : TIMEOUTS.DEFAULT_EXEC_SECONDS;
+/** Products thinr made or adopted: the ones whose devices run the agent. */
+export const THINREMOTE_PRODUCT_TYPE = 'thinremote';
+
+const positive = (n, fallback) => (Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback);
+
+/** One device: the output as the shell printed it, then the exit code. */
+async function execOne(device, args, timeout) {
+    const { api } = getAPI(device, args.user);
     let output = '';
     const { exitCode, timedOut } = await api.execStream(args.command, {
         timeout,
@@ -32,202 +36,238 @@ async function toolExec(args) {
     };
 }
 
-async function toolUpdate(args) {
-    const { api: deviceApi } = getAPI(args.device_id, args.user);
-    const payload = {
-        action: args.action,
-        channel: args.channel || 'latest',
-    };
-    const result = await deviceApi.callResource('update', payload);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        isError: false,
-    };
+/**
+ * The products of the account made for ThinRemote. The product list does
+ * not carry `config`, so each one is read.
+ */
+async function thinremoteProducts(user) {
+    const ids = (await getProducts(user)).map((p) => p.product);
+    const read = await runPool(ids, 8, (id) => getProduct(id, user));
+    return new Set(
+        read
+            .map((r, i) =>
+                r?.ok && r.value?.config?.type === THINREMOTE_PRODUCT_TYPE ? ids[i] : null,
+            )
+            .filter(Boolean),
+    );
 }
 
-async function toolMonitoring(args) {
-    const device = args.device_id;
-    const user = args.user;
+/**
+ * The devices a fleet call reaches: a list, a product (optionally one of
+ * its groups), a group, or every device of the ThinRemote products.
+ * Offline ones are left out unless asked for, and named when they were
+ * asked for by id.
+ *
+ * @returns {Promise<{ devices: any[], offline: string[] }>}
+ */
+async function targetsOf(args) {
+    let devices;
+    let named = false;
+    if (Array.isArray(args.devices) && args.devices.length) {
+        named = true;
+        const wanted = new Set(args.devices.map(String));
+        const known = await getDevices({}, args.user);
+        devices = known.filter((d) => wanted.has(d.device));
+        const missing = [...wanted].filter((id) => !devices.some((d) => d.device === id));
+        if (missing.length) throw inputError(`Unknown devices: ${missing.join(', ')}`);
+    } else if (args.product || args.group) {
+        const filter = {};
+        if (args.product) filter.product = args.product;
+        if (args.group) filter.asset_group = args.group;
+        devices = await getDevices(filter, args.user);
+    } else {
+        const ids = await thinremoteProducts(args.user);
+        devices = (await getDevices({}, args.user)).filter((d) => ids.has(d.product));
+    }
+    if (args.include_offline) return { devices, offline: [] };
+    const active = filterActiveDevices(devices);
+    const offline = named ? devices.filter((d) => !active.includes(d)).map((d) => d.device) : [];
+    return { devices: active, offline };
+}
 
-    // Real-time: read the device's `monitoring` resource directly.
-    if (args.realtime) {
-        if (!device) throw inputError('Device required for real-time monitoring');
-        const { api: deviceApi } = getAPI(device, args.user);
-        const mon = await deviceApi.getResource('monitoring');
-        const parts = [`Real-time monitoring for ${device}:`];
-        if (mon.cpu)
-            parts.push(
-                `CPU: ${mon.cpu.usage?.toFixed(1)}% (${mon.cpu.cores} cores, ${mon.cpu.temperature?.toFixed(1)}°C)`,
-            );
-        if (mon.memory)
-            parts.push(
-                `Memory: ${mon.memory.usage?.toFixed(1)}% (available: ${(mon.memory.available / BYTES.GB).toFixed(1)}GB / total: ${(mon.memory.total / BYTES.GB).toFixed(1)}GB)`,
-            );
-        if (mon.disk?.root)
-            parts.push(
-                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (available: ${(mon.disk.root.available / BYTES.GB).toFixed(1)}GB / total: ${(mon.disk.root.total / BYTES.GB).toFixed(0)}GB)`,
-            );
-        if (mon.network)
-            parts.push(
-                `Network: rx=${(mon.network.rx_rate / BYTES.KB).toFixed(1)}KB/s tx=${(mon.network.tx_rate / BYTES.KB).toFixed(1)}KB/s`,
-            );
-        if (mon.load)
-            parts.push(
-                `Load: ${mon.load['1m']?.toFixed(2)} / ${mon.load['5m']?.toFixed(2)} / ${mon.load['15m']?.toFixed(2)}`,
-            );
-        if (mon.processes) parts.push(`Processes: ${mon.processes.total}`);
-        if (mon.uptime)
-            parts.push(
-                `Uptime: ${Math.floor(mon.uptime / 86400)}d ${Math.floor((mon.uptime % 86400) / 3600)}h ${Math.floor((mon.uptime % 3600) / 60)}m`,
-            );
-        if (mon.agent) parts.push(`Agent: ${mon.agent.version}`);
-        return { content: [{ type: 'text', text: parts.join('\n') }], isError: false };
+async function toolExec(args) {
+    if (typeof args.command !== 'string' || !args.command.trim()) {
+        throw inputError('command is required');
+    }
+    const listed = Array.isArray(args.devices) && args.devices.length > 0;
+    const fleet = listed || args.product || args.group;
+    const kinds = [args.device, listed, args.product || args.group, args.all].filter(Boolean);
+    if (kinds.length > 1) {
+        throw inputError(
+            'give one kind of target: `device`, `devices`, `product` (and `group`) or `group`, or `all`',
+        );
+    }
+    if (!args.device && !fleet && !args.all) {
+        throw inputError(
+            'give the target: `device` for one device; `devices`, `product` or `group` for several; `all: true` for every device of the ThinRemote products',
+        );
     }
+    // Default guards against hung commands locking the session; callers
+    // override for known-long operations. Knob lives in lib/constants.js.
+    const timeout = positive(args.timeout, TIMEOUTS.DEFAULT_EXEC_SECONDS);
+    if (args.device && !args.dry_run) return execOne(args.device, args, timeout);
 
-    // Historical: query the monitoring bucket.
-    const data = await getMonitoringData({
-        device,
-        user,
-        items: args.items || 10,
-        sort: args.sort || 'desc',
-        minutes: args.minutes,
-        min_ts: args.min_ts,
-        max_ts: args.max_ts,
-        agg: args.agg,
-        agg_type: args.agg_type,
-        fields: args.fields,
+    const { devices, offline } = args.device
+        ? { devices: [{ device: args.device }], offline: [] }
+        : await targetsOf(args);
+    const skipped = offline.length
+        ? `\nNot connected, left out (include_offline to try them): ${offline.join(', ')}.`
+        : '';
+    if (args.dry_run) {
+        const ids = devices.map((d) => d.device);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Would run \`${args.command}\` on ${ids.length} device(s)${ids.length ? `: ${ids.join(', ')}` : ''}.${skipped}`,
+                },
+            ],
+            isError: false,
+        };
+    }
+    if (devices.length === 0) {
+        return {
+            content: [{ type: 'text', text: `No connected devices match the target.${skipped}` }],
+            isError: offline.length > 0,
+        };
+    }
+
+    const concurrency = positive(args.concurrency, 10);
+    const { entries, durationMs } = await runProductFanOut({
+        devices,
+        user: args.user,
+        concurrency,
+        failFast: !!args.fail_fast,
+        worker: async (device) => {
+            const perStart = Date.now();
+            let stdout = '';
+            let stderr = '';
+            try {
+                const api = createDeviceAPI(device.device, { user: args.user || undefined });
+                const { exitCode, timedOut } = await api.execStream(args.command, {
+                    timeout,
+                    onStdout: (s) => {
+                        stdout += s;
+                    },
+                    onStderr: (s) => {
+                        stderr += s;
+                    },
+                });
+                return {
+                    device: device.device,
+                    ok: !timedOut && exitCode === 0,
+                    exitCode: exitCode ?? null,
+                    timedOut: !!timedOut,
+                    durationMs: Date.now() - perStart,
+                    stdout,
+                    stderr,
+                };
+            } catch (err) {
+                return {
+                    device: device.device,
+                    ok: false,
+                    exitCode: null,
+                    timedOut: false,
+                    durationMs: Date.now() - perStart,
+                    stdout,
+                    stderr,
+                    error: err instanceof Error ? err.message : String(err),
+                };
+            }
+        },
+        skipped: (device, firstFailure) => ({
+            device: device.device,
+            ok: false,
+            exitCode: null,
+            timedOut: false,
+            durationMs: 0,
+            stdout: '',
+            stderr: '',
+            error: `skipped (fail-fast after ${firstFailure})`,
+        }),
+        isFailure: (entry) => !entry.ok,
     });
 
-    let output;
-    if (Array.isArray(data) && data.length > 0) {
-        output = data
-            .map((d) => {
-                // Single-window aggregated rows (group_by without `agg`) come
-                // back without `ts`; skip it rather than emitting "Invalid Date".
-                const parts = [];
-                if (d.ts) parts.push(new Date(d.ts).toISOString());
-                if (d.device) parts.push(`device=${d.device}`);
-                if (d.cpu) {
-                    const cpuParts = [];
-                    if (d.cpu.usage !== undefined) cpuParts.push(`${d.cpu.usage.toFixed(1)}%`);
-                    if (d.cpu.temperature !== undefined)
-                        cpuParts.push(`${d.cpu.temperature.toFixed(1)}°C`);
-                    if (cpuParts.length) parts.push(`cpu=${cpuParts.join(' ')}`);
-                }
-                if (d.memory) parts.push(`mem=${d.memory.usage?.toFixed(1)}%`);
-                if (d.disk?.root) parts.push(`disk=${d.disk.root.usage?.toFixed(1)}%`);
-                if (d.network)
-                    parts.push(
-                        `net_rx=${(d.network.rx_rate / BYTES.KB)?.toFixed(1)}KB/s tx=${(d.network.tx_rate / BYTES.KB)?.toFixed(1)}KB/s`,
-                    );
-                if (d.load) parts.push(`load=${d.load['1m']?.toFixed(2)}`);
-                if (d.processes) parts.push(`procs=${d.processes.total}`);
-                return parts.join(' | ');
-            })
-            .join('\n');
-    } else {
-        output = JSON.stringify(data, null, 2);
-    }
+    const okCount = entries.filter((e) => e.ok).length;
+    const timedOutCount = entries.filter((e) => e.timedOut).length;
+    const errorCount = entries.filter((e) => e.error).length;
+    const failCount = entries.length - okCount - timedOutCount - errorCount;
 
+    const lines = [
+        `Ran \`${args.command}\` on ${entries.length} device(s) (concurrency=${concurrency}, timeout=${timeout}s).\n`,
+    ];
+    for (const e of entries) {
+        const status = e.error
+            ? `ERROR (${e.error})`
+            : e.timedOut
+              ? `TIMEOUT after ${timeout}s`
+              : e.ok
+                ? `OK exit=0`
+                : `FAIL exit=${e.exitCode}`;
+        lines.push(`--- ${e.device} [${status}] ${e.durationMs}ms ---`);
+        if (e.stdout) lines.push(e.stdout.trimEnd());
+        if (e.stderr) lines.push(`stderr: ${e.stderr.trimEnd()}`);
+    }
+    lines.push(
+        `\nSummary: ${okCount} ok, ${failCount} failed, ${timedOutCount} timed out, ${errorCount} errored — ${durationMs}ms total${skipped}`,
+    );
     return {
-        content: [{ type: 'text', text: output || 'No data' }],
-        isError: false,
+        content: [{ type: 'text', text: lines.join('\n') }],
+        isError: failCount + timedOutCount + errorCount + offline.length > 0,
     };
 }
 
 export const tools = [
     {
-        name: 'thinr_exec',
-        description: `Execute a shell command on a remote device. Returns stdout, stderr, and exit code.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                command: { type: 'string', description: 'Shell command to execute' },
-                device_id: { type: 'string', description: 'Device ID (from thinr_devices)' },
-                timeout: { type: 'number', description: 'Timeout in seconds (default: 30)' },
-                user: { type: 'string', description: 'API user (for admin impersonation)' },
-            },
-            required: ['command', 'device_id'],
-        },
-        handler: toolExec,
-    },
-    {
-        name: 'thinr_update',
-        description: `Check for agent updates or apply an update on a remote device.`,
+        name: 'device_exec',
+        description:
+            'Run a shell command on devices with the ThinRemote agent: on one (`device`: its output and exit code), or on several in parallel (`devices`, a `product` and optionally its `group`, or `all: true` for every device of the ThinRemote products: output, exit code and duration per device plus a summary). Offline devices are skipped unless `include_offline`. `dry_run` says which devices it would reach without running anything. On several devices it acts at once: confirm with the user first; for repeatable, checked changes use a playbook (type "product_playbook").',
         inputSchema: {
             type: 'object',
             properties: {
-                device_id: { type: 'string', description: 'Device ID' },
-                action: {
+                command: { type: 'string', description: 'Shell command to run.' },
+                device: {
                     type: 'string',
-                    description: '"check" to check for updates, "apply" to install the update',
+                    description: 'One device (from {tool:resource_list} type "device").',
                 },
-                channel: { type: 'string', description: 'Update channel (default: "latest")' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['action', 'device_id'],
-        },
-        handler: toolUpdate,
-    },
-    {
-        name: 'thinr_monitoring',
-        description: `Get monitoring data (CPU, memory, disk, network, temperature, load).
-
-Modes:
-- realtime=true + device: live sample read straight from the agent.
-- device only: historical time series for that device. Use \`agg\`+\`agg_type\` for time-windowed aggregates (e.g. avg CPU every 5m over the last hour).
-- no device: historical fleet view — returns ONE ROW PER DEVICE. Without \`agg_type\` each row is the latest sample for that device ("current fleet state"). With \`agg_type\` each row is the reducer applied over the time window per device (e.g. \`agg_type=max\`+\`minutes=60\` ⇒ peak per device in the last hour, ideal for ranking "which device had the most X"). Sort the returned array client-side on the metric to get the top N.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                realtime: {
-                    type: 'boolean',
-                    description:
-                        'If true, get live data directly from the device. If false/omitted, query historical data from the monitoring bucket.',
+                devices: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Several devices by id.',
                 },
-                device_id: {
+                product: { type: 'string', description: 'Every device of this product.' },
+                group: {
                     type: 'string',
-                    description:
-                        'Device ID. Required for realtime. Omit for a one-row-per-device fleet view.',
+                    description: 'Asset group: alone, or narrowing `product`.',
                 },
-                items: {
-                    type: 'number',
-                    description:
-                        'Number of data points to return (default: 10). In multi-device mode set ≥ number of devices (e.g. 200) since each device contributes one row.',
+                all: {
+                    type: 'boolean',
+                    description: 'Every device of the ThinRemote products of the account.',
                 },
-                minutes: {
-                    type: 'number',
-                    description: 'Get data from the last N minutes. Alternative to min_ts/max_ts.',
+                include_offline: {
+                    type: 'boolean',
+                    description: 'Also try devices that are not connected (default false).',
                 },
-                min_ts: { type: 'number', description: 'Minimum timestamp in milliseconds' },
-                max_ts: {
+                timeout: {
                     type: 'number',
-                    description: 'Maximum timestamp in milliseconds (0 = now)',
+                    description: 'Seconds per device before giving up (default 30).',
                 },
-                sort: {
-                    type: 'string',
-                    description:
-                        'Sort order by timestamp: "asc" or "desc" (default: "desc"). Does NOT sort by metric — do that client-side on the result.',
-                },
-                agg: {
-                    type: 'string',
-                    description:
-                        'Time-window size for windowed aggregation: "5m", "10m", "1h", "6h". Only meaningful with a specific device. For a per-device single value across the whole range, omit `agg` and pass `agg_type` alone.',
+                concurrency: {
+                    type: 'number',
+                    description: 'Devices at a time, on several (default 10).',
                 },
-                agg_type: {
-                    type: 'string',
-                    description:
-                        'Reducer applied to each group/window. Supported: "mean", "max", "min", "sum", "count", "first", "last", "median", "spread" (max-min), "stddev". Most common for monitoring: max, mean, min.',
+                fail_fast: {
+                    type: 'boolean',
+                    description: 'On several: start no more devices after one fails.',
                 },
-                fields: {
-                    type: 'string',
-                    description:
-                        'Comma-separated fields to return (e.g., "cpu.usage,memory.usage,disk.root.usage"). Narrower queries are cheaper and produce tidier output.',
+                dry_run: {
+                    type: 'boolean',
+                    description: 'Only list the devices it would run on.',
                 },
-                user: { type: 'string', description: 'API user' },
+                user: { type: 'string', description: 'Account to act on (admin only).' },
             },
-            required: [],
+            required: ['command'],
         },
-        handler: toolMonitoring,
+        handler: toolExec,
     },
 ];

package/lib/monitoring.js

@@ -1,6 +1,6 @@
-import api from './api.js';
-import { apiError } from './errors.js';
-import { v2, v3 } from './paths.js';
+import api from '@thinger-io/cli-core/api';
+import { apiError } from '@thinger-io/cli-core/errors';
+import { v2, v3 } from '@thinger-io/cli-core/paths';
 
 /**
  * Query the monitoring bucket. When `device` is provided, scopes to

package/lib/playbook/actions.js

@@ -1,11 +1,12 @@
 // @ts-check
 import { readFileSync } from 'fs';
+import { localFileToRead, localFileToWrite } from '../local-files.js';
 import { writeFile as writeLocalFile } from 'fs/promises';
 import { resolve as resolvePath } from 'path';
 import { createHash } from 'crypto';
 import { createDeviceAPI } from '../device-api.js';
-import { setDeviceProperty, getDeviceProperty } from '../property.js';
-import { callDeviceResource, readDeviceResource } from '../resource.js';
+import { setDeviceProperty, getDeviceProperty } from '@thinger-io/cli-core/property';
+import { callDeviceResource, readDeviceResource } from '@thinger-io/cli-core/resource';
 import { TIMEOUTS } from '../constants.js';
 
 /**
@@ -18,12 +19,22 @@ import { TIMEOUTS } from '../constants.js';
  * in runner.js — handlers only care about their one job.
  */
 
-function resolveLocalPath(relPath, baseDir) {
-    return baseDir ? resolvePath(baseDir, relPath) : resolvePath(relPath);
+/**
+ * A local file a step names. Run from the MCP server (`ctx.localRoot`), it
+ * must stay inside that folder (see lib/local-files.js); from the CLI,
+ * relative paths resolve against the playbook's folder.
+ */
+function localPath(ctx, relPath, { write = false } = {}) {
+    if (ctx.localRoot) {
+        return write
+            ? localFileToWrite(relPath, ctx.localRoot, { overwrite: true })
+            : localFileToRead(relPath, ctx.localRoot);
+    }
+    return resolveLocalPath(relPath, ctx.baseDir);
 }
 
-function resolveLocalFile(relPath, baseDir) {
-    return readFileSync(resolveLocalPath(relPath, baseDir), 'utf8');
+function resolveLocalPath(relPath, baseDir) {
+    return baseDir ? resolvePath(baseDir, relPath) : resolvePath(relPath);
 }
 
 const MAX_CAPTURED_STREAM_BYTES = 32 * 1024;
@@ -97,20 +108,20 @@ export const HANDLERS = {
     },
 
     async push(ctx, params) {
-        const local = resolveLocalPath(params.source, ctx.baseDir);
+        const local = localPath(ctx, params.source);
         const content = readFileSync(local);
         await ctx.api.writeFile(params.destination, content);
         return `pushed ${content.byteLength} bytes`;
     },
 
     async pull(ctx, params) {
-        const local = resolveLocalPath(params.destination, ctx.baseDir);
+        const local = localPath(ctx, params.destination, { write: true });
         const buf = await ctx.api.readFile(params.source);
         await writeLocalFile(local, buf);
         return `pulled ${buf.byteLength} bytes`;
     },
 
-    async rm(ctx, params) {
+    async delete(ctx, params) {
         await ctx.api.delete(params.path, params.recursive !== false);
         return `removed ${params.path}`;
     },
@@ -120,7 +131,7 @@ export const HANDLERS = {
         return `created ${params.path}`;
     },
 
-    async mv(ctx, params) {
+    async move(ctx, params) {
         await ctx.api.move(params.source, params.destination, !!params.overwrite);
         return `moved ${params.source} → ${params.destination}`;
     },
@@ -160,7 +171,7 @@ export const HANDLERS = {
         let content;
         if (typeof params.content === 'string') content = params.content;
         else if (typeof params.content_file === 'string')
-            content = resolveLocalFile(params.content_file, ctx.baseDir);
+            content = readFileSync(localPath(ctx, params.content_file), 'utf8');
         else throw new Error('`content` or `content_file` is required');
 
         if (!/^[A-Za-z0-9._-]+$/.test(params.name)) {
@@ -220,7 +231,7 @@ export const CHECKERS = {
     },
 
     async push(ctx, params) {
-        const local = resolveLocalPath(params.source, ctx.baseDir);
+        const local = localPath(ctx, params.source);
         const content = readFileSync(local);
         return hashCheck(ctx.api, params.destination, content);
     },
@@ -248,7 +259,7 @@ export const CHECKERS = {
         if (!/^[A-Za-z0-9._-]+$/.test(params.name)) {
             throw new Error(`invalid script name "${params.name}"`);
         }
-        const content = resolveWriteContent(params, ctx.baseDir);
+        const content = resolveWriteContent(params, ctx);
         const localHash = sha256Hex(content);
         const info = await readDeviceResource(ctx.deviceId, '$scripts/info', { user: ctx.user });
         const baseDir = info?.path;
@@ -288,7 +299,7 @@ export const CHECKERS = {
         return { status: 'changed', summary: `property ${params.property} would change` };
     },
 
-    async rm(ctx, params) {
+    async delete(ctx, params) {
         try {
             await ctx.api.info(params.path);
         } catch (err) {
@@ -318,7 +329,7 @@ export const CHECKERS = {
         }
     },
 
-    async mv(ctx, params) {
+    async move(ctx, params) {
         try {
             await ctx.api.info(params.source);
         } catch (err) {
@@ -386,12 +397,12 @@ export const CHECKERS = {
  * logic the handler uses — so the check path hashes exactly the same
  * bytes that would be uploaded.
  */
-function resolveWriteContent(params, baseDir) {
+function resolveWriteContent(params, ctx) {
     if (typeof params.content === 'string') {
         return Buffer.from(params.content, 'utf8');
     }
     if (typeof params.content_file === 'string') {
-        return Buffer.from(resolveLocalFile(params.content_file, baseDir), 'utf8');
+        return readFileSync(localPath(ctx, params.content_file));
     }
     throw new Error('`content` or `content_file` is required');
 }
@@ -455,11 +466,12 @@ function stableStringify(value) {
 /**
  * Build a per-device execution context that handlers share.
  */
-export function createActionContext({ deviceId, user, baseDir }) {
+export function createActionContext({ deviceId, user, baseDir, localRoot }) {
     return {
         deviceId,
         user,
         baseDir,
+        localRoot,
         api: createDeviceAPI(deviceId, { user: user || undefined }),
     };
 }

package/lib/playbook/expression.js

@@ -104,10 +104,7 @@ function tokenize(src) {
         }
         if ((c >= '0' && c <= '9') || (c === '-' && src[i + 1] >= '0' && src[i + 1] <= '9')) {
             let j = i + 1;
-            while (
-                j < src.length &&
-                ((src[j] >= '0' && src[j] <= '9') || src[j] === '.')
-            ) {
+            while (j < src.length && ((src[j] >= '0' && src[j] <= '9') || src[j] === '.')) {
                 j++;
             }
             const n = Number(src.slice(i, j));

package/lib/playbook/fleet.js

@@ -31,6 +31,7 @@ export const DEFAULT_FAILURE_THRESHOLD = 10;
  *   overrides?: Record<string, unknown>,
  *   checkMode?: boolean,
  *   baseDir?: string,
+ *   localRoot?: string,
  *   signal?: AbortSignal,
  *   onBatchStart?: (info: { index: number, size: number, firstIndex: number, deviceIds: string[] }) => void,
  *   onBatchEnd?:   (info: { index: number, size: number, firstIndex: number, deviceIds: string[], results: any[], cumulative: { attempted: number, succeeded: number, failed: number, failureRate: number } }) => void,
@@ -88,6 +89,7 @@ export async function runFleetPlaybook(pb, devices, opts = {}) {
             failFast: false,
             checkMode: !!opts.checkMode,
             baseDir: opts.baseDir,
+            localRoot: opts.localRoot,
             overrides: opts.overrides,
         });
 
@@ -139,7 +141,8 @@ export async function runFleetPlaybook(pb, devices, opts = {}) {
     }
 
     if (aborted) {
-        const skipReason = reason === 'cancelled' ? 'cancelled' : 'aborted (failure threshold reached)';
+        const skipReason =
+            reason === 'cancelled' ? 'cancelled' : 'aborted (failure threshold reached)';
         for (let i = 0; i < devices.length; i++) {
             if (results[i] === undefined) {
                 results[i] = {