@thinremote/thinr-cli 1.3.4 → 1.4.0

package/lib/property.js

@@ -1,75 +0,0 @@
-import { resolveUser } from './config.js';
-import { device } from './paths.js';
-import api from './api.js';
-import { apiError } from './errors.js';
-import { info, success } from './format.js';
-
-export async function getDeviceProperties(deviceId, user) {
-    try {
-        const response = await api.get(`${device(user, deviceId)}/properties`);
-        return response.data;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Device not found: ${deviceId} (account ${resolveUser(user)})`,
-        });
-    }
-}
-
-export async function getDeviceProperty(deviceId, propertyId, user) {
-    try {
-        const response = await api.get(`${device(user, deviceId)}/properties/${propertyId}`);
-        return response.data.value;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Property not found: ${propertyId} on device ${deviceId}`,
-        });
-    }
-}
-
-// PUT so the operation is idempotent — missing properties are created,
-// existing ones are overwritten wholesale.
-export async function setDeviceProperty(deviceId, propertyId, value, user) {
-    try {
-        const response = await api.put(`${device(user, deviceId)}/properties/${propertyId}`, {
-            value,
-        });
-        return response.data;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Device not found: ${deviceId} (account ${resolveUser(user)})`,
-        });
-    }
-}
-
-export function formatDeviceProperties(deviceId, properties) {
-    let formattedProperties = '\nProperties of device ' + info(deviceId) + ':\n';
-
-    properties.forEach((property) => {
-        formattedProperties += `- ${property.property}\n`;
-    });
-
-    return formattedProperties;
-}
-
-export function formatDeviceProperty(deviceId, propertyId, propertyValue) {
-    let formattedValue =
-        '\nValue of property ' + info(propertyId) + ' for device ' + info(deviceId) + ':\n';
-    const flattenedValue = flatten(propertyValue);
-    for (const key in flattenedValue) {
-        formattedValue += `${key}: ${success(flattenedValue[key])}\n`;
-    }
-    return formattedValue;
-}
-
-function flatten(obj, prefix = '', res = {}) {
-    for (const key in obj) {
-        const val = obj[key];
-        const path = prefix ? `${prefix}.${key}` : key;
-        if (typeof val === 'object' && val !== null) {
-            flatten(val, path, res);
-        } else {
-            res[path] = val;
-        }
-    }
-    return res;
-}

package/lib/resource.js

@@ -1,151 +0,0 @@
-import { resolveUser } from './config.js';
-import { device } from './paths.js';
-import api from './api.js';
-import { apiError } from './errors.js';
-import { info, warning, hint } from './format.js';
-
-// Drops internal resources whose keys start with `$`; those belong to
-// the agent's own framework (cmd, fs, scripts…) and shouldn't surface
-// through the user-facing resource list.
-export async function getDeviceResources(deviceId, options = {}) {
-    const user = resolveUser(options.user);
-
-    try {
-        // `/resources/api` merges firmware resources with API resources
-        // inherited from the product profile, which `/resources` alone omits.
-        const response = await api.get(`${device(user, deviceId)}/resources/api`);
-        return Object.fromEntries(
-            Object.entries(response.data).filter(([key]) => !key.startsWith('$')),
-        );
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Device not found: ${deviceId} (account ${user})`,
-        });
-    }
-}
-
-/**
- * Read the current value of a resource via GET. Appropriate for
- * output-only (fn=3) or fn=4 resources when you only want the latest
- * sample, not to trigger the input side.
- */
-export async function readDeviceResource(deviceId, resourceId, options = {}) {
-    const user = resolveUser(options.user);
-    try {
-        const response = await api.get(`${device(user, deviceId)}/resources/${resourceId}`);
-        return response.data;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Resource not found: ${resourceId} on device ${deviceId} (account ${user})`,
-        });
-    }
-}
-
-/**
- * Introspect a single resource. Returns the `{in, out}` schema the
- * agent advertises for that resource, e.g. for `cmd`:
- *   { in: { cmd: "", mode: "api", timeout: 30 }, out: { stdout: "", stderr: "", retcode: 0 } }
- *
- * Read-only resources (fn=3) only return `out`; input-only (fn=2) only
- * return `in`; fn=1 may return an empty object. Not every agent/firmware
- * exposes /api — callers should tolerate 404/501.
- */
-export async function getDeviceResourceApi(deviceId, resourceId, options = {}) {
-    const user = resolveUser(options.user);
-    try {
-        const response = await api.get(`${device(user, deviceId)}/resources/${resourceId}/api`);
-        return response.data;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Resource not found: ${resourceId} on device ${deviceId} (account ${user})`,
-        });
-    }
-}
-
-export async function executeDeviceResource(deviceId, resourceId, inputs, options = {}) {
-    const user = resolveUser(options.user);
-
-    try {
-        const response = await api.post(
-            `${device(user, deviceId)}/resources/${resourceId}`,
-            inputs,
-        );
-        return response.data;
-    } catch (error) {
-        throw apiError(error, {
-            notFound: `Resource not found: ${resourceId} on device ${deviceId} (account ${user})`,
-        });
-    }
-}
-
-/**
- * Decide GET vs POST based on whether the caller passed real inputs.
- * No inputs (undefined, null, or an empty object) → GET, which reads
- * the output side of fn=3/4 resources without triggering the input
- * handler. Otherwise POST with the payload.
- */
-export async function callDeviceResource(deviceId, resourceId, inputs, options = {}) {
-    const hasInputs =
-        inputs !== undefined &&
-        inputs !== null &&
-        !(typeof inputs === 'object' && !Array.isArray(inputs) && Object.keys(inputs).length === 0);
-    return hasInputs
-        ? executeDeviceResource(deviceId, resourceId, inputs, options)
-        : readDeviceResource(deviceId, resourceId, options);
-}
-
-/**
- * Fetch the resource list and, in parallel, introspect each resource's
- * `/api` schema. Returns an array with `{name, fn, in?, out?}` so both
- * the CLI and the MCP can render the same information.
- */
-export async function listDeviceResourcesWithSchemas(deviceId, options = {}) {
-    const resources = await getDeviceResources(deviceId, options);
-    const names = Object.keys(resources);
-    const entries = await Promise.all(
-        names.map(async (name) => {
-            const fn = resources[name]?.fn;
-            try {
-                const schema = await getDeviceResourceApi(deviceId, name, options);
-                return { name, fn, ...schema };
-            } catch {
-                return { name, fn };
-            }
-        }),
-    );
-    return entries;
-}
-
-/**
- * Format the resource entries produced by listDeviceResourcesWithSchemas
- * (`{name, fn, in?, out?}`). Shared between CLI (with chalk) and any
- * other human-facing surface.
- */
-export function formatDeviceResourcesWithSchemas(deviceId, entries) {
-    let out = `\nResources for device ${info(deviceId)}:\n`;
-    if (!entries || entries.length === 0) {
-        return out + warning('No resources found for this device.\n');
-    }
-    for (const e of entries) {
-        const kind = getResourceType({ fn: e.fn });
-        out += `\n- ${info(e.name)}  ${hint('[' + kind + ']')}\n`;
-        if (e.in !== undefined) out += `    in:  ${JSON.stringify(e.in)}\n`;
-        if (e.out !== undefined) out += `    out: ${JSON.stringify(e.out)}\n`;
-    }
-    return out;
-}
-
-function getResourceType(value) {
-    switch (value.fn) {
-        case 1:
-            return 'no parameters';
-        case 2:
-            return 'input';
-        case 3:
-            return 'output';
-        case 4:
-            return 'input/output';
-        default:
-            return 'unknown';
-    }
-}

package/lib/storage.js

@@ -1,117 +0,0 @@
-import api from './api.js';
-import { apiError } from './errors.js';
-import { v1, v2 } from './paths.js';
-
-/**
- * Helpers for ThinRemote file storages — independent buckets that the
- * platform exposes alongside products. The product script workflow
- * uses them to host the actual JS files; storages are also useful on
- * their own (config blobs, firmware artefacts, etc.).
- *
- * Functions return raw data and throw `apiError` on failure, except
- * the `*Exists` and `delete*` helpers which use boolean return values
- * so orchestration code can stay branch-light.
- */
-
-export async function getStorage(storageId, user) {
-    try {
-        const res = await api.get(`${v1(user)}/storages/${storageId}`);
-        return res.data || {};
-    } catch (e) {
-        throw apiError(e, { notFound: `Storage not found: ${storageId}` });
-    }
-}
-
-export async function storageExists(storageId, user) {
-    try {
-        await api.get(`${v1(user)}/storages/${storageId}`);
-        return true;
-    } catch (e) {
-        if (e.response?.status === 404) return false;
-        throw apiError(e);
-    }
-}
-
-export async function createStorage(
-    storageId,
-    user,
-    { name, description, public: isPublic = false } = {},
-) {
-    try {
-        await api.post(`${v1(user)}/storages`, {
-            storage: storageId,
-            name: name || storageId,
-            description: description || `Storage for ${storageId}`,
-            public: isPublic,
-        });
-    } catch (e) {
-        throw apiError(e);
-    }
-}
-
-export async function deleteStorage(storageId, user) {
-    try {
-        await api.delete(`${v1(user)}/storages/${storageId}`);
-        return true;
-    } catch (e) {
-        if (e.response?.status === 404) return false;
-        throw apiError(e);
-    }
-}
-
-export async function listStorageFiles(storageId, user) {
-    try {
-        const res = await api.get(`${v1(user)}/storages/${storageId}/files`);
-        return res.data || [];
-    } catch (e) {
-        if (e.response?.status === 404) return [];
-        throw apiError(e);
-    }
-}
-
-/**
- * Read a file as raw text (no JSON parsing). The agent stores script
- * bodies as `text/plain` — parsing them as JSON would corrupt them.
- */
-export async function readStorageFile(storageId, filePath, user) {
-    try {
-        const res = await api.get(`${v2(user)}/storages/${storageId}/files/${filePath}`, {
-            transformResponse: [(x) => x],
-        });
-        return res.data;
-    } catch (e) {
-        throw apiError(e, { notFound: `File not found in storage "${storageId}": ${filePath}` });
-    }
-}
-
-export async function storageFileExists(storageId, filePath, user) {
-    try {
-        await api.get(`${v2(user)}/storages/${storageId}/files/${filePath}`);
-        return true;
-    } catch (e) {
-        if (e.response?.status === 404) return false;
-        throw apiError(e);
-    }
-}
-
-export async function writeStorageFile(storageId, filePath, content, user) {
-    try {
-        await api.put(
-            `${v2(user)}/storages/${storageId}/files/${filePath}?overwrite=true`,
-            content,
-            { headers: { 'Content-Type': 'text/plain' } },
-        );
-    } catch (e) {
-        throw apiError(e);
-    }
-}
-
-export async function deleteStorageFile(storageId, filePath, user) {
-    try {
-        await api.delete(`${v2(user)}/storages/${storageId}/files/${filePath}`);
-        return true;
-    } catch (e) {
-        if (e.response?.status === 404) return false;
-        throw apiError(e);
-    }
-}