node-ch347 0.0.1

package/dist/usb.js

@@ -0,0 +1,422 @@
+"use strict";
+/**
+ * CH347 USB Communication Layer
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347USB = void 0;
+const usb = __importStar(require("usb"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+class CH347USB {
+    device = null;
+    interface = null;
+    epIn = null;
+    epOut = null;
+    isOpen = false;
+    /**
+     * Get the underlying USB device (for advanced operations)
+     */
+    getDevice() {
+        return this.device;
+    }
+    /**
+     * List all connected CH347 devices
+     */
+    static listDevices() {
+        const devices = [];
+        const allDevices = usb.getDeviceList();
+        for (const device of allDevices) {
+            const desc = device.deviceDescriptor;
+            if (desc.idVendor === constants_1.CH347_VID &&
+                (desc.idProduct === constants_1.CH347_PID_SPI_I2C_UART ||
+                    desc.idProduct === constants_1.CH347_PID_JTAG_I2C_UART)) {
+                const info = {
+                    vendorId: desc.idVendor,
+                    productId: desc.idProduct,
+                    busNumber: device.busNumber,
+                    deviceAddress: device.deviceAddress,
+                };
+                // Note: Getting string descriptors requires opening the device
+                // which may fail without proper permissions. We skip this for now
+                // and just return basic device info.
+                devices.push(info);
+            }
+        }
+        return devices;
+    }
+    /**
+     * Open connection to CH347 device
+     */
+    async open(deviceIndex = 0) {
+        const devices = CH347USB.listDevices();
+        if (devices.length === 0) {
+            throw new Error('No CH347 device found');
+        }
+        if (deviceIndex >= devices.length) {
+            throw new Error(`Device index ${deviceIndex} out of range (${devices.length} devices found)`);
+        }
+        const targetDevice = devices[deviceIndex];
+        const allDevices = usb.getDeviceList();
+        // Find the matching device
+        this.device = allDevices.find((d) => d.busNumber === targetDevice.busNumber &&
+            d.deviceAddress === targetDevice.deviceAddress) ?? null;
+        if (!this.device) {
+            throw new Error('Failed to find target device');
+        }
+        try {
+            this.device.open();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new Error(`Failed to open device: ${message}`);
+        }
+        // Claim interface 2 for SPI/I2C/GPIO
+        try {
+            this.interface = this.device.interface(constants_1.CH347_IFACE_SPI_I2C_GPIO);
+            // On Linux, we may need to detach the kernel driver
+            if (this.interface.isKernelDriverActive()) {
+                this.interface.detachKernelDriver();
+            }
+            this.interface.claim();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.device.close();
+            throw new Error(`Failed to claim interface: ${message}`);
+        }
+        // Find endpoints
+        for (const endpoint of this.interface.endpoints) {
+            if (endpoint.address === constants_1.CH347_EP_IN) {
+                this.epIn = endpoint;
+            }
+            else if (endpoint.address === constants_1.CH347_EP_OUT) {
+                this.epOut = endpoint;
+            }
+        }
+        if (!this.epIn || !this.epOut) {
+            this.close();
+            throw new Error('Failed to find USB endpoints');
+        }
+        this.isOpen = true;
+    }
+    /**
+     * Close connection
+     */
+    close() {
+        if (this.interface) {
+            try {
+                this.interface.release(true);
+            }
+            catch {
+                // Ignore
+            }
+            this.interface = null;
+        }
+        if (this.device) {
+            try {
+                this.device.close();
+            }
+            catch {
+                // Ignore
+            }
+            this.device = null;
+        }
+        this.epIn = null;
+        this.epOut = null;
+        this.isOpen = false;
+    }
+    /**
+     * Check if device is open
+     */
+    isConnected() {
+        return this.isOpen;
+    }
+    /**
+     * Send data to device
+     */
+    async write(data) {
+        if (!this.isOpen || !this.epOut) {
+            throw new Error('Device not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.epOut.transfer(data, (err, actual) => {
+                if (err) {
+                    reject(new Error(`USB write error: ${err.message}`));
+                }
+                else {
+                    resolve(actual ?? data.length);
+                }
+            });
+        });
+    }
+    /**
+     * Read data from device
+     */
+    async read(length = constants_1.CH347_PACKET_SIZE, timeout = constants_1.CH347_TIMEOUT_MS) {
+        if (!this.isOpen || !this.epIn) {
+            throw new Error('Device not open');
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error('USB read timeout'));
+            }, timeout);
+            this.epIn.transfer(length, (err, data) => {
+                clearTimeout(timeoutId);
+                if (err) {
+                    reject(new Error(`USB read error: ${err.message}`));
+                }
+                else {
+                    resolve(data ?? Buffer.alloc(0));
+                }
+            });
+        });
+    }
+    /**
+     * Write and then read response
+     */
+    async transfer(outData, readLength = constants_1.CH347_PACKET_SIZE) {
+        await this.write(outData);
+        return this.read(readLength);
+    }
+    /**
+     * Bulk write for large data transfers
+     */
+    async bulkWrite(data, chunkSize = constants_1.CH347_PACKET_SIZE) {
+        let offset = 0;
+        while (offset < data.length) {
+            const chunk = data.subarray(offset, offset + chunkSize);
+            await this.write(chunk);
+            offset += chunkSize;
+        }
+    }
+    /**
+     * Bulk read for large data transfers
+     */
+    async bulkRead(totalLength, chunkSize = constants_1.CH347_PACKET_SIZE) {
+        const chunks = [];
+        let remaining = totalLength;
+        while (remaining > 0) {
+            const readSize = Math.min(remaining, chunkSize);
+            const data = await this.read(readSize);
+            chunks.push(data);
+            remaining -= data.length;
+            // Break if we got less than expected (end of data)
+            if (data.length < readSize) {
+                break;
+            }
+        }
+        return Buffer.concat(chunks);
+    }
+    /**
+     * USB control transfer (for vendor-specific commands)
+     */
+    async controlTransfer(bmRequestType, bRequest, wValue, wIndex, dataOrLength) {
+        if (!this.device) {
+            throw new Error('Device not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.device.controlTransfer(bmRequestType, bRequest, wValue, wIndex, dataOrLength, (err, data) => {
+                if (err) {
+                    reject(new Error(`Control transfer error: ${err.message}`));
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    /**
+     * Get USB string descriptor
+     */
+    async getStringDescriptor(index) {
+        if (!this.device) {
+            throw new Error('Device not open');
+        }
+        return new Promise((resolve, reject) => {
+            this.device.getStringDescriptor(index, (err, data) => {
+                if (err) {
+                    reject(new Error(`Failed to get string descriptor: ${err.message}`));
+                }
+                else {
+                    resolve(data ?? '');
+                }
+            });
+        });
+    }
+    /**
+     * Get device descriptor info including serial number index
+     */
+    getDeviceDescriptor() {
+        return this.device?.deviceDescriptor ?? null;
+    }
+    /**
+     * Get the UART tty path for this CH347 device
+     * On Linux: scans /sys/class/tty for matching USB device
+     * On macOS: scans /dev for matching usbmodem device
+     */
+    getUARTPath() {
+        if (!this.device) {
+            return null;
+        }
+        const busNumber = this.device.busNumber;
+        const deviceAddress = this.device.deviceAddress;
+        if (process.platform === 'linux') {
+            return this.findLinuxTTY(busNumber, deviceAddress);
+        }
+        else if (process.platform === 'darwin') {
+            return this.findMacOSTTY(busNumber, deviceAddress);
+        }
+        return null;
+    }
+    /**
+     * Find TTY device on Linux by scanning sysfs
+     */
+    findLinuxTTY(busNumber, deviceAddress) {
+        const ttyClassPath = '/sys/class/tty';
+        try {
+            const entries = fs.readdirSync(ttyClassPath);
+            for (const entry of entries) {
+                // Only check ttyACM devices (CDC ACM)
+                if (!entry.startsWith('ttyACM')) {
+                    continue;
+                }
+                const devicePath = path.join(ttyClassPath, entry, 'device');
+                try {
+                    // Resolve symlink to get the actual device path
+                    const realPath = fs.realpathSync(devicePath);
+                    // Parse USB device info from path
+                    // Path looks like: /sys/devices/pci.../usb1/1-1/1-1:1.0/tty/ttyACM0
+                    // We need to find the USB device part (e.g., 1-1) and check bus/dev
+                    const usbDevMatch = realPath.match(/usb(\d+)\/[\d.-]+/);
+                    if (!usbDevMatch) {
+                        continue;
+                    }
+                    // Read busnum and devnum from the USB device directory
+                    // Go up from the interface to the device
+                    const interfaceMatch = realPath.match(/(\/sys\/devices\/.*\/usb\d+\/[\d.-]+):\d+\.\d+/);
+                    if (!interfaceMatch) {
+                        continue;
+                    }
+                    const usbDevicePath = interfaceMatch[1];
+                    const busnumPath = path.join(usbDevicePath, 'busnum');
+                    const devnumPath = path.join(usbDevicePath, 'devnum');
+                    if (fs.existsSync(busnumPath) && fs.existsSync(devnumPath)) {
+                        const busnum = parseInt(fs.readFileSync(busnumPath, 'utf8').trim(), 10);
+                        const devnum = parseInt(fs.readFileSync(devnumPath, 'utf8').trim(), 10);
+                        if (busnum === busNumber && devnum === deviceAddress) {
+                            return `/dev/${entry}`;
+                        }
+                    }
+                }
+                catch {
+                    // Skip entries we can't read
+                    continue;
+                }
+            }
+        }
+        catch {
+            // sysfs not available
+        }
+        return null;
+    }
+    /**
+     * Find TTY device on macOS
+     * macOS names CDC ACM devices as /dev/tty.usbmodem* with location ID
+     */
+    findMacOSTTY(_busNumber, _deviceAddress) {
+        try {
+            const entries = fs.readdirSync('/dev');
+            // Look for usbmodem devices
+            const usbmodemDevices = entries
+                .filter(e => e.startsWith('tty.usbmodem'))
+                .map(e => `/dev/${e}`);
+            if (usbmodemDevices.length === 0) {
+                return null;
+            }
+            // On macOS, the location ID is encoded in the device name
+            // Format: tty.usbmodem<locationID><suffix>
+            // We can try to match by using ioreg, but for simplicity,
+            // if there's only one CH347 device, return the first match
+            // For multiple devices, user may need to specify manually
+            // Try to use system_profiler to match (async would be better but keeping it sync)
+            try {
+                const { execSync } = require('child_process');
+                const output = execSync('system_profiler SPUSBDataType 2>/dev/null', { encoding: 'utf8' });
+                // Parse the output to find CH347 device location
+                const lines = output.split('\n');
+                let inCH347Section = false;
+                let locationId = '';
+                for (const line of lines) {
+                    if (line.includes('CH347') || line.includes('1a86')) {
+                        inCH347Section = true;
+                    }
+                    if (inCH347Section && line.includes('Location ID:')) {
+                        const match = line.match(/Location ID:\s*0x([0-9a-fA-F]+)/);
+                        if (match) {
+                            locationId = match[1].toLowerCase();
+                            break;
+                        }
+                    }
+                }
+                if (locationId) {
+                    // Match device name containing location ID
+                    for (const dev of usbmodemDevices) {
+                        // Location ID is often part of the device name
+                        if (dev.toLowerCase().includes(locationId.substring(0, 4))) {
+                            return dev;
+                        }
+                    }
+                }
+            }
+            catch {
+                // system_profiler failed, fall through
+            }
+            // Fallback: return first usbmodem device if only one exists
+            if (usbmodemDevices.length === 1) {
+                return usbmodemDevices[0];
+            }
+            // Multiple devices, can't determine which one
+            return usbmodemDevices[0]; // Return first as best guess
+        }
+        catch {
+            // /dev not readable
+        }
+        return null;
+    }
+}
+exports.CH347USB = CH347USB;
+//# sourceMappingURL=usb.js.map

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "node-ch347",
+  "version": "0.0.1",
+  "description": "Node.js library for CH347 USB interface - GPIO, SPI flash programming, and UART",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/examples",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "node --test dist/**/*.test.js",
+    "prepublishOnly": "npm run build",
+    "example": "node dist/examples/basic.js"
+  },
+  "keywords": [
+    "ch347",
+    "usb",
+    "gpio",
+    "spi",
+    "uart",
+    "flash",
+    "programmer",
+    "embedded",
+    "hardware"
+  ],
+  "author": "",
+  "license": "Unlicense",
+  "dependencies": {
+    "usb": "^2.14.0"
+  },
+  "optionalDependencies": {
+    "serialport": "^12.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ]
+}