@ecobridge.xyz/devicemanager 3.0.2

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

@@ -0,0 +1,45 @@
+import type { IPrinterCapabilities, IPrintOptions, IPrintJob } from '../interfaces/index.js';
+/**
+ * IPP protocol wrapper using the ipp npm package
+ */
+export declare class IppProtocol {
+    private printerUrl;
+    private printer;
+    constructor(address: string, port: number, path?: string);
+    /**
+     * Get printer attributes/capabilities
+     */
+    getAttributes(): Promise<IPrinterCapabilities>;
+    /**
+     * Print a document
+     */
+    print(data: Buffer, options?: IPrintOptions): Promise<IPrintJob>;
+    /**
+     * Get all jobs
+     */
+    getJobs(): Promise<IPrintJob[]>;
+    /**
+     * Get specific job info
+     */
+    getJobInfo(jobId: number): Promise<IPrintJob>;
+    /**
+     * Cancel a job
+     */
+    cancelJob(jobId: number): Promise<void>;
+    /**
+     * Check if printer is available
+     */
+    checkAvailability(): Promise<boolean>;
+    /**
+     * Build IPP print message from options
+     */
+    private buildPrintMessage;
+    /**
+     * Parse printer capabilities from attributes
+     */
+    private parseCapabilities;
+    /**
+     * Parse job info from attributes
+     */
+    private parseJobInfo;
+}

package/dist_ts/protocols/protocol.ipp.js

@@ -0,0 +1,284 @@
+import * as plugins from '../plugins.js';
+/**
+ * IPP protocol wrapper using the ipp npm package
+ */
+export class IppProtocol {
+    printerUrl;
+    printer;
+    constructor(address, port, path = '/ipp/print') {
+        this.printerUrl = `ipp://${address}:${port}${path}`;
+        this.printer = plugins.ipp.Printer(this.printerUrl);
+    }
+    /**
+     * Get printer attributes/capabilities
+     */
+    async getAttributes() {
+        return new Promise((resolve, reject) => {
+            this.printer.execute('Get-Printer-Attributes', null, (err, res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                try {
+                    const attrs = res['printer-attributes-tag'] || {};
+                    resolve(this.parseCapabilities(attrs));
+                }
+                catch (parseErr) {
+                    reject(parseErr);
+                }
+            });
+        });
+    }
+    /**
+     * Print a document
+     */
+    async print(data, options) {
+        const msg = this.buildPrintMessage(options);
+        return new Promise((resolve, reject) => {
+            this.printer.execute('Print-Job', { ...msg, data }, (err, res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                try {
+                    const jobAttrs = res['job-attributes-tag'] || {};
+                    resolve(this.parseJobInfo(jobAttrs));
+                }
+                catch (parseErr) {
+                    reject(parseErr);
+                }
+            });
+        });
+    }
+    /**
+     * Get all jobs
+     */
+    async getJobs() {
+        return new Promise((resolve, reject) => {
+            this.printer.execute('Get-Jobs', {
+                'operation-attributes-tag': {
+                    'requesting-user-name': 'devicemanager',
+                    'which-jobs': 'not-completed',
+                },
+            }, (err, res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                try {
+                    const jobs = [];
+                    const jobTags = res['job-attributes-tag'];
+                    if (Array.isArray(jobTags)) {
+                        for (const jobAttrs of jobTags) {
+                            jobs.push(this.parseJobInfo(jobAttrs));
+                        }
+                    }
+                    else if (jobTags && typeof jobTags === 'object') {
+                        jobs.push(this.parseJobInfo(jobTags));
+                    }
+                    resolve(jobs);
+                }
+                catch (parseErr) {
+                    reject(parseErr);
+                }
+            });
+        });
+    }
+    /**
+     * Get specific job info
+     */
+    async getJobInfo(jobId) {
+        return new Promise((resolve, reject) => {
+            this.printer.execute('Get-Job-Attributes', {
+                'operation-attributes-tag': {
+                    'job-id': jobId,
+                },
+            }, (err, res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                try {
+                    const jobAttrs = res['job-attributes-tag'] || {};
+                    resolve(this.parseJobInfo(jobAttrs));
+                }
+                catch (parseErr) {
+                    reject(parseErr);
+                }
+            });
+        });
+    }
+    /**
+     * Cancel a job
+     */
+    async cancelJob(jobId) {
+        return new Promise((resolve, reject) => {
+            this.printer.execute('Cancel-Job', {
+                'operation-attributes-tag': {
+                    'job-id': jobId,
+                },
+            }, (err, _res) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Check if printer is available
+     */
+    async checkAvailability() {
+        try {
+            await this.getAttributes();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Build IPP print message from options
+     */
+    buildPrintMessage(options) {
+        const operationAttrs = {
+            'requesting-user-name': 'devicemanager',
+            'job-name': options?.jobName ?? 'Print Job',
+            'document-format': 'application/octet-stream',
+        };
+        const jobAttrs = {};
+        if (options?.copies && options.copies > 1) {
+            jobAttrs['copies'] = options.copies;
+        }
+        if (options?.mediaSize) {
+            jobAttrs['media'] = options.mediaSize;
+        }
+        if (options?.mediaType) {
+            jobAttrs['media-type'] = options.mediaType;
+        }
+        if (options?.sides) {
+            jobAttrs['sides'] = options.sides;
+        }
+        if (options?.quality) {
+            const qualityMap = {
+                draft: 3,
+                normal: 4,
+                high: 5,
+            };
+            jobAttrs['print-quality'] = qualityMap[options.quality] ?? 4;
+        }
+        if (options?.colorMode) {
+            jobAttrs['print-color-mode'] = options.colorMode;
+        }
+        const msg = {
+            'operation-attributes-tag': operationAttrs,
+        };
+        if (Object.keys(jobAttrs).length > 0) {
+            msg['job-attributes-tag'] = jobAttrs;
+        }
+        return msg;
+    }
+    /**
+     * Parse printer capabilities from attributes
+     */
+    parseCapabilities(attrs) {
+        const getArray = (key) => {
+            const value = attrs[key];
+            if (Array.isArray(value))
+                return value.map(String);
+            if (value !== undefined)
+                return [String(value)];
+            return [];
+        };
+        const getNumber = (key, defaultVal) => {
+            const value = attrs[key];
+            if (typeof value === 'number')
+                return value;
+            if (typeof value === 'string')
+                return parseInt(value) || defaultVal;
+            return defaultVal;
+        };
+        const getBool = (key, defaultVal) => {
+            const value = attrs[key];
+            if (typeof value === 'boolean')
+                return value;
+            if (value === 'true' || value === 1)
+                return true;
+            if (value === 'false' || value === 0)
+                return false;
+            return defaultVal;
+        };
+        // Parse resolutions
+        const resolutions = [];
+        const resSupported = attrs['printer-resolution-supported'];
+        if (Array.isArray(resSupported)) {
+            for (const res of resSupported) {
+                if (typeof res === 'object' && res !== null && 'x' in res) {
+                    resolutions.push(res.x);
+                }
+                else if (typeof res === 'number') {
+                    resolutions.push(res);
+                }
+            }
+        }
+        if (resolutions.length === 0) {
+            resolutions.push(300, 600);
+        }
+        return {
+            colorSupported: getBool('color-supported', false),
+            duplexSupported: getArray('sides-supported').some((s) => s.includes('two-sided')),
+            mediaSizes: getArray('media-supported'),
+            mediaTypes: getArray('media-type-supported'),
+            resolutions: [...new Set(resolutions)],
+            maxCopies: getNumber('copies-supported', 99),
+            sidesSupported: getArray('sides-supported'),
+            qualitySupported: getArray('print-quality-supported').map(String),
+        };
+    }
+    /**
+     * Parse job info from attributes
+     */
+    parseJobInfo(attrs) {
+        const getString = (key, defaultVal) => {
+            const value = attrs[key];
+            if (typeof value === 'string')
+                return value;
+            if (value !== undefined)
+                return String(value);
+            return defaultVal;
+        };
+        const getNumber = (key, defaultVal) => {
+            const value = attrs[key];
+            if (typeof value === 'number')
+                return value;
+            if (typeof value === 'string')
+                return parseInt(value) || defaultVal;
+            return defaultVal;
+        };
+        // Map IPP job state to our state
+        const ippState = getNumber('job-state', 3);
+        const stateMap = {
+            3: 'pending', // pending
+            4: 'pending', // pending-held
+            5: 'processing', // processing
+            6: 'processing', // processing-stopped
+            7: 'canceled', // canceled
+            8: 'aborted', // aborted
+            9: 'completed', // completed
+        };
+        const createdTime = attrs['time-at-creation'];
+        const completedTime = attrs['time-at-completed'];
+        return {
+            id: getNumber('job-id', 0),
+            name: getString('job-name', 'Unknown Job'),
+            state: stateMap[ippState] ?? 'pending',
+            stateReason: getString('job-state-reasons', undefined),
+            createdAt: createdTime ? new Date(createdTime * 1000) : new Date(),
+            completedAt: completedTime ? new Date(completedTime * 1000) : undefined,
+            pagesPrinted: getNumber('job-media-sheets-completed', undefined),
+            pagesTotal: getNumber('job-media-sheets', undefined),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.ipp.js","sourceRoot":"","sources":["../../ts/protocols/protocol.ipp.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,160 @@
+/**
+ * NUT Protocol variable definitions
+ */
+export declare const NUT_VARIABLES: {
+    deviceMfr: string;
+    deviceModel: string;
+    deviceSerial: string;
+    deviceType: string;
+    upsStatus: string;
+    upsAlarm: string;
+    upsTime: string;
+    upsLoad: string;
+    upsTemperature: string;
+    batteryCharge: string;
+    batteryRuntime: string;
+    batteryVoltage: string;
+    batteryVoltageNominal: string;
+    batteryType: string;
+    batteryDate: string;
+    batteryTemperature: string;
+    inputVoltage: string;
+    inputVoltageNominal: string;
+    inputFrequency: string;
+    inputFrequencyNominal: string;
+    inputTransferHigh: string;
+    inputTransferLow: string;
+    outputVoltage: string;
+    outputVoltageNominal: string;
+    outputFrequency: string;
+    outputCurrent: string;
+};
+/**
+ * NUT instant commands
+ */
+export declare const NUT_COMMANDS: {
+    testBatteryStart: string;
+    testBatteryStartQuick: string;
+    testBatteryStartDeep: string;
+    testBatteryStop: string;
+    calibrateStart: string;
+    calibrateStop: string;
+    shutdown: string;
+    shutdownStayOff: string;
+    shutdownStop: string;
+    shutdownReboot: string;
+    beeperEnable: string;
+    beeperDisable: string;
+    beeperMute: string;
+    beeperToggle: string;
+    loadOff: string;
+    loadOn: string;
+};
+/**
+ * UPS status flags from NUT
+ */
+export type TNutStatusFlag = 'OL' | 'OB' | 'LB' | 'HB' | 'RB' | 'CHRG' | 'DISCHRG' | 'BYPASS' | 'CAL' | 'OFF' | 'OVER' | 'TRIM' | 'BOOST' | 'FSD';
+/**
+ * NUT UPS information
+ */
+export interface INutUpsInfo {
+    name: string;
+    description: string;
+}
+/**
+ * NUT variable
+ */
+export interface INutVariable {
+    name: string;
+    value: string;
+}
+/**
+ * NUT Protocol handler for Network UPS Tools
+ * TCP-based text protocol on port 3493
+ */
+export declare class NutProtocol {
+    private socket;
+    private address;
+    private port;
+    private connected;
+    private responseBuffer;
+    private responseResolver;
+    private responseRejecter;
+    constructor(address: string, port?: number);
+    /**
+     * Connect to NUT server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from NUT server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Handle incoming data
+     */
+    private handleData;
+    /**
+     * Send command and get response
+     */
+    private sendCommand;
+    /**
+     * List available UPS devices
+     */
+    listUps(): Promise<INutUpsInfo[]>;
+    /**
+     * Get all variables for a UPS
+     */
+    listVariables(upsName: string): Promise<INutVariable[]>;
+    /**
+     * Get a specific variable value
+     */
+    getVariable(upsName: string, varName: string): Promise<string | null>;
+    /**
+     * Get multiple variables at once
+     */
+    getVariables(upsName: string, varNames: string[]): Promise<Map<string, string>>;
+    /**
+     * Execute an instant command
+     */
+    runCommand(upsName: string, command: string): Promise<boolean>;
+    /**
+     * List available commands for a UPS
+     */
+    listCommands(upsName: string): Promise<string[]>;
+    /**
+     * Parse UPS status string into flags
+     */
+    parseStatus(statusString: string): TNutStatusFlag[];
+    /**
+     * Get comprehensive UPS status
+     */
+    getUpsStatus(upsName: string): Promise<{
+        status: TNutStatusFlag[];
+        batteryCharge: number;
+        batteryRuntime: number;
+        inputVoltage: number;
+        outputVoltage: number;
+        load: number;
+    }>;
+    /**
+     * Get device information
+     */
+    getDeviceInfo(upsName: string): Promise<{
+        manufacturer: string;
+        model: string;
+        serial: string;
+        type: string;
+    }>;
+    /**
+     * Ensure connected before command
+     */
+    private ensureConnected;
+    /**
+     * Check if a NUT server is reachable
+     */
+    static probe(address: string, port?: number, timeout?: number): Promise<boolean>;
+}