@thinremote/thinr-cli 1.3.4 → 1.4.0

package/lib/mcp/tools-devices.js

@@ -1,235 +0,0 @@
-// @ts-check
-import { getDevices, getDevice, deleteDevice } from '../devices.js';
-import { setDeviceProduct } from '../product.js';
-import { inputError } from '../errors.js';
-import { BYTES } from '../constants.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);
-
-    // `connection.ts` is when the state last changed, so it reads as
-    // "connected since" for a live device and "offline since" for a dead
-    // one. Showing it saves a trip to the monitoring history to find out
-    // whether something dropped a minute ago or back in July.
-    const since = (d) => {
-        const ts = d.connection?.ts;
-        if (!ts) return '';
-        const when = new Date(ts).toISOString().replace('T', ' ').slice(0, 16);
-        return d.connection?.active ? `  connected since ${when}` : `  offline since ${when}`;
-    };
-
-    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}${since(d)}`;
-    };
-
-    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_id, 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_id, 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 / BYTES.GB).toFixed(1)}GB total)`,
-            );
-        if (mon.disk?.root)
-            parts.push(
-                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (${(mon.disk.root.total / BYTES.GB).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_id;
-    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 };
-}
-
-async function toolDeviceDelete(args) {
-    const device = args.device_id;
-    if (!device) throw inputError('device is required');
-    const removed = await deleteDevice(device, args.user);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: removed ? `Deleted ${device}` : `Device ${device} did not exist`,
-            },
-        ],
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['device_id'],
-        },
-        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_id: { 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_id', 'product'],
-        },
-        handler: toolDeviceSetProduct,
-    },
-    {
-        name: 'thinr_device_delete',
-        description:
-            'Delete a device record from the platform. Destructive and irreversible — drops the device, its server-side metadata, and stored properties. The agent on the host (if still running) will be left orphaned and will not auto-recreate the record. Idempotent: returns success when the device was already absent.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                device_id: { type: 'string', description: 'Device ID to delete.' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['device_id'],
-        },
-        handler: toolDeviceDelete,
-    },
-];

package/lib/mcp/tools-filesystem.js

@@ -1,281 +0,0 @@
-// @ts-check
-import { readFile as readLocalFile, writeFile as writeLocalFile } from 'fs/promises';
-import { resolve as resolvePath, basename } from 'path';
-import { getAPI } from './helpers.js';
-import { inputError } from '../errors.js';
-
-async function toolRead(args) {
-    const { api } = getAPI(args.device_id, 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_id, 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_id, args.user);
-    const requested = args.path || '/';
-    const entries = await api.listDir(requested, args.include_hidden || false);
-
-    // "/" is the agent's base directory, not the filesystem root, while every
-    // other absolute path is literal. Listing "/" on an agent based in
-    // /var/log and reading it as the root is an easy and wrong conclusion to
-    // draw, so say which directory these entries actually came from.
-    let header = '';
-    if (requested === '/') {
-        try {
-            const root = await api.info('/');
-            if (root?.path && root.path !== '/') {
-                header = `listing ${root.path} (the agent's base directory, which "/" resolves to)\n`;
-            }
-        } catch {
-            // Labelling is a convenience; a listing without it still stands.
-        }
-    }
-
-    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: header + (lines.join('\n') || '(empty directory)') }],
-        isError: false,
-    };
-}
-
-async function toolMkdir(args) {
-    const { api } = getAPI(args.device_id, args.user);
-    await api.mkdir(args.path);
-    return {
-        content: [{ type: 'text', text: `Created directory: ${args.path}` }],
-        isError: false,
-    };
-}
-
-async function toolRm(args) {
-    const { api } = getAPI(args.device_id, args.user);
-    await api.delete(args.path, args.recursive !== false);
-    return {
-        content: [{ type: 'text', text: `Deleted: ${args.path}` }],
-        isError: false,
-    };
-}
-
-async function toolMv(args) {
-    const { api } = getAPI(args.device_id, args.user);
-    await api.move(args.source, args.destination, args.overwrite || false);
-    return {
-        content: [{ type: 'text', text: `Moved: ${args.source} → ${args.destination}` }],
-        isError: false,
-    };
-}
-
-async function toolPush(args) {
-    if (typeof args.source !== 'string' || !args.source) {
-        throw inputError('`source` (local file path) is required');
-    }
-    if (typeof args.destination !== 'string' || !args.destination) {
-        throw inputError('`destination` (remote path on the device) is required');
-    }
-    const localPath = resolvePath(args.source);
-    const remotePath = args.destination.endsWith('/')
-        ? args.destination + basename(localPath)
-        : args.destination;
-    const { api } = getAPI(args.device_id, args.user);
-    const content = await readLocalFile(localPath);
-    await api.writeFile(remotePath, content);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Pushed ${content.byteLength} bytes: ${localPath} → ${remotePath}`,
-            },
-        ],
-        isError: false,
-    };
-}
-
-async function toolPull(args) {
-    if (typeof args.source !== 'string' || !args.source) {
-        throw inputError('`source` (remote path on the device) is required');
-    }
-    if (typeof args.destination !== 'string' || !args.destination) {
-        throw inputError('`destination` (local file path) is required');
-    }
-    const localPath = args.destination.endsWith('/')
-        ? resolvePath(args.destination, basename(args.source))
-        : resolvePath(args.destination);
-    const { api } = getAPI(args.device_id, args.user);
-    const buf = await api.readFile(args.source);
-    await writeLocalFile(localPath, buf);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `Pulled ${buf.byteLength} bytes: ${args.source} → ${localPath}`,
-            },
-        ],
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['path', 'device_id'],
-        },
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['path', 'content', 'device_id'],
-        },
-        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"), with one exception: "/" on its own resolves to the agent's base directory (\`fs_base_path\` in thinr_device_info), which for a system install is usually /var/log. The listing says which directory it came from when the two differ. Nothing is confined to that directory — "/etc" reads the real /etc — so do not read a "/" listing as the root filesystem. Subject to the OS user the agent runs as; check whoami (or thinr_device_info) before assuming write access to system paths. Use include_hidden to see dotfiles.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: {
-                    type: 'string',
-                    description:
-                        'Directory path. Absolute and literal, except "/", which means the agent\'s base directory (default: "/").',
-                },
-                include_hidden: {
-                    type: 'boolean',
-                    description: 'Include hidden files (default: false)',
-                },
-                device_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['device_id'],
-        },
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['path', 'device_id'],
-        },
-        handler: toolMkdir,
-    },
-    {
-        name: 'thinr_rm',
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['path', 'device_id'],
-        },
-        handler: toolRm,
-    },
-    {
-        name: 'thinr_mv',
-        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_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['source', 'destination', 'device_id'],
-        },
-        handler: toolMv,
-    },
-    {
-        name: 'thinr_push',
-        description: `Upload a local file to a remote device. \`source\` is a path on the machine running the MCP server; \`destination\` is an absolute path on the device (trailing "/" keeps the source basename). Use this for binary or large payloads that don't fit as inline strings in thinr_write.`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                source: {
-                    type: 'string',
-                    description: 'Local file path (absolute or relative to the MCP server CWD).',
-                },
-                destination: {
-                    type: 'string',
-                    description:
-                        'Absolute path on the device. Trailing "/" keeps the source basename.',
-                },
-                device_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['source', 'destination', 'device_id'],
-        },
-        handler: toolPush,
-    },
-    {
-        name: 'thinr_pull',
-        description: `Download a remote file from a device to the local disk of the machine running the MCP server. \`source\` is an absolute path on the device; \`destination\` is a local file path (trailing "/" keeps the source basename).`,
-        inputSchema: {
-            type: 'object',
-            properties: {
-                source: {
-                    type: 'string',
-                    description: 'Absolute file path on the device.',
-                },
-                destination: {
-                    type: 'string',
-                    description:
-                        'Local file path (absolute or relative to the MCP server CWD). Trailing "/" keeps the source basename.',
-                },
-                device_id: { type: 'string', description: 'Device ID' },
-                user: { type: 'string', description: 'API user' },
-            },
-            required: ['source', 'destination', 'device_id'],
-        },
-        handler: toolPull,
-    },
-];