@thinremote/thinr-cli 1.0.0-alpha.1

package/.github/workflows/publish.yml

@@ -0,0 +1,79 @@
+name: "publish"
+
+on:
+  push:
+    branches: [ master, develop ]
+
+jobs:
+  publish:
+    name: publish
+    runs-on: ubuntu-latest
+
+    steps:
+
+      - name: Extract branch name
+        shell: bash
+        run: echo "branch=${GITHUB_REF#refs/heads/}" >> $GITHUB_ENV
+
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: ${{ env.branch }}
+
+      - name: node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+
+      - name: Get tag version
+        run: |
+          echo "tag_version=`awk '/^## \[[0-9]+/' CHANGELOG.md | awk 'NR==1 && -F"\[\]" {print $2}' 2>/dev/null | tail -c +2 | head -c -2`" >> $GITHUB_ENV
+
+      - name: Check if tag is for develop and if it already exists
+        run: |
+          git fetch --prune --tags
+          if [ ${{ env.branch }} == 'develop' ]; then
+              for i in {1..100}; do
+                  if [ `git tag --list | grep ${{ env.tag_version }}"-alpha.${i}" | wc -l` -eq 0 ]; then
+                      tag_version=${{ env.tag_version }}"-alpha.${i}"
+                      echo "tag_version=${tag_version}" >> $GITHUB_ENV
+                      echo "npm_tag_version=develop" >> $GITHUB_ENV
+                      break;
+                  fi
+              done
+          elif [ ${{ env.branch }} == 'master' ]; then
+              echo "npm_tag_version=latest" >> $GITHUB_ENV
+          elif [ `git tag --list | grep -q ${{ env.tag_version }}` -ne 0 ]; then exit 1; fi
+
+      - name: update version
+        run: |
+          npm version --no-git-tag-version ${{ env.tag_version }}
+
+      - name: publish
+        run: npm publish --tag ${{ env.npm_tag_version }} --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
+
+      - name: Get changelog body
+        run: |
+          awk '/^## \[[0-9]+/,EOF' CHANGELOG.md | awk '(NR>1)' | awk '1;/^## \[[0-9]+/{exit}' | sed '$d' > release_body.md
+
+      - name: Set pre-release boolean
+        run: |
+          prerelease=false
+          if [ ${{ env.branch }} == 'develop' ]; then
+              prerelease=true
+          fi
+          echo "prerelease=$prerelease" >> $GITHUB_ENV
+
+      - name: Create GitHub release
+        uses: ncipollo/release-action@v1
+        with:
+          prerelease: ${{ env.prerelease }}
+          commit: ${{ env.branch }}
+          tag: ${{ env.tag_version }}
+          name: ${{ env.tag_version }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+          bodyFile: "release_body.md"

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## [1.0.0] - 2025-06-20
+
+### Added
+
+- Initial release of ThinR CLI, a command-line interface for managing remote devices
+- OAuth device flow authentication
+- Device and product management commands
+- Remote terminal access
+- Proxy creation
+- Device status checks
+- Property listing and retrieval
+- Device resource listing and execution
+
+[1.0.0]: https://github.com/Thin-Remote/thinr-cli/tag/1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+
+MIT License
+
+Copyright (c) 2025 Thinger.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,206 @@
+# ThingR - ThingRemote CLI
+
+A modern command-line interface for managing remote devices through the ThingRemote platform.
+
+![ThingR CLI](https://raw.githubusercontent.com/Thin-Remote/thinr/main/assets/thinr-cli.png)
+
+## Features
+
+- **Remote Terminal**: Connect to a device's terminal and interact with it directly
+- **TCP/Web Proxy**: Create proxies to remote devices, either for TCP connections or web interfaces
+- **Device Status**: Check connection status and statistics for a device
+- **Secure Authentication**: Support for both username/password and token-based authentication
+- **Modern UI**: Clean and intuitive command-line interface
+
+## Installation
+
+### From NPM (recommended)
+
+```bash
+npm install -g thinr-cli
+```
+
+### From Source
+
+```bash
+git clone https://github.com/Thin-Remote/thinr-cli.git
+cd thinr-cli
+npm install
+npm link
+```
+
+## Usage
+
+### Initial Setup
+
+Run the CLI without any parameters to set up:
+
+```bash
+thinr
+```
+
+You'll be prompted to authenticate either with username/password or with an existing token.
+
+### Available Commands
+
+#### Device
+
+##### Console
+
+Connect to a device's terminal:
+
+```bash
+thinr device <deviceId> console
+```
+
+##### Proxy
+
+Create a TCP or HTTP proxy to a remote device:
+
+```bash
+thinr device <deviceId> tcp <target> [options]
+thinr device <deviceId> tls <target> [options]
+thinr device <deviceId> http <taget> [options]
+```
+
+The target being the remote port on the device (defaults: tcp: 22, http: 80, tls: 443).
+
+Options:
+- `-w, --web`: Create an HTTP proxy for web interface instead of TCP
+- `--no-secure`: Do not use SSL for the target connection
+- `--no-open`: Do not open browser automatically (web mode only)
+
+Examples:
+```bash
+# Create a TCP proxy to SSH
+thinr proxy RevPi20679
+
+# Create a web interface proxy
+thinr proxy RevPi20679 --web
+
+# Create a proxy to a specific port with SSL
+thinr proxy RevPi20679 --remote-port 8080 --ssl
+
+# Create a proxy to a specific address
+thinr proxy RevPi20679 --remote-address 192.168.1.100
+```
+
+##### Status
+
+Check the connection status of a device:
+
+```bash
+thinr status <deviceId> [options]
+```
+
+Options:
+- `-j, --json`: Output the status in JSON format
+
+##### Property
+
+Retrieve the properties of a device:
+
+```bash
+thinr device <deviceId> property [options]
+```
+
+Retrieve a property from a device:
+
+```bash
+thinr device <deviceId> property <propertyId> [options]
+```
+
+Options:
+- `-j, --json`: Output the status in JSON format
+- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
+
+##### Resource
+
+Get the avaiable resources of a device:
+
+```bash
+thinr device <deviceId> resource [options]
+```
+
+Options:
+- `-j, --json`: Output the status in JSON format
+
+Execute a resource on a device:
+
+```bash
+thinr device <deviceId> resource <resourceId> [options]
+```
+
+Options:
+- `-i, --input`: Input for the resource (e.g., -i param1=value1 -i param2=value2)
+- `-j, --json`: Output the status in JSON format
+- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
+
+##### Product
+
+Iterate over all devices of a specific product in order to retrieve a property or execute a resource:
+
+```bash
+thinr product <productId> property [options]
+thinr product <productId> resource [options]
+```
+
+Options:
+- `-j, --json`: Output the status in JSON format
+- `-f, --field`: Field to extract from the property or resource (e.g., -f data.value)
+
+Options for executing a resource:
+- `-i, --input`: Input for the resource (e.g., -i param1=value1 -i param2=value2)
+
+
+### Help
+
+Get help for any command:
+
+```bash
+thinr --help
+thinr device --help
+thinr logout --help
+```
+
+## Development
+
+The project structure is organized as follows:
+
+```
+thinr/
+├── bin/           # Main executable
+├── lib/           # Core functionality
+├── commands/      # Command implementations
+├── package.json
+└── README.md
+```
+
+### Building
+
+```bash
+npm install
+npm link
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+## License
+
+<a href="http://opensource.org/">
+  <img style="float: right;" width="100px" height="137px" src="/assets/OSI_Standard_Logo_0.svg">
+</a>
+
+The plugin is licensed under the [MIT License](http://opensource.org/licenses/MIT):
+
+Copyright &copy; [Thinger.io](http://thinger.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/bin/thinr.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import ora from 'ora';
+import { configExists } from '../lib/config.js';
+import { authenticate } from '../lib/auth.js';
+import { deviceCommand } from '../commands/device.js';
+import { logoutCommand } from '../commands/logout.js';
+import { productCommand } from "../commands/product.js";
+import { setBaseURL } from '../lib/api.js';
+
+// Function to display the banner
+function displayBanner() {
+    console.log(
+        chalk.cyan(
+            figlet.textSync('thinr-cli', { horizontalLayout: 'full' })
+        )
+    );
+    console.log(chalk.blue('Thin Remote CLI - Remote management for IoT devices'));
+    console.log();
+}
+
+const program = new Command();
+
+// Set up CLI information
+program
+    .name('thinr')
+    .description('CLI for ThinRemote - Remote management for IoT devices')
+    .version('1.0.0');
+
+// Register commands
+deviceCommand(program);
+productCommand(program);
+logoutCommand(program);
+
+// Handle help
+const originalHelp = program.help;
+program.help = function(cb) {
+    displayBanner();
+    return originalHelp.call(this, cb);
+};
+
+// initialize API base URL
+if (configExists()) {
+    const config = readConfig();
+    if (config.server) {
+        // Initialize API with the server if configured
+        setBaseURL(`https://${config.server}`);
+    }
+}
+
+// Handle no command (just "thinr")
+if (process.argv.length <= 2) {
+    const spinner = ora('Checking configuration...').start();
+
+    try {
+        if (!configExists()) {
+            // Display banner only if configuration doesn't exist
+            displayBanner();
+            spinner.succeed('No configuration found. Starting setup...');
+            await authenticate();
+            program.help();
+        } else {
+            spinner.succeed('Configuration found');
+            // Show help if already configured, but don't display banner twice
+            program.help();
+        }
+    } catch (error) {
+        spinner.fail(`Configuration error: ${error.message}`);
+        process.exit(1);
+    }
+    spinner.succeed('Configuration found');
+} else {
+    // Parse arguments - don't show banner for regular commands
+    program.parse(process.argv);
+}

package/commands/device.js

@@ -0,0 +1,272 @@
+import { handleProxyAction } from '../lib/proxy.js';
+import { connectToDeviceConsole } from '../lib/console.js';
+import { getDeviceStatus, formatDeviceStatus } from '../lib/status.js';
+import { formatDeviceProperty, getDeviceProperty, getDeviceProperties, formatDeviceProperties } from '../lib/property.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { configExists } from '../lib/config.js';
+import { getDeviceResources, executeDeviceResource, formatDeviceResources } from "../lib/resource.js";
+
+
+/**
+ * Register the device command with all device-related subcommands
+ * @param {Command} program - Commander program instance
+ */
+export function deviceCommand(program) {
+
+    const device = program.command('device').description('Device commands');
+
+    device
+        .argument('<deviceId>', 'ID of the device to manage')
+        .description('Manage device connections and proxies')
+        .allowUnknownOption(true)
+        .allowExcessArguments(true)
+        .action(async (deviceId, options, command) => {
+            // Get additional arguments manually
+            const args = command.args.slice(1); // Skip deviceId
+            const action = args[0];
+            const target = args[1] && !args[1].startsWith('-') ? args[1] : null; // Check if target is provided, skip if it's an option
+
+            // Check if configured
+            if (!configExists()) {
+                console.error(chalk.red('Error: Not configured. Run thinr without parameters to set up.'));
+                process.exit(1);
+            }
+
+            // If no action provided, show help
+            if (!action) {
+                printHelp(deviceId);
+                return;
+            }
+
+            // Parse options manually from process.argv
+            const parsedOptions = {
+                port: null,
+                json: false,
+                openBrowser: true,
+                targetSecure: true,
+                inputs: {},
+                field: "",
+            };
+
+            const argv = process.argv;
+            for (let i = 0; i < argv.length; i++) {
+                if (argv[i] === '-p' || argv[i] === '--port') {
+                    parsedOptions.port = argv[i + 1];
+                    i++; // Skip the value
+                } else if (argv[i] === '-j' || argv[i] === '--json') {
+                    parsedOptions.json = true;
+                } else if (argv[i] === '--no-open') {
+                    parsedOptions.open = false;
+                } 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] === '--no-secure') {
+                    parsedOptions.targetSecure = false;
+                } else if (argv[i] === '-h' || argv[i] === '--help') {
+                    printHelp(deviceId);
+                    return;
+                }
+            }
+
+            switch (action.toLowerCase()) {
+                case 'tcp':
+                    await handleProxyAction(deviceId, 'tcp', target, parsedOptions);
+                    break;
+                
+                case 'tls':
+                    await handleProxyAction(deviceId, 'tls', target, parsedOptions);
+                    break;
+                
+                case 'http':
+                    await handleProxyAction(deviceId, 'http', target, parsedOptions);
+                    break;
+                
+                case 'console':
+                    try {
+                        await connectToDeviceConsole(deviceId);
+                    } catch (error) {
+                        console.error(chalk.red(`Error: ${error.message}`));
+                        process.exit(1);
+                    }
+                    break;
+                
+                case 'status': {
+                    const spinner = ora(`Checking status of ${deviceId}...`).start();
+                    try {
+                        const status = await getDeviceStatus(deviceId);
+                        spinner.succeed(`Device ${deviceId} found`);
+
+                        if (parsedOptions.json) {
+                            console.log(JSON.stringify(status, null, 2));
+                        } else {
+                            console.log(formatDeviceStatus(deviceId, status));
+                        }
+                    } catch (error) {
+                        spinner.fail(`Status check failed`);
+                        console.error(chalk.red(`Error: ${error.message}`));
+                        process.exit(1);
+                    }
+                    break;
+                }
+
+                case 'property': {
+
+                    if ( !target ) {
+                        const spinner = ora(`Getting properties for ${deviceId}...`).start();
+                        try {
+                            const result = await getDeviceProperties(deviceId);
+                            spinner.succeed(`Properties for ${deviceId} retrieved successfully`);
+                            if (parsedOptions.json) {
+                                console.log(result);
+                            } else {
+                                console.log(chalk.green(`Resource result for device ${deviceId}:`));
+                                console.log(formatDeviceProperties(deviceId, result));
+                            }
+                        } catch (error) {
+                            spinner.fail(`Property retrieval failed`);
+                            console.error(chalk.red(`Error: ${error.message}`));
+                            process.exit(1);
+                        }
+                    } else {
+                        const spinner = ora(`Retrieving property for ${deviceId}...`).start();
+                        try {
+                            const property = await getDeviceProperty(deviceId, target);
+                            spinner.succeed(`Property ${target} for ${deviceId} found`);
+
+                            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(deviceId, target, property));
+                            }
+                        } catch (error) {
+                            spinner.fail(`Property retrieval failed`);
+                            console.error(chalk.red(`Error: ${error.message}`));
+                            process.exit(1);
+                        }
+
+                    }
+
+                    break;
+                }
+
+                case 'resource': {
+
+                    if (!target) {
+                        const spinner = ora(`Getting resources for ${deviceId}...`).start();
+                        try {
+
+                            const result = await getDeviceResources(deviceId);
+                            spinner.succeed(`Succesfully retrieved resources for ${deviceId}`);
+
+                            if (parsedOptions.json) {
+                                console.log(result);
+                            } else {
+                                //console.log(chalk.green(`Resource ${target} result for device ${deviceId}:`));
+                                console.log(chalk.green(`Resource result for device ${deviceId}:`));
+                                console.log(formatDeviceResources(deviceId, result));
+                            }
+                        } catch (error) {
+                            spinner.fail(`Resource retrieval failed`);
+                            console.error(chalk.red(`Error: ${error.message}`));
+                            process.exit(1);
+                        }
+
+                    } else {
+                        const spinner = ora(`Executing resource ${target} for ${deviceId}...`).start();
+                        try {
+
+                            const result = await executeDeviceResource(deviceId, target, parsedOptions.inputs);
+                            spinner.succeed(`Resource ${target} executed successfully for ${deviceId}`);
+
+                            if ( parsedOptions.field ) {
+                                console.log(parsedOptions.field.split('.').reduce((obj, key) => obj && obj[key], result));
+                            } else {
+                                console.log(result);
+                            }
+
+                        } catch (error) {
+                            spinner.fail(`Resource execution failed`);
+                            console.error(chalk.red(`Error: ${error.message}`));
+                            process.exit(1);
+                        }
+                    }
+
+                    break;
+                }
+
+                default:
+                    console.error(chalk.red(`Error: Unknown action '${action}'. Available actions: tcp, tls, http, console, status, property, resource.\n`));
+                    printHelp(deviceId);
+                    process.exit(1);
+            }
+        });
+
+}
+function printHelp(deviceId) {
+    console.log(`Usage: thinr device ${deviceId} <command> [options]
+
+Available commands for device "${deviceId}":
+
+  tcp [target]                  Create a TCP proxy (no TLS)
+                                Example: thinr device ${deviceId} tcp 22
+  
+  tls [target]                  Create a TLS proxy  
+                                Example: thinr device ${deviceId} tls 443
+  
+  http [target]                 Create an HTTP proxy
+                                Example: thinr device ${deviceId} http 8080
+  
+  console                       Open terminal console
+                                Example: thinr device ${deviceId} console
+  
+  status                        Check device status
+                                Example: thinr device ${deviceId} status
+                            
+  property                      Get device properties
+                                Example: thinr device ${deviceId} property
+                     
+  property [propertyId]         Get a specific property of the device
+                                Example: thinr device ${deviceId} property uptime
+                            
+  resource                      Get resources of the device
+                                Example: thinr device ${deviceId} resource
+                            
+  resource [resource]           Execute a specific resource of the device
+                                Example: thinr device ${deviceId} resource reboot
+
+Arguments:
+
+  target                        Target for proxy commands (address:port, port, or address)
+                                Defaults: tcp=22, tls=443, http=80
+                     
+  propertyId                    ID of the property to retrieve (for property command)
+  
+  resource                      Name of the resource to execute (for resource command)
+
+Options (for proxy commands):
+  -p, --port <port>  Local port to use (default: random)
+  --no-secure        Do not use SSL/TLS for the target
+  --no-open          Do not open browser (http only)
+
+Options (for status command):
+  -j, --json         Output as JSON
+  
+Options (for property command):
+  -j, --json         Output as JSON
+  -f, --field <field>          Field to extract from the property (e.g., -f data.value)
+    
+Options (for resource command):
+  -i, --input <input>=<value>  Input for the resource (e.g., -i param1=value1 -i param2=value2)
+  -j, --json         Output as JSON
+  -f, --field <field>          Field to extract from the property (e.g., -f data.value)
+
+Use "thinr device ${deviceId} <command> --help" for more details on each command.`);
+
+}