@thinremote/thinr-cli 1.2.0-alpha.1 → 1.3.0

package/lib/fleet-upgrade.js

@@ -0,0 +1,106 @@
+import { createDeviceAPI } from './device-api.js';
+import { TIMEOUTS } from './constants.js';
+
+/**
+ * Roll a fleet-wide agent upgrade. Strategy:
+ *   1. If `canary` is set and there's more than one device, upgrade one
+ *      device in isolation first. A canary failure always aborts — the
+ *      point of the canary is to catch arch / channel / connectivity
+ *      mistakes before we touch the rest.
+ *   2. The remainder is upgraded in parallel batches of `batchSize`. If
+ *      `abortOnFailure` is set, any failure inside a batch stops the run
+ *      after that batch completes (we never leave requests dangling).
+ *   3. Results come back as { ok, failed, aborted } plus the per-device
+ *      records. Progress is reported through `onProgress` so the UI can
+ *      show `updating N/M…` live.
+ *
+ * We intentionally treat any HTTP rejection as a failure and any resolved
+ * call as success. The agent's `update` resource doesn't expose a stable
+ * machine-readable status across every "nothing to do" case, so finer
+ * classification would be fragile here — a resolved call means the agent
+ * accepted the request; whether it then swapped binaries is visible in
+ * the next sample's version field.
+ */
+export async function runFleetUpgrade({
+    deviceIds,
+    channel = 'latest',
+    user,
+    canary = true,
+    abortOnFailure = true,
+    batchSize = 5,
+    onProgress,
+    onDeviceResult,
+    signal,
+}) {
+    const queue = [...deviceIds];
+    const total = queue.length;
+    const results = [];
+    let done = 0;
+
+    const emitProgress = (phase) => {
+        onProgress?.({ done, total, phase });
+    };
+
+    async function upgradeOne(id) {
+        if (signal?.aborted) {
+            const r = { deviceId: id, ok: false, error: 'cancelled' };
+            results.push(r);
+            onDeviceResult?.(r);
+            return r;
+        }
+        let r;
+        try {
+            const api = createDeviceAPI(id, user ? { user } : {});
+            const result = await api.callResource(
+                'update',
+                { action: 'apply', channel },
+                { timeout: TIMEOUTS.DEVICE_UPDATE_APPLY_MS },
+            );
+            r = { deviceId: id, ok: true, result };
+        } catch (e) {
+            r = {
+                deviceId: id,
+                ok: false,
+                error: e?.message || String(e),
+            };
+        }
+        results.push(r);
+        done += 1;
+        onDeviceResult?.(r);
+        emitProgress('running');
+        return r;
+    }
+
+    emitProgress('running');
+
+    // Canary first — a single device, synchronously. Treat failure as
+    // terminal regardless of `abortOnFailure`: if the canary fails we have
+    // no signal that a wider rollout would succeed, and blindly firing at
+    // 95 more devices would only amplify whatever went wrong.
+    if (canary && queue.length > 1) {
+        const canaryId = queue.shift();
+        const r = await upgradeOne(canaryId);
+        if (!r.ok) {
+            return { results, aborted: true, reason: 'canary-failed' };
+        }
+    }
+
+    while (queue.length > 0) {
+        if (signal?.aborted) {
+            return { results, aborted: true, reason: 'cancelled' };
+        }
+        const batch = queue.splice(0, batchSize);
+        const batchResults = await Promise.all(batch.map(upgradeOne));
+        if (abortOnFailure && batchResults.some((r) => !r.ok)) {
+            return { results, aborted: true, reason: 'batch-failed' };
+        }
+    }
+
+    return { results, aborted: false };
+}
+
+export function summarize(results) {
+    const ok = results.filter((r) => r.ok).length;
+    const failed = results.length - ok;
+    return { ok, failed, total: results.length };
+}

package/lib/format.js

@@ -0,0 +1,114 @@
+// @ts-check
+import chalk from 'chalk';
+
+// ─────────────────────────────────────────────────────────────────────
+// Theme — semantic wrappers over chalk so every CLI surface speaks
+// the same visual language. New colours / a `--no-color` switch / a
+// dark-on-light adjustment only have to be touched here.
+// ─────────────────────────────────────────────────────────────────────
+
+/** Title / header text. */
+export const label = (s) => chalk.bold(s);
+/** Secondary / disabled / "—" text. */
+export const muted = (s) => chalk.dim(s);
+/** Hints, trailing metadata, footers, timestamps. */
+export const hint = (s) => chalk.gray(s);
+/** Positive states (online, ok, success). */
+export const success = (s) => chalk.green(s);
+/** Negative states (offline, failed, errored). */
+export const error = (s) => chalk.red(s);
+/** Caution states (timeout, at-risk thresholds). */
+export const warning = (s) => chalk.yellow(s);
+/** Decorative accents (separators, prompts). */
+export const accent = (s) => chalk.cyan(s);
+/** Neutral-but-noteworthy identifiers (device ids, resource names). */
+export const info = (s) => chalk.blue(s);
+
+/**
+ * Format a duration in seconds as a human-readable string: `309d16h`,
+ * `42d15h`, `17m`, `42s`, etc. Returns `—` for invalid/missing values.
+ *
+ * @param {number | null | undefined} seconds
+ * @returns {string}
+ */
+export function formatUptime(seconds) {
+    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
+    const d = Math.floor(seconds / 86400);
+    const h = Math.floor((seconds % 86400) / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    if (d > 0) return `${d}d${h}h`;
+    if (h > 0) return `${h}h${m}m`;
+    if (m > 0) return `${m}m`;
+    return `${Math.floor(seconds)}s`;
+}
+
+/**
+ * Format seconds elapsed as a "time ago" label: `5s ago`, `3m ago`,
+ * `2h ago`, `4d ago`. Returns `—` for invalid/missing values.
+ *
+ * @param {number | null | undefined} seconds
+ * @returns {string}
+ */
+export function formatAgo(seconds) {
+    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
+    if (seconds < 60) return `${Math.floor(seconds)}s ago`;
+    if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+
+/**
+ * Render a percentage value coloured by threshold: green below 70 %,
+ * yellow below 90 %, red at or above 90 %. Returns a dim `—` when the
+ * value is missing. Formatted with no decimal places so columns in
+ * cli-table3 stay aligned.
+ *
+ * @param {number | null | undefined} v
+ * @returns {string}
+ */
+export function colorPct(v) {
+    if (v == null || !Number.isFinite(v)) return muted('—');
+    const s = `${v.toFixed(0)}%`;
+    if (v >= 90) return error(s);
+    if (v >= 70) return warning(s);
+    return success(s);
+}
+
+/**
+ * Format a duration in seconds as a short ETA label: `12s`, `3m15s`,
+ * `2h30m`. Returns `—` for non-finite / missing values.
+ *
+ * @param {number | null | undefined} seconds
+ * @returns {string}
+ */
+export function formatETA(seconds) {
+    if (seconds == null || !Number.isFinite(seconds) || seconds < 0) return '—';
+    if (seconds < 60) return `${Math.max(1, Math.ceil(seconds))}s`;
+    if (seconds < 3600) {
+        const m = Math.floor(seconds / 60);
+        const s = Math.ceil(seconds % 60);
+        return s > 0 ? `${m}m${s}s` : `${m}m`;
+    }
+    const h = Math.floor(seconds / 3600);
+    const m = Math.ceil((seconds % 3600) / 60);
+    return m > 0 ? `${h}h${m}m` : `${h}h`;
+}
+
+/**
+ * Format a byte count as a human-readable string picking the largest
+ * unit where the value is ≥ 1. `2 bytes`, `12.3 KB`, `145 MB`,
+ * `2.4 GB`. Returns `—` for invalid/missing values.
+ *
+ * @param {number | null | undefined} bytes
+ * @returns {string}
+ */
+export function formatBytes(bytes) {
+    if (bytes == null || !Number.isFinite(bytes) || bytes < 0) return '—';
+    if (bytes < 1024) return `${bytes} B`;
+    const kb = bytes / 1024;
+    if (kb < 1024) return `${kb.toFixed(1)} KB`;
+    const mb = kb / 1024;
+    if (mb < 1024) return `${mb.toFixed(mb >= 100 ? 0 : 1)} MB`;
+    const gb = mb / 1024;
+    return `${gb.toFixed(gb >= 100 ? 0 : 2)} GB`;
+}

package/lib/mcp/registry.js

@@ -6,7 +6,14 @@ import { tools as resourcesTools } from './tools-resources.js';
 import { tools as propertiesTools } from './tools-properties.js';
 import { tools as scriptsTools } from './tools-scripts.js';
 import { tools as productsTools } from './tools-products.js';
+import { tools as playbookTools } from './tools-playbook.js';
 import { tools as profilesTools } from './tools-profiles.js';
+import { tools as installTools } from './tools-install.js';
+import { tools as bucketsTools } from './tools-buckets.js';
+import { tools as logsTools } from './tools-logs.js';
+import { tools as productProfileTools } from './tools-profile.js';
+import { tools as tokensTools } from './tools-tokens.js';
+import { tools as alarmsTools } from './tools-alarms.js';
 
 export const tools = [
     ...devicesTools,
@@ -16,7 +23,14 @@ export const tools = [
     ...propertiesTools,
     ...scriptsTools,
     ...productsTools,
+    ...playbookTools,
     ...profilesTools,
+    ...installTools,
+    ...bucketsTools,
+    ...logsTools,
+    ...productProfileTools,
+    ...tokensTools,
+    ...alarmsTools,
 ];
 
 // Inject the optional `profile` parameter on every tool so callers can