@thinremote/thinr-cli 1.0.2 → 1.1.0-alpha.1

package/commands/product.js

@@ -1,198 +1,167 @@
-import { configExists } from "../lib/config.js";
-import chalk from "chalk";
-import ora from "ora";
-import { formatDeviceProperty, getDeviceProperty } from "../lib/property.js";
-import { executeDeviceResource } from "../lib/resource.js";
-import { filterActiveDevices, getDevices } from "../lib/device.js";
+import chalk from 'chalk';
+import { InvalidArgumentError } from 'commander';
+import { configExists } from '../lib/config.js';
+import { formatDeviceProperty, getDeviceProperty } from '../lib/property.js';
+import { callDeviceResource } from '../lib/resource.js';
+import { filterActiveDevices, getDevices } from '../lib/devices.js';
+import {
+    setJsonMode,
+    isJsonMode,
+    printOk,
+    printErr,
+    createSpinner,
+    classifyError,
+} from '../lib/output.js';
+
+function ensureConfigured() {
+    if (!configExists()) {
+        printErr('Not configured. Run thinr without parameters to set up.', {
+            code: 'not_configured',
+        });
+    }
+}
 
-/**
- * Register the product command with all product related functionality.
- * @param {Command} program - Commander program instance
- */
-export function productCommand(program) {
+function applyJsonFlag(opts) {
+    if (opts.json) setJsonMode(true);
+}
 
-    const product = program.command('product').description('Product commands');
+function getGlobalUser(cmd) {
+    let root = cmd;
+    while (root.parent) root = root.parent;
+    return root.opts().user || null;
+}
 
-    product
-        .argument('<productId>', 'ID of the product to manage')
-        .description('Device commands for a specific product')
-        .allowUnknownOption(true)
-        .allowExcessArguments(true)
-        .action( async (productId, options, command) => {
+function collectInput(value, previous = {}) {
+    const idx = value.indexOf('=');
+    if (idx === -1) throw new InvalidArgumentError('must be key=value');
+    return { ...previous, [value.slice(0, idx)]: value.slice(idx + 1) };
+}
 
-            // Get additional arguments manually
-            const args = command.args.slice(1); // Skip productId
-            const action = args[0];
-            const target = args[1] && !args[1].startsWith('-') ? args[1] : null;
+async function fetchProductDevices(productId, group, user) {
+    const filter = { productId };
+    if (group) filter.asset_group = group;
+    return getDevices(filter, user);
+}
 
-            // Check if configured
-            if (!configExists()) {
-                console.error(chalk.red('Error: Not configured. Run thinr without parameters to set up.'));
-                process.exit(1);
-            }
+/**
+ * `thinr product <subcommand> <productId> …` — fan-out commands across
+ * every device that belongs to a product.
+ */
+export function productCommand(program) {
+    const product = program
+        .command('product')
+        .description('Product commands (subcommand-first: thinr product <action> <productId>)');
 
-            // If no action provided, show help
-            if (!action) {
-                printHelp(productId);
+    product
+        .command('property <productId> <propertyId>')
+        .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;
             }
-
-            // Parse options manually from process.argv
-            const parsedOptions = {
-                json: false,
-                inputs: {},
-                field: "",
-                allDevices: false,
-                group: null // Group option for filtering devices
-            };
-
-            const argv = process.argv;
-            for (let i = 0; i < argv.length; i++) {
-                if (argv[i] === '-j' || argv[i] === '--json') {
-                    parsedOptions.json = true;
-                } else if (argv[i] === '-i' || argv[i] === '--input') {
-                    let inputPair = argv[i + 1].split('=');
-                    parsedOptions.inputs[inputPair[0]] = inputPair[1];
-                } else if (argv[i] === '-f' || argv[i] === '--field') {
-                    parsedOptions.field = argv[i + 1];
-                } else if (argv[i] === '-h' || argv[i] === '--help') {
-                    printHelp(productId);
-                    return;
-                } else if (argv[i] === '-a' || argv[i] === '--all') {
-                    parsedOptions.allDevices = true;
-                } else if (argv[i] === '-g' || argv[i] === '--group') {
-                    parsedOptions.group = argv[i + 1];
+            if (!opts.all) devices = filterActiveDevices(devices);
+
+            const results = [];
+            for (const device of devices) {
+                try {
+                    const property = await getDeviceProperty(device.device, propertyId);
+                    const value = opts.field
+                        ? opts.field.split('.').reduce((obj, key) => obj && obj[key], property)
+                        : property;
+                    results.push({ device: device.device, ok: true, data: value });
+                    if (!isJsonMode()) {
+                        console.log(
+                            'Device',
+                            chalk.blue(device.device),
+                            'property',
+                            chalk.blue(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(
+                            chalk.red(
+                                `Error retrieving property ${propertyId} for device ${device.device}: ${message}`,
+                            ),
+                        );
+                    }
                 }
-
             }
+            if (isJsonMode()) printOk({ product: productId, property: propertyId, results });
+        });
 
-            let devices = [];
-            const spinner = ora(`Retrieving devices for product ${productId}...`).start();
+    product
+        .command('resource <productId> <resource>')
+        .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 {
-                let filter = {
-                    productId: productId,
-                };
-                if (parsedOptions.group) {
-                    filter.asset_group = parsedOptions.group;
-                }
-                devices = await getDevices(filter);
+                devices = await fetchProductDevices(productId, opts.group, user);
                 spinner.succeed(`Devices for product ${productId} retrieved successfully`);
-            } catch (e) {
+            } catch (error) {
                 spinner.fail(`Failed to retrieve devices for product ${productId}`);
-                process.exit(1);
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+                return;
             }
-
-            switch (action.toLowerCase()) {
-
-                case 'property': {
-
-                    //const spinner = ora(`Retrieving property ${target} for devices belonging to the product ${productId}...`).start();
-
-                    if ( ! parsedOptions.allDevices ) {
-                        devices = filterActiveDevices(devices);
+            devices = filterActiveDevices(devices);
+
+            const results = [];
+            for (const device of devices) {
+                try {
+                    const result = await callDeviceResource(device.device, resource, opts.input);
+                    const value = opts.field
+                        ? opts.field.split('.').reduce((obj, key) => obj && obj[key], result)
+                        : result;
+                    results.push({ device: device.device, ok: true, data: value });
+                    if (!isJsonMode()) {
+                        console.log(
+                            'Device',
+                            chalk.blue(device.device),
+                            'resource',
+                            chalk.blue(resource),
+                        );
+                        console.log(value);
                     }
-
-                    try {
-                        for (const device of devices) {
-                            try {
-                                const property = await getDeviceProperty(device.device, target);
-                                console.log('Device', chalk.blue(device.device), 'property', chalk.blue(target));
-
-                                if (parsedOptions.json) {
-                                    if ( parsedOptions.field ) {
-                                        console.log(parsedOptions.field.split('.').reduce((obj, key) => obj && obj[key], property));
-                                    } else {
-                                        console.log(JSON.stringify(property, null, 2));
-                                    }
-                                } else {
-                                    console.log(formatDeviceProperty(device.device, target, property));
-                                }
-                            } catch (e) {
-                                console.error(chalk.red(`Error retrieving property ${target} for device ${device.device}: ${e.message}`));
-                            }
-                        }
-                        //spinner.succeed(`Property ${target} for devices belonging to product ${productId} found`);
-                    } catch (error) {
-                        spinner.fail(`Property retrieval failed`);
-                        console.error(chalk.red(`Error: ${error.message}`));
-                        process.exit(1);
-                    }
-                    break;
-                }
-
-                case 'resource': {
-
-                    //const spinner = ora(`Executing resource ${target} for devices belonging to the product ${productId}...`).start();
-
-                    // Obviously, we can only execute resources on active devices
-                    devices = filterActiveDevices(devices);
-
-                    try {
-                        for (const device of devices) {
-                            try {
-                                const result = await executeDeviceResource(device.device, target, parsedOptions.inputs);
-                                console.log('Device', chalk.blue(device.device), 'resource', chalk.blue(target));
-                                if ( parsedOptions.field ) {
-                                    console.log(parsedOptions.field.split('.').reduce((obj, key) => obj && obj[key], result));
-                                } else {
-                                    console.log(result);
-                                }
-                            } catch (e) {
-                                console.error(chalk.red(`Error retrieving property ${target} for device ${device.device}: ${e.message}`));
-                            }
-                        }
-                        //spinner.succeed(`Resource ${target} executed successfully for devices belonging to product ${productId}`);
-
-
-                    } catch (error) {
-                        spinner.fail(`Resource execution failed`);
-                        console.error(chalk.red(`Error: ${error.message}`));
-                        process.exit(1);
+                } catch (error) {
+                    const { message, code } = classifyError(error);
+                    results.push({ device: device.device, ok: false, error: { message, code } });
+                    if (!isJsonMode()) {
+                        console.error(
+                            chalk.red(
+                                `Error executing resource ${resource} for device ${device.device}: ${message}`,
+                            ),
+                        );
                     }
-
-                    break;
-
                 }
-
-                default:
-                    console.error(chalk.red(`Error: Unknown action '${action}'. Available actions: property, resource.\n`));
-                    printHelp(productId);
-                    process.exit(1);
-
             }
+            if (isJsonMode()) printOk({ product: productId, resource, results });
         });
 }
-
-function printHelp(productId) {
-    console.log(`Usage: thinr device product ${productId} <command> [options]
-
-Available commands for device product "${productId}":
-
-  property [propertyId]         Get a specific property of all devices belonging to the product
-                                Example: thinr device product ${productId} property uptime
-
-  resource [resource]           Execute a specific resource of all devices belonging to the product
-                                Example: thinr device product ${productId} resource reboot
-
-Arguments:
-
-  propertyId                    ID of the property to retrieve (for property command)
-
-  resource                      Name of the resource to execute (for resource command)
-  
-
-Options (for all product subcommands):
-  -g, --group <group>          Group of devices to filter (e.g., -g group1)
-
-Options (for property command):
-  -j, --json                   Output as JSON
-  -f, --field <field>          Field to extract from the property (e.g., -f data.value)
-  -a, --all                    Include non active devices (default: false)
-
-Options (for resource command):
-  -j, --json                   Output as JSON
-  -f, --field <field>          Field to extract from the property (e.g., -f data.value)
-
-Use "thinr product device ${productId} <command> --help" for more details on each command.`);
-
-}

package/commands/profile.js

@@ -0,0 +1,105 @@
+import chalk from 'chalk';
+import {
+    listProfiles,
+    getActiveProfile,
+    getProfile,
+    setDefaultProfile,
+    deleteProfile,
+} from '../lib/config.js';
+import { setJsonMode, isJsonMode, printOk, printErr } from '../lib/output.js';
+
+function applyJsonFlag(opts) {
+    if (opts.json) setJsonMode(true);
+}
+
+export function profileCommand(program) {
+    const profile = program.command('profile').description('Manage configuration profiles');
+
+    profile
+        .command('list')
+        .description('List configured profiles')
+        .option('-j, --json', 'Output as JSON')
+        .action((opts) => {
+            applyJsonFlag(opts);
+            const names = listProfiles();
+            const active = getActiveProfile();
+            if (isJsonMode()) {
+                const entries = names.map((name) => {
+                    const data = getProfile(name) || {};
+                    return {
+                        name,
+                        active: name === active,
+                        username: data.username || null,
+                        server: data.server || null,
+                    };
+                });
+                printOk({ active, profiles: entries });
+                return;
+            }
+            if (!names.length) {
+                console.log(chalk.gray('No profiles configured. Run thinr to set one up.'));
+                return;
+            }
+            for (const name of names) {
+                const data = getProfile(name) || {};
+                const marker = name === active ? chalk.green('* ') : '  ';
+                const detail = chalk.gray(`${data.username || ''}@${data.server || name}`);
+                console.log(`${marker}${chalk.bold(name)}  ${detail}`);
+            }
+        });
+
+    profile
+        .command('current')
+        .description('Print the active profile')
+        .option('-j, --json', 'Output as JSON')
+        .action((opts) => {
+            applyJsonFlag(opts);
+            const name = getActiveProfile();
+            if (isJsonMode()) {
+                printOk({ active: name });
+                return;
+            }
+            if (!name) {
+                console.log(chalk.gray('No active profile.'));
+                return;
+            }
+            console.log(name);
+        });
+
+    profile
+        .command('use <name>')
+        .description('Set the default profile')
+        .option('-j, --json', 'Output as JSON')
+        .action((name, opts) => {
+            applyJsonFlag(opts);
+            try {
+                setDefaultProfile(name);
+            } catch (error) {
+                printErr(error.message, { code: 'not_found' });
+                return;
+            }
+            if (isJsonMode()) {
+                printOk({ active: name });
+                return;
+            }
+            console.log(chalk.green(`Default profile set to ${name}`));
+        });
+
+    profile
+        .command('delete <name>')
+        .description('Remove a profile')
+        .option('-j, --json', 'Output as JSON')
+        .action((name, opts) => {
+            applyJsonFlag(opts);
+            const ok = deleteProfile(name);
+            if (!ok) {
+                printErr(`Profile not found: ${name}`, { code: 'not_found' });
+                return;
+            }
+            if (isJsonMode()) {
+                printOk({ removed: name });
+                return;
+            }
+            console.log(chalk.green(`Removed profile ${name}`));
+        });
+}

package/lib/api.js

@@ -1,10 +1,15 @@
 import axios from 'axios';
-import { refreshToken, getAccessToken } from './auth.js'; // Adjust the import based on your project structure
+import { refreshToken, getAccessToken } from './auth.js';
+import { readConfig } from './config.js';
 import http from 'http';
 import https from 'https';
 
 const httpAgent = new http.Agent({ keepAlive: true });
+// Accept self-signed certificates when talking to local dev servers
+// (localhost / 127.0.0.1). Any other host still enforces full TLS
+// validation. Toggleable via THINR_INSECURE=1 for other local setups.
 const httpsAgent = new https.Agent({ keepAlive: true });
+const insecureAgent = new https.Agent({ keepAlive: true, rejectUnauthorized: false });
 
 const api = axios.create({
     // You can leave baseURL undefined initially
@@ -17,44 +22,62 @@ export function setBaseURL(url) {
     api.defaults.baseURL = url;
 }
 
-api.interceptors.request.use(request => {
+api.interceptors.request.use(
+    (request) => {
+        const token = getAccessToken();
+        if (token) {
+            request.headers['Authorization'] = `Bearer ${token}`;
+        }
 
-    const token = getAccessToken();
-    if (token) {
-        request.headers['Authorization'] = `Bearer ${token}`;
-    }
-    return request;
-}, error => {
-    return Promise.reject(error);
-});
+        // Allow self-signed TLS against localhost / 127.0.0.1 or when the user
+        // opts in explicitly. Anything else keeps default certificate validation.
+        try {
+            const base = request.baseURL || api.defaults.baseURL || '';
+            const url = new URL(request.url || '', base || 'https://placeholder/');
+            const isLocal = url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+            if (url.protocol === 'https:' && (isLocal || process.env.THINR_INSECURE === '1')) {
+                request.httpsAgent = insecureAgent;
+            }
+        } catch {}
+
+        return request;
+    },
+    (error) => {
+        return Promise.reject(error);
+    },
+);
 
 api.interceptors.response.use(
-    response => response,
-    async error => {
+    (response) => response,
+    async (error) => {
         const originalRequest = error.config;
 
-        // Only handle 401 once
-        if (error.response?.status === 401 && !originalRequest._retry) {
-            originalRequest._retry = true;
+        // Only intervene on 401s; everything else surfaces unchanged.
+        if (error.response?.status !== 401) return Promise.reject(error);
 
-            try {
-                const newToken = await refreshToken();
+        // Don't recurse: refresh requests themselves and already-retried
+        // requests must not trigger another refresh.
+        if (originalRequest?._isRefresh || originalRequest?._retry) {
+            return Promise.reject(error);
+        }
 
-                // Set new token on headers
-                api.defaults.headers.common['Authorization'] = `Bearer ${newToken}`;
-                originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+        // Tokens issued via the username/password flow have no
+        // refresh_token. Skip the refresh attempt and let the 401 reach
+        // the caller — they can re-run `thinr` to re-authenticate.
+        if (!readConfig().refresh_token) return Promise.reject(error);
 
-                // return the retried request
-                return api(originalRequest);
-            } catch (refreshError) {
-                // Token refresh failed, reject to trigger outer catch
-                return Promise.reject(refreshError);
-            }
-        }
+        originalRequest._retry = true;
 
-        // Any other errors
-        return Promise.reject(error);
-    }
+        try {
+            const newToken = await refreshToken();
+            // Patch only this request; subsequent requests pick up the new
+            // token from config via the request interceptor.
+            originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+            return api(originalRequest);
+        } catch (refreshError) {
+            return Promise.reject(refreshError);
+        }
+    },
 );
 
-export default api;
+export default api;