iobroker.beszel 0.1.2

package/src/lib/types.ts

@@ -0,0 +1,192 @@
+/**
+ * Adapter configuration as stored in ioBroker native config
+ */
+export interface AdapterConfig {
+  url: string;
+  username: string;
+  password: string;
+  pollInterval: number;
+
+  // Metric toggles
+  metrics_uptime: boolean;
+  metrics_agentVersion: boolean;
+  metrics_services: boolean;
+
+  metrics_cpu: boolean;
+  metrics_loadAvg: boolean;
+  metrics_cpuBreakdown: boolean;
+
+  metrics_memory: boolean;
+  metrics_memoryDetails: boolean;
+  metrics_swap: boolean;
+
+  metrics_disk: boolean;
+  metrics_diskSpeed: boolean;
+  metrics_extraFs: boolean;
+
+  metrics_network: boolean;
+
+  metrics_temperature: boolean;
+  metrics_temperatureDetails: boolean;
+
+  metrics_gpu: boolean;
+
+  metrics_containers: boolean;
+
+  metrics_battery: boolean;
+}
+
+/**
+ * System info object from Beszel systems record
+ */
+export interface SystemInfo {
+  /** Uptime in seconds */
+  u?: number;
+  /** Agent version */
+  v?: string;
+  /** Systemd services [total, failed] */
+  sv?: [number, number];
+  /** Load average [1m, 5m, 15m] */
+  la?: [number, number, number];
+  /** Battery [percent, charge_state] */
+  bat?: [number, number];
+  /** Connection type */
+  ct?: number;
+}
+
+/**
+ * A system record from /api/collections/systems/records
+ */
+export interface BeszelSystem {
+  id: string;
+  name: string;
+  status: "up" | "down" | "paused" | "pending";
+  host: string;
+  info: SystemInfo;
+}
+
+/**
+ * Extra filesystem stats
+ */
+export interface FsStats {
+  /** disk total GB */
+  d?: number;
+  /** disk used GB */
+  du?: number;
+  /** read MB/s */
+  r?: number;
+  /** write MB/s */
+  w?: number;
+}
+
+/**
+ * GPU data
+ */
+export interface GPUData {
+  /** GPU name */
+  n?: string;
+  /** GPU usage % */
+  u?: number;
+  /** GPU memory used GB */
+  mu?: number;
+  /** GPU memory total GB */
+  mt?: number;
+  /** GPU power W */
+  p?: number;
+}
+
+/**
+ * The stats object inside a system_stats record
+ */
+export interface SystemStats {
+  /** CPU usage % */
+  cpu?: number;
+  /** RAM used GB */
+  mu?: number;
+  /** RAM total GB */
+  m?: number;
+  /** RAM % */
+  mp?: number;
+  /** Buffers + cache GB */
+  mb?: number;
+  /** ZFS ARC GB */
+  mz?: number;
+  /** Swap used GB */
+  su?: number;
+  /** Swap total GB */
+  s?: number;
+  /** Disk used GB */
+  du?: number;
+  /** Disk total GB */
+  d?: number;
+  /** Disk % */
+  dp?: number;
+  /** Disk read MB/s */
+  dr?: number;
+  /** Disk write MB/s */
+  dw?: number;
+  /** Network sent MB/s */
+  ns?: number;
+  /** Network recv MB/s */
+  nr?: number;
+  /** Temperatures map sensor->°C */
+  t?: Record<string, number>;
+  /** Load avg [1m, 5m, 15m] */
+  la?: [number, number, number];
+  /** GPU data */
+  g?: Record<string, GPUData>;
+  /** Extra filesystems */
+  efs?: Record<string, FsStats>;
+  /** Battery [%, charge_state] */
+  bat?: [number, number];
+  /** CPU breakdown [user, sys, iowait, steal, idle] % */
+  cpub?: number[];
+}
+
+/**
+ * A system_stats record from /api/collections/system_stats/records
+ */
+export interface BeszelSystemStats {
+  id: string;
+  system: string;
+  type: string;
+  stats: SystemStats;
+  updated: string;
+}
+
+/**
+ * A container record from /api/collections/containers/records
+ */
+export interface BeszelContainer {
+  id: string;
+  system: string;
+  name: string;
+  status: string;
+  health: number;
+  cpu: number;
+  memory: number;
+  image: string;
+}
+
+/**
+ * PocketBase list response
+ */
+export interface PocketBaseList<T> {
+  page: number;
+  perPage: number;
+  totalItems: number;
+  totalPages: number;
+  items: T[];
+}
+
+/**
+ * PocketBase auth response
+ */
+export interface AuthResponse {
+  token: string;
+  record: {
+    id: string;
+    email: string;
+    [key: string]: unknown;
+  };
+}

package/src/main.ts

@@ -0,0 +1,199 @@
+import * as utils from "@iobroker/adapter-core";
+import { BeszelClient } from "./lib/beszel-client.js";
+import { StateManager } from "./lib/state-manager.js";
+import type { AdapterConfig } from "./lib/types.js";
+
+class BeszelAdapter extends utils.Adapter {
+  private client: BeszelClient | null = null;
+  private stateManager: StateManager | null = null;
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private isPolling = false;
+
+  public constructor(options: Partial<utils.AdapterOptions> = {}) {
+    super({
+      ...options,
+      name: "beszel",
+    });
+    this.on("ready", this.onReady.bind(this));
+    this.on("unload", this.onUnload.bind(this));
+    this.on("message", this.onMessage.bind(this));
+  }
+
+  private async onReady(): Promise<void> {
+    const config = this.config as unknown as AdapterConfig;
+
+    // Ensure info objects exist before any setState calls
+    await this.setObjectNotExistsAsync("info", {
+      type: "channel",
+      common: { name: "Information" },
+      native: {},
+    });
+    await this.setObjectNotExistsAsync("info.connection", {
+      type: "state",
+      common: {
+        name: "Connection status",
+        type: "boolean",
+        role: "indicator.connected",
+        read: true,
+        write: false,
+        def: false,
+      },
+      native: {},
+    });
+    await this.setStateAsync("info.connection", { val: false, ack: true });
+
+    // Validate required config
+    if (!config.url || !config.username || !config.password) {
+      this.log.error(
+        "Beszel adapter: URL, username, and password are required. Please configure the adapter.",
+      );
+      await this.setStateAsync("info.connection", { val: false, ack: true });
+      return;
+    }
+
+    this.client = new BeszelClient(
+      config.url,
+      config.username,
+      config.password,
+    );
+    this.stateManager = new StateManager(this);
+
+    // Cleanup disabled metric states for existing systems (config may have changed)
+    const existingObjects = await this.getObjectViewAsync("system", "device", {
+      startkey: `${this.namespace}.systems.`,
+      endkey: `${this.namespace}.systems.\u9999`,
+    });
+    if (existingObjects?.rows) {
+      for (const row of existingObjects.rows) {
+        const relId = row.id.startsWith(`${this.namespace}.`)
+          ? row.id.slice(this.namespace.length + 1)
+          : row.id;
+        const parts = relId.split(".");
+        if (parts.length === 2 && parts[0] === "systems") {
+          await this.stateManager.cleanupMetrics(parts[1], config);
+        }
+      }
+    }
+
+    // Initial poll
+    await this.poll();
+
+    // Set up recurring poll
+    const intervalMs = Math.max(10, config.pollInterval ?? 60) * 1000;
+    this.pollTimer = setInterval(() => {
+      void this.poll();
+    }, intervalMs);
+
+    this.log.info(
+      `Beszel adapter started. Polling every ${config.pollInterval ?? 60}s from ${config.url}`,
+    );
+  }
+
+  private async onUnload(callback: () => void): Promise<void> {
+    try {
+      if (this.pollTimer) {
+        clearInterval(this.pollTimer);
+        this.pollTimer = null;
+      }
+      await this.setStateAsync("info.connection", { val: false, ack: true });
+    } catch {
+      // ignore
+    }
+    callback();
+  }
+
+  private async onMessage(obj: ioBroker.Message): Promise<void> {
+    if (obj.command === "checkConnection") {
+      const config = obj.message as Partial<AdapterConfig>;
+      const url = config.url ?? "";
+      const username = config.username ?? "";
+      const password = config.password ?? "";
+
+      if (!url || !username || !password) {
+        this.sendTo(
+          obj.from,
+          obj.command,
+          {
+            success: false,
+            message: "URL, username and password are required",
+          },
+          obj.callback,
+        );
+        return;
+      }
+
+      const testClient = new BeszelClient(url, username, password);
+      const result = await testClient.checkConnection();
+      this.sendTo(obj.from, obj.command, result, obj.callback);
+    }
+  }
+
+  private async poll(): Promise<void> {
+    if (this.isPolling) {
+      this.log.debug("Skipping poll — previous poll still running");
+      return;
+    }
+    if (!this.client || !this.stateManager) {
+      return;
+    }
+
+    this.isPolling = true;
+    try {
+      const config = this.config as unknown as AdapterConfig;
+
+      // Fetch all data
+      const [systems, containers] = await Promise.all([
+        this.client.getSystems(),
+        config.metrics_containers
+          ? this.client.getContainers()
+          : Promise.resolve([]),
+      ]);
+
+      const systemIds = systems.map((s) => s.id);
+      const statsMap = await this.client.getLatestStats(systemIds);
+
+      // Update connection state
+      await this.setStateAsync("info.connection", { val: true, ack: true });
+
+      // Update each system
+      for (const system of systems) {
+        const stats = statsMap.get(system.id);
+        const sysContainers = containers.filter((c) => c.system === system.id);
+        await this.stateManager.updateSystem(
+          system,
+          stats,
+          sysContainers,
+          config,
+        );
+      }
+
+      // Cleanup stale systems
+      await this.stateManager.cleanupSystems(systems.map((s) => s.name));
+
+      this.log.debug(`Polled ${systems.length} systems successfully`);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      this.log.error(`Poll failed: ${errMsg}`);
+
+      // On 401, invalidate token so next poll re-authenticates
+      if (
+        err instanceof Error &&
+        (err as NodeJS.ErrnoException).code === "UNAUTHORIZED"
+      ) {
+        this.client?.invalidateToken();
+      }
+
+      await this.setStateAsync("info.connection", { val: false, ack: true });
+    } finally {
+      this.isPolling = false;
+    }
+  }
+}
+
+if (require.main !== module) {
+  // Export the constructor in compact mode
+  module.exports = (options: Partial<utils.AdapterOptions> | undefined) =>
+    new BeszelAdapter(options);
+} else {
+  (() => new BeszelAdapter())();
+}

package/test/testPackageFiles.ts

@@ -0,0 +1,5 @@
+import path from "node:path";
+import { tests } from "@iobroker/testing";
+
+// __dirname is build/test/ after compilation, navigate to project root
+tests.packageFiles(path.join(__dirname, "..", ".."));

package/tsconfig.build.json

@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "sourceMap": false
+    },
+    "exclude": ["node_modules", "build", "**/*.test.ts", "test"]
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "strict": true,
+        "esModuleInterop": true,
+        "outDir": "./build",
+        "rootDir": "./src",
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true,
+        "noImplicitAny": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "build", "test"]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "sourceMap": true,
+        "rootDir": "."
+    },
+    "include": ["src/**/*", "test/**/*"],
+    "exclude": ["node_modules", "build"]
+}