@thinremote/thinr-cli 1.0.0-alpha.1

package/lib/console.js

@@ -0,0 +1,172 @@
+import WebSocket from 'ws';
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import api from './api.js';
+
+/**
+ * Creates a WebSocket connection to a device terminal
+ * @param {string} deviceId - The ID of the device to connect to
+ */
+export async function connectToDeviceConsole(deviceId) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server || !config.username) {
+        console.error(chalk.red('Error: Not configured. Run thinr without parameters to set up.'));
+        process.exit(1);
+    }
+
+    // Create a unique session ID
+    const sessionId = createUUID();
+
+    // Create WebSocket URL
+    const wsUrl = `wss://${config.server}/v3/users/${config.username}/devices/${deviceId}/resources/$terminal/${sessionId}?raw=1`;
+
+    //console.log(chalk.blue(`Connecting to ${deviceId}...`));
+
+    // Create WebSocket connection
+    const ws = new WebSocket(wsUrl, {
+        headers: {
+            'Authorization': `Bearer ${config.token}`
+        }
+    });
+
+    // Flag to track if terminal settings have been restored
+    let terminalRestored = false;
+
+    // Setup raw mode for process.stdin
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    // Function to restore terminal settings
+    const restoreTerminal = () => {
+        if (!terminalRestored) {
+            // Restore terminal settings
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            terminalRestored = true;
+        }
+    };
+
+    // Handle WebSocket connection
+    ws.on('open', () => {
+        //console.log(chalk.green(`Connected to ${deviceId}`));
+
+        // Set initial terminal size
+        updateTerminalSize(config, deviceId, sessionId, process.stdout.columns, process.stdout.rows);
+
+        // Handle window resize
+        process.stdout.on('resize', () => {
+            updateTerminalSize(config, deviceId, sessionId, process.stdout.columns, process.stdout.rows);
+        });
+
+        // Forward stdin to WebSocket
+        process.stdin.on('data', (data) => {
+            // Check for Ctrl+D (EOT character, ASCII 4) to exit gracefully
+            if (data.toString() === '\u0004') {
+                ws.close();
+                return;
+            }
+
+            // Forward any other input (including Ctrl+C) to the remote device
+            ws.send(data);
+        });
+
+        // Forward WebSocket data to stdout
+        ws.on('message', (data) => {
+            // Ensure we're writing Buffer data to avoid encoding issues
+            if (!(data instanceof Buffer)) {
+                data = Buffer.from(data);
+            }
+
+            process.stdout.write(data);
+        });
+    });
+
+    // Handle WebSocket close
+    ws.on('close', () => {
+        console.log(chalk.yellow('\nConnection closed'));
+        restoreTerminal();
+
+        // Small delay before exiting to flush any remaining output
+        setTimeout(() => {
+            process.exit(0);
+        }, 100);
+    });
+
+    // Handle WebSocket errors
+    ws.on('error', (error) => {
+        console.error(chalk.red(`\nWebSocket error: ${error.message}`));
+        restoreTerminal();
+        process.exit(1);
+    });
+
+    // Handle SIGINT (Ctrl+C) at process level
+    process.on('SIGINT', () => {
+        // Try to send Ctrl+C to the remote terminal
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send('\u0003');
+        }
+
+        // Don't exit our process - let the remote terminal handle it
+        return false;
+    });
+
+    // Ensure cleanup on other exit signals
+    process.on('SIGTERM', () => {
+        restoreTerminal();
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.close();
+        }
+    });
+
+    // Handle uncaught exceptions gracefully
+    process.on('uncaughtException', (error) => {
+        console.error(chalk.red(`\nUnexpected error: ${error.message}`));
+        restoreTerminal();
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.close();
+        }
+        process.exit(1);
+    });
+}
+
+/**
+ * Update terminal size on remote device
+ * @param {Object} config - Configuration object
+ * @param {string} deviceId - Device ID
+ * @param {string} sessionId - Session ID
+ * @param {number} cols - Number of columns
+ * @param {number} rows - Number of rows
+ */
+async function updateTerminalSize(config, deviceId, sessionId, cols, rows) {
+    try {
+        const url = `/v3/users/${config.username}/devices/${deviceId}/resources/$terminal/${sessionId}/params`;
+
+        await api.post(
+            url,
+            {
+                size: {
+                    cols: cols,
+                    rows: rows
+                }
+            },
+        );
+    } catch (error) {
+        console.error(chalk.red(`Error updating terminal size: ${error.message}`));
+    }
+}
+
+/**
+ * Generate a UUID
+ * @returns {string} UUID
+ */
+function createUUID() {
+    let dt = new Date().getTime();
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        const r = (dt + Math.random() * 16) % 16 | 0;
+        dt = Math.floor(dt / 16);
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}

package/lib/device.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import api from './api.js';
+
+/**
+ * Get devices belonging to a product
+ * @param {Object} filter - Filters to query devices
+ * @return {Promise<Array>} List of devices
+ */
+export async function getDevices(filter) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server || !config.username) {
+        throw new Error('Not configured. Run thinr without parameters to set up.');
+    }
+
+    let devices = [];
+
+    // Query parameters to string
+    let queryParametersString = "";
+    for (const [key, value] of Object.entries(filter)) {
+        if ( value ) queryParametersString += key+"="+value+"&";
+    }
+
+    try {
+        const count = 50;
+        let url = `/v1/users/${config.username}/devices?count=${count}&${queryParametersString}`;
+
+        let index = 0;
+        let res_length = 0;
+
+        do {
+            // Fetch devices for the product
+            const response = await api.get(
+                `${url}index=${index}`,
+            );
+
+            res_length = response.data.length;
+            index += res_length;
+            devices = devices.concat(response.data);
+
+        } while ( res_length === count );
+
+        return devices;
+
+    } catch (error) {
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            if (error.response.status === 404) {
+                throw new Error(`Product not found: ${productId}`);
+            } else if (error.response.status === 401) {
+                throw new Error('Unauthorized. Your token may have expired. Please reconfigure.');
+            } else {
+                throw new Error(`Server error: ${error.response.status} ${error.response.statusText}`);
+            }
+        } else if (error.request) {
+            // The request was made but no response was received
+            throw new Error('No response from server. Please check your connection.');
+        } else {
+            // Something happened in setting up the request that triggered an Error
+            throw new Error(`Error: ${error.message}`);
+        }
+    }
+
+}
+
+/**
+ * Filter active devices from a list of devices
+ * @param {Array} devices - List of devices to filter
+ * @return {Array} List of active devices
+ */
+export function filterActiveDevices(devices) {
+    return devices.filter(device => device.connection && device.connection.active === true);
+}
+

package/lib/property.js

@@ -0,0 +1,134 @@
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import api from './api.js';
+
+/**
+ * Get device properties
+ * @param {string} deviceId - Device ID to query
+ * @returns {Promise<Object>} Device properties
+ */
+export async function getDeviceProperties(deviceId) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server || !config.username) {
+        throw new Error('Not configured. Run thinr without parameters to set up.');
+    }
+
+    try {
+        // Fetch device properties
+        const response = await api.get(
+            `/v3/users/${config.username}/devices/${deviceId}/properties`,
+        );
+
+        return response.data;
+    } catch (error) {
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            if (error.response.status === 404) {
+                throw new Error(`Device not found: ${deviceId}`);
+            } else if (error.response.status === 401) {
+                throw new Error('Unauthorized. Your token may have expired. Please reconfigure.');
+            } else {
+                throw new Error(`Server error: ${error.response.status} ${error.response.statusText}`);
+            }
+        } else if (error.request) {
+            // The request was made but no response was received
+            throw new Error('No response from server. Please check your connection.');
+        } else {
+            // Something happened in setting up the request that triggered an Error
+            throw new Error(`Error: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Get device property value
+ * @param {string} deviceId - Device ID to query
+ * @param {string} propertyId - Property ID to retrieve
+ * @returns {Promise<Object>} Property value
+ */
+export async function getDeviceProperty(deviceId, propertyId) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server || !config.username) {
+        throw new Error('Not configured. Run thinr without parameters to set up.');
+    }
+
+    try {
+        // Fetch property value
+        const response = await api.get(
+            `/v3/users/${config.username}/devices/${deviceId}/properties/${propertyId}`
+        );
+
+        return response.data.value;
+    } catch (error) {
+        console.log(error);
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            if (error.response.status === 404) {
+                throw new Error(`Property not found: ${propertyId} on device ${deviceId}`);
+            } else if (error.response.status === 401) {
+                throw new Error('Unauthorized. Your token may have expired. Please reconfigure.');
+            } else {
+                throw new Error(`Server error: ${error.response.status} ${error.response.statusText}`);
+            }
+        } else if (error.request) {
+            // The request was made but no response was received
+            throw new Error('No response from server. Please check your connection.');
+        } else {
+            // Something happened in setting up the request that triggered an Error
+            throw new Error(`Error: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Format device properties for display
+ * @param {string} deviceId - Device ID
+ * @param {Object} properties - Properties object from API
+ * @returns {string} Formatted properties
+ */
+export function formatDeviceProperties(deviceId, properties) {
+
+    let formattedProperties = '\nProperties of device ' + chalk.cyan(deviceId) + ':\n';
+
+    properties.forEach(property => {
+        formattedProperties += `- ${property.property}\n`;
+    })
+
+    return formattedProperties;
+}
+
+/**
+ * Format device property value for display
+ * @param {string} deviceId - Device ID
+ * @param {string} propertyId - Property ID
+ * @param {Object} propertyValue - Property value from API
+ * @returns {string} Formatted property value
+ */
+export function formatDeviceProperty(deviceId, propertyId, propertyValue) {
+    // show json with flattened structure
+    let formattedValue = '\nValue of property ' + chalk.cyan(propertyId) + ' for device ' + chalk.cyan(deviceId) + ':\n';
+    const flattenedValue = flatten(propertyValue);
+    for (const key in flattenedValue) {
+        formattedValue += `${key}: ${chalk.green(flattenedValue[key])}\n`;
+    }
+    return formattedValue;
+}
+
+function flatten(obj, prefix = '', res = {}) {
+    for (const key in obj) {
+        const val = obj[key];
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (typeof val === 'object' && val !== null) {
+            flatten(val, path, res);
+        } else {
+            res[path] = val;
+        }
+    }
+    return res;
+}
+
+

package/lib/proxy.js

@@ -0,0 +1,310 @@
+import chalk from 'chalk';
+import open, { apps } from 'open';
+import { configExists, readConfig } from './config.js';
+import api from './api.js';
+
+/**
+ * Parse target argument into address and port
+ * @param {string} target - Target in format 'address:port', 'port', 'address', or 'protocol://hostname_or_ip:port'
+ * @param {number} defaultPort - Default port if not specified
+ * @returns {Object} Parsed address, port, and secure flag
+ */
+function parseTarget(target, defaultPort) {
+    if (!target) {
+        return { address: 'localhost', port: defaultPort, isSecure: false };
+    }
+
+    // Check if target is just a number (port only)
+    if (/^\d+$/.test(target)) {
+        return { address: 'localhost', port: parseInt(target), isSecure: false };
+    }
+
+    let isSecure = false;
+    let cleanTarget = target;
+
+    // Check if target starts with a protocol (full URL format)
+    if (target.startsWith('https://')) {
+        isSecure = true;
+        cleanTarget = target.replace('https://', '');
+    } else if (target.startsWith('http://')) {
+        isSecure = false;
+        cleanTarget = target.replace('http://', '');
+    }
+
+    // Remove any path/query/fragment from the URL (everything after the first slash)
+    const slashIndex = cleanTarget.indexOf('/');
+    if (slashIndex !== -1) {
+        cleanTarget = cleanTarget.substring(0, slashIndex);
+    }
+
+    // Parse the remaining part (hostname_or_ip:port or just hostname_or_ip)
+    let address;
+    let port;
+
+    if (cleanTarget.includes(':')) {
+        // Format: hostname_or_ip:port
+        const lastColonIndex = cleanTarget.lastIndexOf(':');
+        address = cleanTarget.substring(0, lastColonIndex);
+        const portStr = cleanTarget.substring(lastColonIndex + 1);
+
+        // Check if the part after the last colon is actually a port number
+        const parsedPort = parseInt(portStr);
+        if (!isNaN(parsedPort) && parsedPort > 0 && parsedPort <= 65535) {
+            port = parsedPort;
+        } else {
+            // Not a valid port, treat the whole thing as address
+            address = cleanTarget;
+            port = defaultPort;
+        }
+    } else {
+        // Format: just hostname_or_ip
+        address = cleanTarget;
+        port = defaultPort;
+    }
+
+    // If we detected a protocol but no explicit port, use protocol defaults
+    if ((target.startsWith('https://') || target.startsWith('http://')) && port === defaultPort) {
+        if (isSecure && defaultPort !== 443) {
+            port = 443; // Default HTTPS port
+        } else if (!isSecure && defaultPort !== 80) {
+            port = 80; // Default HTTP port
+        }
+    }
+
+    return {
+        address: address || 'localhost',
+        port: port,
+        isSecure
+    };
+}
+
+/**
+ * Create proxy action handler
+ */
+export async function handleProxyAction(deviceId, protocol, target, options) {
+    // Check if configured
+    if (!configExists()) {
+        console.error(chalk.red('Error: Not configured. Run thinr without parameters to set up.'));
+        process.exit(1);
+    }
+
+    // Determine default port based on protocol
+    const defaultPort = protocol === 'http' ? 80 : (protocol === 'tls' ? 443 : 22);
+    const { address, port, isSecure } = parseTarget(target, defaultPort);
+
+    // Determine proxy configuration based on protocol
+    let proxyConfig = {
+        targetAddress: address,
+        targetPort: port,
+        serverPort: options.port ? parseInt(options.port) : null,
+        targetSecure: false,
+        serverSecure: false,
+        web: false
+    };
+
+    switch (protocol) {
+        case 'tcp':
+            // TCP proxy without TLS
+            proxyConfig.serverSecure = false;
+            break;
+        case 'tls':
+            // TLS proxy
+            proxyConfig.targetSecure = true;
+            proxyConfig.serverSecure = true;
+            break;
+        case 'http':
+            // HTTP proxy
+            proxyConfig.web = true;
+            proxyConfig.serverSecure = true; // Default to HTTPS for web interface
+            // Use the isSecure flag from parseTarget
+            proxyConfig.targetSecure = isSecure || port === 443;
+            break;
+    }
+
+    const proxyType = proxyConfig.web ? 'HTTP proxy' : `${protocol.toUpperCase()} proxy`;
+    const spinner = ora(`Creating ${proxyType} to ${deviceId} (${address}:${port})...`).start();
+    let proxyId = null;
+
+    try {
+        // Create proxy
+        const proxy = await createProxy(deviceId, proxyConfig);
+        proxyId = proxy.proxyId;
+
+        if (proxyConfig.web) {
+            // For HTTP proxy, show target as URL format
+            const targetProtocol = isSecure ? 'https' : 'http';
+            const targetUrl = `${targetProtocol}://${address}${port === 80 || port === 443 ? '' : `:${port}`}`;
+
+            spinner.succeed(`HTTP proxy running at ${chalk.blue(proxy.url)} → ${deviceId} -> ${chalk.cyan(targetUrl)}`);
+
+            // Open browser if not disabled
+            if (options.openBrowser !== false) {
+                await openBrowser(proxy.url);
+            }
+        } else {
+            // For TCP/TLS proxy, show address:port format
+            const secureInfo = isSecure ? ' [TLS]' : '';
+            spinner.succeed(`${protocol.toUpperCase()} proxy running on ${chalk.blue(proxy.serverHost + ':' + proxy.serverPort)} → ${deviceId} (${address}:${port})${secureInfo}`);
+        }
+
+        console.log(chalk.gray(`Press Ctrl+C to stop`));
+
+        // Handle process termination
+        process.on('SIGINT', async () => {
+            console.log(chalk.yellow('\nStopping proxy...'));
+            if (proxyId) {
+                await deleteProxy(proxyId);
+            }
+            process.exit(0);
+        });
+
+        // Keep the process running
+        process.stdin.resume();
+
+    } catch (error) {
+        spinner.fail(`Failed to create ${proxyType}`);
+        console.error(chalk.red(`Error: ${error.message}`));
+
+        // Clean up if needed
+        if (proxyId) {
+            await deleteProxy(proxyId);
+        }
+
+        process.exit(1);
+    }
+}
+
+/**
+ * Generate a random port number within a range
+ * @param {number} min - Minimum port number
+ * @param {number} max - Maximum port number
+ * @returns {number} Random port number
+ */
+function getRandomPort(min = 50000, max = 51000) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+/**
+ * Create a proxy to a device
+ * @param {string} deviceId - Device ID
+ * @param {Object} options - Proxy options
+ * @returns {Promise<Object>} Proxy information
+ */
+async function createProxy(deviceId, options) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server || !config.username) {
+        throw new Error('Not configured. Run thinr without parameters to set up.');
+    }
+
+    const protocol = options.web ? 'http_iotmp' : 'tcp_iotmp';
+    const targetAddress = options.targetAddress || 'localhost';
+    const targetPort = options.targetPort || (options.web ? 80 : 22);
+    const serverPort = options.serverPort || getRandomPort();
+    const serverSecure = options.serverSecure || (!!options.web);
+    const targetSecure = options.targetSecure || false;
+
+    // Create a unique proxy ID based on device, protocol and a timestamp
+    const timestamp = new Date().getTime().toString(36);
+    const proxyId = `${protocol}_${deviceId.slice(0,12)}_${timestamp}`;
+
+    try {
+        // Create proxy
+        const response = await api.post(
+            `/v1/proxies`,
+            {
+                enabled: true,
+                config: {
+                    target: {
+                        type: 'address',
+                        user: config.username,
+                        device: deviceId,
+                        address: targetAddress,
+                        port: targetPort,
+                        secure: targetSecure
+                    },
+                    protocol: protocol,
+                    source: {
+                        port: serverPort,
+                        secure: serverSecure
+                    }
+                },
+                proxy: proxyId,
+                name: options.web ? `Web access for ${deviceId}` : `TCP proxy for ${deviceId}`,
+                description: `${options.web ? 'Web interface' : 'TCP proxy'} for ${deviceId}:${targetPort} created by ThingR CLI`
+            },
+            {
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            }
+        );
+
+        // Determine the URL based on protocol and SSL setting
+        const scheme = serverSecure ? 'https' : 'http';
+        const url = options.web ? `${scheme}://${config.server}:${serverPort}` : null;
+
+        return {
+            proxyId: proxyId,
+            url: url,
+            serverPort: serverPort,
+            serverHost: config.server,
+            targetAddress: targetAddress,
+            targetPort: targetPort,
+            protocol: protocol,
+            serverSecure: serverSecure,
+            targetSecure: targetSecure
+        };
+    } catch (error) {
+        if (error.response) {
+            if (error.response.status === 401) {
+                throw new Error('Unauthorized. Your token may have expired. Please reconfigure.');
+            } else {
+                throw new Error(`Server error: ${error.response.status} ${error.response.statusText}`);
+            }
+        } else if (error.request) {
+            throw new Error('No response from server. Please check your connection.');
+        } else {
+            throw new Error(`Error: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Delete a proxy
+ * @param {string} proxyId - Proxy ID to delete
+ */
+async function deleteProxy(proxyId) {
+    // Get configuration
+    const config = readConfig();
+
+    if (!config.token || !config.server) {
+        return; // Silently fail on config issues during cleanup
+    }
+
+    try {
+        await api.delete(
+            `/v1/proxies/${proxyId}`,
+        );
+
+        return true;
+    } catch (error) {
+        console.error(chalk.red(`Error deleting proxy: ${error.message}`));
+        return false;
+    }
+}
+
+/**
+ * Open web browser to the proxy URL
+ * @param {string} url - URL to open
+ */
+async function openBrowser(url) {
+    try {
+        await open(url, {app: [{name: apps.browser}, 'firefox-developer-edition']});
+        return true;
+    } catch (error) {
+        console.error(chalk.red(`Error opening browser: ${error.message}`));
+        return false;
+    }
+}