@thinremote/thinr-cli 1.1.0 → 1.2.0

package/commands/product/property.js

@@ -0,0 +1,76 @@
+// @ts-check
+import { formatDeviceProperty, getDeviceProperty } from '../../lib/property.js';
+import { filterActiveDevices } from '../../lib/devices.js';
+import { error as errorStyle, info } from '../../lib/format.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../../lib/output.js';
+import {
+    applyJsonFlag,
+    ensureConfigured,
+    extractField,
+    getGlobalUser,
+} from '../_shared.js';
+import { fetchProductDevices } from './_shared.js';
+
+export function registerProductPropertyCommand(product) {
+    product
+        .command('property <productId> <propertyId>')
+        .helpGroup('Fan-out:')
+        .description('Read a property on every device of the product')
+        .option('-j, --json', 'Output as JSON')
+        .option('-f, --field <field>', 'Extract a sub-field from each property (dot path)')
+        .option('-a, --all', 'Include offline devices (default: only active)')
+        .option('-g, --group <group>', 'Filter devices by asset group')
+        .action(async (productId, propertyId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            const spinner = createSpinner(`Retrieving devices for product ${productId}...`).start();
+            let devices;
+            try {
+                devices = await fetchProductDevices(productId, opts.group, user);
+                spinner.succeed(`Devices for product ${productId} retrieved successfully`);
+            } catch (error) {
+                spinner.fail(`Failed to retrieve devices for product ${productId}`);
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
+            }
+            if (!opts.all) devices = filterActiveDevices(devices);
+
+            const results = [];
+            for (const device of devices) {
+                try {
+                    const property = await getDeviceProperty(device.device, propertyId);
+                    const value = extractField(property, opts.field);
+                    results.push({ device: device.device, ok: true, data: value });
+                    if (!isJsonMode()) {
+                        console.log(
+                            'Device',
+                            info(device.device),
+                            'property',
+                            info(propertyId),
+                        );
+                        if (opts.field) console.log(value);
+                        else console.log(formatDeviceProperty(device.device, propertyId, property));
+                    }
+                } catch (error) {
+                    const { message, code } = classifyError(error);
+                    results.push({ device: device.device, ok: false, error: { message, code } });
+                    if (!isJsonMode()) {
+                        console.error(
+                            errorStyle(
+                                `Error retrieving property ${propertyId} for device ${device.device}: ${message}`,
+                            ),
+                        );
+                    }
+                }
+            }
+            if (isJsonMode()) printOk({ product: productId, property: propertyId, results });
+        });
+}

package/commands/product/props.js

@@ -0,0 +1,125 @@
+// @ts-check
+import {
+    getProductProperties,
+    getProductProperty,
+    setProductProperty,
+    deleteProductProperty,
+} from '../../lib/product.js';
+import { info, success } from '../../lib/format.js';
+import { isJsonMode, printOk, printErr, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured, getGlobalUser } from '../_shared.js';
+
+function parseJsonValue(raw) {
+    if (raw == null) return raw;
+    try {
+        return JSON.parse(raw);
+    } catch {
+        // Fall back to raw string so `thinr product property-set p x foo` still works
+        // for trivial scalar writes without shell-escaping quotes.
+        return raw;
+    }
+}
+
+export function registerProductPropertyAdminCommands(product) {
+    product
+        .command('property-list <productId>')
+        .helpGroup('Product config:')
+        .description('List the names of properties attached to a product')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const list = await getProductProperties(productId, user);
+                const names = Array.isArray(list) ? list.map((p) => p.property).filter(Boolean) : [];
+                if (isJsonMode()) {
+                    printOk({ product: productId, properties: names });
+                    return;
+                }
+                if (names.length === 0) {
+                    console.log(`No properties on product ${info(productId)}`);
+                    return;
+                }
+                console.log(`Properties of product ${info(productId)}:`);
+                for (const n of names) console.log(`- ${n}`);
+            } catch (error) {
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+
+    product
+        .command('property-get <productId> <propertyId>')
+        .helpGroup('Product config:')
+        .description('Read a property attached to a product')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, propertyId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const value = await getProductProperty(productId, propertyId, user);
+                if (isJsonMode()) {
+                    printOk({ product: productId, property: propertyId, value });
+                    return;
+                }
+                console.log(`Value of ${info(propertyId)} on product ${info(productId)}:`);
+                console.log(JSON.stringify(value, null, 2));
+            } catch (error) {
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+
+    product
+        .command('property-set <productId> <propertyId> <value>')
+        .helpGroup('Product config:')
+        .description('Create or overwrite a product property (value parsed as JSON)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, propertyId, value, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            const parsed = parseJsonValue(value);
+            try {
+                const saved = await setProductProperty(productId, propertyId, parsed, user);
+                if (isJsonMode()) {
+                    printOk({ product: productId, property: propertyId, value: saved.value });
+                    return;
+                }
+                console.log(
+                    `Saved property ${info(propertyId)} on product ${info(productId)} → ${success(JSON.stringify(saved.value))}`,
+                );
+            } catch (error) {
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+
+    product
+        .command('property-delete <productId> <propertyId>')
+        .helpGroup('Product config:')
+        .description('Delete a product property (idempotent)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, propertyId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const removed = await deleteProductProperty(productId, propertyId, user);
+                if (isJsonMode()) {
+                    printOk({ product: productId, property: propertyId, removed });
+                    return;
+                }
+                console.log(
+                    removed
+                        ? `Deleted ${info(propertyId)} from ${info(productId)}`
+                        : `Property ${info(propertyId)} was not set on ${info(productId)}`,
+                );
+            } catch (error) {
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+}

package/commands/product/push.js

@@ -0,0 +1,184 @@
+// @ts-check
+import { readFile as readLocalFile } from 'fs/promises';
+import Table from 'cli-table3';
+import { createDeviceAPI } from '../../lib/device-api.js';
+import { runProductFanOut } from '../../lib/product-orchestrator.js';
+import {
+    label,
+    muted,
+    hint,
+    success,
+    error as errorStyle,
+    warning,
+} from '../../lib/format.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../../lib/output.js';
+import {
+    applyJsonFlag,
+    ensureConfigured,
+    getGlobalUser,
+    parsePositiveInt,
+    ProgressSpinner,
+} from '../_shared.js';
+
+export function registerProductPushCommand(product) {
+    product
+        .command('push <productId> <localPath> <remotePath>')
+        .helpGroup('Filesystem:')
+        .description('Upload a local file to every active device of a product, in parallel')
+        .option('-j, --json', 'Output as JSON')
+        .option('-g, --group <group>', 'Filter devices by asset group')
+        .option(
+            '-c, --concurrency <n>',
+            'Max parallel uploads (default: 10)',
+            parsePositiveInt('concurrency'),
+            10,
+        )
+        .option('--fail-fast', 'Stop dequeueing new devices on the first failure')
+        .option('-a, --all', 'Include offline devices (by default, only active)')
+        .action(async (productId, localPath, remotePath, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+
+            let content;
+            try {
+                content = await readLocalFile(localPath);
+            } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                printErr(`Cannot read local file: ${msg}`, { code: 'input_error' });
+                return;
+            }
+
+            const fetchSpinner = createSpinner(
+                `Retrieving devices for product ${productId}...`,
+            ).start();
+            /** @type {ProgressSpinner | null} */
+            let progress = null;
+
+            let result;
+            try {
+                result = await runProductFanOut({
+                    product: productId,
+                    group: opts.group,
+                    includeOffline: !!opts.all,
+                    user,
+                    concurrency: opts.concurrency,
+                    failFast: !!opts.failFast,
+                    worker: async (device) => {
+                        const api = createDeviceAPI(device.device, { user });
+                        const perStart = Date.now();
+                        try {
+                            await api.writeFile(remotePath, content);
+                            return {
+                                device: device.device,
+                                ok: true,
+                                bytes: content.byteLength,
+                                durationMs: Date.now() - perStart,
+                            };
+                        } catch (err) {
+                            return {
+                                device: device.device,
+                                ok: false,
+                                error: err instanceof Error ? err.message : String(err),
+                                durationMs: Date.now() - perStart,
+                            };
+                        }
+                    },
+                    skipped: (device, firstFailure) => ({
+                        device: device.device,
+                        ok: false,
+                        error: `skipped (fail-fast after ${firstFailure})`,
+                        durationMs: 0,
+                    }),
+                    isFailure: (entry) => !entry.ok,
+                    onDevicesResolved: (devices) => {
+                        fetchSpinner.succeed(
+                            `Found ${devices.length} device(s) in product ${productId}`,
+                        );
+                        if (devices.length > 0 && !isJsonMode()) {
+                            progress = new ProgressSpinner(
+                                createSpinner('').start(),
+                                devices.length,
+                                ({ done, total, inFlight }) =>
+                                    `Uploading ${localPath} → ${remotePath} on ${total} device(s) — ` +
+                                    `${done}/${total} done · ${inFlight} in flight` +
+                                    (opts.failFast ? ' · fail-fast' : ''),
+                            );
+                            progress.render();
+                        }
+                    },
+                    onItemStart: () => progress?.startItem(),
+                    onItemFinish: () => progress?.finishItem(),
+                });
+            } catch (error) {
+                fetchSpinner.fail(`Failed to retrieve devices for product ${productId}`);
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
+            }
+            progress?.stop();
+
+            const { devices, entries, durationMs } = result;
+
+            if (devices.length === 0) {
+                if (isJsonMode()) {
+                    printOk({
+                        product: productId,
+                        local: localPath,
+                        remote: remotePath,
+                        summary: { total: 0, ok: 0, failed: 0 },
+                        results: [],
+                    });
+                } else {
+                    console.log(warning('No devices to upload to.'));
+                }
+                return;
+            }
+
+            const okCount = entries.filter((e) => e.ok).length;
+            const failCount = entries.length - okCount;
+
+            if (isJsonMode()) {
+                printOk({
+                    product: productId,
+                    local: localPath,
+                    remote: remotePath,
+                    summary: {
+                        total: entries.length,
+                        ok: okCount,
+                        failed: failCount,
+                        bytes: content.byteLength,
+                        durationMs,
+                    },
+                    results: entries,
+                });
+                return;
+            }
+
+            const table = new Table({
+                head: ['Device', 'Status', 'Detail', 'Duration'].map((h) => label(h)),
+                style: { head: [], border: ['gray'] },
+                colAligns: ['left', 'left', 'left', 'right'],
+            });
+            for (const e of entries) {
+                table.push([
+                    e.device,
+                    e.ok ? success('ok') : errorStyle('fail'),
+                    e.ok ? muted(`${e.bytes} bytes`) : e.error || '',
+                    `${e.durationMs}ms`,
+                ]);
+            }
+            console.log(table.toString());
+            console.log(
+                hint(
+                    `${entries.length} total · ${okCount} ok · ${failCount} failed · ${content.byteLength} bytes · ${durationMs}ms`,
+                ),
+            );
+        });
+}

package/commands/product/resource.js

@@ -0,0 +1,76 @@
+// @ts-check
+import { callDeviceResource } from '../../lib/resource.js';
+import { filterActiveDevices } from '../../lib/devices.js';
+import { error as errorStyle, info } from '../../lib/format.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../../lib/output.js';
+import {
+    applyJsonFlag,
+    collectInput,
+    ensureConfigured,
+    extractField,
+    getGlobalUser,
+} from '../_shared.js';
+import { fetchProductDevices } from './_shared.js';
+
+export function registerProductResourceCommand(product) {
+    product
+        .command('resource <productId> <resource>')
+        .helpGroup('Fan-out:')
+        .description('Call a resource on every active device of the product')
+        .option('-j, --json', 'Output as JSON')
+        .option('-f, --field <field>', 'Extract a sub-field from each result (dot path)')
+        .option('-g, --group <group>', 'Filter devices by asset group')
+        .option('-i, --input <key=value>', 'Resource input (repeatable)', collectInput, {})
+        .action(async (productId, resource, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            const spinner = createSpinner(`Retrieving devices for product ${productId}...`).start();
+            let devices;
+            try {
+                devices = await fetchProductDevices(productId, opts.group, user);
+                spinner.succeed(`Devices for product ${productId} retrieved successfully`);
+            } catch (error) {
+                spinner.fail(`Failed to retrieve devices for product ${productId}`);
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
+            }
+            devices = filterActiveDevices(devices);
+
+            const results = [];
+            for (const device of devices) {
+                try {
+                    const result = await callDeviceResource(device.device, resource, opts.input);
+                    const value = extractField(result, opts.field);
+                    results.push({ device: device.device, ok: true, data: value });
+                    if (!isJsonMode()) {
+                        console.log(
+                            'Device',
+                            info(device.device),
+                            'resource',
+                            info(resource),
+                        );
+                        console.log(value);
+                    }
+                } catch (error) {
+                    const { message, code } = classifyError(error);
+                    results.push({ device: device.device, ok: false, error: { message, code } });
+                    if (!isJsonMode()) {
+                        console.error(
+                            errorStyle(
+                                `Error executing resource ${resource} for device ${device.device}: ${message}`,
+                            ),
+                        );
+                    }
+                }
+            }
+            if (isJsonMode()) printOk({ product: productId, resource, results });
+        });
+}

package/commands/product/status.js

@@ -0,0 +1,213 @@
+// @ts-check
+import Table from 'cli-table3';
+import { InvalidArgumentError } from 'commander';
+import { runPool } from '../../lib/concurrency.js';
+import { getMonitoringData } from '../../lib/monitoring.js';
+import {
+    formatUptime,
+    colorPct,
+    label,
+    muted,
+    hint,
+    success,
+    error as errorStyle,
+} from '../../lib/format.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../../lib/output.js';
+import {
+    applyJsonFlag,
+    ensureConfigured,
+    getGlobalUser,
+    parsePositiveInt,
+} from '../_shared.js';
+import { fetchProductDevices } from './_shared.js';
+
+export function registerProductStatusCommand(product) {
+    product
+        .command('status <productId>')
+        .helpGroup('Discovery:')
+        .description('Snapshot of every device in the product (status + monitoring)')
+        .option('-j, --json', 'Output as JSON')
+        .option('-g, --group <group>', 'Filter devices by asset group')
+        .option(
+            '-c, --concurrency <n>',
+            'Max parallel monitoring queries (default: 10)',
+            parsePositiveInt('concurrency'),
+            10,
+        )
+        .option(
+            '-w, --watch [seconds]',
+            'Refresh continuously every N seconds (default: 5)',
+        )
+        .action(async (productId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+
+            // Parse the optional value of --watch. Commander delivers `true`
+            // when the flag is present without a value, the string value
+            // when one is given, and `undefined` when absent.
+            let watchSeconds = 0;
+            if (opts.watch !== undefined) {
+                if (opts.watch === true) watchSeconds = 5;
+                else {
+                    const n = Number(opts.watch);
+                    if (!Number.isInteger(n) || n <= 0) {
+                        throw new InvalidArgumentError(
+                            'watch interval must be a positive integer (seconds)',
+                        );
+                    }
+                    watchSeconds = n;
+                }
+            }
+
+            // Snapshot a single pass: fetch devices, pull latest monitoring
+            // for each, and return parallel arrays the renderer can consume.
+            const collect = async () => {
+                const devices = await fetchProductDevices(productId, opts.group, user);
+                const monResults = await runPool(devices, opts.concurrency, async (device) => {
+                    if (!device.connection?.active) return null;
+                    try {
+                        const data = await getMonitoringData({
+                            device: device.device,
+                            user,
+                            items: 1,
+                            sort: 'desc',
+                        });
+                        return Array.isArray(data) && data.length > 0 ? data[0] : null;
+                    } catch {
+                        return null;
+                    }
+                });
+                return devices.map((device, i) => {
+                    const mon = monResults[i] && monResults[i].ok ? monResults[i].value : null;
+                    return { device, mon };
+                });
+            };
+
+            const render = (rows) => {
+                if (isJsonMode()) {
+                    printOk({
+                        product: productId,
+                        ts: Date.now(),
+                        devices: rows.map(({ device, mon }) => ({
+                            device: device.device,
+                            name: device.name || null,
+                            online: !!device.connection?.active,
+                            ip: device.connection?.ip_address || null,
+                            monitoring: mon,
+                        })),
+                    });
+                    return;
+                }
+                const table = new Table({
+                    head: ['Device', 'Status', 'CPU', 'Mem', 'Disk', 'Load', 'Uptime'].map((h) =>
+                        label(h),
+                    ),
+                    style: { head: [], border: ['gray'] },
+                    colAligns: ['left', 'left', 'right', 'right', 'right', 'right', 'right'],
+                });
+                for (const { device, mon } of rows) {
+                    const online = !!device.connection?.active;
+                    const status = online ? success('online') : muted('offline');
+                    if (online && mon) {
+                        table.push([
+                            device.device,
+                            status,
+                            colorPct(mon.cpu?.usage),
+                            colorPct(mon.memory?.usage),
+                            colorPct(mon.disk?.root?.usage),
+                            mon.load?.['1m'] != null
+                                ? mon.load['1m'].toFixed(2)
+                                : muted('—'),
+                            formatUptime(mon.uptime),
+                        ]);
+                    } else {
+                        const dim = muted('—');
+                        table.push([device.device, status, dim, dim, dim, dim, dim]);
+                    }
+                }
+                const header = watchSeconds
+                    ? hint(
+                          `${productId} · refreshed ${new Date().toLocaleTimeString()} · every ${watchSeconds}s · Ctrl+C to stop`,
+                      )
+                    : hint(`${productId} · ${new Date().toLocaleTimeString()}`);
+                console.log(header);
+                console.log(table.toString());
+                const onlineCount = rows.filter((r) => r.device.connection?.active).length;
+                console.log(
+                    hint(`${rows.length} total · ${onlineCount} online · ${rows.length - onlineCount} offline`),
+                );
+            };
+
+            // In watch mode + TTY, switch to the terminal's alternate
+            // screen buffer (`\x1b[?1049h`) so updates redraw in place
+            // without piling up in the scrollback. On exit we restore
+            // the main buffer (`\x1b[?1049l`) and the user's prompt
+            // reappears with their previous history intact — same
+            // pattern `htop`, `vim` and `less` use.
+            const isTty = !!process.stdout.isTTY;
+            const useAltScreen = !!watchSeconds && isTty && !isJsonMode();
+            const enterAltScreen = () => process.stdout.write('\x1b[?1049h\x1b[H');
+            const exitAltScreen = () => process.stdout.write('\x1b[?1049l');
+            const clearScreen = () => process.stdout.write('\x1b[H\x1b[2J');
+
+            // First pass — always. The spinner runs in the main buffer so
+            // the user sees progress while we fetch devices + monitoring
+            // in parallel; once data is ready, we (optionally) switch to
+            // the alternate screen and draw the table from there.
+            let rows;
+            const spinner = createSpinner(
+                `Fetching status for devices in product ${productId}...`,
+            ).start();
+            try {
+                rows = await collect();
+                spinner.stop();
+            } catch (error) {
+                spinner.fail(`Failed to fetch status for product ${productId}`);
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
+            }
+
+            if (useAltScreen) {
+                enterAltScreen();
+                // Restore the main screen on any path out, including
+                // uncaught errors. `once` avoids double-emitting the
+                // escape sequence if the process exits multiple times.
+                process.once('exit', exitAltScreen);
+            }
+
+            render(rows);
+
+            if (!watchSeconds) return;
+
+            // Watch loop. Redraw on each tick; clear in-buffer when
+            // we're on the alternate screen, and just append when
+            // stdout isn't a TTY (piped) — useful for logging.
+            let stopped = false;
+            process.on('SIGINT', () => {
+                stopped = true;
+                if (useAltScreen) exitAltScreen();
+                console.log('Watch stopped.');
+                process.exit(0);
+            });
+            while (!stopped) {
+                await new Promise((r) => setTimeout(r, watchSeconds * 1000));
+                if (stopped) break;
+                try {
+                    const rows = await collect();
+                    if (useAltScreen) clearScreen();
+                    render(rows);
+                } catch (error) {
+                    const { message, code } = classifyError(error);
+                    console.error(errorStyle(`[watch] ${code}: ${message}`));
+                }
+            }
+        });
+}