@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/protocols/protocol.sane.js

@@ -0,0 +1,597 @@
+import * as plugins from '../plugins.js';
+/**
+ * SANE network protocol RPC codes
+ */
+var SaneRpc;
+(function (SaneRpc) {
+    SaneRpc[SaneRpc["INIT"] = 0] = "INIT";
+    SaneRpc[SaneRpc["GET_DEVICES"] = 1] = "GET_DEVICES";
+    SaneRpc[SaneRpc["OPEN"] = 2] = "OPEN";
+    SaneRpc[SaneRpc["CLOSE"] = 3] = "CLOSE";
+    SaneRpc[SaneRpc["GET_OPTION_DESCRIPTORS"] = 4] = "GET_OPTION_DESCRIPTORS";
+    SaneRpc[SaneRpc["CONTROL_OPTION"] = 5] = "CONTROL_OPTION";
+    SaneRpc[SaneRpc["GET_PARAMETERS"] = 6] = "GET_PARAMETERS";
+    SaneRpc[SaneRpc["START"] = 7] = "START";
+    SaneRpc[SaneRpc["CANCEL"] = 8] = "CANCEL";
+    SaneRpc[SaneRpc["AUTHORIZE"] = 9] = "AUTHORIZE";
+    SaneRpc[SaneRpc["EXIT"] = 10] = "EXIT";
+})(SaneRpc || (SaneRpc = {}));
+/**
+ * SANE status codes
+ */
+var SaneStatus;
+(function (SaneStatus) {
+    SaneStatus[SaneStatus["GOOD"] = 0] = "GOOD";
+    SaneStatus[SaneStatus["UNSUPPORTED"] = 1] = "UNSUPPORTED";
+    SaneStatus[SaneStatus["CANCELLED"] = 2] = "CANCELLED";
+    SaneStatus[SaneStatus["DEVICE_BUSY"] = 3] = "DEVICE_BUSY";
+    SaneStatus[SaneStatus["INVAL"] = 4] = "INVAL";
+    SaneStatus[SaneStatus["EOF"] = 5] = "EOF";
+    SaneStatus[SaneStatus["JAMMED"] = 6] = "JAMMED";
+    SaneStatus[SaneStatus["NO_DOCS"] = 7] = "NO_DOCS";
+    SaneStatus[SaneStatus["COVER_OPEN"] = 8] = "COVER_OPEN";
+    SaneStatus[SaneStatus["IO_ERROR"] = 9] = "IO_ERROR";
+    SaneStatus[SaneStatus["NO_MEM"] = 10] = "NO_MEM";
+    SaneStatus[SaneStatus["ACCESS_DENIED"] = 11] = "ACCESS_DENIED";
+})(SaneStatus || (SaneStatus = {}));
+/**
+ * SANE option types
+ */
+var SaneValueType;
+(function (SaneValueType) {
+    SaneValueType[SaneValueType["BOOL"] = 0] = "BOOL";
+    SaneValueType[SaneValueType["INT"] = 1] = "INT";
+    SaneValueType[SaneValueType["FIXED"] = 2] = "FIXED";
+    SaneValueType[SaneValueType["STRING"] = 3] = "STRING";
+    SaneValueType[SaneValueType["BUTTON"] = 4] = "BUTTON";
+    SaneValueType[SaneValueType["GROUP"] = 5] = "GROUP";
+})(SaneValueType || (SaneValueType = {}));
+/**
+ * SANE option units
+ */
+var SaneUnit;
+(function (SaneUnit) {
+    SaneUnit[SaneUnit["NONE"] = 0] = "NONE";
+    SaneUnit[SaneUnit["PIXEL"] = 1] = "PIXEL";
+    SaneUnit[SaneUnit["BIT"] = 2] = "BIT";
+    SaneUnit[SaneUnit["MM"] = 3] = "MM";
+    SaneUnit[SaneUnit["DPI"] = 4] = "DPI";
+    SaneUnit[SaneUnit["PERCENT"] = 5] = "PERCENT";
+    SaneUnit[SaneUnit["MICROSECOND"] = 6] = "MICROSECOND";
+})(SaneUnit || (SaneUnit = {}));
+/**
+ * SANE constraint types
+ */
+var SaneConstraintType;
+(function (SaneConstraintType) {
+    SaneConstraintType[SaneConstraintType["NONE"] = 0] = "NONE";
+    SaneConstraintType[SaneConstraintType["RANGE"] = 1] = "RANGE";
+    SaneConstraintType[SaneConstraintType["WORD_LIST"] = 2] = "WORD_LIST";
+    SaneConstraintType[SaneConstraintType["STRING_LIST"] = 3] = "STRING_LIST";
+})(SaneConstraintType || (SaneConstraintType = {}));
+/**
+ * SANE control option actions
+ */
+var SaneAction;
+(function (SaneAction) {
+    SaneAction[SaneAction["GET_VALUE"] = 0] = "GET_VALUE";
+    SaneAction[SaneAction["SET_VALUE"] = 1] = "SET_VALUE";
+    SaneAction[SaneAction["SET_AUTO"] = 2] = "SET_AUTO";
+})(SaneAction || (SaneAction = {}));
+const SANE_PORT = 6566;
+const SANE_NET_PROTOCOL_VERSION = 3;
+/**
+ * Status code to error message mapping
+ */
+const STATUS_MESSAGES = {
+    [SaneStatus.GOOD]: 'Success',
+    [SaneStatus.UNSUPPORTED]: 'Operation not supported',
+    [SaneStatus.CANCELLED]: 'Operation cancelled',
+    [SaneStatus.DEVICE_BUSY]: 'Device busy',
+    [SaneStatus.INVAL]: 'Invalid argument',
+    [SaneStatus.EOF]: 'End of file',
+    [SaneStatus.JAMMED]: 'Document feeder jammed',
+    [SaneStatus.NO_DOCS]: 'No documents in feeder',
+    [SaneStatus.COVER_OPEN]: 'Scanner cover open',
+    [SaneStatus.IO_ERROR]: 'I/O error',
+    [SaneStatus.NO_MEM]: 'Out of memory',
+    [SaneStatus.ACCESS_DENIED]: 'Access denied',
+};
+/**
+ * SANE network protocol client
+ */
+export class SaneProtocol {
+    socket = null;
+    address;
+    port;
+    handle = -1;
+    options = [];
+    readBuffer = Buffer.alloc(0);
+    constructor(address, port = SANE_PORT) {
+        this.address = address;
+        this.port = port;
+    }
+    /**
+     * Connect to SANE daemon
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.socket = plugins.net.createConnection({ host: this.address, port: this.port }, () => {
+                this.init()
+                    .then(() => resolve())
+                    .catch(reject);
+            });
+            this.socket.on('error', reject);
+            this.socket.on('data', (data) => {
+                this.readBuffer = Buffer.concat([this.readBuffer, data]);
+            });
+        });
+    }
+    /**
+     * Disconnect from SANE daemon
+     */
+    async disconnect() {
+        if (this.handle >= 0) {
+            await this.close();
+        }
+        await this.exit();
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    /**
+     * Initialize connection (SANE_NET_INIT)
+     */
+    async init() {
+        const request = this.buildRequest(SaneRpc.INIT);
+        this.writeWord(request, SANE_NET_PROTOCOL_VERSION);
+        this.writeString(request, ''); // Username (empty for now)
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        const version = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            throw new Error(`SANE init failed: ${STATUS_MESSAGES[status] || 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get available devices (SANE_NET_GET_DEVICES)
+     */
+    async getDevices() {
+        const request = this.buildRequest(SaneRpc.GET_DEVICES);
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            throw new Error(`Failed to get devices: ${STATUS_MESSAGES[status]}`);
+        }
+        const devices = [];
+        const count = this.readWord(response);
+        for (let i = 0; i < count; i++) {
+            const hasDevice = this.readWord(response);
+            if (hasDevice) {
+                devices.push({
+                    name: this.readString(response),
+                    vendor: this.readString(response),
+                    model: this.readString(response),
+                    type: this.readString(response),
+                });
+            }
+        }
+        return devices;
+    }
+    /**
+     * Open a device (SANE_NET_OPEN)
+     */
+    async open(deviceName) {
+        const request = this.buildRequest(SaneRpc.OPEN);
+        this.writeString(request, deviceName);
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            // Check for authorization required
+            const resource = this.readString(response);
+            if (resource) {
+                throw new Error(`Authorization required for: ${resource}`);
+            }
+            throw new Error(`Failed to open device: ${STATUS_MESSAGES[status]}`);
+        }
+        this.handle = this.readWord(response);
+        this.readString(response); // resource (should be empty on success)
+        // Get option descriptors
+        await this.getOptionDescriptors();
+    }
+    /**
+     * Close the current device (SANE_NET_CLOSE)
+     */
+    async close() {
+        if (this.handle < 0) {
+            return;
+        }
+        const request = this.buildRequest(SaneRpc.CLOSE);
+        this.writeWord(request, this.handle);
+        await this.sendRequest(request);
+        await this.readResponse(); // Just read to clear buffer
+        this.handle = -1;
+        this.options = [];
+    }
+    /**
+     * Exit connection (SANE_NET_EXIT)
+     */
+    async exit() {
+        const request = this.buildRequest(SaneRpc.EXIT);
+        await this.sendRequest(request);
+    }
+    /**
+     * Get option descriptors (SANE_NET_GET_OPTION_DESCRIPTORS)
+     */
+    async getOptionDescriptors() {
+        const request = this.buildRequest(SaneRpc.GET_OPTION_DESCRIPTORS);
+        this.writeWord(request, this.handle);
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const count = this.readWord(response);
+        this.options = [];
+        for (let i = 0; i < count; i++) {
+            const hasOption = this.readWord(response);
+            if (!hasOption) {
+                continue;
+            }
+            const option = {
+                name: this.readString(response),
+                title: this.readString(response),
+                description: this.readString(response),
+                type: this.mapValueType(this.readWord(response)),
+                unit: this.mapUnit(this.readWord(response)),
+                size: this.readWord(response),
+                capabilities: this.readWord(response),
+                constraintType: this.mapConstraintType(this.readWord(response)),
+            };
+            // Read constraint based on type
+            if (option.constraintType === 'range') {
+                option.constraint = {
+                    range: {
+                        min: this.readWord(response),
+                        max: this.readWord(response),
+                        quant: this.readWord(response),
+                    },
+                };
+            }
+            else if (option.constraintType === 'word_list') {
+                const wordCount = this.readWord(response);
+                const words = [];
+                for (let j = 0; j < wordCount; j++) {
+                    words.push(this.readWord(response));
+                }
+                option.constraint = { wordList: words };
+            }
+            else if (option.constraintType === 'string_list') {
+                const strings = [];
+                let str;
+                while ((str = this.readString(response)) !== '') {
+                    strings.push(str);
+                }
+                option.constraint = { stringList: strings };
+            }
+            this.options.push(option);
+        }
+    }
+    /**
+     * Set an option value
+     */
+    async setOption(name, value) {
+        const optionIndex = this.options.findIndex((o) => o.name === name);
+        if (optionIndex < 0) {
+            throw new Error(`Unknown option: ${name}`);
+        }
+        const option = this.options[optionIndex];
+        const request = this.buildRequest(SaneRpc.CONTROL_OPTION);
+        this.writeWord(request, this.handle);
+        this.writeWord(request, optionIndex);
+        this.writeWord(request, SaneAction.SET_VALUE);
+        this.writeWord(request, option.type === 'string' ? value.length + 1 : option.size);
+        // Write value based on type
+        if (option.type === 'bool' || option.type === 'int') {
+            this.writeWord(request, value);
+        }
+        else if (option.type === 'fixed') {
+            this.writeWord(request, Math.round(value * 65536));
+        }
+        else if (option.type === 'string') {
+            this.writeString(request, value);
+        }
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            throw new Error(`Failed to set option ${name}: ${STATUS_MESSAGES[status]}`);
+        }
+    }
+    /**
+     * Get scan parameters (SANE_NET_GET_PARAMETERS)
+     */
+    async getParameters() {
+        const request = this.buildRequest(SaneRpc.GET_PARAMETERS);
+        this.writeWord(request, this.handle);
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            throw new Error(`Failed to get parameters: ${STATUS_MESSAGES[status]}`);
+        }
+        const formatCode = this.readWord(response);
+        const format = this.mapFormat(formatCode);
+        return {
+            format,
+            lastFrame: this.readWord(response) === 1,
+            bytesPerLine: this.readWord(response),
+            pixelsPerLine: this.readWord(response),
+            lines: this.readWord(response),
+            depth: this.readWord(response),
+        };
+    }
+    /**
+     * Start scanning (SANE_NET_START)
+     */
+    async start() {
+        const request = this.buildRequest(SaneRpc.START);
+        this.writeWord(request, this.handle);
+        await this.sendRequest(request);
+        const response = await this.readResponse();
+        const status = this.readWord(response);
+        if (status !== SaneStatus.GOOD) {
+            throw new Error(`Failed to start scan: ${STATUS_MESSAGES[status]}`);
+        }
+        const port = this.readWord(response);
+        const byteOrder = this.readWord(response) === 0x1234 ? 'little' : 'big';
+        this.readString(response); // resource
+        return { port, byteOrder };
+    }
+    /**
+     * Cancel scanning (SANE_NET_CANCEL)
+     */
+    async cancel() {
+        const request = this.buildRequest(SaneRpc.CANCEL);
+        this.writeWord(request, this.handle);
+        await this.sendRequest(request);
+        await this.readResponse();
+    }
+    /**
+     * Perform a complete scan
+     */
+    async scan(options) {
+        // Configure scan options
+        await this.configureOptions(options);
+        // Get parameters
+        const params = await this.getParameters();
+        // Start scan and get data port
+        const { port, byteOrder } = await this.start();
+        // Connect to data port and read image data
+        const imageData = await this.readImageData(port, params, byteOrder);
+        return {
+            data: imageData,
+            format: options.format ?? 'png',
+            width: params.pixelsPerLine,
+            height: params.lines,
+            resolution: options.resolution ?? 300,
+            colorMode: options.colorMode ?? 'color',
+            mimeType: `image/${options.format ?? 'png'}`,
+        };
+    }
+    /**
+     * Configure scan options based on IScanOptions
+     */
+    async configureOptions(options) {
+        // Set resolution
+        if (options.resolution) {
+            const resOption = this.options.find((o) => o.name === 'resolution');
+            if (resOption) {
+                await this.setOption('resolution', options.resolution);
+            }
+        }
+        // Set color mode
+        if (options.colorMode) {
+            const modeOption = this.options.find((o) => o.name === 'mode');
+            if (modeOption) {
+                const modeValue = this.mapColorMode(options.colorMode);
+                await this.setOption('mode', modeValue);
+            }
+        }
+        // Set scan area
+        if (options.area) {
+            const tlxOption = this.options.find((o) => o.name === 'tl-x');
+            const tlyOption = this.options.find((o) => o.name === 'tl-y');
+            const brxOption = this.options.find((o) => o.name === 'br-x');
+            const bryOption = this.options.find((o) => o.name === 'br-y');
+            if (tlxOption)
+                await this.setOption('tl-x', options.area.x);
+            if (tlyOption)
+                await this.setOption('tl-y', options.area.y);
+            if (brxOption)
+                await this.setOption('br-x', options.area.x + options.area.width);
+            if (bryOption)
+                await this.setOption('br-y', options.area.y + options.area.height);
+        }
+        // Set source
+        if (options.source) {
+            const sourceOption = this.options.find((o) => o.name === 'source');
+            if (sourceOption) {
+                await this.setOption('source', options.source);
+            }
+        }
+    }
+    /**
+     * Read image data from data port
+     */
+    async readImageData(port, params, _byteOrder) {
+        return new Promise((resolve, reject) => {
+            const dataSocket = plugins.net.createConnection({ host: this.address, port }, () => {
+                const chunks = [];
+                dataSocket.on('data', (data) => {
+                    // Data format: 4 bytes length + data
+                    // Read records until length is 0xFFFFFFFF (end marker)
+                    let offset = 0;
+                    while (offset < data.length) {
+                        if (offset + 4 > data.length) {
+                            break;
+                        }
+                        const length = data.readUInt32BE(offset);
+                        offset += 4;
+                        if (length === 0xffffffff) {
+                            // End of data
+                            dataSocket.destroy();
+                            resolve(Buffer.concat(chunks));
+                            return;
+                        }
+                        if (offset + length > data.length) {
+                            // Incomplete record, wait for more data
+                            break;
+                        }
+                        chunks.push(data.subarray(offset, offset + length));
+                        offset += length;
+                    }
+                });
+                dataSocket.on('end', () => {
+                    resolve(Buffer.concat(chunks));
+                });
+                dataSocket.on('error', reject);
+            });
+            dataSocket.on('error', reject);
+        });
+    }
+    /**
+     * Map color mode to SANE mode string
+     */
+    mapColorMode(mode) {
+        switch (mode) {
+            case 'color':
+                return 'Color';
+            case 'grayscale':
+                return 'Gray';
+            case 'blackwhite':
+                return 'Lineart';
+            default:
+                return 'Color';
+        }
+    }
+    /**
+     * Map SANE format code to string
+     */
+    mapFormat(code) {
+        const formats = {
+            0: 'gray',
+            1: 'rgb',
+            2: 'red',
+            3: 'green',
+            4: 'blue',
+        };
+        return formats[code] ?? 'gray';
+    }
+    /**
+     * Map value type code to string
+     */
+    mapValueType(code) {
+        const types = {
+            [SaneValueType.BOOL]: 'bool',
+            [SaneValueType.INT]: 'int',
+            [SaneValueType.FIXED]: 'fixed',
+            [SaneValueType.STRING]: 'string',
+            [SaneValueType.BUTTON]: 'button',
+            [SaneValueType.GROUP]: 'group',
+        };
+        return types[code] ?? 'int';
+    }
+    /**
+     * Map unit code to string
+     */
+    mapUnit(code) {
+        const units = {
+            [SaneUnit.NONE]: 'none',
+            [SaneUnit.PIXEL]: 'pixel',
+            [SaneUnit.BIT]: 'bit',
+            [SaneUnit.MM]: 'mm',
+            [SaneUnit.DPI]: 'dpi',
+            [SaneUnit.PERCENT]: 'percent',
+            [SaneUnit.MICROSECOND]: 'microsecond',
+        };
+        return units[code] ?? 'none';
+    }
+    /**
+     * Map constraint type code to string
+     */
+    mapConstraintType(code) {
+        const types = {
+            [SaneConstraintType.NONE]: 'none',
+            [SaneConstraintType.RANGE]: 'range',
+            [SaneConstraintType.WORD_LIST]: 'word_list',
+            [SaneConstraintType.STRING_LIST]: 'string_list',
+        };
+        return types[code] ?? 'none';
+    }
+    // =========================================================================
+    // Low-level protocol helpers
+    // =========================================================================
+    buildRequest(rpc) {
+        const chunks = [];
+        const header = Buffer.alloc(4);
+        header.writeUInt32BE(rpc, 0);
+        chunks.push(header);
+        return chunks;
+    }
+    writeWord(chunks, value) {
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32BE(value >>> 0, 0);
+        chunks.push(buf);
+    }
+    writeString(chunks, str) {
+        const strBuf = Buffer.from(str + '\0', 'utf-8');
+        this.writeWord(chunks, strBuf.length);
+        chunks.push(strBuf);
+    }
+    async sendRequest(chunks) {
+        if (!this.socket) {
+            throw new Error('Not connected');
+        }
+        const data = Buffer.concat(chunks);
+        return new Promise((resolve, reject) => {
+            this.socket.write(data, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    async readResponse() {
+        // Wait for data
+        await this.waitForData(4);
+        return { buffer: this.readBuffer, offset: 0 };
+    }
+    async waitForData(minBytes) {
+        const startTime = Date.now();
+        const timeout = 30000;
+        while (this.readBuffer.length < minBytes) {
+            if (Date.now() - startTime > timeout) {
+                throw new Error('Timeout waiting for SANE response');
+            }
+            await plugins.smartdelay.delayFor(10);
+        }
+    }
+    readWord(response) {
+        const value = response.buffer.readUInt32BE(response.offset);
+        response.offset += 4;
+        return value;
+    }
+    readString(response) {
+        const length = this.readWord(response);
+        if (length === 0) {
+            return '';
+        }
+        const str = response.buffer.toString('utf-8', response.offset, response.offset + length - 1);
+        response.offset += length;
+        return str;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.sane.js","sourceRoot":"","sources":["../../ts/protocols/protocol.sane.ts"],"names":[],"mappings":"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"}