@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/protocols/protocol.nut.js

@@ -0,0 +1,364 @@
+import * as plugins from '../plugins.js';
+/**
+ * NUT Protocol variable definitions
+ */
+export const NUT_VARIABLES = {
+    // Device info
+    deviceMfr: 'device.mfr',
+    deviceModel: 'device.model',
+    deviceSerial: 'device.serial',
+    deviceType: 'device.type',
+    // UPS status
+    upsStatus: 'ups.status',
+    upsAlarm: 'ups.alarm',
+    upsTime: 'ups.time',
+    upsLoad: 'ups.load',
+    upsTemperature: 'ups.temperature',
+    // Battery
+    batteryCharge: 'battery.charge',
+    batteryRuntime: 'battery.runtime',
+    batteryVoltage: 'battery.voltage',
+    batteryVoltageNominal: 'battery.voltage.nominal',
+    batteryType: 'battery.type',
+    batteryDate: 'battery.date',
+    batteryTemperature: 'battery.temperature',
+    // Input
+    inputVoltage: 'input.voltage',
+    inputVoltageNominal: 'input.voltage.nominal',
+    inputFrequency: 'input.frequency',
+    inputFrequencyNominal: 'input.frequency.nominal',
+    inputTransferHigh: 'input.transfer.high',
+    inputTransferLow: 'input.transfer.low',
+    // Output
+    outputVoltage: 'output.voltage',
+    outputVoltageNominal: 'output.voltage.nominal',
+    outputFrequency: 'output.frequency',
+    outputCurrent: 'output.current',
+};
+/**
+ * NUT instant commands
+ */
+export const NUT_COMMANDS = {
+    testBatteryStart: 'test.battery.start',
+    testBatteryStartQuick: 'test.battery.start.quick',
+    testBatteryStartDeep: 'test.battery.start.deep',
+    testBatteryStop: 'test.battery.stop',
+    calibrateStart: 'calibrate.start',
+    calibrateStop: 'calibrate.stop',
+    shutdown: 'shutdown.return',
+    shutdownStayOff: 'shutdown.stayoff',
+    shutdownStop: 'shutdown.stop',
+    shutdownReboot: 'shutdown.reboot',
+    beeperEnable: 'beeper.enable',
+    beeperDisable: 'beeper.disable',
+    beeperMute: 'beeper.mute',
+    beeperToggle: 'beeper.toggle',
+    loadOff: 'load.off',
+    loadOn: 'load.on',
+};
+/**
+ * NUT Protocol handler for Network UPS Tools
+ * TCP-based text protocol on port 3493
+ */
+export class NutProtocol {
+    socket = null;
+    address;
+    port;
+    connected = false;
+    responseBuffer = '';
+    responseResolver = null;
+    responseRejecter = null;
+    constructor(address, port = 3493) {
+        this.address = address;
+        this.port = port;
+    }
+    /**
+     * Connect to NUT server
+     */
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.socket = new plugins.net.Socket();
+            const timeout = setTimeout(() => {
+                if (this.socket) {
+                    this.socket.destroy();
+                    this.socket = null;
+                }
+                reject(new Error(`Connection timeout to ${this.address}:${this.port}`));
+            }, 5000);
+            this.socket.on('connect', () => {
+                clearTimeout(timeout);
+                this.connected = true;
+                resolve();
+            });
+            this.socket.on('error', (err) => {
+                clearTimeout(timeout);
+                this.connected = false;
+                if (this.responseRejecter) {
+                    this.responseRejecter(err);
+                    this.responseRejecter = null;
+                    this.responseResolver = null;
+                }
+                reject(err);
+            });
+            this.socket.on('data', (data) => {
+                this.handleData(data);
+            });
+            this.socket.on('close', () => {
+                this.connected = false;
+                if (this.responseRejecter) {
+                    this.responseRejecter(new Error('Connection closed'));
+                    this.responseRejecter = null;
+                    this.responseResolver = null;
+                }
+            });
+            this.socket.connect(this.port, this.address);
+        });
+    }
+    /**
+     * Disconnect from NUT server
+     */
+    async disconnect() {
+        if (!this.connected || !this.socket) {
+            return;
+        }
+        try {
+            await this.sendCommand('LOGOUT');
+        }
+        catch {
+            // Ignore logout errors
+        }
+        this.socket.destroy();
+        this.socket = null;
+        this.connected = false;
+    }
+    /**
+     * Check if connected
+     */
+    get isConnected() {
+        return this.connected;
+    }
+    /**
+     * Handle incoming data
+     */
+    handleData(data) {
+        this.responseBuffer += data.toString();
+        // Check for complete response (ends with newline)
+        const lines = this.responseBuffer.split('\n');
+        // Check if we have a complete response
+        if (this.responseBuffer.endsWith('\n')) {
+            const responseLines = lines.filter((l) => l.trim().length > 0);
+            this.responseBuffer = '';
+            if (this.responseResolver) {
+                this.responseResolver(responseLines);
+                this.responseResolver = null;
+                this.responseRejecter = null;
+            }
+        }
+    }
+    /**
+     * Send command and get response
+     */
+    async sendCommand(command) {
+        if (!this.socket || !this.connected) {
+            throw new Error('Not connected to NUT server');
+        }
+        return new Promise((resolve, reject) => {
+            this.responseResolver = resolve;
+            this.responseRejecter = reject;
+            const timeout = setTimeout(() => {
+                this.responseResolver = null;
+                this.responseRejecter = null;
+                reject(new Error(`Command timeout: ${command}`));
+            }, 10000);
+            this.responseResolver = (lines) => {
+                clearTimeout(timeout);
+                resolve(lines);
+            };
+            this.responseRejecter = (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            };
+            this.socket.write(`${command}\n`);
+        });
+    }
+    /**
+     * List available UPS devices
+     */
+    async listUps() {
+        await this.ensureConnected();
+        const response = await this.sendCommand('LIST UPS');
+        const upsList = [];
+        for (const line of response) {
+            // Format: UPS <name> "<description>"
+            const match = line.match(/^UPS\s+(\S+)\s+"([^"]*)"/);
+            if (match) {
+                upsList.push({
+                    name: match[1],
+                    description: match[2],
+                });
+            }
+        }
+        return upsList;
+    }
+    /**
+     * Get all variables for a UPS
+     */
+    async listVariables(upsName) {
+        await this.ensureConnected();
+        const response = await this.sendCommand(`LIST VAR ${upsName}`);
+        const variables = [];
+        for (const line of response) {
+            // Format: VAR <ups> <name> "<value>"
+            const match = line.match(/^VAR\s+\S+\s+(\S+)\s+"([^"]*)"/);
+            if (match) {
+                variables.push({
+                    name: match[1],
+                    value: match[2],
+                });
+            }
+        }
+        return variables;
+    }
+    /**
+     * Get a specific variable value
+     */
+    async getVariable(upsName, varName) {
+        await this.ensureConnected();
+        const response = await this.sendCommand(`GET VAR ${upsName} ${varName}`);
+        for (const line of response) {
+            // Format: VAR <ups> <name> "<value>"
+            const match = line.match(/^VAR\s+\S+\s+\S+\s+"([^"]*)"/);
+            if (match) {
+                return match[1];
+            }
+            // Handle error responses
+            if (line.startsWith('ERR')) {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get multiple variables at once
+     */
+    async getVariables(upsName, varNames) {
+        const results = new Map();
+        for (const varName of varNames) {
+            const value = await this.getVariable(upsName, varName);
+            if (value !== null) {
+                results.set(varName, value);
+            }
+        }
+        return results;
+    }
+    /**
+     * Execute an instant command
+     */
+    async runCommand(upsName, command) {
+        await this.ensureConnected();
+        const response = await this.sendCommand(`INSTCMD ${upsName} ${command}`);
+        for (const line of response) {
+            if (line === 'OK') {
+                return true;
+            }
+            if (line.startsWith('ERR')) {
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * List available commands for a UPS
+     */
+    async listCommands(upsName) {
+        await this.ensureConnected();
+        const response = await this.sendCommand(`LIST CMD ${upsName}`);
+        const commands = [];
+        for (const line of response) {
+            // Format: CMD <ups> <command>
+            const match = line.match(/^CMD\s+\S+\s+(\S+)/);
+            if (match) {
+                commands.push(match[1]);
+            }
+        }
+        return commands;
+    }
+    /**
+     * Parse UPS status string into flags
+     */
+    parseStatus(statusString) {
+        return statusString.split(/\s+/).filter((s) => s.length > 0);
+    }
+    /**
+     * Get comprehensive UPS status
+     */
+    async getUpsStatus(upsName) {
+        const vars = await this.getVariables(upsName, [
+            NUT_VARIABLES.upsStatus,
+            NUT_VARIABLES.batteryCharge,
+            NUT_VARIABLES.batteryRuntime,
+            NUT_VARIABLES.inputVoltage,
+            NUT_VARIABLES.outputVoltage,
+            NUT_VARIABLES.upsLoad,
+        ]);
+        return {
+            status: this.parseStatus(vars.get(NUT_VARIABLES.upsStatus) || ''),
+            batteryCharge: parseFloat(vars.get(NUT_VARIABLES.batteryCharge) || '0'),
+            batteryRuntime: parseFloat(vars.get(NUT_VARIABLES.batteryRuntime) || '0'),
+            inputVoltage: parseFloat(vars.get(NUT_VARIABLES.inputVoltage) || '0'),
+            outputVoltage: parseFloat(vars.get(NUT_VARIABLES.outputVoltage) || '0'),
+            load: parseFloat(vars.get(NUT_VARIABLES.upsLoad) || '0'),
+        };
+    }
+    /**
+     * Get device information
+     */
+    async getDeviceInfo(upsName) {
+        const vars = await this.getVariables(upsName, [
+            NUT_VARIABLES.deviceMfr,
+            NUT_VARIABLES.deviceModel,
+            NUT_VARIABLES.deviceSerial,
+            NUT_VARIABLES.deviceType,
+        ]);
+        return {
+            manufacturer: vars.get(NUT_VARIABLES.deviceMfr) || '',
+            model: vars.get(NUT_VARIABLES.deviceModel) || '',
+            serial: vars.get(NUT_VARIABLES.deviceSerial) || '',
+            type: vars.get(NUT_VARIABLES.deviceType) || '',
+        };
+    }
+    /**
+     * Ensure connected before command
+     */
+    async ensureConnected() {
+        if (!this.connected) {
+            await this.connect();
+        }
+    }
+    /**
+     * Check if a NUT server is reachable
+     */
+    static async probe(address, port = 3493, timeout = 3000) {
+        return new Promise((resolve) => {
+            const socket = new plugins.net.Socket();
+            const timer = setTimeout(() => {
+                socket.destroy();
+                resolve(false);
+            }, timeout);
+            socket.on('connect', () => {
+                clearTimeout(timer);
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on('error', () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+            socket.connect(port, address);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.nut.js","sourceRoot":"","sources":["../../ts/protocols/protocol.nut.ts"],"names":[],"mappings":"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"}

package/dist_ts/protocols/protocol.sane.d.ts

@@ -0,0 +1,104 @@
+import type { ISaneDevice, ISaneParameters, IScanOptions, IScanResult } from '../interfaces/index.js';
+/**
+ * SANE network protocol client
+ */
+export declare class SaneProtocol {
+    private socket;
+    private address;
+    private port;
+    private handle;
+    private options;
+    private readBuffer;
+    constructor(address: string, port?: number);
+    /**
+     * Connect to SANE daemon
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from SANE daemon
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Initialize connection (SANE_NET_INIT)
+     */
+    private init;
+    /**
+     * Get available devices (SANE_NET_GET_DEVICES)
+     */
+    getDevices(): Promise<ISaneDevice[]>;
+    /**
+     * Open a device (SANE_NET_OPEN)
+     */
+    open(deviceName: string): Promise<void>;
+    /**
+     * Close the current device (SANE_NET_CLOSE)
+     */
+    close(): Promise<void>;
+    /**
+     * Exit connection (SANE_NET_EXIT)
+     */
+    private exit;
+    /**
+     * Get option descriptors (SANE_NET_GET_OPTION_DESCRIPTORS)
+     */
+    private getOptionDescriptors;
+    /**
+     * Set an option value
+     */
+    setOption(name: string, value: unknown): Promise<void>;
+    /**
+     * Get scan parameters (SANE_NET_GET_PARAMETERS)
+     */
+    getParameters(): Promise<ISaneParameters>;
+    /**
+     * Start scanning (SANE_NET_START)
+     */
+    start(): Promise<{
+        port: number;
+        byteOrder: 'little' | 'big';
+    }>;
+    /**
+     * Cancel scanning (SANE_NET_CANCEL)
+     */
+    cancel(): Promise<void>;
+    /**
+     * Perform a complete scan
+     */
+    scan(options: IScanOptions): Promise<IScanResult>;
+    /**
+     * Configure scan options based on IScanOptions
+     */
+    private configureOptions;
+    /**
+     * Read image data from data port
+     */
+    private readImageData;
+    /**
+     * Map color mode to SANE mode string
+     */
+    private mapColorMode;
+    /**
+     * Map SANE format code to string
+     */
+    private mapFormat;
+    /**
+     * Map value type code to string
+     */
+    private mapValueType;
+    /**
+     * Map unit code to string
+     */
+    private mapUnit;
+    /**
+     * Map constraint type code to string
+     */
+    private mapConstraintType;
+    private buildRequest;
+    private writeWord;
+    private writeString;
+    private sendRequest;
+    private readResponse;
+    private waitForData;
+    private readWord;
+    private readString;
+}