@thinremote/thinr-cli 1.5.0 → 1.6.1

package/bin/thinr.js

@@ -3,22 +3,10 @@
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
-import figlet from 'figlet';
 import { defineIdentity } from '@thinger-io/cli-core/identity';
 import { runCli } from '@thinger-io/cli-core/cli';
-import { authenticate } from '@thinger-io/cli-core/auth';
-import { configExists } from '@thinger-io/cli-core/config';
-import { accent, info } from '@thinger-io/cli-core/format';
-import { mcpInstructions, thinrIdentity } from '../lib/identity.js';
-import { tools as mcpTools } from '../lib/mcp/registry.js';
-import { resourceHooks } from '../lib/mcp/resource-hooks.js';
-import { resourceActions, resourceTypes } from '../lib/mcp/resource-types.js';
-import { guides } from '../lib/guides.js';
-import { registerDeviceCommands } from '../commands/device/index.js';
-import { registerProductCommands } from '../commands/product/index.js';
-import { fleetCommand } from '../commands/fleet/index.js';
-import { playbookCommand } from '../commands/playbook/index.js';
-import { runDashboard } from '../commands/dashboard.js';
+import { thinrIdentity } from '../lib/identity.js';
+import { cliOptions } from '../lib/cli.js';
 
 // Single source of truth for the version: package.json. Avoids the drift
 // between `package.json#version` and a hardcoded string in this file.
@@ -26,49 +14,6 @@ const pkg = JSON.parse(
     readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf8'),
 );
 
-function displayBanner() {
-    console.log(accent(figlet.textSync('thinr-cli', { horizontalLayout: 'full' })));
-    console.log(info('Thin Remote CLI - Remote management for IoT devices'));
-    console.log();
-}
-
 defineIdentity(thinrIdentity);
 
-await runCli({
-    version: pkg.version,
-    mcpTools,
-    resourceHooks,
-    resourceTypes,
-    resourceActions,
-    docs: guides,
-    mcpInstructions,
-    register(program, groups) {
-        registerDeviceCommands(groups.device);
-        registerProductCommands(groups.product);
-        fleetCommand(program);
-        playbookCommand(program);
-
-        const originalHelp = program.help;
-        program.help = function (cb) {
-            displayBanner();
-            return originalHelp.call(this, cb);
-        };
-    },
-    // Just `thinr`: launch the dashboard when running interactively (signing
-    // in first if there is no profile yet). Non-TTY contexts (pipes,
-    // scripts, `thinr | cat`) fall back to `--help` so they get something
-    // useful instead of an Ink crash.
-    async onNoCommand(program) {
-        if (!process.stdout.isTTY) program.help();
-        if (!configExists()) {
-            displayBanner();
-            try {
-                await authenticate();
-            } catch (error) {
-                console.error(`Configuration error: ${error.message}`);
-                process.exit(1);
-            }
-        }
-        await runDashboard();
-    },
-});
+await runCli({ version: pkg.version, ...cliOptions });

package/commands/_shared.js

@@ -4,6 +4,7 @@ import { InvalidArgumentError } from 'commander';
 // is the name thinr's subcommands have always used for its `runCommand`.
 export {
     applyJsonFlag,
+    confirmDestructive,
     ensureConfigured,
     extractField,
     getGlobalUser,

package/commands/{device/update.js → agent/device.js}

@@ -9,12 +9,17 @@ import {
 } from '@thinger-io/cli-core/output';
 import { label as labelText, accent } from '@thinger-io/cli-core/format';
 import { TIMEOUTS } from '../../lib/constants.js';
-import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
 
-const runUpdate = async (action, deviceId, opts, cmd) => {
-    applyJsonFlag(opts);
-    ensureConfigured();
-    const user = getGlobalUser(cmd);
+/**
+ * Ask the agent of one device to check for a release (`check`) or to
+ * install it (`apply`), through its `update` resource.
+ *
+ * @param {'check' | 'apply'} action
+ * @param {string} deviceId
+ * @param {{ channel?: string }} opts
+ * @param {string | null} user
+ */
+export async function runDeviceUpdate(action, deviceId, opts, user) {
     const channel = opts.channel || 'latest';
     const phase = action === 'check' ? 'Checking for updates' : 'Applying update';
     const spinner = createSpinner(`${phase} on ${deviceId}...`).start();
@@ -40,25 +45,4 @@ const runUpdate = async (action, deviceId, opts, cmd) => {
         const { message, code } = classifyError(error);
         printErr(message, { code });
     }
-};
-
-export function registerUpdateCommand(device) {
-    const update = device
-        .command('update')
-        .helpGroup('Execution:')
-        .description('Check for or apply agent updates');
-
-    update
-        .command('check <deviceId>')
-        .description('Check if an agent update is available')
-        .option('-j, --json', 'Output as JSON')
-        .option('--channel <name>', 'Update channel (default: latest)')
-        .action((deviceId, opts, cmd) => runUpdate('check', deviceId, opts, cmd));
-
-    update
-        .command('apply <deviceId>')
-        .description('Apply an agent update')
-        .option('-j, --json', 'Output as JSON')
-        .option('--channel <name>', 'Update channel (default: latest)')
-        .action((deviceId, opts, cmd) => runUpdate('apply', deviceId, opts, cmd));
 }

package/commands/agent/fleet.js

@@ -0,0 +1,254 @@
+// @ts-check
+import { confirm } from '@inquirer/prompts';
+import { getDevices } from '@thinger-io/cli-core/devices';
+import { getMonitoringData } from '../../lib/monitoring.js';
+import { fetchLatestAgentVersion } from '../../lib/agent-releases.js';
+import { runFleetUpgrade, summarize } from '../../lib/fleet-upgrade.js';
+import { classifyAgainst, normalizeAgentVersion } from '../../lib/agent-versions.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '@thinger-io/cli-core/output';
+import {
+    success,
+    error as errorStyle,
+    warning,
+    hint,
+    label,
+    muted,
+    accent,
+} from '@thinger-io/cli-core/format';
+
+/**
+ * `thinr agent update --all`: update the agent on every outdated device of
+ * the fleet (or of a product, or an asset group), a canary first, then in
+ * batches, after a confirmation unless `-y`.
+ *
+ * @param {Record<string, any>} opts  The options of `agent update`.
+ * @param {string | null} user
+ */
+export async function runFleetUpdate(opts, user) {
+    // ── 1. Target version ──────────────────────────────────────
+    const latestSpinner = createSpinner(`Resolving ${opts.channel} release…`).start();
+    let target;
+    try {
+        target = await fetchLatestAgentVersion({ channel: opts.channel });
+        latestSpinner.succeed(`Channel ${accent(opts.channel)} → ${success(target)}`);
+    } catch (err) {
+        latestSpinner.fail(`Failed to resolve channel ${opts.channel}`);
+        const { message, code } = classifyError(err);
+        printErr(message, { code });
+        return;
+    }
+
+    // ── 2. Fleet inventory ─────────────────────────────────────
+    const listSpinner = createSpinner('Listing fleet…').start();
+    let devices;
+    try {
+        const filter = {};
+        if (opts.product) filter.product = opts.product;
+        if (opts.group) filter.asset_group = opts.group;
+        devices = await getDevices(filter, user);
+        listSpinner.succeed(`Fleet size: ${label(devices.length)} device(s)`);
+    } catch (err) {
+        listSpinner.fail('Failed to list devices');
+        const { message, code } = classifyError(err);
+        printErr(message, { code });
+        return;
+    }
+    if (devices.length === 0) {
+        if (isJsonMode()) {
+            printOk({ target, outdated: [], results: [] });
+        } else {
+            console.log(hint('No devices match the filter.'));
+        }
+        return;
+    }
+
+    // ── 3. Current versions ────────────────────────────────────
+    // Fleet-wide monitoring snapshot trimmed to `agent.version`.
+    // The backend may return several rows per device (history
+    // tail); with `sort=desc` the first row we see per device is
+    // the most recent one, so we ignore later repeats. We also
+    // scope to the filtered fleet so monitoring data from devices
+    // outside the product/group filter doesn't leak into the count.
+    const versionsSpinner = createSpinner('Reading agent versions…').start();
+    const fleetIds = new Set(devices.map((d) => d.device));
+    const deviceVersions = {};
+    for (const d of devices) deviceVersions[d.device] = null;
+    try {
+        const rows = await getMonitoringData({
+            user,
+            items: Math.max(500, devices.length),
+            sort: 'desc',
+            fields: 'agent.version',
+        });
+        if (Array.isArray(rows)) {
+            for (const row of rows) {
+                const id = row?.device;
+                const v = row?.agent?.version;
+                if (!id || !v || !fleetIds.has(id)) continue;
+                if (deviceVersions[id]) continue;
+                deviceVersions[id] = v;
+            }
+        }
+        const known = Object.values(deviceVersions).filter(Boolean).length;
+        versionsSpinner.succeed(`Read versions for ${label(known)} of ${devices.length} device(s)`);
+    } catch (err) {
+        versionsSpinner.fail('Failed to read monitoring data');
+        const { message, code } = classifyError(err);
+        printErr(message, { code });
+        return;
+    }
+
+    const { outdated, current, unknown } = classifyAgainst(target, deviceVersions);
+
+    // ── 4. Render summary ──────────────────────────────────────
+    const versionCounts = countVersions(deviceVersions);
+    if (!isJsonMode()) {
+        console.log();
+        console.log(label('Agent versions in fleet:'));
+        for (const [v, c] of versionCounts) {
+            const tag = v === target ? success('●') : warning('●');
+            console.log(`  ${tag} ${v.padEnd(12)} ${muted(String(c))}`);
+        }
+        if (unknown.length) {
+            console.log(`  ${muted('?')} ${'unknown'.padEnd(12)} ${muted(String(unknown.length))}`);
+        }
+        console.log();
+        console.log(
+            `Target: ${success(target)}  ·  ` +
+                `outdated: ${label(outdated.length)}  ·  ` +
+                `current: ${muted(current.length)}` +
+                (unknown.length ? `  ·  unknown: ${muted(unknown.length)}` : ''),
+        );
+        console.log();
+    }
+
+    if (outdated.length === 0) {
+        if (isJsonMode()) {
+            printOk({
+                target,
+                summary: { outdated: 0, current: current.length, unknown: unknown.length },
+                results: [],
+            });
+        } else {
+            console.log(success('All devices are already on the target version.'));
+        }
+        return;
+    }
+
+    // ── 5. Dry-run ─────────────────────────────────────────────
+    if (opts.dryRun) {
+        if (isJsonMode()) {
+            printOk({
+                target,
+                dryRun: true,
+                outdated,
+                current,
+                unknown,
+            });
+            return;
+        }
+        console.log(label(`Would upgrade ${outdated.length} device(s):`));
+        for (const id of outdated) {
+            console.log(
+                `  - ${id} ${muted(`(${normalizeAgentVersion(deviceVersions[id]) || '?'})`)}`,
+            );
+        }
+        return;
+    }
+
+    // ── 6. Confirmation ────────────────────────────────────────
+    if (!opts.yes && !isJsonMode()) {
+        if (!process.stdin.isTTY) {
+            printErr('Refusing to upgrade without --yes in a non-interactive shell', {
+                code: 'needs_confirm',
+            });
+            return;
+        }
+        const plan = opts.canary ? 'canary first, then batches' : 'all in batches';
+        const failure = opts.continueOnError ? 'continue on failure' : 'abort on failure';
+        const ok = await confirm({
+            message: `Upgrade ${outdated.length} device(s) to ${target}? (${plan} · ${failure})`,
+            default: false,
+        });
+        if (!ok) {
+            console.log(hint('Cancelled.'));
+            return;
+        }
+    }
+
+    // ── 7. Rollout ─────────────────────────────────────────────
+    const runSpinner = createSpinner('').start();
+    const setRunText = (done, total) => {
+        runSpinner.text = `Upgrading · ${done}/${total} device(s) processed`;
+    };
+    setRunText(0, outdated.length);
+
+    const perDevice = [];
+    const { results, aborted, reason } = await runFleetUpgrade({
+        deviceIds: outdated,
+        channel: opts.channel,
+        user,
+        canary: opts.canary,
+        abortOnFailure: !opts.continueOnError,
+        batchSize: opts.batchSize,
+        onProgress: ({ done, total }) => setRunText(done, total),
+        onDeviceResult: (r) => {
+            perDevice.push(r);
+        },
+    });
+    runSpinner.stop();
+
+    // ── 8. Results ─────────────────────────────────────────────
+    const sum = summarize(results);
+    if (isJsonMode()) {
+        printOk({
+            target,
+            channel: opts.channel,
+            aborted,
+            reason: aborted ? reason : undefined,
+            summary: sum,
+            results,
+        });
+        return;
+    }
+
+    for (const r of results) {
+        if (r.ok) {
+            console.log(`  ${success('✓')} ${r.deviceId}`);
+        } else {
+            console.log(`  ${errorStyle('✗')} ${r.deviceId}  ${muted(r.error)}`);
+        }
+    }
+
+    console.log();
+    const verdict = aborted
+        ? `${warning('aborted')} (${reason}) · ${sum.ok} ok · ${sum.failed} failed`
+        : `${success('done')} · ${sum.ok} ok · ${sum.failed} failed`;
+    console.log(label(`Rollout ${verdict}`));
+
+    if (aborted || sum.failed > 0) {
+        // Scripts can use the exit code to gate follow-up work — a
+        // partial rollout is a "soft failure" worth surfacing.
+        process.exitCode = 1;
+    }
+}
+
+function countVersions(deviceVersions) {
+    const counts = new Map();
+    for (const raw of Object.values(deviceVersions)) {
+        const v = normalizeAgentVersion(raw);
+        if (!v) continue;
+        counts.set(v, (counts.get(v) || 0) + 1);
+    }
+    // Newest first by semver — reuse the comparator via dynamic import
+    // would be overkill here; the caller only needs a stable human order.
+    return [...counts.entries()].sort((a, b) =>
+        b[0].localeCompare(a[0], undefined, { numeric: true }),
+    );
+}

package/commands/agent/index.js

@@ -0,0 +1,79 @@
+// @ts-check
+import { printErr } from '@thinger-io/cli-core/output';
+import { applyJsonFlag, ensureConfigured, getGlobalUser, parsePositiveInt } from '../_shared.js';
+import { runDeviceUpdate } from './device.js';
+import { runFleetUpdate } from './fleet.js';
+
+/**
+ * `thinr agent check|update` — the ThinRemote agent on the devices: check
+ * whether a device has a newer release, and update one device or, with
+ * `--all`, every outdated device of the fleet (narrowed by product or asset
+ * group), a canary first and then in batches.
+ */
+export function agentCommand(program) {
+    const agent = program
+        .command('agent')
+        .helpGroup('Operations:')
+        .description('The ThinRemote agent of the devices: check for and apply its updates');
+
+    agent
+        .command('check <device>')
+        .helpGroup('Updates:')
+        .description('Check whether a newer agent release is available for a device')
+        .option('--channel <name>', 'Release channel', 'latest')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (device, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            await runDeviceUpdate('check', device, opts, getGlobalUser(cmd));
+        });
+
+    agent
+        .command('update [device]')
+        .helpGroup('Updates:')
+        .description(
+            'Update the agent of a device, or with --all of every outdated device of the fleet',
+        )
+        .option('--channel <name>', 'Release channel', 'latest')
+        .option('--all', 'Every outdated device of the fleet (narrow it with -p and -g)')
+        .option('-p, --product <id>', 'With --all: only the devices of this product')
+        .option('-g, --group <id>', 'With --all: only the devices of this asset group')
+        .option(
+            '--batch-size <n>',
+            'With --all: devices updated in parallel once the canary passes',
+            parsePositiveInt('batch-size'),
+            5,
+        )
+        .option('--no-canary', 'With --all: no canary phase (everything in batches from the start)')
+        .option('--continue-on-error', 'With --all: keep rolling after a batch failure')
+        .option('--dry-run', 'With --all: list what would be updated, without updating it')
+        .option('-y, --yes', 'With --all: no confirmation (required in non-interactive shells)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (device, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            if (device && opts.all) {
+                printErr('give a device or --all, not both', { code: 'input_error' });
+                return;
+            }
+            if (!device && !opts.all) {
+                printErr('give a device, or --all for every outdated device of the fleet', {
+                    code: 'input_error',
+                });
+                return;
+            }
+            if (opts.all) return runFleetUpdate(opts, user);
+            const fleetOnly = ['product', 'group', 'dryRun', 'continueOnError'].filter(
+                (o) => opts[o] !== undefined,
+            );
+            if (fleetOnly.length || opts.canary === false) {
+                printErr(
+                    `--product, --group, --dry-run, --continue-on-error and --no-canary go with --all (to check one device: agent check ${device})`,
+                    { code: 'input_error' },
+                );
+                return;
+            }
+            await runDeviceUpdate('apply', device, opts, user);
+        });
+}

package/commands/device/console.js

@@ -4,7 +4,7 @@ import { ensureConfigured, runInteractive } from './_shared.js';
 
 export function registerConsoleCommand(device) {
     device
-        .command('console <deviceId>')
+        .command('console <device>')
         .helpGroup('Remote access:')
         .description('Open an interactive terminal on the device')
         .action((deviceId) =>

package/commands/device/exec.js

@@ -6,7 +6,7 @@ import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
 
 export function registerExecCommand(device) {
     device
-        .command('exec <deviceId> <command...>')
+        .command('exec <device> <command...>')
         .helpGroup('Execution:')
         .description('Execute a shell command on the device')
         .option('-j, --json', 'Buffer stdout/stderr and emit a single JSON envelope')

package/commands/device/fs.js

@@ -13,7 +13,7 @@ import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
  */
 export function registerFsCommands(device) {
     device
-        .command('ls <deviceId> [path]')
+        .command('ls <device> [path]')
         .helpGroup('Filesystem:')
         .description('List a directory on the device')
         .option('-j, --json', 'Output as JSON')
@@ -46,7 +46,7 @@ export function registerFsCommands(device) {
         });
 
     device
-        .command('read <deviceId> <path>')
+        .command('read <device> <path>')
         .alias('cat')
         .helpGroup('Filesystem:')
         .description('Print the contents of a remote file to stdout')
@@ -72,7 +72,7 @@ export function registerFsCommands(device) {
         });
 
     device
-        .command('write <deviceId> <path> [content]')
+        .command('write <device> <path> [content]')
         .helpGroup('Filesystem:')
         .description(
             'Write inline content to a remote file (use `push` for large local files). Reads from stdin when <content> is omitted.',
@@ -111,7 +111,7 @@ export function registerFsCommands(device) {
         });
 
     device
-        .command('mkdir <deviceId> <path>')
+        .command('mkdir <device> <path>')
         .helpGroup('Filesystem:')
         .description('Create a directory on the device')
         .option('-j, --json', 'Output as JSON')
@@ -133,7 +133,7 @@ export function registerFsCommands(device) {
         });
 
     device
-        .command('rm <deviceId> <path>')
+        .command('rm <device> <path>')
         .helpGroup('Filesystem:')
         .description(
             'Delete a file or directory on the device (pass --recursive for directories with contents)',
@@ -159,7 +159,7 @@ export function registerFsCommands(device) {
         });
 
     device
-        .command('mv <deviceId> <source> <destination>')
+        .command('mv <device> <source> <destination>')
         .helpGroup('Filesystem:')
         .description('Move or rename a file or directory on the device')
         .option('-j, --json', 'Output as JSON')

package/commands/device/index.js

@@ -3,23 +3,21 @@ import { registerProxyCommands } from './proxy.js';
 import { registerConsoleCommand } from './console.js';
 import { registerStatusCommand } from './status.js';
 import { registerExecCommand } from './exec.js';
-import { registerUpdateCommand } from './update.js';
 import { registerTransferCommands } from './transfer.js';
 import { registerFsCommands } from './fs.js';
 import { registerLogsCommand } from './logs.js';
 
 /**
- * `thinr device <subcommand> [<deviceId>] …` — the agent-backed actions
- * (console, proxies, exec, files, logs, status, agent updates), added to
- * the generic `device` group of @thinger-io/cli-core, which already holds
- * list, info, create, delete, set-product, property and resource.
+ * `thinr device <verb> <device> …` — the agent-backed actions (console,
+ * proxies, exec, files, logs, status), added to the generic `device` group
+ * of @thinger-io/cli-core, which holds its records, properties, resources
+ * and children. Agent updates are `thinr agent`.
  */
 export function registerDeviceCommands(device) {
     registerProxyCommands(device);
     registerConsoleCommand(device);
     registerStatusCommand(device);
     registerExecCommand(device);
-    registerUpdateCommand(device);
     registerTransferCommands(device);
     registerFsCommands(device);
     registerLogsCommand(device);

package/commands/device/logs.js

@@ -62,7 +62,7 @@ async function resolveProductSource({ deviceId, sourceName, user }) {
 
 export function registerLogsCommand(device) {
     device
-        .command('logs <deviceId>')
+        .command('logs <device>')
         .helpGroup('Observability:')
         .description('Stream or tail device logs (journalctl by default, or a file path)')
         .option('-f, --follow', 'Keep streaming until interrupted (Ctrl+C)')

package/commands/device/proxy.js

@@ -4,10 +4,13 @@ import { ensureConfigured, runInteractive } from './_shared.js';
 
 export function registerProxyCommands(device) {
     device
-        .command('tcp <deviceId> [target]')
+        .command('tcp <device> [target]')
         .helpGroup('Remote access:')
         .description('Create a TCP proxy (no TLS). Default target: 22.')
-        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .option(
+            '-p, --port <port>',
+            'Port of the relay on the server (default: random, 50000-51000)',
+        )
         .action((deviceId, target, opts) =>
             runInteractive(() => {
                 ensureConfigured();
@@ -16,10 +19,13 @@ export function registerProxyCommands(device) {
         );
 
     device
-        .command('tls <deviceId> [target]')
+        .command('tls <device> [target]')
         .helpGroup('Remote access:')
         .description('Create a TLS proxy. Default target: 443.')
-        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .option(
+            '-p, --port <port>',
+            'Port of the relay on the server (default: random, 50000-51000)',
+        )
         .action((deviceId, target, opts) =>
             runInteractive(() => {
                 ensureConfigured();
@@ -28,10 +34,13 @@ export function registerProxyCommands(device) {
         );
 
     device
-        .command('http <deviceId> [target]')
+        .command('http <device> [target]')
         .helpGroup('Remote access:')
         .description('Create an HTTP proxy. Default target: 80.')
-        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .option(
+            '-p, --port <port>',
+            'Port of the relay on the server (default: random, 50000-51000)',
+        )
         .option('--no-open', 'Do not open the browser')
         .action((deviceId, target, opts) =>
             runInteractive(() => {

package/commands/device/status.js

@@ -6,7 +6,7 @@ import { applyJsonFlag, ensureConfigured, runDeviceCommand } from './_shared.js'
 
 export function registerStatusCommand(device) {
     device
-        .command('status <deviceId>')
+        .command('status <device>')
         .helpGroup('Discovery:')
         .description('Check device status, data transfer and the latest monitoring sample')
         .option('-j, --json', 'Output as JSON')

package/commands/device/transfer.js

@@ -88,7 +88,7 @@ function makeTransferBar(totalBytes) {
  */
 export function registerTransferCommands(device) {
     device
-        .command('push <deviceId> <localPath> <remotePath>')
+        .command('push <device> <local-path> <remote-path>')
         .helpGroup('Filesystem:')
         .description('Upload a local file to the device (use trailing "/" on remote to keep the source basename)')
         .option('-j, --json', 'Output as JSON')
@@ -167,7 +167,7 @@ export function registerTransferCommands(device) {
         });
 
     device
-        .command('pull <deviceId> <remotePath> <localPath>')
+        .command('pull <device> <remote-path> <local-path>')
         .helpGroup('Filesystem:')
         .description('Download a remote file from the device to local disk')
         .option('-j, --json', 'Output as JSON')

package/commands/product/exec.js

@@ -28,7 +28,7 @@ import {
 
 export function registerProductExecCommand(product) {
     product
-        .command('exec <productId> <command...>')
+        .command('exec <product> <command...>')
         .helpGroup('Fan-out:')
         .description(
             'Execute a shell command in parallel on every active device of the product',