@ecobridge.xyz/devicemanager 3.1.1 → 3.2.0

package/dist_ts/protocols/protocol.brother.js

@@ -0,0 +1,560 @@
+import * as plugins from '../plugins.js';
+const BROTHER_SCAN_PORT = 54921;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_SCAN_TIMEOUT_MS = 10 * 60_000;
+const DEFAULT_BUSY_RETRY_INTERVAL_MS = 1_000;
+const DEFAULT_BUSY_TIMEOUT_MS = 30_000;
+const MAX_PAGES = 500;
+const MAX_PAGE_BYTES = 256 * 1024 * 1024;
+const TERMINATOR = 0x80;
+export class BrotherScanError extends Error {
+    code;
+    statusCode;
+    constructor(message, code, statusCode) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.name = 'BrotherScanError';
+    }
+}
+class SocketBuffer {
+    socket;
+    buffer = Buffer.alloc(0);
+    error = null;
+    ended = false;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on('data', (data) => {
+            this.buffer = Buffer.concat([this.buffer, data]);
+        });
+        socket.on('error', (error) => {
+            this.error = error;
+        });
+        socket.on('end', () => {
+            this.ended = true;
+        });
+        socket.on('close', () => {
+            this.ended = true;
+        });
+    }
+    discard() {
+        this.buffer = Buffer.alloc(0);
+    }
+    async readExactly(length, timeout) {
+        await this.waitForLength(length, timeout);
+        const result = this.buffer.subarray(0, length);
+        this.buffer = this.buffer.subarray(length);
+        return result;
+    }
+    async peekExactly(length, timeout) {
+        await this.waitForLength(length, timeout);
+        return this.buffer.subarray(0, length);
+    }
+    async readUntil(delimiter, timeout, maxLength) {
+        const deadline = Date.now() + timeout;
+        while (true) {
+            const index = this.buffer.indexOf(delimiter);
+            if (index >= 0) {
+                const end = index + delimiter.length;
+                const result = this.buffer.subarray(0, end);
+                this.buffer = this.buffer.subarray(end);
+                return result;
+            }
+            if (this.buffer.length > maxLength) {
+                throw new BrotherScanError('Brother scanner response exceeded the expected length', 'invalid-response');
+            }
+            await this.waitForData(deadline);
+        }
+    }
+    async readMatch(pattern, timeout, maxLength) {
+        const deadline = Date.now() + timeout;
+        while (true) {
+            const match = this.buffer.toString('latin1').match(pattern);
+            if (match)
+                return match;
+            if (this.buffer.length > maxLength) {
+                throw new BrotherScanError('Brother scanner lease response was malformed', 'invalid-response');
+            }
+            await this.waitForData(deadline);
+        }
+    }
+    async waitForLength(length, timeout) {
+        const deadline = Date.now() + timeout;
+        while (this.buffer.length < length) {
+            await this.waitForData(deadline);
+        }
+    }
+    async waitForData(deadline) {
+        if (this.error)
+            throw this.error;
+        if (this.ended) {
+            throw new BrotherScanError('Brother scanner closed the connection', 'invalid-response');
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            throw new BrotherScanError('Timed out waiting for the Brother scanner', 'timeout');
+        }
+        await new Promise((resolve, reject) => {
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.socket.off('data', onData);
+                this.socket.off('error', onError);
+                this.socket.off('end', onEnd);
+                this.socket.off('close', onEnd);
+            };
+            const onData = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            const onEnd = () => {
+                cleanup();
+                reject(new BrotherScanError('Brother scanner closed the connection', 'invalid-response'));
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                reject(new BrotherScanError('Timed out waiting for the Brother scanner', 'timeout'));
+            }, remaining);
+            this.socket.once('data', onData);
+            this.socket.once('error', onError);
+            this.socket.once('end', onEnd);
+            this.socket.once('close', onEnd);
+        });
+    }
+}
+/**
+ * Brother's native network scan protocol on TCP 54921.
+ *
+ * Brother devices expose richer scan control here than they do through some
+ * eSCL implementations. The protocol returns one JPEG stream per sheet/side.
+ */
+export class BrotherScanProtocol {
+    address;
+    port;
+    socket = null;
+    reader = null;
+    scanning = false;
+    cancelled = false;
+    timeout;
+    scanTimeout;
+    busyRetryInterval;
+    busyTimeout;
+    constructor(address, port = BROTHER_SCAN_PORT, options = {}) {
+        this.address = address;
+        this.port = port;
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.scanTimeout = options.scanTimeout ?? DEFAULT_SCAN_TIMEOUT_MS;
+        this.busyRetryInterval = options.busyRetryInterval ?? DEFAULT_BUSY_RETRY_INTERVAL_MS;
+        this.busyTimeout = options.busyTimeout ?? DEFAULT_BUSY_TIMEOUT_MS;
+    }
+    async connect() {
+        if (this.socket && !this.socket.destroyed)
+            return;
+        const busyDeadline = Date.now() + this.busyTimeout;
+        while (true) {
+            try {
+                await this.connectOnce();
+                return;
+            }
+            catch (error) {
+                await this.disconnect();
+                if (!(error instanceof BrotherScanError) ||
+                    error.code !== 'busy' ||
+                    Date.now() >= busyDeadline) {
+                    throw error;
+                }
+                await delay(Math.min(this.busyRetryInterval, Math.max(0, busyDeadline - Date.now())));
+            }
+        }
+    }
+    async connectOnce() {
+        const socket = new plugins.net.Socket();
+        socket.setNoDelay(true);
+        this.socket = socket;
+        this.reader = new SocketBuffer(socket);
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                socket.destroy();
+                reject(new BrotherScanError('Timed out connecting to the Brother scanner', 'timeout'));
+            }, this.timeout);
+            const cleanup = () => {
+                clearTimeout(timer);
+                socket.off('connect', onConnect);
+                socket.off('error', onError);
+            };
+            const onConnect = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            socket.once('connect', onConnect);
+            socket.once('error', onError);
+            socket.connect(this.port, this.address);
+        });
+        const banner = (await this.requireReader().readUntil(Buffer.from('\r\n'), this.timeout, 128))
+            .toString('ascii')
+            .trim();
+        if (banner.startsWith('+OK 200'))
+            return;
+        if (banner.startsWith('-NG 401')) {
+            throw new BrotherScanError('Brother scanner is busy', 'busy');
+        }
+        throw new BrotherScanError(`Unexpected Brother scanner banner: ${banner}`, 'invalid-response');
+    }
+    async disconnect() {
+        const socket = this.socket;
+        this.socket = null;
+        this.reader = null;
+        this.scanning = false;
+        if (!socket || socket.destroyed)
+            return;
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                socket.off('close', finish);
+                socket.off('error', finish);
+                if (!socket.destroyed)
+                    socket.destroy();
+                resolve();
+            };
+            const timer = setTimeout(finish, 250);
+            socket.once('close', finish);
+            socket.once('error', finish);
+            socket.end();
+        });
+    }
+    getCapabilities() {
+        return {
+            resolutions: [100, 150, 200, 300, 600],
+            formats: ['jpeg'],
+            colorModes: ['color'],
+            sources: ['flatbed', 'adf', 'adf-duplex'],
+            maxWidth: 215.9,
+            maxHeight: 355.6,
+            minWidth: 10,
+            minHeight: 10,
+        };
+    }
+    async scan(options) {
+        if (!this.socket || !this.reader) {
+            throw new Error('Brother scanner is not connected');
+        }
+        if (this.scanning) {
+            throw new BrotherScanError('A Brother scan is already in progress', 'busy');
+        }
+        this.validateOptions(options);
+        this.scanning = true;
+        this.cancelled = false;
+        try {
+            await this.selectSource(options.source);
+            const lease = await this.requestLease(options.resolution);
+            this.assertLease(lease, options);
+            const area = this.resolveScanArea(options.area, lease);
+            await this.writeCommand([
+                '\x1bX',
+                `R=${lease.resolutionX},${lease.resolutionY}`,
+                'M=CGRAY',
+                'C=JPEG',
+                'J=MID',
+                'B=50',
+                'N=50',
+                `A=${area.x},${area.y},${area.x + area.width},${area.y + area.height}`,
+                options.source === 'adf-duplex' ? 'D=DUP' : 'D=SIN',
+            ]);
+            const pages = await this.readPages();
+            if (pages.length === 0) {
+                throw new BrotherScanError('Brother scanner returned no document data', 'no-document');
+            }
+            const firstMetadata = readJpegMetadata(pages[0]);
+            return {
+                data: pages[0],
+                format: 'jpeg',
+                width: firstMetadata.width ?? area.width,
+                height: firstMetadata.height ?? area.height,
+                resolution: firstMetadata.resolution ?? lease.resolutionX,
+                colorMode: 'color',
+                mimeType: 'image/jpeg',
+                pageCount: pages.length,
+                pages: pages.map((data) => {
+                    const metadata = readJpegMetadata(data);
+                    return {
+                        data,
+                        width: metadata.width ?? area.width,
+                        height: metadata.height ?? area.height,
+                        mimeType: 'image/jpeg',
+                    };
+                }),
+                isComplete: true,
+                settingsWarnings: [],
+            };
+        }
+        catch (error) {
+            if (this.cancelled) {
+                throw new BrotherScanError('Brother scan was cancelled', 'cancelled');
+            }
+            try {
+                await this.write(Buffer.from([0x1b, 0x52]));
+            }
+            catch {
+                // Preserve the scan error if the connection is already gone.
+            }
+            throw error;
+        }
+        finally {
+            this.scanning = false;
+        }
+    }
+    async cancel() {
+        if (!this.socket || !this.scanning)
+            return;
+        this.cancelled = true;
+        await this.write(Buffer.from([0x1b, 0x52]));
+    }
+    validateOptions(options) {
+        if (options.format !== 'jpeg') {
+            throw new BrotherScanError(`Brother native scanning returns JPEG pages, not ${options.format}`, 'unsupported');
+        }
+        if (options.colorMode !== 'color') {
+            throw new BrotherScanError(`Brother native ${options.colorMode} decoding is not implemented`, 'unsupported');
+        }
+    }
+    async selectSource(source) {
+        const brotherSource = source === 'flatbed' ? 'FB' : 'AUTO';
+        await this.writeCommand(['\x1bS', brotherSource]);
+        const response = await this.requireReader().readExactly(1, this.timeout);
+        if (response[0] !== TERMINATOR) {
+            throw this.statusError(response[0], 'Brother scanner rejected the requested source');
+        }
+    }
+    async requestLease(resolution) {
+        await this.writeCommand(['\x1bI', `R=${resolution},${resolution}`, 'M=CGRAY']);
+        const match = await this.requireReader().readMatch(/(\d+),(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)/, this.timeout, 256);
+        this.requireReader().discard();
+        const values = match.slice(1).map((value) => Number.parseInt(value, 10));
+        return {
+            resolutionX: values[0],
+            resolutionY: values[1],
+            adfStatus: values[2],
+            planeWidth: values[3],
+            width: values[4],
+            planeHeight: values[5],
+            height: values[6],
+        };
+    }
+    assertLease(lease, options) {
+        if (lease.resolutionX !== options.resolution || lease.resolutionY !== options.resolution) {
+            throw new BrotherScanError(`Brother scanner rejected ${options.resolution} dpi and offered ${lease.resolutionX}x${lease.resolutionY} dpi`, 'settings-rejected');
+        }
+        if (lease.width <= 0 || lease.height < 0) {
+            throw new BrotherScanError('Brother scanner returned an invalid scan area', 'invalid-response');
+        }
+    }
+    resolveScanArea(area, lease) {
+        const mmToPixels = (millimetres, dpi) => Math.round((millimetres * dpi) / 25.4);
+        const x = Math.max(0, mmToPixels(area.x, lease.resolutionX));
+        const y = Math.max(0, mmToPixels(area.y, lease.resolutionY));
+        const requestedWidth = mmToPixels(area.width, lease.resolutionX);
+        const requestedHeight = mmToPixels(area.height, lease.resolutionY);
+        const width = Math.max(1, Math.min(requestedWidth, lease.width - x));
+        // Brother ADF leases report zero height because page length is determined
+        // while feeding. Platen leases provide a fixed pixel height.
+        const height = lease.height === 0
+            ? Math.max(1, requestedHeight)
+            : Math.max(1, Math.min(requestedHeight, lease.height - y));
+        if (x >= lease.width || (lease.height > 0 && y >= lease.height)) {
+            throw new BrotherScanError('Requested scan area is outside the scanner bed', 'settings-rejected');
+        }
+        return { x, y, width, height };
+    }
+    async readPages() {
+        const pages = [];
+        let chunks = [];
+        let pageBytes = 0;
+        const wrappedChunks = new Map();
+        const wrappedPageBytes = new Map();
+        const wrappedPages = new Map();
+        let frameMode;
+        while (pages.length + wrappedPages.size < MAX_PAGES) {
+            const header = (await this.requireReader().readExactly(1, this.scanTimeout))[0];
+            if (header < 0x80) {
+                const lengthBytes = await this.requireReader().readExactly(2, this.scanTimeout);
+                const firstLength = lengthBytes.readUInt16LE(0);
+                if (!frameMode) {
+                    const startsWithJpeg = firstLength >= 2 &&
+                        (await this.requireReader().peekExactly(2, this.scanTimeout)).equals(Buffer.from([0xff, 0xd8]));
+                    frameMode = firstLength <= 64 && !startsWithJpeg ? 'wrapped' : 'simple';
+                }
+                if (frameMode === 'wrapped') {
+                    const metadata = await this.requireReader().readExactly(firstLength, this.scanTimeout);
+                    const dataLengthBytes = await this.requireReader().readExactly(2, this.scanTimeout);
+                    const dataLength = dataLengthBytes.readUInt16LE(0);
+                    const imageNumber = metadata.length >= 2 ? metadata.readUInt16LE(0) : 0;
+                    const imageChunks = wrappedChunks.get(imageNumber) ?? [];
+                    imageChunks.push(await this.requireReader().readExactly(dataLength, this.scanTimeout));
+                    wrappedChunks.set(imageNumber, imageChunks);
+                    const imageBytes = (wrappedPageBytes.get(imageNumber) ?? 0) + dataLength;
+                    wrappedPageBytes.set(imageNumber, imageBytes);
+                    if (imageBytes > MAX_PAGE_BYTES) {
+                        throw new BrotherScanError('Brother scanner page exceeded the safety limit', 'invalid-response');
+                    }
+                }
+                else {
+                    chunks.push(await this.requireReader().readExactly(firstLength, this.scanTimeout));
+                    pageBytes += firstLength;
+                    if (pageBytes > MAX_PAGE_BYTES) {
+                        throw new BrotherScanError('Brother scanner page exceeded the safety limit', 'invalid-response');
+                    }
+                }
+                continue;
+            }
+            if (header === 0x84 || header === 0x85) {
+                await this.requireReader().readExactly(1, this.scanTimeout);
+                continue;
+            }
+            if (header === 0x81) {
+                this.finishPage(chunks, pages);
+                chunks = [];
+                pageBytes = 0;
+                frameMode = undefined;
+                await this.writeCommand(['\x1bX']);
+                continue;
+            }
+            if (header === 0x82) {
+                const metadata = await this.requireReader().readExactly(9, this.scanTimeout);
+                const imageNumber = metadata.readUInt16LE(2);
+                let imageChunks = wrappedChunks.get(imageNumber);
+                let resolvedImageNumber = imageNumber;
+                if (!imageChunks && wrappedChunks.size === 1) {
+                    const onlyImage = wrappedChunks.entries().next().value;
+                    resolvedImageNumber = onlyImage[0];
+                    imageChunks = onlyImage[1];
+                }
+                const page = this.makePage(imageChunks ?? []);
+                if (page)
+                    wrappedPages.set(resolvedImageNumber, page);
+                wrappedChunks.delete(resolvedImageNumber);
+                wrappedPageBytes.delete(resolvedImageNumber);
+                frameMode = undefined;
+                continue;
+            }
+            if (header === TERMINATOR) {
+                this.finishPage(chunks, pages);
+                for (const [imageNumber, imageChunks] of wrappedChunks) {
+                    const page = this.makePage(imageChunks);
+                    if (page)
+                        wrappedPages.set(imageNumber, page);
+                }
+                pages.push(...[...wrappedPages.entries()]
+                    .sort(([left], [right]) => left - right)
+                    .map(([, page]) => page));
+                return pages;
+            }
+            throw this.statusError(header, 'Brother scanner stopped the scan');
+        }
+        throw new BrotherScanError(`Brother scanner exceeded the ${MAX_PAGES}-page safety limit`, 'invalid-response');
+    }
+    finishPage(chunks, pages) {
+        const page = this.makePage(chunks);
+        if (page)
+            pages.push(page);
+    }
+    makePage(chunks) {
+        if (chunks.length === 0)
+            return undefined;
+        const page = Buffer.concat(chunks);
+        if (page[0] !== 0xff || page[1] !== 0xd8) {
+            const firstBytes = page.subarray(0, 8).toString('hex');
+            const lastBytes = page.subarray(Math.max(0, page.length - 8)).toString('hex');
+            throw new BrotherScanError(`Brother scanner returned an invalid JPEG page (${page.length} bytes, first ${firstBytes}, last ${lastBytes})`, 'invalid-response');
+        }
+        const endMarker = page.lastIndexOf(Buffer.from([0xff, 0xd9]));
+        return endMarker >= 0
+            ? page.subarray(0, endMarker + 2)
+            : Buffer.concat([page, Buffer.from([0xff, 0xd9])]);
+    }
+    statusError(status, prefix) {
+        if (status === 0xc2)
+            return new BrotherScanError(`${prefix}: no document in feeder`, 'no-document', status);
+        if (status === 0xc3)
+            return new BrotherScanError(`${prefix}: document jam`, 'document-jam', status);
+        if (status === 0xc4)
+            return new BrotherScanError(`${prefix}: cover open`, 'cover-open', status);
+        if (status === 0xc5)
+            return new BrotherScanError(`${prefix}: service error`, 'service-error', status);
+        if (status === 0xc6) {
+            return new BrotherScanError(`${prefix}: device is stuck and must be restarted`, 'device-stuck', status);
+        }
+        if (status === 0x83 || status === 0x86 || status === 0xe3) {
+            return new BrotherScanError(`${prefix}: cancelled`, 'cancelled', status);
+        }
+        return new BrotherScanError(`${prefix}: status 0x${status.toString(16)}`, 'invalid-response', status);
+    }
+    async writeCommand(lines) {
+        const command = `${lines.join('\n')}\n`;
+        await this.write(Buffer.concat([Buffer.from(command, 'ascii'), Buffer.from([TERMINATOR])]));
+    }
+    async write(data) {
+        const socket = this.socket;
+        if (!socket || socket.destroyed) {
+            throw new BrotherScanError('Brother scanner is not connected', 'invalid-response');
+        }
+        await new Promise((resolve, reject) => {
+            socket.write(data, (error) => error ? reject(error) : resolve());
+        });
+    }
+    requireReader() {
+        if (!this.reader)
+            throw new BrotherScanError('Brother scanner is not connected', 'invalid-response');
+        return this.reader;
+    }
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function readJpegMetadata(data) {
+    if (data.length < 4 || data[0] !== 0xff || data[1] !== 0xd8)
+        return {};
+    const metadata = {};
+    const startOfFrameMarkers = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
+    let offset = 2;
+    while (offset + 4 <= data.length) {
+        while (offset < data.length && data[offset] === 0xff)
+            offset++;
+        const marker = data[offset++];
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7))
+            continue;
+        if (offset + 2 > data.length)
+            break;
+        const length = data.readUInt16BE(offset);
+        if (length < 2 || offset + length > data.length)
+            break;
+        const content = offset + 2;
+        if (marker === 0xe0 && length >= 16 && data.toString('ascii', content, content + 5) === 'JFIF\0') {
+            const units = data[content + 7];
+            const density = data.readUInt16BE(content + 8);
+            if (units === 1 && density > 0)
+                metadata.resolution = density;
+            if (units === 2 && density > 0)
+                metadata.resolution = Math.round(density * 2.54);
+        }
+        if (startOfFrameMarkers.has(marker) && length >= 7) {
+            metadata.height = data.readUInt16BE(content + 1);
+            metadata.width = data.readUInt16BE(content + 3);
+        }
+        offset += length;
+    }
+    return metadata;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.brother.js","sourceRoot":"","sources":["../../ts/protocols/protocol.brother.ts"],"names":[],"mappings":"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"}

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

@@ -1,10 +1,15 @@
 import type { IEsclCapabilities, IEsclScanStatus, IScanOptions, IScanResult } from '../interfaces/index.js';
+export declare class EsclScanError extends Error {
+    readonly partialResult?: IScanResult | undefined;
+    constructor(message: string, partialResult?: IScanResult | undefined);
+}
 /**
  * eSCL/AirScan protocol client for network scanners
  */
 export declare class EsclProtocol {
     private baseUrl;
     private capabilities;
+    private activeJobUri;
     constructor(address: string, port: number, secure?: boolean);
     /**
      * Get scanner capabilities
@@ -27,30 +32,34 @@ export declare class EsclProtocol {
      * until complete. We try direct download first, then fall back to polling.
      */
     waitForScanComplete(jobUri: string, options: IScanOptions, pollInterval?: number): Promise<IScanResult>;
+    private combinePages;
     /**
      * Download scanned document
      */
     downloadScan(jobUri: string, options: IScanOptions): Promise<IScanResult>;
+    private downloadNextDocument;
     /**
      * Cancel a scan job
      */
     cancelJob(jobUri: string): Promise<void>;
+    cancelCurrentScan(): Promise<void>;
     /**
      * Build XML scan settings
      */
     private buildScanSettings;
-    /**
-     * Map source to eSCL format
-     */
-    private mapSource;
+    private mapIntent;
+    private nextDocumentDelay;
     /**
      * Parse capabilities XML response
      */
     private parseCapabilities;
+    private parseInputSource;
     /**
      * Parse status XML response
      */
     private parseStatus;
+    private resolveJobUri;
+    private findJob;
     /**
      * Perform a complete scan operation
      */