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

package/lib/mcp/tools-devices.js

@@ -0,0 +1,194 @@
+// @ts-check
+import { getDevices, getDevice } from '../devices.js';
+import { setDeviceProduct } from '../product.js';
+import { inputError } from '../errors.js';
+import { getAPI } from './helpers.js';
+
+async function toolDevices(args) {
+    const query = args.query ? String(args.query).trim() : '';
+    const filter = query ? { name: query } : {};
+    const devices = await getDevices(filter, args.user);
+
+    const renderLine = (d) => {
+        const status = d.connection?.active ? 'online ' : 'offline';
+        const label = d.name ? ` (${d.name})` : '';
+        const product = d.type && d.type !== 'Generic' ? ` [${d.type}]` : '';
+        return `${status}  ${d.device}${label}${product}`;
+    };
+
+    if (!query) {
+        return {
+            content: [
+                { type: 'text', text: devices.map(renderLine).join('\n') || 'No devices found' },
+            ],
+            isError: false,
+        };
+    }
+
+    const limit = Number.isFinite(args.limit) && args.limit > 0 ? Math.floor(args.limit) : 20;
+    const limited = devices.slice(0, limit);
+    const header =
+        devices.length === 0
+            ? `No devices match "${query}"`
+            : `${devices.length} match(es) for "${query}"${devices.length > limit ? ` — showing first ${limit}` : ''}:`;
+    return {
+        content: [{ type: 'text', text: [header, ...limited.map(renderLine)].join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolDeviceInfo(args) {
+    const { api: deviceApi } = getAPI(args.device, args.user);
+    const parts = [];
+
+    // Server-side record first — surfaces the assigned product,
+    // asset group, description, etc. that the device's own agent
+    // can't see. Best effort: don't fail the whole tool if the
+    // record can't be read.
+    try {
+        const record = await getDevice(args.device, args.user);
+        const meta = [];
+        if (record.device) meta.push(`device:        ${record.device}`);
+        if (record.name) meta.push(`name:          ${record.name}`);
+        if (record.product) meta.push(`product:       ${record.product}`);
+        if (record.asset_group) meta.push(`asset_group:   ${record.asset_group}`);
+        if (record.description) meta.push(`description:   ${record.description}`);
+        if (record.connection) {
+            const c = record.connection;
+            meta.push(
+                `connection:    ${c.active ? 'online' : 'offline'}${c.ip_address ? ` from ${c.ip_address}` : ''}`,
+            );
+        }
+        if (meta.length) {
+            parts.push('--- Server record ---');
+            parts.push(...meta);
+            parts.push('');
+        }
+    } catch {}
+
+    try {
+        const sysInfo = await deviceApi.getResource('system_info');
+        parts.push('--- System info ---');
+        parts.push(JSON.stringify(sysInfo, null, 2));
+    } catch {
+        const info = await deviceApi.exec(
+            'echo "hostname=$(hostname);os=$(uname -s);arch=$(uname -m);kernel=$(uname -r);user=$(whoami);home=$HOME;uptime=$(uptime -p 2>/dev/null || uptime)"',
+            10,
+        );
+        parts.push(info.stdout || '');
+    }
+
+    try {
+        const mon = await deviceApi.getResource('monitoring');
+        parts.push('\n--- Real-time monitoring ---');
+        if (mon.cpu)
+            parts.push(
+                `CPU: ${mon.cpu.usage?.toFixed(1)}% (${mon.cpu.cores} cores, ${mon.cpu.temperature?.toFixed(1)}°C)`,
+            );
+        if (mon.memory)
+            parts.push(
+                `Memory: ${mon.memory.usage?.toFixed(1)}% (${(mon.memory.total / 1073741824).toFixed(1)}GB total)`,
+            );
+        if (mon.disk?.root)
+            parts.push(
+                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (${(mon.disk.root.total / 1073741824).toFixed(0)}GB total)`,
+            );
+        if (mon.network)
+            parts.push(
+                `Network: rx=${(mon.network.rx_rate / 1024).toFixed(1)}KB/s tx=${(mon.network.tx_rate / 1024).toFixed(1)}KB/s`,
+            );
+        if (mon.load)
+            parts.push(
+                `Load: ${mon.load['1m']?.toFixed(2)} / ${mon.load['5m']?.toFixed(2)} / ${mon.load['15m']?.toFixed(2)}`,
+            );
+        if (mon.uptime)
+            parts.push(
+                `Uptime: ${Math.floor(mon.uptime / 86400)}d ${Math.floor((mon.uptime % 86400) / 3600)}h`,
+            );
+    } catch {}
+
+    try {
+        const rootInfo = await deviceApi.info('/');
+        parts.push(`\nfs_base_path=${rootInfo.path || '/'}`);
+    } catch {}
+
+    return {
+        content: [{ type: 'text', text: parts.join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolDeviceSetProduct(args) {
+    const device = args.device;
+    if (!device) throw inputError('device is required');
+    if (args.product === undefined || args.product === null)
+        throw inputError('product is required (pass "" to unassign)');
+    await setDeviceProduct(device, args.product, args.user);
+    const label =
+        args.product === ''
+            ? `Unassigned ${device} from its product.`
+            : `Assigned ${device} → product "${args.product}".`;
+    return { content: [{ type: 'text', text: label }], isError: false };
+}
+
+export const tools = [
+    {
+        name: 'thinr_devices',
+        description:
+            'List remote devices with their online/offline status. Pass `query` to filter by device id or name (case-insensitive regex on the server side, so plain substrings, anchors, wildcards and alternations all work). Use this before any other device tool to discover or narrow down ids.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description:
+                        'Optional pattern matched against device id and name. Plain substrings work ("office"); regex metacharacters are also honoured ("^raspberry", "mac|book"). Case-insensitive.',
+                },
+                limit: {
+                    type: 'number',
+                    description:
+                        'Maximum matches to return when `query` is set (default: 20). Ignored when listing without a query.',
+                },
+                user: {
+                    type: 'string',
+                    description:
+                        'API user (for admin impersonation). Omit to use your own account.',
+                },
+            },
+            required: [],
+        },
+        handler: toolDevices,
+    },
+    {
+        name: 'thinr_device_info',
+        description:
+            'Get device information: hostname, OS, architecture, filesystem base path, and system resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolDeviceInfo,
+    },
+    {
+        name: 'thinr_device_set_product',
+        description:
+            "Assign a device to a product, or unassign it by passing an empty string. Devices inherit the product's API resources and profile configuration (scripts, buckets, etc.) once assigned. Typical flow: create product scripts with thinr_product_script_write, then set a device's product here so it can invoke those scripts.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID' },
+                product: {
+                    type: 'string',
+                    description: 'Product ID to assign, or empty string "" to unassign.',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device', 'product'],
+        },
+        handler: toolDeviceSetProduct,
+    },
+];

package/lib/mcp/tools-exec.js

@@ -0,0 +1,213 @@
+// @ts-check
+import { getMonitoringData } from '../monitoring.js';
+import { inputError } from '../errors.js';
+import { getAPI } from './helpers.js';
+
+async function toolExec(args) {
+    const { api } = getAPI(args.device, args.user);
+    // Default to 30s so a hung command doesn't lock the session
+    // indefinitely. Callers can pass a larger value for known-long
+    // operations (compiles, backups, …).
+    const timeout = Number.isFinite(args.timeout) && args.timeout > 0 ? args.timeout : 30;
+    let output = '';
+    const { exitCode, timedOut } = await api.execStream(args.command, {
+        timeout,
+        onStdout: (s) => {
+            output += s;
+        },
+        onStderr: (s) => {
+            output += s;
+        },
+    });
+    const trailer = [];
+    if (timedOut) trailer.push(`[command timed out after ${timeout}s]`);
+    trailer.push(`[exit code: ${exitCode ?? 'unknown'}]`);
+    const text = [output.trimEnd(), trailer.join(' ')].filter(Boolean).join('\n');
+    return {
+        content: [{ type: 'text', text: text || '(no output)' }],
+        isError: timedOut || exitCode !== 0,
+    };
+}
+
+async function toolUpdate(args) {
+    const { api: deviceApi } = getAPI(args.device, args.user);
+    const payload = {
+        action: args.action,
+        channel: args.channel || 'latest',
+    };
+    const result = await deviceApi.callResource('update', payload);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        isError: false,
+    };
+}
+
+async function toolMonitoring(args) {
+    const device = args.device;
+    const user = args.user;
+
+    // Real-time: read the device's `monitoring` resource directly.
+    if (args.realtime) {
+        if (!device) throw inputError('Device required for real-time monitoring');
+        const { api: deviceApi } = getAPI(device, args.user);
+        const mon = await deviceApi.getResource('monitoring');
+        const parts = [`Real-time monitoring for ${device}:`];
+        if (mon.cpu)
+            parts.push(
+                `CPU: ${mon.cpu.usage?.toFixed(1)}% (${mon.cpu.cores} cores, ${mon.cpu.temperature?.toFixed(1)}°C)`,
+            );
+        if (mon.memory)
+            parts.push(
+                `Memory: ${mon.memory.usage?.toFixed(1)}% (available: ${(mon.memory.available / 1073741824).toFixed(1)}GB / total: ${(mon.memory.total / 1073741824).toFixed(1)}GB)`,
+            );
+        if (mon.disk?.root)
+            parts.push(
+                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (available: ${(mon.disk.root.available / 1073741824).toFixed(1)}GB / total: ${(mon.disk.root.total / 1073741824).toFixed(0)}GB)`,
+            );
+        if (mon.network)
+            parts.push(
+                `Network: rx=${(mon.network.rx_rate / 1024).toFixed(1)}KB/s tx=${(mon.network.tx_rate / 1024).toFixed(1)}KB/s`,
+            );
+        if (mon.load)
+            parts.push(
+                `Load: ${mon.load['1m']?.toFixed(2)} / ${mon.load['5m']?.toFixed(2)} / ${mon.load['15m']?.toFixed(2)}`,
+            );
+        if (mon.processes) parts.push(`Processes: ${mon.processes.total}`);
+        if (mon.uptime)
+            parts.push(
+                `Uptime: ${Math.floor(mon.uptime / 86400)}d ${Math.floor((mon.uptime % 86400) / 3600)}h ${Math.floor((mon.uptime % 3600) / 60)}m`,
+            );
+        if (mon.agent) parts.push(`Agent: ${mon.agent.version}`);
+        return { content: [{ type: 'text', text: parts.join('\n') }], isError: false };
+    }
+
+    // Historical: query the monitoring bucket.
+    const data = await getMonitoringData({
+        device,
+        user,
+        items: args.items || 10,
+        sort: args.sort || 'desc',
+        minutes: args.minutes,
+        min_ts: args.min_ts,
+        max_ts: args.max_ts,
+        agg: args.agg,
+        agg_type: args.agg_type,
+        fields: args.fields,
+    });
+
+    let output;
+    if (Array.isArray(data) && data.length > 0) {
+        output = data
+            .map((d) => {
+                const ts = new Date(d.ts).toISOString();
+                const parts = [ts];
+                if (d.device) parts.push(`device=${d.device}`);
+                if (d.cpu) {
+                    const cpuParts = [];
+                    if (d.cpu.usage !== undefined) cpuParts.push(`${d.cpu.usage.toFixed(1)}%`);
+                    if (d.cpu.temperature !== undefined)
+                        cpuParts.push(`${d.cpu.temperature.toFixed(1)}°C`);
+                    if (cpuParts.length) parts.push(`cpu=${cpuParts.join(' ')}`);
+                }
+                if (d.memory) parts.push(`mem=${d.memory.usage?.toFixed(1)}%`);
+                if (d.disk?.root) parts.push(`disk=${d.disk.root.usage?.toFixed(1)}%`);
+                if (d.network)
+                    parts.push(
+                        `net_rx=${(d.network.rx_rate / 1024)?.toFixed(1)}KB/s tx=${(d.network.tx_rate / 1024)?.toFixed(1)}KB/s`,
+                    );
+                if (d.load) parts.push(`load=${d.load['1m']?.toFixed(2)}`);
+                if (d.processes) parts.push(`procs=${d.processes.total}`);
+                return parts.join(' | ');
+            })
+            .join('\n');
+    } else {
+        output = JSON.stringify(data, null, 2);
+    }
+
+    return {
+        content: [{ type: 'text', text: output || 'No data' }],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_exec',
+        description: `Execute a shell command on a remote device. Returns stdout, stderr, and exit code.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                device: { type: 'string', description: 'Device ID (from thinr_devices)' },
+                timeout: { type: 'number', description: 'Timeout in seconds (default: 30)' },
+                user: { type: 'string', description: 'API user (for admin impersonation)' },
+            },
+            required: ['command', 'device'],
+        },
+        handler: toolExec,
+    },
+    {
+        name: 'thinr_update',
+        description: `Check for agent updates or apply an update on a remote device.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID' },
+                action: {
+                    type: 'string',
+                    description: '"check" to check for updates, "apply" to install the update',
+                },
+                channel: { type: 'string', description: 'Update channel (default: "latest")' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['action', 'device'],
+        },
+        handler: toolUpdate,
+    },
+    {
+        name: 'thinr_monitoring',
+        description: `Get monitoring data (CPU, memory, disk, network, temperature, load) from a device or all devices. Use realtime=true for live data from the device, or omit for historical data from the monitoring bucket.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                realtime: {
+                    type: 'boolean',
+                    description:
+                        'If true, get live data directly from the device. If false/omitted, query historical data from the monitoring bucket.',
+                },
+                device: {
+                    type: 'string',
+                    description:
+                        'Device ID. Required for realtime. Omit for historical data from ALL devices.',
+                },
+                items: {
+                    type: 'number',
+                    description: 'Number of data points to return (default: 10)',
+                },
+                minutes: {
+                    type: 'number',
+                    description: 'Get data from the last N minutes. Alternative to min_ts/max_ts.',
+                },
+                min_ts: { type: 'number', description: 'Minimum timestamp in milliseconds' },
+                max_ts: {
+                    type: 'number',
+                    description: 'Maximum timestamp in milliseconds (0 = now)',
+                },
+                sort: {
+                    type: 'string',
+                    description: 'Sort order: "asc" or "desc" (default: "desc")',
+                },
+                agg: { type: 'string', description: 'Aggregation period: "5m", "10m", "1h", "6h"' },
+                agg_type: { type: 'string', description: 'Aggregation type: "mean", "min", "max"' },
+                fields: {
+                    type: 'string',
+                    description:
+                        'Comma-separated fields to return (e.g., "cpu.usage,memory.usage,disk.root.usage")',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: [],
+        },
+        handler: toolMonitoring,
+    },
+];

package/lib/mcp/tools-filesystem.js

@@ -0,0 +1,163 @@
+// @ts-check
+import { getAPI } from './helpers.js';
+
+async function toolRead(args) {
+    const { api } = getAPI(args.device, args.user);
+    const content = await api.readFile(args.path);
+    return {
+        content: [{ type: 'text', text: content.toString('utf8') }],
+        isError: false,
+    };
+}
+
+async function toolWrite(args) {
+    const { api } = getAPI(args.device, args.user);
+    await api.writeFile(args.path, Buffer.from(args.content, 'utf8'));
+    return {
+        content: [{ type: 'text', text: `Written ${args.content.length} bytes to ${args.path}` }],
+        isError: false,
+    };
+}
+
+async function toolLs(args) {
+    const { api } = getAPI(args.device, args.user);
+    const entries = await api.listDir(args.path || '/', args.include_hidden || false);
+    const lines = entries.map((e) => {
+        const type = e.type === 'directory' ? 'd' : '-';
+        const mode = e.mode || 'rwxr-xr-x';
+        const size = (e.size || 0).toString().padStart(8);
+        return `${type}${mode} ${size} ${e.name}`;
+    });
+    return {
+        content: [{ type: 'text', text: lines.join('\n') || '(empty directory)' }],
+        isError: false,
+    };
+}
+
+async function toolMkdir(args) {
+    const { api } = getAPI(args.device, args.user);
+    await api.mkdir(args.path);
+    return {
+        content: [{ type: 'text', text: `Created directory: ${args.path}` }],
+        isError: false,
+    };
+}
+
+async function toolDelete(args) {
+    const { api } = getAPI(args.device, args.user);
+    await api.delete(args.path, args.recursive !== false);
+    return {
+        content: [{ type: 'text', text: `Deleted: ${args.path}` }],
+        isError: false,
+    };
+}
+
+async function toolMove(args) {
+    const { api } = getAPI(args.device, args.user);
+    await api.move(args.source, args.destination, args.overwrite || false);
+    return {
+        content: [{ type: 'text', text: `Moved: ${args.source} → ${args.destination}` }],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_read',
+        description: `Read a file from a remote device. Paths are absolute on the device filesystem (e.g., "/etc/hosts", "/var/log/syslog"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path on the device' },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['path', 'device'],
+        },
+        handler: toolRead,
+    },
+    {
+        name: 'thinr_write',
+        description: `Write content to a file on a remote device. Paths are absolute on the device filesystem (e.g., "/etc/hosts", "/var/log/syslog"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path on the device' },
+                content: { type: 'string', description: 'File content to write' },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['path', 'content', 'device'],
+        },
+        handler: toolWrite,
+    },
+    {
+        name: 'thinr_ls',
+        description: `List directory contents on a remote device. Paths are absolute on the device filesystem (e.g., "/", "/etc", "/var/log"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc. Use include_hidden to see dotfiles.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path (default: /)' },
+                include_hidden: {
+                    type: 'boolean',
+                    description: 'Include hidden files (default: false)',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolLs,
+    },
+    {
+        name: 'thinr_mkdir',
+        description: `Create a directory on a remote device. Paths are absolute on the device filesystem (e.g., "/etc/hosts", "/var/log/syslog"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path to create' },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['path', 'device'],
+        },
+        handler: toolMkdir,
+    },
+    {
+        name: 'thinr_delete',
+        description: `Delete a file or directory on a remote device. Paths are absolute on the device filesystem (e.g., "/etc/hosts", "/var/log/syslog"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to delete' },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Delete directory contents recursively (default: true)',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['path', 'device'],
+        },
+        handler: toolDelete,
+    },
+    {
+        name: 'thinr_move',
+        description: `Move or rename a file or directory on a remote device. Paths are absolute on the device filesystem (e.g., "/etc/hosts", "/var/log/syslog"). Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths like /etc.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string', description: 'Source path' },
+                destination: { type: 'string', description: 'Destination path' },
+                overwrite: {
+                    type: 'boolean',
+                    description: 'Overwrite destination if exists (default: false)',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['source', 'destination', 'device'],
+        },
+        handler: toolMove,
+    },
+];