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

package/lib/mcp/tools-products.js

@@ -0,0 +1,232 @@
+// @ts-check
+import {
+    getProducts,
+    deleteProductWithStorage,
+    installProductScript,
+    removeProductScript,
+    listProductScripts,
+    readProductScript,
+    getProductApi,
+} from '../product.js';
+import { inputError } from '../errors.js';
+
+async function toolProducts(args) {
+    const user = args.user;
+    const products = await getProducts(user);
+    if (products.length === 0) {
+        return { content: [{ type: 'text', text: 'No products configured' }], isError: false };
+    }
+    const lines = await Promise.all(
+        products.map(async (p) => {
+            const id = p.product;
+            const label = p.name && p.name !== id ? ` (${p.name})` : '';
+            const enabled = p.enabled ? '✓' : '✗';
+            const apis = await getProductApi(id, user);
+            const scripts = Object.keys(apis).length;
+            const scriptsLabel = scripts > 0 ? ` — ${scripts} api-resource(s)` : '';
+            return `${enabled}  ${id}${label}${scriptsLabel}`;
+        }),
+    );
+    return {
+        content: [{ type: 'text', text: `${products.length} product(s):\n${lines.join('\n')}` }],
+        isError: false,
+    };
+}
+
+async function toolProductDelete(args) {
+    if (!args.product) throw inputError('product is required');
+    const { steps } = await deleteProductWithStorage(args.product, args.user, {
+        keepStorage: !!args.keep_storage,
+    });
+    return {
+        content: [
+            { type: 'text', text: `Removed "${args.product}":\n  - ${steps.join('\n  - ')}` },
+        ],
+        isError: false,
+    };
+}
+
+async function toolProductScriptList(args) {
+    if (!args.product) throw inputError('product is required');
+    const entries = await listProductScripts(args.product, args.user);
+    const header =
+        entries.length === 0
+            ? `No scripts in product "${args.product}"`
+            : `${entries.length} script(s) in product "${args.product}":`;
+    const lines = entries.map((e) => {
+        const marker = e.registered ? '[api]' : '[orphan]';
+        return `  ${marker} ${e.name}  (${e.size} bytes) → resource: ${e.stem}`;
+    });
+    return {
+        content: [{ type: 'text', text: [header, ...lines].join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolProductScriptRead(args) {
+    if (!args.product) throw inputError('product is required');
+    if (!args.name) throw inputError('name is required');
+    const body = await readProductScript(args.product, args.name, args.user);
+    return {
+        content: [{ type: 'text', text: body }],
+        isError: false,
+    };
+}
+
+async function toolProductScriptWrite(args) {
+    const { steps, stem } = await installProductScript({
+        product: args.product,
+        name: args.name,
+        content: args.content,
+        user: args.user,
+        icon: args.icon,
+    });
+    const lines = [
+        `Installed product script "${args.name}" on "${args.product}".`,
+        `Steps:`,
+        ...steps.map((s) => `  - ${s}`),
+        `Invoke on any device of this product with thinr_resource_call(device=<id>, resource="${stem}", inputs={input: {...}}).`,
+    ];
+    return {
+        content: [{ type: 'text', text: lines.join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolProductScriptDelete(args) {
+    const { steps } = await removeProductScript({
+        product: args.product,
+        name: args.name,
+        user: args.user,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Removed product script "${args.name}" from "${args.product}":\n  - ${steps.join('\n  - ')}`,
+            },
+        ],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_products',
+        description:
+            'List all products configured on the server, with their device count and whether they have product-level scripts configured. Use this before assigning a device to a product with thinr_device_set_product, or before managing product scripts with thinr_product_script_*.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user: { type: 'string', description: 'API user' },
+            },
+            required: [],
+        },
+        handler: toolProducts,
+    },
+    {
+        name: 'thinr_product_delete',
+        description:
+            'Delete a product and, by default, its file storage with all scripts. Destructive: confirm with the user before calling. Any device currently assigned to the product is left as-is (unassigned from it by the server) — this tool does not touch the user-level monitoring bucket, which is shared across products.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string', description: 'Product ID to delete.' },
+                keep_storage: {
+                    type: 'boolean',
+                    description:
+                        "When true, preserve the product's file storage (scripts + index.js). Default: false (also delete the storage).",
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['product'],
+        },
+        handler: toolProductDelete,
+    },
+    {
+        name: 'thinr_product_script_list',
+        description: `List product-level scripts stored under the product's file storage, cross-referenced with the API resources they expose.
+
+Product scripts are executable files kept in a per-product storage ("<product>") under scripts/. Each script file is exposed as a product API resource (same name without the extension) that can be invoked on any device of the product via thinr_resource_call. Compared to device-level scripts (thinr_script_*), product scripts scale to large fleets because the source of truth lives server-side and is downloaded inline on each invocation — no per-device deployment, no drift.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string', description: 'Product ID.' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['product'],
+        },
+        handler: toolProductScriptList,
+    },
+    {
+        name: 'thinr_product_script_read',
+        description: `Read the current content of a product script from the product storage. Useful to inspect or edit an existing script before rewriting it with thinr_product_script_write.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string', description: 'Product ID.' },
+                name: {
+                    type: 'string',
+                    description:
+                        'Script filename as stored under scripts/ (with extension if any, e.g. "backup.sh").',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['product', 'name'],
+        },
+        handler: toolProductScriptRead,
+    },
+    {
+        name: 'thinr_product_script_write',
+        description: `Install or replace a product-level script. Orchestrates everything transparently: creates the product's storage if missing, writes the generic index.js wrapper on first use, wires profile.code.storage, enables the product, uploads the script under scripts/<name>, and creates/updates the API resource so the script is immediately callable on any device of the product.
+
+Script contract:
+- Any executable source. If the body starts with a shebang (#!/usr/bin/env python3, #!/bin/bash, …) the agent materializes it to a temp file and runs it with the declared interpreter. Without a shebang, the body runs through the shell (pipes, redirects, && all work).
+- The caller's optional "input" object is forwarded to the script on stdin as JSON. Parse with jq / json.load / JSON.parse.
+- Stdout/stderr/exit code are returned in the response.
+
+The file extension (.sh, .py, .js, …) is preserved in the storage for editor highlighting, but the API resource name is the stem without extension. So scripts/backup.sh is callable as the resource "backup".`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string', description: 'Product ID.' },
+                name: {
+                    type: 'string',
+                    description:
+                        'Script filename (e.g. "backup.sh"). The stem ("backup") becomes the API resource name.',
+                },
+                content: {
+                    type: 'string',
+                    description:
+                        'Full script source code. Include a shebang to use a non-shell interpreter.',
+                },
+                icon: {
+                    type: 'string',
+                    description:
+                        'Optional Font Awesome 5 icon class to use when the product is created (only applied on first write). Default: "fab fa-linux". Examples: "fab fa-apple", "fab fa-raspberry-pi", "fas fa-server".',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['product', 'name', 'content'],
+        },
+        handler: toolProductScriptWrite,
+    },
+    {
+        name: 'thinr_product_script_delete',
+        description: `Remove a product script: deletes the file under scripts/ in the product storage and the associated API resource.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product: { type: 'string', description: 'Product ID.' },
+                name: {
+                    type: 'string',
+                    description:
+                        'Script filename as stored under scripts/ (with extension if any).',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['product', 'name'],
+        },
+        handler: toolProductScriptDelete,
+    },
+];

package/lib/mcp/tools-profiles.js

@@ -0,0 +1,30 @@
+// @ts-check
+import { listProfiles, getActiveProfile, getProfile } from '../config.js';
+
+async function toolProfiles() {
+    const names = listProfiles();
+    const active = getActiveProfile();
+    const lines = names.map((n) => {
+        const data = getProfile(n) || {};
+        const marker = n === active ? '* ' : '  ';
+        return `${marker}${n}  (${data.username || ''}@${data.server || n})`;
+    });
+    return {
+        content: [{ type: 'text', text: lines.join('\n') || 'No profiles configured' }],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_profiles',
+        description:
+            'List configured CLI profiles (each profile targets a different ThinRemote server). Use the returned profile name as the optional `profile` parameter on any other tool to target that environment for a single call.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+        handler: toolProfiles,
+    },
+];

package/lib/mcp/tools-properties.js

@@ -0,0 +1,79 @@
+// @ts-check
+import { getDeviceProperties, getDeviceProperty, setDeviceProperty } from '../property.js';
+import { inputError } from '../errors.js';
+
+async function toolPropertyGet(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    if (args.property) {
+        const value = await getDeviceProperty(device, args.property);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+            isError: false,
+        };
+    }
+    const list = await getDeviceProperties(device);
+    const names = Array.isArray(list) ? list.map((p) => p.property).filter(Boolean) : [];
+    return {
+        content: [{ type: 'text', text: names.length ? names.join('\n') : '(no properties)' }],
+        isError: false,
+    };
+}
+
+async function toolPropertySet(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    if (!args.property) throw inputError('property is required');
+    if (args.value === undefined) throw inputError('value is required');
+    const saved = await setDeviceProperty(device, args.property, args.value);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Saved property "${saved.property}" on ${saved.device} (value: ${JSON.stringify(saved.value)})`,
+            },
+        ],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_property_get',
+        description: `Read a device property. Properties are the device's structured state (e.g. configuration, last values, calibration). Call without \`property\` to list the names of every property the device has. Prefer this over thinr_exec when you need config data — it returns the raw typed value without shell parsing.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                property: {
+                    type: 'string',
+                    description:
+                        'Property name. Omit to list the names of all properties on the device.',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolPropertyGet,
+    },
+    {
+        name: 'thinr_property_set',
+        description: `Create or overwrite a device property. The value can be any JSON-serialisable shape (string, number, object, array). Existing properties are replaced wholesale; missing ones are created. Use this instead of thinr_exec when you want to persist structured state on the device record, since properties survive device restarts and are visible from the dashboard.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                property: { type: 'string', description: 'Property name to create or overwrite.' },
+                value: {
+                    description:
+                        'Any JSON-serialisable value (string, number, boolean, object, array).',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['property', 'value', 'device'],
+        },
+        handler: toolPropertySet,
+    },
+];

package/lib/mcp/tools-resources.js

@@ -0,0 +1,76 @@
+// @ts-check
+import { callDeviceResource, listDeviceResourcesWithSchemas } from '../resource.js';
+import { inputError } from '../errors.js';
+
+async function toolResourceList(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    const entries = await listDeviceResourcesWithSchemas(device);
+    const fnLabel = (f) =>
+        ({ 1: 'no params', 2: 'input', 3: 'output', 4: 'input/output' })[f] || 'unknown';
+    const lines = entries.map((e) => {
+        const parts = [`${e.name} [${fnLabel(e.fn)}]`];
+        if (e.in !== undefined) parts.push(`  in:  ${JSON.stringify(e.in)}`);
+        if (e.out !== undefined) parts.push(`  out: ${JSON.stringify(e.out)}`);
+        return parts.join('\n');
+    });
+    return {
+        content: [{ type: 'text', text: lines.length ? lines.join('\n\n') : '(no resources)' }],
+        isError: false,
+    };
+}
+
+async function toolResourceCall(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    if (!args.resource) throw inputError('resource is required');
+    const result = await callDeviceResource(device, args.resource, args.inputs);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: typeof result === 'string' ? result : JSON.stringify(result, null, 2),
+            },
+        ],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_resource_list',
+        description: `List the callable resources exposed by a device, with their input/output schemas when available. Resources are the device's public API — typed endpoints like "cmd" (run a shell command), "monitoring" (live metrics), "update" (upgrade the agent), "system" (OS info), etc. Prefer this before calling thinr_resource_call to discover what a device offers and how to call each resource.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolResourceList,
+    },
+    {
+        name: 'thinr_resource_call',
+        description: `Invoke a resource on a device. Pass \`inputs\` when the resource declares an input schema (e.g. cmd, update); omit for read-only resources like monitoring/system/agent. Returns the resource's output. Use thinr_resource_list first to discover available resources and their expected inputs.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource: {
+                    type: 'string',
+                    description: 'Resource name as returned by thinr_resource_list.',
+                },
+                inputs: {
+                    description:
+                        'JSON object with the input parameters declared by the resource. Omit or pass {} for input-less resources.',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['resource', 'device'],
+        },
+        handler: toolResourceCall,
+    },
+];

package/lib/mcp/tools-scripts.js

@@ -0,0 +1,172 @@
+// @ts-check
+import { callDeviceResource, readDeviceResource } from '../resource.js';
+import { inputError } from '../errors.js';
+import { getAPI } from './helpers.js';
+
+async function toolScriptList(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    const info = await readDeviceResource(device, '$scripts/info');
+    const scripts = Array.isArray(info?.scripts) ? info.scripts : [];
+    const header = `Scripts directory: ${info?.path || '(unknown)'}\n${scripts.length} script(s) registered:`;
+    const entries = scripts.map((s) => {
+        const parts = [`\n- ${s.name}  (${s.path})`];
+        if (s.describe?.input !== undefined)
+            parts.push(`    in:  ${JSON.stringify(s.describe.input)}`);
+        if (s.describe?.output !== undefined)
+            parts.push(`    out: ${JSON.stringify(s.describe.output)}`);
+        return parts.join('\n');
+    });
+    return {
+        content: [{ type: 'text', text: [header, ...entries].join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolScriptWrite(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    if (!args.name) throw inputError('name is required');
+    if (typeof args.content !== 'string') throw inputError('content is required (string)');
+
+    const { api: deviceApi } = getAPI(device, args.user);
+
+    const info = await readDeviceResource(device, '$scripts/info');
+    const baseDir = info?.path;
+    if (!baseDir)
+        throw new Error('Agent did not return a scripts directory (is $scripts/info supported?)');
+
+    if (!/^[A-Za-z0-9._-]+$/.test(args.name)) {
+        throw inputError(
+            `Invalid script name "${args.name}" (allowed: letters, digits, dot, dash, underscore)`,
+        );
+    }
+    const scriptPath = `${baseDir}/${args.name}`;
+
+    await deviceApi.writeFile(scriptPath, args.content, true);
+
+    const chmod = await deviceApi.exec(`chmod +x ${JSON.stringify(scriptPath)}`, 10);
+    if (chmod.retcode !== 0) {
+        throw new Error(`chmod +x failed: ${chmod.stderr || `exit ${chmod.retcode}`}`);
+    }
+
+    const reloaded = await callDeviceResource(device, '$scripts/reload', {});
+    // The agent registers resources by the file's stem, so "battery.sh"
+    // becomes scripts/battery. Match the same way to echo back the schema.
+    const registeredName = args.name.replace(/\.[^./]+$/, '');
+    const found = Array.isArray(reloaded?.scripts)
+        ? reloaded.scripts.find((s) => s.name === registeredName)
+        : null;
+
+    const lines = [`Installed script "${registeredName}" at ${scriptPath}`];
+    if (found?.describe) {
+        lines.push(`Schema: ${JSON.stringify(found.describe)}`);
+    } else {
+        lines.push(
+            'Schema: (no --describe provided; script will accept any input and return raw output)',
+        );
+    }
+    lines.push(`Resource: ${registeredName} — call it with thinr_resource_call.`);
+    return {
+        content: [{ type: 'text', text: lines.join('\n') }],
+        isError: false,
+    };
+}
+
+async function toolScriptDelete(args) {
+    const device = args.device;
+    if (!device)
+        throw inputError('No device specified. Use thinr_devices to list available devices.');
+    if (!args.name) throw inputError('name is required');
+
+    const { api: deviceApi } = getAPI(device, args.user);
+    const info = await readDeviceResource(device, '$scripts/info');
+    const baseDir = info?.path;
+    if (!baseDir)
+        throw new Error('Agent did not return a scripts directory (is $scripts/info supported?)');
+
+    if (!/^[A-Za-z0-9._-]+$/.test(args.name)) {
+        throw inputError(`Invalid script name "${args.name}"`);
+    }
+    const scriptPath = `${baseDir}/${args.name}`;
+
+    await deviceApi.delete(scriptPath, false);
+    const reloaded = await callDeviceResource(device, '$scripts/reload', {});
+    const remaining = Array.isArray(reloaded?.scripts) ? reloaded.scripts.length : 0;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Removed script "${args.name}". ${remaining} script(s) remain registered.`,
+            },
+        ],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_script_list',
+        description: `List the custom scripts registered by the agent's scripts extension, including the on-device scripts directory and each script's --describe schema. Scripts are user-provided executables in <agent_base>/scripts/ that the agent registers as first-class resources under their own names (e.g. a file named \`battery.sh\` becomes the resource \`battery\`). Use this to discover which scripted capabilities the device exposes.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolScriptList,
+    },
+    {
+        name: 'thinr_script_write',
+        description: `Install or replace a custom script on the device and reload the scripts extension so the new resource is immediately callable.
+
+Scripts turn an ad-hoc operation into a reusable, typed, discoverable resource on the device. Prefer this over thinr_exec when you want to formalise a recurring task (read sensors, rotate a log, run a backup, collect a health report) so it becomes a persistent resource with an input/output schema that future tool calls can introspect and invoke via thinr_resource_call. A script named \`battery.sh\` is registered as the resource \`battery\` — collisions with native resources (e.g. \`monitoring\`, \`system\`) overwrite them, so pick a name that doesn't clash.
+
+Script contract:
+- Must be executable code (any interpreter works — add a shebang like \`#!/bin/bash\` or \`#!/usr/bin/env python3\`).
+- When invoked with \`--describe\`, it should print a JSON object with \`input\` and/or \`output\` sample objects on stdout (e.g. \`{"input": {"path": ""}, "output": {"size": 0, "mtime": 0}}\`). These populate the resource's schema.
+- When invoked normally, the full input JSON object is passed on stdin; stdout is parsed as JSON. If stdout is a JSON object, its keys become the output fields; otherwise the value is exposed under \`output\`. Non-zero exit codes surface as errors.
+
+This tool writes the script, makes it executable, and calls the agent's \`$scripts/reload\` so the change takes effect without restarting the agent.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description:
+                        'Script filename. The file extension (e.g. .sh, .py) is stripped to form the resource name, so battery.sh registers as the resource "battery".',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Full script source code, including shebang.',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['name', 'content', 'device'],
+        },
+        handler: toolScriptWrite,
+    },
+    {
+        name: 'thinr_script_delete',
+        description: `Remove a previously installed custom script from the device and reload the scripts extension so the corresponding resource is unregistered. Use this to retire a scripted capability you no longer want the device to expose.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description:
+                        'Name of the script to remove (must match the file basename, without extension).',
+                },
+                device: { type: 'string', description: 'Device ID' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['name', 'device'],
+        },
+        handler: toolScriptDelete,
+    },
+];

package/lib/monitoring.js

@@ -0,0 +1,72 @@
+import api from './api.js';
+import { apiError } from './errors.js';
+import { requireConfig } from './config.js';
+
+function resolveUser(user) {
+    return user || requireConfig().username;
+}
+
+/**
+ * Query the monitoring bucket. When `device` is provided, scopes to
+ * that device's bucket; otherwise queries the user-level bucket
+ * across every device of the account.
+ *
+ * Time range:
+ *   - `minutes`: shortcut for "last N minutes" (sets min_ts to
+ *     `Date.now() - minutes * 60_000`, max_ts to 0).
+ *   - `min_ts` / `max_ts`: explicit unix-millis range when `minutes`
+ *     is not supplied; either may be omitted for an open bound.
+ *
+ * Aggregation: `agg` is the bucket size (e.g. "5m"), `agg_type` the
+ * reducer (e.g. "avg"), and `fields` a comma-separated allowlist to
+ * trim the response down.
+ *
+ * @param {{
+ *   device?: string | null,
+ *   user?: string | null,
+ *   items?: number,
+ *   sort?: string,
+ *   minutes?: number,
+ *   min_ts?: number,
+ *   max_ts?: number,
+ *   agg?: string,
+ *   agg_type?: string,
+ *   fields?: string,
+ * }} [opts]
+ */
+export async function getMonitoringData({
+    device = null,
+    user = null,
+    items = 10,
+    sort = 'desc',
+    minutes,
+    min_ts,
+    max_ts,
+    agg,
+    agg_type,
+    fields,
+} = {}) {
+    const apiUser = resolveUser(user);
+    const params = { items, sort };
+    if (minutes) {
+        params.min_ts = Date.now() - minutes * 60 * 1000;
+        params.max_ts = 0;
+    } else {
+        if (min_ts) params.min_ts = min_ts;
+        if (max_ts !== undefined) params.max_ts = max_ts;
+    }
+    if (agg) params.agg = agg;
+    if (agg_type) params.agg_type = agg_type;
+    if (fields) params.fields = fields;
+
+    const url = device
+        ? `/v3/users/${apiUser}/devices/${device}/buckets/monitoring/data`
+        : `/v2/users/${apiUser}/buckets/monitoring/data`;
+
+    try {
+        const res = await api.get(url, { params });
+        return res.data;
+    } catch (e) {
+        throw apiError(e);
+    }
+}