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

package/lib/property.js

@@ -1,13 +1,8 @@
-import chalk from 'chalk';
 import { requireConfig } from './config.js';
 import api from './api.js';
 import { apiError } from './errors.js';
+import { info, success } from './format.js';
 
-/**
- * Get device properties
- * @param {string} deviceId - Device ID to query
- * @returns {Promise<Object>} Device properties
- */
 export async function getDeviceProperties(deviceId) {
     const config = requireConfig();
 
@@ -21,12 +16,6 @@ export async function getDeviceProperties(deviceId) {
     }
 }
 
-/**
- * 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) {
     const config = requireConfig();
 
@@ -42,16 +31,8 @@ export async function getDeviceProperty(deviceId, propertyId) {
     }
 }
 
-/**
- * Create or update a property value on a device. Uses PUT so the
- * operation is idempotent — missing properties are created, existing
- * ones are overwritten wholesale.
- *
- * @param {string} deviceId
- * @param {string} propertyId
- * @param {*} value  JSON-serialisable value to store.
- * @returns {Promise<Object>} The server's persisted record.
- */
+// PUT so the operation is idempotent — missing properties are created,
+// existing ones are overwritten wholesale.
 export async function setDeviceProperty(deviceId, propertyId, value) {
     const config = requireConfig();
 
@@ -66,14 +47,8 @@ export async function setDeviceProperty(deviceId, propertyId, value) {
     }
 }
 
-/**
- * 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';
+    let formattedProperties = '\nProperties of device ' + info(deviceId) + ':\n';
 
     properties.forEach((property) => {
         formattedProperties += `- ${property.property}\n`;
@@ -82,24 +57,16 @@ export function formatDeviceProperties(deviceId, properties) {
     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) +
+        info(propertyId) +
         ' for device ' +
-        chalk.cyan(deviceId) +
+        info(deviceId) +
         ':\n';
     const flattenedValue = flatten(propertyValue);
     for (const key in flattenedValue) {
-        formattedValue += `${key}: ${chalk.green(flattenedValue[key])}\n`;
+        formattedValue += `${key}: ${success(flattenedValue[key])}\n`;
     }
     return formattedValue;
 }

package/lib/proxy.js

@@ -1,9 +1,10 @@
-import chalk from 'chalk';
 import open, { apps } from 'open';
 import ora from 'ora';
 import { readConfig, requireConfig } from './config.js';
 import api from './api.js';
+import { PROXY_PORTS } from './constants.js';
 import { apiError } from './errors.js';
+import { info, accent, hint, warning, error as errorStyle } from './format.js';
 
 /**
  * Parse target argument into address and port
@@ -135,7 +136,7 @@ export async function handleProxyAction(deviceId, protocol, target, options) {
         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)}`,
+            `HTTP proxy running at ${info(proxy.url)} → ${deviceId} -> ${accent(targetUrl)}`,
         );
         if (options.openBrowser !== false) {
             await openBrowser(proxy.url);
@@ -143,17 +144,17 @@ export async function handleProxyAction(deviceId, protocol, target, options) {
     } else {
         const secureInfo = isSecure ? ' [TLS]' : '';
         spinner.succeed(
-            `${protocol.toUpperCase()} proxy running on ${chalk.blue(proxy.serverHost + ':' + proxy.serverPort)} → ${deviceId} (${address}:${port})${secureInfo}`,
+            `${protocol.toUpperCase()} proxy running on ${info(proxy.serverHost + ':' + proxy.serverPort)} → ${deviceId} (${address}:${port})${secureInfo}`,
         );
     }
 
-    console.log(chalk.gray(`Press Ctrl+C to stop`));
+    console.log(hint(`Press Ctrl+C to stop`));
     process.stdin.resume();
 
     // Resolve when the user hits Ctrl+C — the CLI command then exits cleanly.
     return new Promise((resolve) => {
         process.on('SIGINT', async () => {
-            console.log(chalk.yellow('\nStopping proxy...'));
+            console.log(warning('\nStopping proxy...'));
             if (proxyId) await deleteProxy(proxyId);
             resolve(0);
         });
@@ -166,7 +167,7 @@ export async function handleProxyAction(deviceId, protocol, target, options) {
  * @param {number} max - Maximum port number
  * @returns {number} Random port number
  */
-function getRandomPort(min = 50000, max = 51000) {
+function getRandomPort(min = PROXY_PORTS.MIN, max = PROXY_PORTS.MAX) {
     return Math.floor(Math.random() * (max - min + 1)) + min;
 }
 
@@ -259,7 +260,7 @@ async function deleteProxy(proxyId) {
 
         return true;
     } catch (error) {
-        console.error(chalk.red(`Error deleting proxy: ${error.message}`));
+        console.error(errorStyle(`Error deleting proxy: ${error.message}`));
         return false;
     }
 }
@@ -273,7 +274,7 @@ async function openBrowser(url) {
         await open(url, { app: [{ name: apps.browser }, 'firefox-developer-edition'] });
         return true;
     } catch (error) {
-        console.error(chalk.red(`Error opening browser: ${error.message}`));
+        console.error(errorStyle(`Error opening browser: ${error.message}`));
         return false;
     }
 }

package/lib/resource.js

@@ -1,21 +1,20 @@
-import chalk from 'chalk';
 import { requireConfig } from './config.js';
 import api from './api.js';
 import { apiError } from './errors.js';
+import { info, warning, hint } from './format.js';
 
-/**
- * Get device resource value
- * @param {string} deviceId - Device ID to query
- * @return {Promise<Object>} Resource value
- */
+// Drops internal resources whose keys start with `$`; those belong to
+// the agent's own framework (cmd, fs, scripts…) and shouldn't surface
+// through the user-facing resource list.
 export async function getDeviceResources(deviceId) {
     const config = requireConfig();
 
     try {
+        // `/resources/api` merges firmware resources with API resources
+        // inherited from the product profile, which `/resources` alone omits.
         const response = await api.get(
-            `/v3/users/${config.username}/devices/${deviceId}/resources`,
+            `/v3/users/${config.username}/devices/${deviceId}/resources/api`,
         );
-        // Drop internal resources whose keys start with '$'
         return Object.fromEntries(
             Object.entries(response.data).filter(([key]) => !key.startsWith('$')),
         );
@@ -66,9 +65,6 @@ export async function getDeviceResourceApi(deviceId, resourceId) {
     }
 }
 
-/**
- * Execute a resource on a device
- */
 export async function executeDeviceResource(deviceId, resourceId, inputs) {
     const config = requireConfig();
 
@@ -129,13 +125,13 @@ export async function listDeviceResourcesWithSchemas(deviceId) {
  * other human-facing surface.
  */
 export function formatDeviceResourcesWithSchemas(deviceId, entries) {
-    let out = `\nResources for device ${chalk.cyan(deviceId)}:\n`;
+    let out = `\nResources for device ${info(deviceId)}:\n`;
     if (!entries || entries.length === 0) {
-        return out + chalk.yellow('No resources found for this device.\n');
+        return out + warning('No resources found for this device.\n');
     }
     for (const e of entries) {
         const kind = getResourceType({ fn: e.fn });
-        out += `\n- ${chalk.green(e.name)}  ${chalk.gray('[' + kind + ']')}\n`;
+        out += `\n- ${info(e.name)}  ${hint('[' + kind + ']')}\n`;
         if (e.in !== undefined) out += `    in:  ${JSON.stringify(e.in)}\n`;
         if (e.out !== undefined) out += `    out: ${JSON.stringify(e.out)}\n`;
     }

package/lib/status.js

@@ -1,7 +1,15 @@
-import chalk from 'chalk';
 import { requireConfig } from './config.js';
 import api from './api.js';
 import { apiError } from './errors.js';
+import {
+    formatUptime,
+    colorPct,
+    formatBytes,
+    label,
+    muted,
+    success,
+    error,
+} from './format.js';
 
 /**
  * Get device status
@@ -20,51 +28,84 @@ export async function getDeviceStatus(deviceId) {
 }
 
 /**
- * Format device status data for display
- * @param {string} deviceId - Device ID
- * @param {Object} status - Status data from API
- * @returns {string} Formatted status
+ * Format device status data for display. When a `monitoring` payload
+ * (one sample from the monitoring bucket) is supplied the output
+ * includes a metrics section with CPU / memory / disk / load / uptime;
+ * otherwise the section is omitted.
+ *
+ * @param {string} deviceId
+ * @param {Object} status
+ * @param {Object | null} [monitoring]
+ * @returns {string}
  */
-export function formatDeviceStatus(deviceId, status) {
-    const connectedStatus = status.connected ? chalk.green('● Online') : chalk.red('○ Offline');
+export function formatDeviceStatus(deviceId, status, monitoring = null) {
+    const connectedStatus = status.connected ? success('● Online') : error('○ Offline');
 
-    // Format connected time
     let connectedTime = '';
     if (status.connected && status.connected_ts) {
-        const now = new Date().getTime();
-        const connectedSince = new Date(status.connected_ts).getTime();
-        const diffSeconds = Math.floor((now - connectedSince) / 1000);
-
-        if (diffSeconds < 60) {
-            connectedTime = `for ${diffSeconds} seconds`;
-        } else if (diffSeconds < 3600) {
-            connectedTime = `for ${Math.floor(diffSeconds / 60)} minutes`;
-        } else if (diffSeconds < 86400) {
-            connectedTime = `for ${Math.floor(diffSeconds / 3600)} hours`;
-        } else {
-            connectedTime = `for ${Math.floor(diffSeconds / 86400)} days`;
-        }
+        const diffSeconds = Math.floor(
+            (Date.now() - new Date(status.connected_ts).getTime()) / 1000,
+        );
+        connectedTime = `for ${formatUptime(diffSeconds)}`;
     }
 
-    // Format data transfer
-    const rxMB = status.rx_bytes ? (status.rx_bytes / (1024 * 1024)).toFixed(2) : '0.00';
-    const txMB = status.tx_bytes ? (status.tx_bytes / (1024 * 1024)).toFixed(2) : '0.00';
+    const lines = [''];
+    lines.push(label(`Device: ${deviceId}`));
+    lines.push(`Status: ${connectedStatus} ${connectedTime}`);
+    if (status.ip_address) lines.push(`IP:     ${status.ip_address}`);
 
-    // Build the output
-    let output = `
-${chalk.bold(`Device: ${deviceId}`)}
-Status: ${connectedStatus} ${connectedTime}
-`;
+    if (monitoring) {
+        lines.push('');
+        lines.push(label('Metrics:'));
 
-    if (status.ip_address) {
-        output += `IP Address: ${status.ip_address}\n`;
+        if (monitoring.cpu?.usage != null) {
+            const bits = [];
+            if (monitoring.cpu.cores != null) bits.push(`${monitoring.cpu.cores} cores`);
+            if (monitoring.cpu.temperature != null)
+                bits.push(`${monitoring.cpu.temperature.toFixed(1)}°C`);
+            const detail = bits.length ? muted(` (${bits.join(', ')})`) : '';
+            lines.push(`  CPU:     ${colorPct(monitoring.cpu.usage)}${detail}`);
+        }
+        if (monitoring.memory?.usage != null) {
+            const total = monitoring.memory.total;
+            const avail = monitoring.memory.available;
+            const used = total != null && avail != null ? total - avail : null;
+            const detail =
+                used != null && total != null
+                    ? muted(` (${formatBytes(used)} of ${formatBytes(total)} used)`)
+                    : '';
+            lines.push(`  Memory:  ${colorPct(monitoring.memory.usage)}${detail}`);
+        }
+        if (monitoring.disk?.root?.usage != null) {
+            const root = monitoring.disk.root;
+            const detail =
+                root.available != null && root.total != null
+                    ? muted(
+                          ` (${formatBytes(root.available)} free of ${formatBytes(root.total)})`,
+                      )
+                    : '';
+            lines.push(`  Disk:    ${colorPct(root.usage)}${detail}`);
+        }
+        if (monitoring.load) {
+            const l = monitoring.load;
+            const parts = [l['1m'], l['5m'], l['15m']].map((v) =>
+                v != null ? v.toFixed(2) : '—',
+            );
+            lines.push(`  Load:    ${parts.join(' · ')}`);
+        }
+        if (monitoring.uptime != null) {
+            lines.push(`  Uptime:  ${formatUptime(monitoring.uptime)}`);
+        }
+        if (monitoring.agent?.version) {
+            lines.push(`  Agent:   ${muted(monitoring.agent.version)}`);
+        }
     }
 
-    output += `
-Data Transfer:
-  ↓ Received: ${rxMB} MB
-  ↑ Sent: ${txMB} MB
-`;
+    lines.push('');
+    lines.push(label('Data Transfer:'));
+    lines.push(`  ↓ Received: ${formatBytes(status.rx_bytes || 0)}`);
+    lines.push(`  ↑ Sent:     ${formatBytes(status.tx_bytes || 0)}`);
+    lines.push('');
 
-    return output;
+    return lines.join('\n');
 }