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

package/bin/thinr.js

@@ -1,23 +1,48 @@
 #!/usr/bin/env node
 
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
 import { Command } from 'commander';
 import chalk from 'chalk';
 import figlet from 'figlet';
 import ora from 'ora';
-import { configExists, readConfig } from '../lib/config.js';
+import { configExists, readConfig, setActiveProfile } from '../lib/config.js';
+import { detectJsonModeFromArgv } from '../lib/output.js';
+
+// Single source of truth for the version: package.json. Avoids the drift
+// between `package.json#version` and a hardcoded string in this file.
+const pkg = JSON.parse(
+    readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf8'),
+);
+
+// Pick up --profile early so subsequent config reads use the right one.
+// Commander parses options later, but the config is touched before that.
+for (let i = 2; i < process.argv.length; i++) {
+    const a = process.argv[i];
+    if (a === '--profile' && process.argv[i + 1]) {
+        setActiveProfile(process.argv[i + 1]);
+        break;
+    }
+    if (a.startsWith('--profile=')) {
+        setActiveProfile(a.slice('--profile='.length));
+        break;
+    }
+}
+
+// Set JSON mode before any command runs so spinners/logs can opt out.
+detectJsonModeFromArgv();
 import { authenticate } from '../lib/auth.js';
-import { deviceCommand } from '../commands/device.js';
+import { deviceCommand } from '../commands/device/index.js';
 import { logoutCommand } from '../commands/logout.js';
-import { productCommand } from "../commands/product.js";
+import { productCommand } from '../commands/product.js';
+import { profileCommand } from '../commands/profile.js';
 import { setBaseURL } from '../lib/api.js';
+import { startMCPServer } from '../lib/mcp/server.js';
 
 // Function to display the banner
 function displayBanner() {
-    console.log(
-        chalk.cyan(
-            figlet.textSync('thinr-cli', { horizontalLayout: 'full' })
-        )
-    );
+    console.log(chalk.cyan(figlet.textSync('thinr-cli', { horizontalLayout: 'full' })));
     console.log(chalk.blue('Thin Remote CLI - Remote management for IoT devices'));
     console.log();
 }
@@ -28,16 +53,31 @@ const program = new Command();
 program
     .name('thinr')
     .description('CLI for ThinRemote - Remote management for IoT devices')
-    .version('1.0.2');
+    .version(pkg.version)
+    .option('-u, --user <username>', 'API user override (admin impersonation)')
+    .option('--profile <name>', 'Configuration profile to use (defaults to the saved default)');
 
 // Register commands
 deviceCommand(program);
 productCommand(program);
+profileCommand(program);
 logoutCommand(program);
 
+program
+    .command('mcp')
+    .description('Start the MCP server (stdio) for AI tool integration')
+    .action(async () => {
+        try {
+            await startMCPServer();
+        } catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+
 // Handle help
 const originalHelp = program.help;
-program.help = function(cb) {
+program.help = function (cb) {
     displayBanner();
     return originalHelp.call(this, cb);
 };
@@ -75,4 +115,4 @@ if (process.argv.length <= 2) {
 } else {
     // Parse arguments - don't show banner for regular commands
     program.parse(process.argv);
-}
+}

package/commands/device/_shared.js

@@ -0,0 +1,48 @@
+// @ts-check
+import chalk from 'chalk';
+import { InvalidArgumentError } from 'commander';
+import { configExists } from '../../lib/config.js';
+import { setJsonMode, classifyError, printErr } from '../../lib/output.js';
+
+export function ensureConfigured() {
+    if (!configExists()) {
+        printErr('Not configured. Run thinr without parameters to set up.', {
+            code: 'not_configured',
+        });
+    }
+}
+
+export function applyJsonFlag(opts) {
+    if (opts.json) setJsonMode(true);
+}
+
+// Walks up to the root program so subcommands can read `--user` regardless
+// of nesting depth.
+export function getGlobalUser(cmd) {
+    let root = cmd;
+    while (root.parent) root = root.parent;
+    return root.opts().user || null;
+}
+
+// Collect repeatable `-i key=value` pairs into a single object. Uses
+// Commander's InvalidArgumentError so a bad value prints a clean
+// "error: option … argument is invalid" line instead of a stack trace.
+export 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) };
+}
+
+// Wrapper for the proxy / console handlers, which return a Promise that
+// resolves with an exit code or rejects with a tagged Error (instead of
+// calling process.exit themselves).
+export const runInteractive = async (fn) => {
+    try {
+        const exitCode = await fn();
+        process.exit(exitCode ?? 0);
+    } catch (error) {
+        const { message, code } = classifyError(error);
+        console.error(chalk.red(`Error [${code}]: ${message}`));
+        process.exit(1);
+    }
+};

package/commands/device/console.js

@@ -0,0 +1,15 @@
+// @ts-check
+import { connectToDeviceConsole } from '../../lib/console.js';
+import { ensureConfigured, runInteractive } from './_shared.js';
+
+export function registerConsoleCommand(device) {
+    device
+        .command('console <deviceId>')
+        .description('Open an interactive terminal on the device')
+        .action((deviceId) =>
+            runInteractive(() => {
+                ensureConfigured();
+                return connectToDeviceConsole(deviceId);
+            }),
+        );
+}

package/commands/device/exec.js

@@ -0,0 +1,76 @@
+// @ts-check
+import chalk from 'chalk';
+import { createDeviceAPI } from '../../lib/device-api.js';
+import { isJsonMode, printOk, printErr, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
+
+export function registerExecCommand(device) {
+    device
+        .command('exec <deviceId> <command...>')
+        .description('Execute a shell command on the device')
+        .option('-j, --json', 'Buffer stdout/stderr and emit a single JSON envelope')
+        .option('--legacy', 'Use the non-streaming one-shot API (older agents)')
+        .action(async (deviceId, commandParts, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            const commandStr = commandParts.join(' ');
+            try {
+                const api = createDeviceAPI(deviceId, { user });
+                if (isJsonMode()) {
+                    let stdout = '';
+                    let stderr = '';
+                    const { exitCode, timedOut, cancelled } = await api.execStream(commandStr, {
+                        onStdout: (s) => {
+                            stdout += s;
+                        },
+                        onStderr: (s) => {
+                            stderr += s;
+                        },
+                    });
+                    if (cancelled) printErr('Interrupted', { code: 'cancelled', exitCode: 130 });
+                    if (timedOut) printErr('Command timed out on the device', { code: 'timeout' });
+                    printOk({ stdout, stderr, exitCode: exitCode ?? null });
+                    process.exit(exitCode ?? 1);
+                }
+                if (opts.legacy) {
+                    const result = await api.exec(commandStr, 120);
+                    if (result.stdout) process.stdout.write(result.stdout);
+                    if (result.stderr) process.stderr.write(result.stderr);
+                    process.exit(result.retcode || 0);
+                }
+                let cancelFn = null;
+                const onSigint = () => cancelFn?.();
+                process.on('SIGINT', onSigint);
+                const { exitCode, timedOut, cancelled } = await api.execStream(commandStr, {
+                    onStdout: (s) => process.stdout.write(s),
+                    onStderr: (s) => process.stderr.write(s),
+                    onCancel: (fn) => {
+                        cancelFn = fn;
+                    },
+                    stdin: process.stdin,
+                });
+                process.off('SIGINT', onSigint);
+                if (timedOut) {
+                    console.error(chalk.red('\nError: command timed out on the device.'));
+                }
+                if (cancelled) {
+                    console.error(chalk.yellow('\n[interrupted]'));
+                    process.exit(130);
+                }
+                process.exit(exitCode ?? 1);
+            } catch (error) {
+                const { message, code } = classifyError(error);
+                if (isJsonMode()) printErr(message, { code });
+                // Human path: prefix `[code]` matches the MCP error format
+                // and the rest of the CLI; the response dump only surfaces
+                // when the failure carries an HTTP body.
+                console.error(chalk.red(`Error [${code}]: ${message}`));
+                if (error.response) {
+                    console.error(chalk.red(`Status: ${error.response.status}`));
+                    console.error(chalk.red(`Body: ${JSON.stringify(error.response.data)}`));
+                }
+                process.exit(1);
+            }
+        });
+}

package/commands/device/index.js

@@ -0,0 +1,31 @@
+// @ts-check
+import { registerListCommand } from './list.js';
+import { registerProxyCommands } from './proxy.js';
+import { registerConsoleCommand } from './console.js';
+import { registerStatusCommand } from './status.js';
+import { registerPropertyCommand } from './property.js';
+import { registerResourceCommand } from './resource.js';
+import { registerExecCommand } from './exec.js';
+import { registerUpdateCommand } from './update.js';
+
+/**
+ * `thinr device <subcommand> [<deviceId>] …` — all device-scoped actions
+ * as proper Commander subcommands. Most subcommands declare `<deviceId>`
+ * as their first positional so help, option parsing and validation are
+ * autogenerated per-action; `list` is the exception (it operates on the
+ * fleet, not a single device).
+ */
+export function deviceCommand(program) {
+    const device = program
+        .command('device')
+        .description('Device commands (subcommand-first: thinr device <action> <deviceId>)');
+
+    registerListCommand(device);
+    registerProxyCommands(device);
+    registerConsoleCommand(device);
+    registerStatusCommand(device);
+    registerPropertyCommand(device);
+    registerResourceCommand(device);
+    registerExecCommand(device);
+    registerUpdateCommand(device);
+}

package/commands/device/list.js

@@ -0,0 +1,43 @@
+// @ts-check
+import chalk from 'chalk';
+import { getDevices } from '../../lib/devices.js';
+import { isJsonMode, printOk, printErr, createSpinner, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
+
+export function registerListCommand(device) {
+    device
+        .command('list [pattern]')
+        .description(
+            'List devices, optionally filtered by name/id pattern (case-insensitive regex)',
+        )
+        .option('-j, --json', 'Output as JSON')
+        .action(async (pattern, opts, cmd) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const user = getGlobalUser(cmd);
+            const filter = pattern ? { name: pattern } : {};
+            const label = pattern
+                ? `Searching devices matching "${pattern}"...`
+                : 'Fetching devices...';
+            const spinner = createSpinner(label).start();
+            try {
+                const devices = await getDevices(filter, user);
+                spinner.succeed(`Found ${devices.length} device(s)`);
+                if (isJsonMode()) {
+                    printOk(devices);
+                } else {
+                    for (const d of devices) {
+                        const online = d.connection?.active
+                            ? chalk.green('online ')
+                            : chalk.gray('offline');
+                        const name = d.name ? chalk.gray(` (${d.name})`) : '';
+                        console.log(`  ${online}  ${chalk.bold(d.device)}${name}`);
+                    }
+                }
+            } catch (error) {
+                spinner.fail('Failed to list devices');
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+}

package/commands/device/property.js

@@ -0,0 +1,50 @@
+// @ts-check
+import {
+    formatDeviceProperty,
+    getDeviceProperty,
+    getDeviceProperties,
+    formatDeviceProperties,
+} from '../../lib/property.js';
+import { isJsonMode, printOk, printErr, createSpinner, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured } from './_shared.js';
+
+export function registerPropertyCommand(device) {
+    device
+        .command('property <deviceId> [propertyId]')
+        .description('List device properties, or read one by ID')
+        .option('-j, --json', 'Output as JSON')
+        .option('-f, --field <field>', 'Extract a sub-field (dot path, e.g. data.value)')
+        .action(async (deviceId, propertyId, opts) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            if (!propertyId) {
+                const spinner = createSpinner(`Getting properties for ${deviceId}...`).start();
+                try {
+                    const result = await getDeviceProperties(deviceId);
+                    spinner.succeed(`Properties for ${deviceId} retrieved successfully`);
+                    if (isJsonMode()) printOk(result);
+                    else console.log(formatDeviceProperties(deviceId, result));
+                } catch (error) {
+                    spinner.fail('Property retrieval failed');
+                    const { message, code } = classifyError(error);
+                    printErr(message, { code });
+                }
+                return;
+            }
+            const spinner = createSpinner(`Retrieving property for ${deviceId}...`).start();
+            try {
+                const property = await getDeviceProperty(deviceId, propertyId);
+                spinner.succeed(`Property ${propertyId} for ${deviceId} found`);
+                const value = opts.field
+                    ? opts.field.split('.').reduce((obj, key) => obj && obj[key], property)
+                    : property;
+                if (isJsonMode()) printOk(value);
+                else if (opts.field) console.log(value);
+                else console.log(formatDeviceProperty(deviceId, propertyId, property));
+            } catch (error) {
+                spinner.fail('Property retrieval failed');
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+}

package/commands/device/proxy.js

@@ -0,0 +1,42 @@
+// @ts-check
+import { handleProxyAction } from '../../lib/proxy.js';
+import { ensureConfigured, runInteractive } from './_shared.js';
+
+export function registerProxyCommands(device) {
+    device
+        .command('tcp <deviceId> [target]')
+        .description('Create a TCP proxy (no TLS). Default target: 22.')
+        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .action((deviceId, target, opts) =>
+            runInteractive(() => {
+                ensureConfigured();
+                return handleProxyAction(deviceId, 'tcp', target, { port: opts.port });
+            }),
+        );
+
+    device
+        .command('tls <deviceId> [target]')
+        .description('Create a TLS proxy. Default target: 443.')
+        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .action((deviceId, target, opts) =>
+            runInteractive(() => {
+                ensureConfigured();
+                return handleProxyAction(deviceId, 'tls', target, { port: opts.port });
+            }),
+        );
+
+    device
+        .command('http <deviceId> [target]')
+        .description('Create an HTTP proxy. Default target: 80.')
+        .option('-p, --port <port>', 'Local port to use (default: random)')
+        .option('--no-open', 'Do not open the browser')
+        .action((deviceId, target, opts) =>
+            runInteractive(() => {
+                ensureConfigured();
+                return handleProxyAction(deviceId, 'http', target, {
+                    port: opts.port,
+                    openBrowser: opts.open,
+                });
+            }),
+        );
+}

package/commands/device/resource.js

@@ -0,0 +1,51 @@
+// @ts-check
+import {
+    callDeviceResource,
+    listDeviceResourcesWithSchemas,
+    formatDeviceResourcesWithSchemas,
+} from '../../lib/resource.js';
+import { isJsonMode, printOk, printErr, createSpinner, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, collectInput, ensureConfigured } from './_shared.js';
+
+export function registerResourceCommand(device) {
+    device
+        .command('resource <deviceId> [resource]')
+        .description('List device resources, or call one by name')
+        .option('-j, --json', 'Output as JSON')
+        .option('-f, --field <field>', 'Extract a sub-field from the result (dot path)')
+        .option('-i, --input <key=value>', 'Resource input (repeatable)', collectInput, {})
+        .action(async (deviceId, resource, opts) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            if (!resource) {
+                const spinner = createSpinner(`Getting resources for ${deviceId}...`).start();
+                try {
+                    const entries = await listDeviceResourcesWithSchemas(deviceId);
+                    spinner.succeed(`Successfully retrieved resources for ${deviceId}`);
+                    if (isJsonMode()) printOk(entries);
+                    else console.log(formatDeviceResourcesWithSchemas(deviceId, entries));
+                } catch (error) {
+                    spinner.fail('Resource retrieval failed');
+                    const { message, code } = classifyError(error);
+                    printErr(message, { code });
+                }
+                return;
+            }
+            const spinner = createSpinner(
+                `Calling resource ${resource} for ${deviceId}...`,
+            ).start();
+            try {
+                const result = await callDeviceResource(deviceId, resource, opts.input);
+                spinner.succeed(`Resource ${resource} returned successfully for ${deviceId}`);
+                const value = opts.field
+                    ? opts.field.split('.').reduce((obj, key) => obj && obj[key], result)
+                    : result;
+                if (isJsonMode()) printOk(value);
+                else console.log(value);
+            } catch (error) {
+                spinner.fail('Resource call failed');
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+}

package/commands/device/status.js

@@ -0,0 +1,26 @@
+// @ts-check
+import { getDeviceStatus, formatDeviceStatus } from '../../lib/status.js';
+import { isJsonMode, printOk, printErr, createSpinner, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured } from './_shared.js';
+
+export function registerStatusCommand(device) {
+    device
+        .command('status <deviceId>')
+        .description('Check device status and stats')
+        .option('-j, --json', 'Output as JSON')
+        .action(async (deviceId, opts) => {
+            applyJsonFlag(opts);
+            ensureConfigured();
+            const spinner = createSpinner(`Checking status of ${deviceId}...`).start();
+            try {
+                const status = await getDeviceStatus(deviceId);
+                spinner.succeed(`Device ${deviceId} found`);
+                if (isJsonMode()) printOk(status);
+                else console.log(formatDeviceStatus(deviceId, status));
+            } catch (error) {
+                spinner.fail('Status check failed');
+                const { message, code } = classifyError(error);
+                printErr(message, { code });
+            }
+        });
+}

package/commands/device/update.js

@@ -0,0 +1,53 @@
+// @ts-check
+import chalk from 'chalk';
+import { createDeviceAPI } from '../../lib/device-api.js';
+import { isJsonMode, printOk, printErr, createSpinner, classifyError } from '../../lib/output.js';
+import { applyJsonFlag, ensureConfigured, getGlobalUser } from './_shared.js';
+
+const runUpdate = async (action, deviceId, opts, cmd) => {
+    applyJsonFlag(opts);
+    ensureConfigured();
+    const user = getGlobalUser(cmd);
+    const channel = opts.channel || 'latest';
+    const label = action === 'check' ? 'Checking for updates' : 'Applying update';
+    const spinner = createSpinner(`${label} on ${deviceId}...`).start();
+    try {
+        const api = createDeviceAPI(deviceId, { user });
+        const timeout = action === 'apply' ? 300000 : 30000;
+        const result = await api.callResource('update', { action, channel }, { timeout });
+        spinner.succeed(`${label} finished`);
+        if (isJsonMode()) {
+            printOk(result);
+        } else if (result && typeof result === 'object') {
+            if (result.current) console.log(`  current: ${chalk.bold(result.current)}`);
+            if (result.latest) console.log(`  latest:  ${chalk.bold(result.latest)}`);
+            if (result.arch) console.log(`  arch:    ${result.arch}`);
+            if (result.status) console.log(`  status:  ${chalk.cyan(result.status)}`);
+            if (result.message) console.log(`  message: ${result.message}`);
+        } else {
+            console.log(result);
+        }
+    } catch (error) {
+        spinner.fail(`${label} failed`);
+        const { message, code } = classifyError(error);
+        printErr(message, { code });
+    }
+};
+
+export function registerUpdateCommand(device) {
+    const update = device.command('update').description('Check for or apply agent updates');
+
+    update
+        .command('check <deviceId>')
+        .description('Check if an agent update is available')
+        .option('-j, --json', 'Output as JSON')
+        .option('--channel <name>', 'Update channel (default: latest)')
+        .action((deviceId, opts, cmd) => runUpdate('check', deviceId, opts, cmd));
+
+    update
+        .command('apply <deviceId>')
+        .description('Apply an agent update')
+        .option('-j, --json', 'Output as JSON')
+        .option('--channel <name>', 'Update channel (default: latest)')
+        .action((deviceId, opts, cmd) => runUpdate('apply', deviceId, opts, cmd));
+}

package/commands/logout.js

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { deleteConfig, configExists } from '../lib/config.js';
-import { deleteToken } from '../lib/auth.js';
 
 /**
  * Register the logout command
@@ -29,13 +28,21 @@ export function logoutCommand(program) {
                     spinner.succeed('Logged out successfully. Configuration removed.');
                 } else {
                     spinner.fail('Failed to remove configuration.');
-                    console.error(chalk.red('Error: Unable to delete configuration file. You may need to remove it manually.'));
-                    console.error(chalk.gray('Configuration is stored in ~/.config/thinr-cli/config.json'));
+                    console.error(
+                        chalk.red(
+                            'Error: Unable to delete configuration file. You may need to remove it manually.',
+                        ),
+                    );
+                    console.error(
+                        chalk.gray('Configuration is stored in ~/.config/thinr-cli/config.json'),
+                    );
                 }
             } catch (error) {
                 spinner.fail('Failed to remove configuration.');
                 console.error(chalk.red(`Error: ${error.message}`));
-                console.error(chalk.gray('Configuration is stored in ~/.config/thinr-cli/config.json'));
+                console.error(
+                    chalk.gray('Configuration is stored in ~/.config/thinr-cli/config.json'),
+                );
             }
         });
-}
+}