@thinremote/thinr-cli 1.2.0-alpha.1 → 1.3.0

package/commands/product/fs.js

@@ -0,0 +1,218 @@
+// @ts-check
+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';
+
+/**
+ * Factory for product-level fan-out filesystem subcommands.
+ * Captures the repetitive boilerplate (fetch product devices,
+ * optionally filter offline, fan out through the shared orchestrator,
+ * render the same cli-table3 summary) so each verb only has to
+ * describe its per-device operation.
+ */
+function registerProductFsCommand(product, { name, description, args, build, perDeviceLabel }) {
+    const cmd = product
+        .command(`${name} ${args}`)
+        .helpGroup('Filesystem:')
+        .description(description)
+        .option('-j, --json', 'Output as JSON')
+        .option('-g, --group <group>', 'Filter devices by asset group')
+        .option(
+            '-c, --concurrency <n>',
+            'Max parallel operations (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)');
+
+    cmd.action(async (...commandArgs) => {
+        const opts = commandArgs[commandArgs.length - 2];
+        const commanderCmd = commandArgs[commandArgs.length - 1];
+        const positionalArgs = commandArgs.slice(0, -2);
+        const [productId, ...rest] = positionalArgs;
+
+        applyJsonFlag(opts);
+        ensureConfigured();
+        const user = getGlobalUser(commanderCmd);
+
+        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 build(api, rest, opts);
+                        return {
+                            device: device.device,
+                            ok: true,
+                            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 }) =>
+                                `${perDeviceLabel(rest)} 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,
+                    summary: { total: 0, ok: 0, failed: 0 },
+                    results: [],
+                });
+            } else {
+                console.log(warning('No devices to target.'));
+            }
+            return;
+        }
+
+        const okCount = entries.filter((e) => e.ok).length;
+        const failCount = entries.length - okCount;
+
+        if (isJsonMode()) {
+            printOk({
+                product: productId,
+                summary: {
+                    total: entries.length,
+                    ok: okCount,
+                    failed: failCount,
+                    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.error || '',
+                `${e.durationMs}ms`,
+            ]);
+        }
+        console.log(table.toString());
+        console.log(
+            hint(`${entries.length} total · ${okCount} ok · ${failCount} failed · ${durationMs}ms`),
+        );
+    });
+
+    return cmd;
+}
+
+export function registerProductFsCommands(product) {
+    registerProductFsCommand(product, {
+        name: 'mkdir',
+        description: 'Create a directory on every active device of the product',
+        args: '<productId> <path>',
+        perDeviceLabel: ([path]) => `mkdir ${path}`,
+        build: async (api, [path]) => {
+            await api.mkdir(path);
+        },
+    });
+
+    registerProductFsCommand(product, {
+        name: 'rm',
+        description:
+            'Delete a file or directory on every active device of the product (DESTRUCTIVE — double-check the path).',
+        args: '<productId> <path>',
+        perDeviceLabel: ([path]) => `rm ${path}`,
+        build: async (api, [path], opts) => {
+            await api.delete(path, opts.recursive !== false);
+        },
+    }).option(
+        '-r, --recursive',
+        'Recursively delete non-empty directories (default: true)',
+        true,
+    ).option('--no-recursive', 'Fail on non-empty directories');
+
+    registerProductFsCommand(product, {
+        name: 'mv',
+        description: 'Move or rename a path on every active device of the product',
+        args: '<productId> <source> <destination>',
+        perDeviceLabel: ([src, dst]) => `mv ${src} → ${dst}`,
+        build: async (api, [src, dst], opts) => {
+            await api.move(src, dst, !!opts.force);
+        },
+    }).option('-f, --force', 'Overwrite destination if it already exists');
+}

package/commands/product/index.js

@@ -0,0 +1,35 @@
+// @ts-check
+import { registerProductListCommand } from './list.js';
+import { registerProductPropertyCommand } from './property.js';
+import { registerProductPropertyAdminCommands } from './props.js';
+import { registerProductMetricCommands } from './metric.js';
+import { registerProductResourceCommand } from './resource.js';
+import { registerProductExecCommand } from './exec.js';
+import { registerProductStatusCommand } from './status.js';
+import { registerProductFsCommands } from './fs.js';
+import { registerProductPushCommand } from './push.js';
+import { registerProductPlaybookCommand } from './playbook.js';
+import { registerProductLogsCommand } from './logs.js';
+
+/**
+ * `thinr product <subcommand> <productId> …` — fan-out commands across
+ * every device that belongs to a product.
+ */
+export function productCommand(program) {
+    const product = program
+        .command('product')
+        .helpGroup('Operations:')
+        .description('Product commands (subcommand-first: thinr product <action> <productId>)');
+
+    registerProductListCommand(product);
+    registerProductStatusCommand(product);
+    registerProductPropertyCommand(product);
+    registerProductPropertyAdminCommands(product);
+    registerProductMetricCommands(product);
+    registerProductResourceCommand(product);
+    registerProductExecCommand(product);
+    registerProductFsCommands(product);
+    registerProductPushCommand(product);
+    registerProductPlaybookCommand(product);
+    registerProductLogsCommand(product);
+}

package/commands/product/list.js

@@ -0,0 +1,86 @@
+// @ts-check
+import { getProducts, getProductApi } from '../../lib/product.js';
+import { runPool } from '../../lib/concurrency.js';
+import { label, hint, success } from '../../lib/format.js';
+import {
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../../lib/output.js';
+import {
+    applyJsonFlag,
+    ensureConfigured,
+    getGlobalUser,
+    parsePositiveInt,
+} from '../_shared.js';
+
+export function registerProductListCommand(product) {
+    product
+        .command('list')
+        .helpGroup('Discovery:')
+        .description('List every product configured on the server')
+        .option('-j, --json', 'Output as JSON')
+        .option(
+            '-c, --concurrency <n>',
+            'Max parallel api-resource lookups (default: 10)',
+            parsePositiveInt('concurrency'),
+            10,
+        )
+        .action(async (opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+
+            const spinner = createSpinner('Fetching products...').start();
+            let products;
+            try {
+                products = await getProducts(user);
+            } catch (error) {
+                spinner.fail('Failed to fetch products');
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
+            }
+
+            // Script counts come from each product's api resources map.
+            // Parallelise so a large catalogue doesn't crawl serially.
+            const scriptResults = await runPool(products, opts.concurrency, async (p) => {
+                try {
+                    const apis = await getProductApi(p.product, user);
+                    return Object.keys(apis || {}).length;
+                } catch {
+                    return null;
+                }
+            });
+            const rows = products.map((p, i) => ({
+                product: p.product,
+                name: p.name && p.name !== p.product ? p.name : null,
+                enabled: !!p.enabled,
+                scripts: scriptResults[i]?.ok ? scriptResults[i].value : null,
+            }));
+
+            spinner.succeed(`Found ${rows.length} product(s)`);
+
+            if (isJsonMode()) {
+                printOk({ products: rows });
+                return;
+            }
+
+            if (rows.length === 0) return;
+
+            // Pad the product id column so the trailing name/scripts
+            // bits align even when ids have very different widths.
+            const idWidth = rows.reduce((w, r) => Math.max(w, r.product.length), 0);
+            for (const r of rows) {
+                const flag = r.enabled ? success('enabled ') : hint('disabled');
+                const id = label(r.product.padEnd(idWidth));
+                const name = r.name ? hint(`(${r.name})`) : '';
+                const scripts =
+                    r.scripts != null && r.scripts > 0 ? hint(`${r.scripts} script(s)`) : '';
+                const extras = [name, scripts].filter(Boolean).join('  ');
+                console.log(`  ${flag}  ${id}${extras ? '  ' + extras : ''}`);
+            }
+        });
+}

package/commands/product/logs.js

@@ -0,0 +1,289 @@
+// @ts-check
+import Table from 'cli-table3';
+import {
+    addLogSource,
+    getProductLogs,
+    listPresets,
+    removeLogSource,
+    setDefaultLogSource,
+} from '../../lib/product/logs.js';
+import { hint, info, label, muted, success } from '../../lib/format.js';
+import { classifyError, isJsonMode, printErr, printOk } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured, getGlobalUser } from '../_shared.js';
+
+function truncate(value, max = 60) {
+    if (typeof value !== 'string') return '';
+    return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+}
+
+function registerList(logs) {
+    logs
+        .command('list <productId>')
+        .helpGroup('Log sources:')
+        .description('List the log sources configured on a product')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const cfg = await getProductLogs(productId, user);
+                const fallback = !!(/** @type {any} */ (cfg).__fallback);
+                const def = cfg.default || cfg.sources[0]?.name || null;
+
+                if (isJsonMode()) {
+                    printOk({
+                        product: productId,
+                        fallback,
+                        default: def,
+                        sources: cfg.sources,
+                    });
+                    return;
+                }
+
+                if (fallback) {
+                    console.log(
+                        `${muted('No logs property set on')} ${info(productId)}${muted('. Showing the synthetic fallback:')}`,
+                    );
+                } else {
+                    console.log(`${cfg.sources.length} source(s) on ${info(productId)}:`);
+                }
+                const table = new Table({
+                    head: ['Name', 'Command', 'Pattern', 'Default'].map((h) => label(h)),
+                    style: { head: [], border: ['gray'] },
+                });
+                for (const s of cfg.sources) {
+                    const pat = s.preset
+                        ? muted(`preset:${s.preset}`)
+                        : s.pattern
+                          ? truncate(s.pattern, 30)
+                          : muted('—');
+                    table.push([
+                        s.name,
+                        truncate(s.command),
+                        pat,
+                        s.name === def ? success('✓') : muted('—'),
+                    ]);
+                }
+                console.log(table.toString());
+            } catch (err) {
+                const { message, code } = classifyError(err);
+                printErr(message, { code });
+            }
+        });
+}
+
+function registerAdd(logs) {
+    logs
+        .command('add <productId> <name>')
+        .helpGroup('Log sources:')
+        .description('Add or replace a log source on a product')
+        .requiredOption('-c, --command <cmd>', 'Shell command the agent should exec-stream for this source')
+        .option('--default', 'Mark this source as the active default')
+        .option(
+            '--pattern <regex>',
+            'Custom regex with named groups (time, level, msg) for structured rendering',
+        )
+        .option(
+            '--preset <name>',
+            'Named preset for structured rendering (see `thinr product logs presets`)',
+        )
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, name, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const { config, action } = await addLogSource(
+                    productId,
+                    {
+                        name,
+                        command: opts.command,
+                        makeDefault: !!opts.default,
+                        pattern: opts.pattern,
+                        preset: opts.preset,
+                    },
+                    user,
+                );
+                if (isJsonMode()) {
+                    printOk({ product: productId, action, name, config });
+                    return;
+                }
+                console.log(
+                    `${success(action === 'added' ? 'Added' : 'Updated')} source ${info(name)} on product ${info(productId)}` +
+                        (opts.default ? ` ${muted('(default)')}` : ''),
+                );
+                console.log(`  ${muted('command:')} ${truncate(opts.command, 80)}`);
+                if (opts.preset) console.log(`  ${muted('preset:')} ${opts.preset}`);
+                if (opts.pattern) console.log(`  ${muted('pattern:')} ${truncate(opts.pattern, 80)}`);
+                console.log(
+                    `  ${muted('total sources:')} ${config.sources.length}${
+                        config.default ? `  ${muted('default:')} ${config.default}` : ''
+                    }`,
+                );
+            } catch (err) {
+                const { message, code } = classifyError(err);
+                printErr(message, { code: code === 'error' ? 'input_error' : code });
+            }
+        });
+}
+
+function registerRemove(logs) {
+    logs
+        .command('remove <productId> <name>')
+        .alias('rm')
+        .helpGroup('Log sources:')
+        .description('Remove a log source from a product (idempotent)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, name, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const { removed, config } = await removeLogSource(productId, name, user);
+                if (isJsonMode()) {
+                    printOk({
+                        product: productId,
+                        name,
+                        removed,
+                        config: config || null,
+                        cleared: removed && config === null,
+                    });
+                    return;
+                }
+                if (!removed) {
+                    console.log(
+                        `Source ${info(name)} was not configured on ${info(productId)}.`,
+                    );
+                    return;
+                }
+                if (config === null) {
+                    console.log(
+                        `${success('Removed')} source ${info(name)} (last one). ${muted('Logs property cleared — falling back to system journal.')}`,
+                    );
+                    return;
+                }
+                console.log(
+                    `${success('Removed')} source ${info(name)}. ${muted(`${config.sources.length} source(s) remain`)}` +
+                        (config.default ? ` ${muted(`· default: ${config.default}`)}` : ''),
+                );
+            } catch (err) {
+                const { message, code } = classifyError(err);
+                printErr(message, { code: code === 'error' ? 'input_error' : code });
+            }
+        });
+}
+
+function registerSetDefault(logs) {
+    logs
+        .command('set-default <productId> <name>')
+        .helpGroup('Log sources:')
+        .description('Set the active default source on a product')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, name, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const config = await setDefaultLogSource(productId, name, user);
+                if (isJsonMode()) {
+                    printOk({ product: productId, default: config.default, config });
+                    return;
+                }
+                console.log(
+                    `${success('Default set')}: ${info(name)} on product ${info(productId)}.`,
+                );
+            } catch (err) {
+                const { message, code } = classifyError(err);
+                printErr(message, { code: code === 'error' ? 'input_error' : code });
+            }
+        });
+}
+
+function registerShow(logs) {
+    logs
+        .command('show <productId> <name>')
+        .helpGroup('Log sources:')
+        .description('Show a single log source (full command, untruncated)')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (productId, name, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            try {
+                const cfg = await getProductLogs(productId, user);
+                const source = cfg.sources.find((s) => s.name === name);
+                if (!source) {
+                    const available = cfg.sources.map((s) => s.name).join(', ') || '(none)';
+                    printErr(
+                        `Source "${name}" is not configured on product "${productId}". Available: ${available}`,
+                        { code: 'not_found' },
+                    );
+                    return;
+                }
+                const fallback = !!(/** @type {any} */ (cfg).__fallback);
+                const isDefault = (cfg.default || cfg.sources[0]?.name) === name;
+                if (isJsonMode()) {
+                    printOk({
+                        product: productId,
+                        fallback,
+                        name: source.name,
+                        command: source.command,
+                        pattern: source.pattern || null,
+                        preset: source.preset || null,
+                        default: isDefault,
+                    });
+                    return;
+                }
+                console.log(`${label('Source')}: ${info(source.name)}${isDefault ? ` ${muted('(default)')}` : ''}`);
+                console.log(`${label('Command')}: ${source.command}`);
+                if (source.preset) console.log(`${label('Preset')}: ${source.preset}`);
+                if (source.pattern) console.log(`${label('Pattern')}: ${source.pattern}`);
+                if (fallback) console.log(hint('(synthetic fallback — no logs property set)'));
+            } catch (err) {
+                const { message, code } = classifyError(err);
+                printErr(message, { code });
+            }
+        });
+}
+
+function registerPresets(logs) {
+    logs
+        .command('presets')
+        .helpGroup('Log sources:')
+        .description('List the named log line patterns shipped with the CLI')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (opts) => {
+            applyJsonFlag(opts);
+            const presets = listPresets();
+            if (isJsonMode()) {
+                printOk({ presets });
+                return;
+            }
+            const table = new Table({
+                head: ['Name', 'Description', 'Pattern'].map((h) => label(h)),
+                style: { head: [], border: ['gray'] },
+            });
+            for (const p of presets) {
+                table.push([p.name, p.description, truncate(p.pattern, 60)]);
+            }
+            console.log(`${presets.length} preset(s) available:`);
+            console.log(table.toString());
+        });
+}
+
+export function registerProductLogsCommand(product) {
+    const logs = product
+        .command('logs')
+        .helpGroup('Log sources:')
+        .description(
+            `Manage log sources stored on a product. ${hint('Subcommands: list, add, remove, set-default, show, presets.')}`,
+        );
+
+    registerList(logs);
+    registerAdd(logs);
+    registerRemove(logs);
+    registerSetDefault(logs);
+    registerShow(logs);
+    registerPresets(logs);
+}