@thinremote/thinr-cli 1.3.4 → 1.4.0

package/lib/config.js

@@ -1,230 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-
-/**
- * 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.
- */
-
-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');
-
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
-    }
-
-    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');
-}
-
-/**
- * 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 setActiveProfile(name) {
-    activeProfileOverride = name || null;
-}
-
-/**
- * Resolve the active profile name, or null if no profile exists.
- */
-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];
-}
-
-/**
- * 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);
-}
-
-/**
- * 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;
-}
-
-/**
- * Check if any profile is configured.
- */
-export function configExists() {
-    const store = readStore();
-    if (!Object.keys(store.profiles).length) return false;
-    return getActiveProfile() != null;
-}
-
-/**
- * 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] || {};
-}
-
-/**
- * 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/.
- */
-/**
- * The account an API call is addressed to: an explicit one when acting on
- * behalf of another account, the active profile's own otherwise. Single
- * source of truth — every path in lib/paths.js goes through it.
- */
-export function resolveUser(user) {
-    return user || requireConfig().username;
-}
-
-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
- * picked (in order): an explicit override set via setActiveProfile()
- * (used by `profile add` to scope the write to a named profile), the
- * supplied `server`, or the currently active profile name. Becomes the
- * default if there isn't one yet.
- */
-export function writeConfig(config) {
-    const store = readStore();
-    const name = activeProfileOverride || (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 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 the entire config (all profiles).
- */
-export function deleteConfig() {
-    const configPath = getConfigPath();
-    if (!fs.existsSync(configPath)) return true;
-    try {
-        fs.unlinkSync(configPath);
-        return true;
-    } catch {
-        return false;
-    }
-}

package/lib/devices.js

@@ -1,60 +0,0 @@
-import api from './api.js';
-import { apiError } from './errors.js';
-import { v1 } from './paths.js';
-
-export async function getDevices(filter, user = null) {
-    let devices = [];
-
-    let queryParametersString = '';
-    for (const [key, value] of Object.entries(filter)) {
-        if (value) queryParametersString += key + '=' + value + '&';
-    }
-
-    try {
-        const count = 50;
-        const url = `${v1(user)}/devices?count=${count}&${queryParametersString}`;
-        let index = 0;
-        let res_length = 0;
-
-        do {
-            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) {
-        const product = filter && filter.product;
-        const notFound = product ? `Product not found: ${product}` : 'Devices not found';
-        throw apiError(error, { notFound });
-    }
-}
-
-// Server-side metadata (assigned product, description, asset group,
-// connection state…). For device-side data — system_info, monitoring —
-// hit the agent resources directly instead.
-export async function getDevice(deviceId, user = null) {
-    try {
-        const response = await api.get(`${v1(user)}/devices/${deviceId}`);
-        return response.data || {};
-    } catch (error) {
-        throw apiError(error, { notFound: `Device not found: ${deviceId}` });
-    }
-}
-
-// Idempotent: returns true if the device record was removed, false if it
-// was already absent. Other failures (auth, network) propagate as apiError.
-export async function deleteDevice(deviceId, user = null) {
-    try {
-        await api.delete(`${v1(user)}/devices/${deviceId}`);
-        return true;
-    } catch (error) {
-        if (error.response?.status === 404) return false;
-        throw apiError(error);
-    }
-}
-
-export function filterActiveDevices(devices) {
-    return devices.filter((device) => device.connection && device.connection.active === true);
-}

package/lib/errors.js

@@ -1,65 +0,0 @@
-/**
- * Normalize an axios / fetch-style error into a single Error with a stable
- * `.code` and `.status`. Replaces the repeated if-response/if-request
- * blocks in status.js / property.js / resource.js / device.js.
- *
- * Pass `messages.notFound` to override the 404 message with something
- * that names the missing entity (e.g. "Device not found: abc").
- */
-export function apiError(error, messages = {}) {
-    // Errors normalized upstream (the tagged 'unauthorized' from a failed
-    // token refresh, inputError, ...) carry a stable string code and no
-    // axios envelope: pass them through so the code survives.
-    if (
-        error &&
-        typeof error.code === 'string' &&
-        !error.isAxiosError &&
-        !error.response &&
-        !error.request
-    ) {
-        return error;
-    }
-    if (error && error.response) {
-        const status = error.response.status;
-        if (status === 404) {
-            const err = new Error(messages.notFound || 'Not found');
-            err.code = 'not_found';
-            err.status = 404;
-            return err;
-        }
-        if (status === 401 || status === 403) {
-            const err = new Error(
-                messages.unauthorized ||
-                    'Unauthorized. Your token may have expired. Please reconfigure.',
-            );
-            err.code = 'unauthorized';
-            err.status = status;
-            return err;
-        }
-        const err = new Error(`Server error: ${status} ${error.response.statusText || ''}`.trim());
-        err.code = 'server_error';
-        err.status = status;
-        return err;
-    }
-    if (error && error.request) {
-        const err = new Error('No response from server. Please check your connection.');
-        err.code = 'network_error';
-        return err;
-    }
-    const err = new Error(error?.message || String(error));
-    err.code = 'error';
-    return err;
-}
-
-/**
- * Pre-tagged error for invalid / missing user input (CLI option,
- * MCP tool argument, …). Picked up by `classifyError` so it surfaces
- * as `code: 'input_error'` in both the CLI JSON envelope and the
- * MCP error metadata, matching the same code the CLI's `printErr`
- * uses for argument validation failures.
- */
-export function inputError(message) {
-    const err = new Error(message);
-    err.code = 'input_error';
-    return err;
-}

package/lib/format.js

@@ -1,114 +0,0 @@
-// @ts-check
-import chalk from 'chalk';
-
-// ─────────────────────────────────────────────────────────────────────
-// Theme — semantic wrappers over chalk so every CLI surface speaks
-// the same visual language. New colours / a `--no-color` switch / a
-// dark-on-light adjustment only have to be touched here.
-// ─────────────────────────────────────────────────────────────────────
-
-/** Title / header text. */
-export const label = (s) => chalk.bold(s);
-/** Secondary / disabled / "—" text. */
-export const muted = (s) => chalk.dim(s);
-/** Hints, trailing metadata, footers, timestamps. */
-export const hint = (s) => chalk.gray(s);
-/** Positive states (online, ok, success). */
-export const success = (s) => chalk.green(s);
-/** Negative states (offline, failed, errored). */
-export const error = (s) => chalk.red(s);
-/** Caution states (timeout, at-risk thresholds). */
-export const warning = (s) => chalk.yellow(s);
-/** Decorative accents (separators, prompts). */
-export const accent = (s) => chalk.cyan(s);
-/** Neutral-but-noteworthy identifiers (device ids, resource names). */
-export const info = (s) => chalk.blue(s);
-
-/**
- * Format a duration in seconds as a human-readable string: `309d16h`,
- * `42d15h`, `17m`, `42s`, etc. Returns `—` for invalid/missing values.
- *
- * @param {number | null | undefined} seconds
- * @returns {string}
- */
-export function formatUptime(seconds) {
-    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
-    const d = Math.floor(seconds / 86400);
-    const h = Math.floor((seconds % 86400) / 3600);
-    const m = Math.floor((seconds % 3600) / 60);
-    if (d > 0) return `${d}d${h}h`;
-    if (h > 0) return `${h}h${m}m`;
-    if (m > 0) return `${m}m`;
-    return `${Math.floor(seconds)}s`;
-}
-
-/**
- * Format seconds elapsed as a "time ago" label: `5s ago`, `3m ago`,
- * `2h ago`, `4d ago`. Returns `—` for invalid/missing values.
- *
- * @param {number | null | undefined} seconds
- * @returns {string}
- */
-export function formatAgo(seconds) {
-    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
-    if (seconds < 60) return `${Math.floor(seconds)}s ago`;
-    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
-    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
-    return `${Math.floor(seconds / 86400)}d ago`;
-}
-
-/**
- * Render a percentage value coloured by threshold: green below 70 %,
- * yellow below 90 %, red at or above 90 %. Returns a dim `—` when the
- * value is missing. Formatted with no decimal places so columns in
- * cli-table3 stay aligned.
- *
- * @param {number | null | undefined} v
- * @returns {string}
- */
-export function colorPct(v) {
-    if (v == null || !Number.isFinite(v)) return muted('—');
-    const s = `${v.toFixed(0)}%`;
-    if (v >= 90) return error(s);
-    if (v >= 70) return warning(s);
-    return success(s);
-}
-
-/**
- * Format a duration in seconds as a short ETA label: `12s`, `3m15s`,
- * `2h30m`. Returns `—` for non-finite / missing values.
- *
- * @param {number | null | undefined} seconds
- * @returns {string}
- */
-export function formatETA(seconds) {
-    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
-    if (seconds < 60) return `${Math.max(1, Math.ceil(seconds))}s`;
-    if (seconds < 3600) {
-        const m = Math.floor(seconds / 60);
-        const s = Math.ceil(seconds % 60);
-        return s > 0 ? `${m}m${s}s` : `${m}m`;
-    }
-    const h = Math.floor(seconds / 3600);
-    const m = Math.ceil((seconds % 3600) / 60);
-    return m > 0 ? `${h}h${m}m` : `${h}h`;
-}
-
-/**
- * Format a byte count as a human-readable string picking the largest
- * unit where the value is ≥ 1. `2 bytes`, `12.3 KB`, `145 MB`,
- * `2.4 GB`. Returns `—` for invalid/missing values.
- *
- * @param {number | null | undefined} bytes
- * @returns {string}
- */
-export function formatBytes(bytes) {
-    if (bytes == null || !Number.isFinite(bytes) || bytes < 0) return '—';
-    if (bytes < 1024) return `${bytes} B`;
-    const kb = bytes / 1024;
-    if (kb < 1024) return `${kb.toFixed(1)} KB`;
-    const mb = kb / 1024;
-    if (mb < 1024) return `${mb.toFixed(mb >= 100 ? 0 : 1)} MB`;
-    const gb = mb / 1024;
-    return `${gb.toFixed(gb >= 100 ? 0 : 2)} GB`;
-}

package/lib/mcp/server.js

@@ -1,67 +0,0 @@
-// @ts-check
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { readConfig } from '../config.js';
-import { setBaseURL } from '../api.js';
-import { classifyError } from '../output.js';
-import { tools } from './registry.js';
-import { withProfile } from './helpers.js';
-
-/**
- * Start a generic MCP server for ThinRemote.
- * All tools accept device (when relevant) plus optional user/profile parameters.
- *
- * @param {{ version?: string }} [opts] `version` is echoed back in the
- *   MCP `initialize` response's `serverInfo.version`. Caller is expected
- *   to pass the CLI's `package.json#version` so the two never drift.
- */
-export async function startMCPServer({ version = 'unknown' } = {}) {
-    const config = readConfig();
-    if (config.server) {
-        setBaseURL(`https://${config.server}`);
-    }
-
-    const server = new Server(
-        {
-            name: 'thinr',
-            version,
-        },
-        {
-            capabilities: { tools: {} },
-        },
-    );
-
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: tools.map(({ handler: _handler, ...t }) => t),
-    }));
-
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const name = request.params.name;
-        const args = request.params.arguments || {};
-        const tool = tools.find((t) => t.name === name);
-        if (!tool) {
-            return {
-                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
-                isError: true,
-            };
-        }
-        try {
-            return await withProfile(args.profile, () => tool.handler(args));
-        } catch (error) {
-            // Surface the same {message, code} pair the CLI emits in JSON
-            // mode so MCP clients can pattern-match on `[code]` instead of
-            // doing fuzzy matches on the human message.
-            const { message, code } = classifyError(error);
-            return {
-                content: [{ type: 'text', text: `Error [${code}]: ${message}` }],
-                isError: true,
-                _meta: { code, message },
-            };
-        }
-    });
-
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('[thinr-mcp] Server started');
-}