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

package/lib/config.js

@@ -3,14 +3,39 @@ import path from 'path';
 import os from 'os';
 
 /**
- * Get the config file path
- * @returns {string} Config file path
+ * Profile-based configuration store.
+ *
+ * On disk the config file looks like:
+ *   {
+ *     "default": "<profile-name>",
+ *     "profiles": {
+ *       "<profile-name>": { server, username, token, refresh_token, ... }
+ *     }
+ *   }
+ *
+ * Profile names default to the server hostname so login against a new
+ * server automatically creates an isolated profile.
+ *
+ * Legacy single-profile files (top-level server/username/token) are
+ * detected on read and migrated to the new layout transparently. The
+ * migration uses the legacy `server` field as the profile name.
+ *
+ * The "active" profile is the one all helpers operate on. It is picked
+ * (in order): explicit override via setActiveProfile(), the THINR_PROFILE
+ * environment variable, the file's `default` field.
  */
-export function getConfigPath() {
+
+let activeProfileOverride = null;
+
+/**
+ * Resolve the on-disk config path, creating the parent directory on
+ * first access. Internal — every consumer goes through readStore /
+ * writeStore so they never have to know the location.
+ */
+function getConfigPath() {
     const homeDir = os.homedir();
     const configDir = path.join(homeDir, '.config', 'thinr-cli');
 
-    // Create config directory if it doesn't exist
     if (!fs.existsSync(configDir)) {
         fs.mkdirSync(configDir, { recursive: true });
     }
@@ -18,71 +43,177 @@ export function getConfigPath() {
     return path.join(configDir, 'config.json');
 }
 
+function emptyStore() {
+    return { default: null, profiles: {} };
+}
+
+function readStore() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) return emptyStore();
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {
+        return emptyStore();
+    }
+
+    // Legacy format: top-level {server, username, token, ...}. Migrate to
+    // a profile keyed by the server hostname.
+    if (raw && typeof raw === 'object' && !raw.profiles && raw.server) {
+        const name = String(raw.server);
+        return { default: name, profiles: { [name]: { ...raw } } };
+    }
+
+    if (!raw || typeof raw !== 'object' || !raw.profiles) return emptyStore();
+    return raw;
+}
+
+function writeStore(store) {
+    const configPath = getConfigPath();
+    fs.writeFileSync(configPath, JSON.stringify(store, null, 2), 'utf8');
+}
+
 /**
- * Check if configuration exists
- * @returns {boolean} True if configuration exists
+ * Override the active profile for the current process. Pass null to fall
+ * back to env var / file default. Used by the CLI entry point when the
+ * user passes --profile.
  */
-export function configExists() {
-    const configPath = getConfigPath();
-    return fs.existsSync(configPath);
+export function setActiveProfile(name) {
+    activeProfileOverride = name || null;
 }
 
 /**
- * Read configuration
- * @returns {Object} Configuration object
+ * Resolve the active profile name, or null if no profile exists.
  */
-export function readConfig() {
-    const configPath = getConfigPath();
+export function getActiveProfile() {
+    if (activeProfileOverride) return activeProfileOverride;
+    if (process.env.THINR_PROFILE) return process.env.THINR_PROFILE;
+    const store = readStore();
+    if (store.default && store.profiles[store.default]) return store.default;
+    // Fall back to the only profile if there's exactly one.
+    const names = Object.keys(store.profiles);
+    return names.length === 1 ? names[0] : null;
+}
+
+/**
+ * List all profile names.
+ */
+export function listProfiles() {
+    return Object.keys(readStore().profiles);
+}
+
+/**
+ * Get a specific profile by name (or undefined if missing).
+ */
+export function getProfile(name) {
+    const store = readStore();
+    return store.profiles[name];
+}
 
-    if (!fs.existsSync(configPath)) {
-        return {};
+/**
+ * Set the persisted default profile.
+ */
+export function setDefaultProfile(name) {
+    const store = readStore();
+    if (!store.profiles[name]) {
+        throw new Error(`Profile not found: ${name}`);
     }
+    store.default = name;
+    writeStore(store);
+}
 
-    try {
-        const configData = fs.readFileSync(configPath, 'utf8');
-        return JSON.parse(configData);
-    } catch (error) {
-        // If there's an error reading the config, return an empty object
-        return {};
+/**
+ * Remove a profile by name. Returns true if removed.
+ */
+export function deleteProfile(name) {
+    const store = readStore();
+    if (!store.profiles[name]) return false;
+    delete store.profiles[name];
+    if (store.default === name) {
+        const remaining = Object.keys(store.profiles);
+        store.default = remaining[0] || null;
     }
+    writeStore(store);
+    return true;
 }
 
 /**
- * Write configuration
- * @param {Object} config - Configuration object
+ * Check if any profile is configured.
  */
-export function writeConfig(config) {
-    const configPath = getConfigPath();
-    const configData = JSON.stringify(config, null, 2);
+export function configExists() {
+    const store = readStore();
+    if (!Object.keys(store.profiles).length) return false;
+    return getActiveProfile() != null;
+}
 
-    fs.writeFileSync(configPath, configData, 'utf8');
+/**
+ * Read the active profile's data.
+ * @returns {Object} Active profile fields (server, username, token, ...) or {}
+ */
+export function readConfig() {
+    const store = readStore();
+    const name = getActiveProfile();
+    if (!name) return {};
+    return store.profiles[name] || {};
 }
 
 /**
- * Merge new configuration properties with existing one
- * @param {Object} newConfig - New configuration properties
+ * Read the active profile and assert that it has the fields every API
+ * call needs (server, username, token). Throws a tagged error so the
+ * MCP and CLI surfaces both classify the failure as `not_configured`
+ * via classifyError. Replaces the same boilerplate that used to live
+ * at the top of every helper in lib/.
+ */
+export function requireConfig() {
+    const config = readConfig();
+    if (!config.token || !config.server || !config.username) {
+        const err = new Error('Not configured. Run thinr without parameters to set up.');
+        err.code = 'not_configured';
+        throw err;
+    }
+    return config;
+}
+
+/**
+ * Write a fresh profile from the supplied data. The profile name is
+ * derived from the supplied `server`, or from the active profile name
+ * if no server is provided. Becomes the default if there isn't one yet.
+ */
+export function writeConfig(config) {
+    const store = readStore();
+    const name = (config && config.server) || getActiveProfile();
+    if (!name) {
+        throw new Error('Cannot write config without a server / profile name');
+    }
+    store.profiles[name] = { ...config };
+    if (!store.default) store.default = name;
+    writeStore(store);
+}
+
+/**
+ * Merge fields into the active profile.
  */
 export function mergeConfig(newConfig) {
-    const existingConfig = readConfig();
-    const mergedConfig = {...existingConfig, ...newConfig};
-    writeConfig(mergedConfig);
+    const store = readStore();
+    const name = getActiveProfile();
+    if (!name) {
+        // No active profile yet: fall back to writeConfig semantics.
+        return writeConfig(newConfig);
+    }
+    store.profiles[name] = { ...store.profiles[name], ...newConfig };
+    writeStore(store);
 }
 
 /**
- * Delete configuration
- * @returns {boolean} True if deleted successfully
+ * Delete the entire config (all profiles).
  */
 export function deleteConfig() {
     const configPath = getConfigPath();
-
-    if (fs.existsSync(configPath)) {
-        try {
-            fs.unlinkSync(configPath);
-            return true;
-        } catch (error) {
-            return false;
-        }
+    if (!fs.existsSync(configPath)) return true;
+    try {
+        fs.unlinkSync(configPath);
+        return true;
+    } catch {
+        return false;
     }
-
-    return true; // Already doesn't exist
-}
+}

package/lib/console.js

@@ -1,134 +1,116 @@
 import WebSocket from 'ws';
 import chalk from 'chalk';
-import { readConfig } from './config.js';
+import { requireConfig } from './config.js';
 import api from './api.js';
 
 /**
- * Creates a WebSocket connection to a device terminal
+ * Creates a WebSocket connection to a device terminal. Returns a
+ * promise that resolves with `0` when the remote side closes
+ * cleanly, and rejects with a tagged Error when the connection
+ * fails (404 → not_found, 401/403 → unauthorized, anything else →
+ * error). The CLI command wrapping this call decides what to do
+ * with the resolved code or the thrown error — the helper itself
+ * never calls process.exit.
+ *
  * @param {string} deviceId - The ID of the device to connect to
+ * @returns {Promise<number>} Exit code (0 on clean close)
  */
 export async function connectToDeviceConsole(deviceId) {
-    // Get configuration
-    const config = readConfig();
+    const config = requireConfig();
 
-    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}`
-        }
+        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);
+    return new Promise((resolve, reject) => {
+        ws.on('open', () => {
+            updateTerminalSize(
+                config,
+                deviceId,
+                sessionId,
+                process.stdout.columns,
+                process.stdout.rows,
+            );
+
+            process.stdout.on('resize', () => {
+                updateTerminalSize(
+                    config,
+                    deviceId,
+                    sessionId,
+                    process.stdout.columns,
+                    process.stdout.rows,
+                );
+            });
+
+            process.stdin.on('data', (data) => {
+                // Ctrl+D (EOT) to exit gracefully
+                if (data.toString() === '\u0004') {
+                    ws.close();
+                    return;
+                }
+                // Forward everything else (including Ctrl+C) to the device
+                ws.send(data);
+            });
+
+            ws.on('message', (data) => {
+                if (!(data instanceof Buffer)) data = Buffer.from(data);
+                process.stdout.write(data);
+            });
         });
 
-        // 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);
+        ws.on('close', () => {
+            console.log(chalk.yellow('\nConnection closed'));
+            restoreTerminal();
+            // Small delay so any final output flushes before the caller exits.
+            setTimeout(() => resolve(0), 100);
         });
 
-        // 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);
+        ws.on('error', (error) => {
+            restoreTerminal();
+            const m = /(\d{3})/.exec(error.message || '');
+            const status = m ? parseInt(m[1], 10) : 0;
+            let msg, code;
+            if (status === 404) {
+                msg = `Device "${deviceId}" not found or offline.`;
+                code = 'not_found';
+            } else if (status === 401 || status === 403) {
+                msg = `Not authorized to access "${deviceId}". Check your token or user.`;
+                code = 'unauthorized';
+            } else {
+                msg = `Connection error: ${error.message}`;
+                code = 'error';
             }
-
-            process.stdout.write(data);
+            const err = new Error(msg);
+            err.code = code;
+            reject(err);
         });
-    });
 
-    // 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();
-        }
-    });
+        // Forward Ctrl+C to the remote terminal instead of killing ourselves.
+        process.on('SIGINT', () => {
+            if (ws.readyState === WebSocket.OPEN) ws.send('\u0003');
+            return false;
+        });
 
-    // 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);
+        // Cleanup on shutdown signals (no exit — the WS close will resolve us).
+        process.on('SIGTERM', () => {
+            restoreTerminal();
+            if (ws.readyState === WebSocket.OPEN) ws.close();
+        });
     });
 }
 
@@ -144,15 +126,12 @@ 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
-                }
+        await api.post(url, {
+            size: {
+                cols: cols,
+                rows: rows,
             },
-        );
+        });
     } catch (error) {
         console.error(chalk.red(`Error updating terminal size: ${error.message}`));
     }
@@ -164,9 +143,9 @@ async function updateTerminalSize(config, deviceId, sessionId, cols, rows) {
  */
 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;
+    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);
+        return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
     });
-}
+}