@thinremote/thinr-cli 1.3.3 → 1.3.5

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [1.3.5] - 2026-09-24
+
+### Fixed
+
+- `thinr_ls` describes what "/" actually resolves to: the agent process's
+  working directory, which is normally the filesystem root. 1.3.4 said it was
+  a base directory "usually /var/log", which was a stale service definition on
+  one device rather than how installs behave.
+
+## [1.3.4] - 2026-09-24
+
+### Fixed
+
+- `thinr_script_delete` resolves the script by the name the agent reports, so
+  both `battery` and `battery.sh` remove the same file. It used to build the
+  path from the argument verbatim, which meant following its own description
+  ("without extension") returned a bare 404. A name that matches nothing now
+  lists the scripts that are registered.
+
+### Changed
+
+- `thinr_script_write` refuses a name that would replace one of the device's
+  built-in resources (`monitoring`, `system`, `cmd`, `update`, `agent`) unless
+  `force: true` is passed. Installing `monitoring.sh` used to shadow the real
+  monitoring resource silently. Its description now also states that the
+  script runs with the agent's privileges, root in a system install.
+- `thinr_devices` shows when each device last changed state: `connected since`
+  for a live one, `offline since` for a dead one. The timestamp was already in
+  the response; finding out whether something dropped minutes or months ago
+  meant a trip to the monitoring history.
+- `thinr_ls` explains that `/` resolves to the agent's base directory while
+  every other absolute path is literal, and a listing of `/` now says which
+  directory it came from. Nothing is confined to that directory, so reading a
+  `/` listing as the root filesystem was an easy wrong conclusion to draw.
+- `thinr_profiles` states that profiles are not accounts, and that `user`
+  addresses another account on the same server.
+
 ## [1.3.3] - 2026-09-24
 
 ### Changed

package/lib/mcp/tools-devices.js

@@ -10,11 +10,22 @@ async function toolDevices(args) {
     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}`;
+        return `${status}  ${d.device}${label}${product}${since(d)}`;
     };
 
     if (!query) {

package/lib/mcp/tools-filesystem.js

@@ -24,7 +24,26 @@ async function toolWrite(args) {
 
 async function toolLs(args) {
     const { api } = getAPI(args.device_id, args.user);
-    const entries = await api.listDir(args.path || '/', args.include_hidden || false);
+    const requested = args.path || '/';
+    const entries = await api.listDir(requested, args.include_hidden || false);
+
+    // "/" resolves through the agent process's working directory, normally
+    // the filesystem root, while every other absolute path is literal. An
+    // agent started elsewhere answers "/" with that directory instead, which
+    // reads as the device's root and is not, so name the 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 working 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';
@@ -32,7 +51,7 @@ async function toolLs(args) {
         return `${type}${mode} ${size} ${e.name}`;
     });
     return {
-        content: [{ type: 'text', text: lines.join('\n') || '(empty directory)' }],
+        content: [{ type: 'text', text: header + (lines.join('\n') || '(empty directory)') }],
         isError: false,
     };
 }
@@ -145,11 +164,15 @@ export const tools = [
     },
     {
         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.`,
+        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 process's working directory, normally the filesystem root, reported as \`fs_base_path\` by thinr_device_info. When it is not the root — an agent started from elsewhere — the listing says which directory it came from. Nothing is confined to it: "/etc" reads the real /etc. 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 (default: /)' },
+                path: {
+                    type: 'string',
+                    description:
+                        'Directory path. Absolute and literal, except "/", which means the agent\'s working directory, normally the filesystem root (default: "/").',
+                },
                 include_hidden: {
                     type: 'boolean',
                     description: 'Include hidden files (default: false)',

package/lib/mcp/tools-profiles.js

@@ -19,7 +19,7 @@ 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.',
+            '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.\n\nProfiles are not accounts. Every tool also takes an optional `user`, which addresses another account on the same server when the profile has admin rights — so a device belonging to `demo` is reached with `user: "demo"`, not by looking for a profile of that name.',
         inputSchema: {
             type: 'object',
             properties: {},

package/lib/mcp/tools-scripts.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { callDeviceResource, readDeviceResource } from '../resource.js';
+import { callDeviceResource, getDeviceResources, readDeviceResource } from '../resource.js';
 import { inputError } from '../errors.js';
 import { getAPI } from './helpers.js';
 
@@ -45,6 +45,27 @@ async function toolScriptWrite(args) {
     }
     const scriptPath = `${baseDir}/${args.name}`;
 
+    // The agent registers scripts at the root of the device's resource
+    // namespace, so a script named after a built-in resource replaces it and
+    // the device silently stops answering the real one. Refuse unless the
+    // caller says that is the intent. A name that already belongs to one of
+    // this device's own scripts is an update, not a collision.
+    const registeredName = args.name.replace(/\.[^./]+$/, '');
+    if (!args.force) {
+        const [native, current] = await Promise.all([
+            getDeviceResources(device, { user: args.user }).catch(() => ({})),
+            Promise.resolve(Array.isArray(info?.scripts) ? info.scripts : []),
+        ]);
+        const isOwnScript = current.some((s) => s.name === registeredName);
+        if (!isOwnScript && Object.prototype.hasOwnProperty.call(native, registeredName)) {
+            throw inputError(
+                `"${registeredName}" is already a resource on this device, and installing this ` +
+                    `script would replace it. Rename the script, or pass force: true if replacing ` +
+                    `it is what you want.`,
+            );
+        }
+    }
+
     await deviceApi.writeFile(scriptPath, args.content, true);
 
     const chmod = await deviceApi.exec(`chmod +x ${JSON.stringify(scriptPath)}`, 10);
@@ -53,9 +74,6 @@ async function toolScriptWrite(args) {
     }
 
     const reloaded = await callDeviceResource(device, '$scripts/reload', {}, { user: args.user });
-    // 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;
@@ -90,7 +108,21 @@ async function toolScriptDelete(args) {
     if (!/^[A-Za-z0-9._-]+$/.test(args.name)) {
         throw inputError(`Invalid script name "${args.name}"`);
     }
-    const scriptPath = `${baseDir}/${args.name}`;
+
+    // Callers name a script either way round: `battery` as it appears in the
+    // resource list, or `battery.sh` as it sits on disk. Resolve against what
+    // the agent reports so both land on the same file, and say what is there
+    // when neither matches instead of letting a 404 through.
+    const scripts = Array.isArray(info?.scripts) ? info.scripts : [];
+    const stem = args.name.replace(/\.[^./]+$/, '');
+    const match = scripts.find((s) => s.name === stem || s.path?.endsWith(`/${args.name}`));
+    if (!match) {
+        const registered = scripts.map((s) => s.name).join(', ') || 'none';
+        throw inputError(
+            `No script named "${args.name}" on this device. Registered: ${registered}.`,
+        );
+    }
+    const scriptPath = match.path || `${baseDir}/${args.name}`;
 
     await deviceApi.delete(scriptPath, false);
     const reloaded = await callDeviceResource(device, '$scripts/reload', {}, { user: args.user });
@@ -99,7 +131,7 @@ async function toolScriptDelete(args) {
         content: [
             {
                 type: 'text',
-                text: `Removed script "${args.name}". ${remaining} script(s) remain registered.`,
+                text: `Removed script "${match.name}" (${scriptPath}). ${remaining} script(s) remain registered.`,
             },
         ],
         isError: false,
@@ -124,12 +156,15 @@ export const tools = [
         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.
+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\`. A name that already belongs to a built-in resource (\`monitoring\`, \`system\`, \`cmd\`, \`update\`, \`agent\`) would replace it and leave the device no longer answering the real one, so this tool refuses that unless you pass \`force: true\`.
+
+The script runs with the agent's privileges, which for a system install means root. Installing one grants permanent remote execution of that code on the device; treat it like adding a service, not like running a command.
 
 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.
+- Emit JSON that matches the \`--describe\` schema. Interpolating values you do not control (hostnames, command output, file contents) into a hand-built string breaks on the first quote or backslash; use \`jq\`, or \`python3 -c\` with \`json.dumps\` and the value passed through the environment. Output landing under \`output\` means the JSON was invalid, not that the raw form was accepted.
 
 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: {
@@ -140,6 +175,11 @@ This tool writes the script, makes it executable, and calls the agent's \`$scrip
                     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".',
                 },
+                force: {
+                    type: 'boolean',
+                    description:
+                        "Install even when the resulting resource name replaces one of the device's built-in resources.",
+                },
                 content: {
                     type: 'string',
                     description: 'Full script source code, including shebang.',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thinremote/thinr-cli",
-    "version": "1.3.3",
+    "version": "1.3.5",
     "description": "CLI for ThinRemote — remote management for IoT devices, with an MCP server for AI clients",
     "main": "bin/thinr.js",
     "bin": {