atoo-studio 0.0.1 → 0.0.2

package/dist/src/serial/cuse-device.js

@@ -0,0 +1,260 @@
+import { spawn, execFileSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import os from 'os';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Frame protocol: [type:1][len:2 BE][payload:len]
+function encodeFrame(type, payload) {
+    const header = Buffer.alloc(3);
+    header[0] = type;
+    header[1] = (payload.length >> 8) & 0xFF;
+    header[2] = payload.length & 0xFF;
+    return Buffer.concat([header, payload]);
+}
+let deviceCounter = 0;
+export function isCuseAvailable() {
+    if (process.platform !== 'linux')
+        return false;
+    // Check if /dev/cuse exists (kernel module loaded)
+    if (!fs.existsSync('/dev/cuse'))
+        return false;
+    // Check if /dev/cuse is actually accessible by the current user
+    try {
+        fs.accessSync('/dev/cuse', fs.constants.R_OK | fs.constants.W_OK);
+    }
+    catch {
+        console.log('[serial] /dev/cuse exists but is not accessible (check permissions: chmod 0666 /dev/cuse)');
+        return false;
+    }
+    // Unprivileged LXC containers can open /dev/cuse but can't create device nodes
+    try {
+        const uidMap = fs.readFileSync('/proc/self/uid_map', 'utf8').trim();
+        // In unprivileged containers, uid 0 maps to a high host uid (e.g., 100000)
+        // In privileged or bare-metal, uid 0 maps to 0
+        const match = uidMap.match(/^\s*0\s+(\d+)/);
+        if (match && parseInt(match[1], 10) > 0)
+            return false;
+    }
+    catch { }
+    // Check if the binary exists and has the required capability or suid bit
+    const bin = findCuseBinarySync();
+    if (!bin)
+        return false;
+    try {
+        const stat = fs.statSync(bin);
+        const hasSuid = (stat.mode & 0o4000) !== 0;
+        if (!hasSuid) {
+            // No suid — check for CAP_SYS_ADMIN via getcap
+            const caps = execFileSync('getcap', [bin], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+            if (!caps.includes('cap_sys_admin')) {
+                console.log(`[serial] cuse_serial binary lacks CAP_SYS_ADMIN and suid bit. Run: sudo setcap cap_sys_admin+ep ${bin}`);
+                return false;
+            }
+        }
+    }
+    catch { }
+    return true;
+}
+function findCuseBinarySync() {
+    // Preferred: installed by setup-cuse.sh to ~/.atoo-studio/bin/ (survives node-gyp rebuilds)
+    const installedPath = path.join(os.homedir(), '.atoo-studio', 'bin', 'cuse_serial');
+    if (fs.existsSync(installedPath))
+        return installedPath;
+    // Check /usr/local/bin
+    if (fs.existsSync('/usr/local/bin/cuse-serial'))
+        return '/usr/local/bin/cuse-serial';
+    // Fallback: node-gyp build dir (may lack capabilities after rebuild)
+    const localPath = path.join(__dirname, 'native', 'build', 'Release', 'cuse_serial');
+    if (fs.existsSync(localPath))
+        return localPath;
+    const distPath = path.join(__dirname, '..', '..', '..', 'src', 'serial', 'native', 'build', 'Release', 'cuse_serial');
+    if (fs.existsSync(distPath))
+        return distPath;
+    return null;
+}
+export function createCuseDevice() {
+    return new Promise((resolve, reject) => {
+        const bin = findCuseBinarySync();
+        if (!bin) {
+            reject(new Error('CUSE serial binary not found'));
+            return;
+        }
+        const devName = `ttyVS${deviceCounter++}`;
+        const child = spawn(bin, ['--name=' + devName, '-f'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let closed = false;
+        let resolved = false;
+        let devicePath = '';
+        const readBuffer = [];
+        let lastModemBits = { dtr: false, rts: false };
+        // Frame parser state for child's stdout
+        let parseState = 'header';
+        let frameType = 0;
+        let frameLen = 0;
+        let frameBuf = Buffer.alloc(0);
+        let headerBuf = Buffer.alloc(0);
+        function processFrame(type, payload) {
+            switch (type) {
+                case 0x00: // Serial data from tool
+                    readBuffer.push(Buffer.from(payload));
+                    break;
+                case 0x01: // Modem signals changed
+                    if (payload.length >= 1) {
+                        lastModemBits = {
+                            dtr: (payload[0] & 0x01) !== 0,
+                            rts: (payload[0] & 0x02) !== 0,
+                        };
+                        // Fire callback immediately for low-latency signal forwarding
+                        device.onModemBitsChanged?.({ ...lastModemBits });
+                    }
+                    break;
+                case 0x02: // Device ready
+                    devicePath = payload.toString('utf8');
+                    break;
+                case 0x03: // Error
+                    const msg = payload.toString('utf8');
+                    if (!devicePath) {
+                        reject(new Error(`CUSE: ${msg}`));
+                    }
+                    else {
+                        console.error(`[cuse] Error: ${msg}`);
+                    }
+                    break;
+            }
+        }
+        function parseStdout(chunk) {
+            let offset = 0;
+            while (offset < chunk.length) {
+                if (parseState === 'header') {
+                    const needed = 3 - headerBuf.length;
+                    const available = chunk.length - offset;
+                    const take = Math.min(needed, available);
+                    headerBuf = Buffer.concat([headerBuf, chunk.subarray(offset, offset + take)]);
+                    offset += take;
+                    if (headerBuf.length === 3) {
+                        frameType = headerBuf[0];
+                        frameLen = (headerBuf[1] << 8) | headerBuf[2];
+                        headerBuf = Buffer.alloc(0);
+                        if (frameLen === 0) {
+                            processFrame(frameType, Buffer.alloc(0));
+                        }
+                        else {
+                            frameBuf = Buffer.alloc(0);
+                            parseState = 'payload';
+                        }
+                    }
+                }
+                else {
+                    const needed = frameLen - frameBuf.length;
+                    const available = chunk.length - offset;
+                    const take = Math.min(needed, available);
+                    frameBuf = Buffer.concat([frameBuf, chunk.subarray(offset, offset + take)]);
+                    offset += take;
+                    if (frameBuf.length === frameLen) {
+                        processFrame(frameType, frameBuf);
+                        parseState = 'header';
+                    }
+                }
+            }
+        }
+        child.stdout.on('data', (chunk) => {
+            parseStdout(chunk);
+            if (devicePath && !resolved) {
+                // Verify the device node actually exists (may fail in LXC due to cgroup restrictions)
+                let retries = 0;
+                const verifyInterval = setInterval(() => {
+                    retries++;
+                    if (fs.existsSync(devicePath)) {
+                        clearInterval(verifyInterval);
+                        resolved = true;
+                        clearTimeout(timeout);
+                        resolve(device);
+                    }
+                    else if (retries >= 10) {
+                        clearInterval(verifyInterval);
+                        resolved = true;
+                        clearTimeout(timeout);
+                        child.kill('SIGTERM');
+                        reject(new Error(`CUSE device ${devicePath} was not created (blocked by container cgroup?)`));
+                    }
+                }, 100);
+            }
+        });
+        child.stderr.on('data', (chunk) => {
+            const msg = chunk.toString().trim();
+            if (msg)
+                console.error(`[cuse] ${msg}`);
+        });
+        child.on('error', (err) => {
+            if (!devicePath)
+                reject(err);
+        });
+        child.on('exit', (code) => {
+            closed = true;
+            if (!devicePath) {
+                reject(new Error(`CUSE helper exited with code ${code}`));
+            }
+        });
+        // Wait up to 5s for device ready
+        const timeout = setTimeout(() => {
+            if (!devicePath) {
+                child.kill();
+                reject(new Error('CUSE device creation timed out'));
+            }
+        }, 5000);
+        const device = {
+            get devicePath() { return devicePath; },
+            get closed() { return closed; },
+            controlSignalsSupported: true,
+            write(data) {
+                if (closed)
+                    return -1;
+                try {
+                    const frame = encodeFrame(0x00, data);
+                    child.stdin.write(frame);
+                    return data.length;
+                }
+                catch {
+                    return -1;
+                }
+            },
+            read() {
+                if (closed)
+                    return null;
+                if (readBuffer.length === 0)
+                    return null;
+                const chunk = readBuffer.shift();
+                return chunk;
+            },
+            getModemBits() {
+                return { ...lastModemBits };
+            },
+            onModemBitsChanged: null,
+            setModemBits(_dtr, _rts) {
+                // Not needed for CUSE — modem bits are set by the tool's ioctls,
+                // which the CUSE helper handles directly
+            },
+            close() {
+                if (!closed) {
+                    closed = true;
+                    clearTimeout(timeout);
+                    try {
+                        child.stdin.end();
+                    }
+                    catch { }
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch { }
+                    // Give it a moment to clean up, then force kill
+                    setTimeout(() => { try {
+                        child.kill('SIGKILL');
+                    }
+                    catch { } }, 1000);
+                }
+            },
+        };
+    });
+}

package/dist/src/serial/manager.d.ts

@@ -0,0 +1,63 @@
+import { WebSocket } from 'ws';
+import { PtyPair } from './pty-pair.js';
+import { CuseDevice } from './cuse-device.js';
+export type SerialDevice = PtyPair | CuseDevice;
+export interface SerialRequestParams {
+    baudRate: number;
+    dataBits: number;
+    stopBits: number;
+    parity: string;
+    description?: string;
+}
+export interface SerialRequest {
+    requestId: string;
+    params: SerialRequestParams;
+    device: SerialDevice;
+    devicePath: string;
+    controlSignalsSupported: boolean;
+    status: 'pending' | 'connected' | 'closed';
+    browserWs: WebSocket | null;
+    resolveReady: ((result: {
+        devicePath: string;
+        controlSignalsSupported: boolean;
+        usbVendorId: number | null;
+        usbProductId: number | null;
+    }) => void) | null;
+    rejectReady: ((err: Error) => void) | null;
+    modemPollInterval: NodeJS.Timeout | null;
+    readPollInterval: NodeJS.Timeout | null;
+    lastModemBits: {
+        dtr: boolean;
+        rts: boolean;
+    };
+}
+declare class SerialManager {
+    private requests;
+    private cuseAvailable;
+    private ptyAvailable;
+    private checkCuseAvailable;
+    private checkPtyAvailable;
+    isAvailable(): boolean;
+    createRequest(requestId: string, params: SerialRequestParams): Promise<{
+        devicePath: string;
+        controlSignalsSupported: boolean;
+        readyPromise: Promise<{
+            devicePath: string;
+            controlSignalsSupported: boolean;
+        }>;
+    }>;
+    getRequest(requestId: string): SerialRequest | undefined;
+    connectBrowser(requestId: string, ws: WebSocket): boolean;
+    handleBrowserData(requestId: string, data: Buffer): void;
+    handleBrowserControl(requestId: string, msg: any): void;
+    rejectRequest(requestId: string, err: Error): void;
+    closeRequest(requestId: string): void;
+    getActiveRequests(): Array<{
+        requestId: string;
+        devicePath: string;
+        status: string;
+        controlSignalsSupported: boolean;
+    }>;
+}
+export declare const serialManager: SerialManager;
+export {};

package/dist/src/serial/manager.js

@@ -0,0 +1,206 @@
+import { WebSocket } from 'ws';
+import { createPtyPair, isPtyAvailable } from './pty-pair.js';
+import { createCuseDevice, isCuseAvailable } from './cuse-device.js';
+import { store } from '../state/store.js';
+class SerialManager {
+    requests = new Map();
+    cuseAvailable = null;
+    ptyAvailable = null;
+    checkCuseAvailable() {
+        if (this.cuseAvailable === null) {
+            this.cuseAvailable = isCuseAvailable();
+            if (this.cuseAvailable) {
+                console.log('[serial] CUSE available — using virtual serial device with control signal support');
+            }
+            else {
+                console.log('[serial] CUSE not available — falling back to PTY (no control signal support)');
+            }
+        }
+        return this.cuseAvailable;
+    }
+    checkPtyAvailable() {
+        if (this.ptyAvailable === null) {
+            this.ptyAvailable = isPtyAvailable();
+            if (!this.ptyAvailable) {
+                console.log('[serial] PTY native module not available — serial passthrough disabled');
+            }
+        }
+        return this.ptyAvailable;
+    }
+    isAvailable() {
+        return this.checkCuseAvailable() || this.checkPtyAvailable();
+    }
+    async createRequest(requestId, params) {
+        let device;
+        let devicePath;
+        let controlSignalsSupported;
+        if (this.checkCuseAvailable()) {
+            try {
+                const cuse = await createCuseDevice();
+                device = cuse;
+                devicePath = cuse.devicePath;
+                controlSignalsSupported = true;
+                console.log(`[serial] Created CUSE device: ${devicePath}`);
+            }
+            catch (err) {
+                console.log(`[serial] CUSE failed (${err.message}), falling back to PTY`);
+                this.cuseAvailable = false;
+                if (!this.checkPtyAvailable()) {
+                    throw new Error('Serial passthrough not available: native PTY module not built. Run npm run build:serial on Linux.');
+                }
+                const pty = createPtyPair();
+                device = pty;
+                devicePath = pty.slavePath;
+                controlSignalsSupported = false;
+                console.log(`[serial] Created PTY pair: master=${pty.masterFd}, slave=${pty.slavePath}`);
+            }
+        }
+        else if (this.checkPtyAvailable()) {
+            const pty = createPtyPair();
+            device = pty;
+            devicePath = pty.slavePath;
+            controlSignalsSupported = false;
+            console.log(`[serial] Created PTY pair: master=${pty.masterFd}, slave=${pty.slavePath}`);
+        }
+        else {
+            throw new Error('Serial passthrough not available on this platform. Requires Linux with pty_pair native module built.');
+        }
+        let resolveReady = null;
+        let rejectReady = null;
+        const readyPromise = new Promise((resolve, reject) => {
+            resolveReady = resolve;
+            rejectReady = reject;
+        });
+        const request = {
+            requestId,
+            params,
+            device,
+            devicePath,
+            controlSignalsSupported,
+            status: 'pending',
+            browserWs: null,
+            resolveReady,
+            rejectReady,
+            modemPollInterval: null,
+            readPollInterval: null,
+            lastModemBits: { dtr: false, rts: false },
+        };
+        this.requests.set(requestId, request);
+        return { devicePath, controlSignalsSupported, readyPromise };
+    }
+    getRequest(requestId) {
+        return this.requests.get(requestId);
+    }
+    connectBrowser(requestId, ws) {
+        const req = this.requests.get(requestId);
+        if (!req || req.status !== 'pending')
+            return false;
+        req.browserWs = ws;
+        req.status = 'connected';
+        // Start piping device reads → browser (poll every 5ms for low latency)
+        req.readPollInterval = setInterval(() => {
+            if (req.device.closed || ws.readyState !== WebSocket.OPEN) {
+                this.closeRequest(requestId);
+                return;
+            }
+            const data = req.device.read();
+            if (data) {
+                ws.send(data);
+            }
+        }, 5);
+        // Forward modem signal changes to browser
+        if ('onModemBitsChanged' in req.device) {
+            // CUSE device: event-driven, immediate forwarding for precise reset timing
+            req.device.onModemBitsChanged = (bits) => {
+                if (ws.readyState !== WebSocket.OPEN)
+                    return;
+                req.lastModemBits = { ...bits };
+                ws.send(JSON.stringify({ type: 'set_signals', signals: { dtr: bits.dtr, rts: bits.rts } }));
+            };
+        }
+        else {
+            // PTY fallback: poll modem bits (no callback support)
+            req.modemPollInterval = setInterval(() => {
+                if (req.device.closed || ws.readyState !== WebSocket.OPEN)
+                    return;
+                const bits = req.device.getModemBits();
+                if (bits.dtr !== req.lastModemBits.dtr || bits.rts !== req.lastModemBits.rts) {
+                    req.lastModemBits = { ...bits };
+                    ws.send(JSON.stringify({ type: 'set_signals', signals: { dtr: bits.dtr, rts: bits.rts } }));
+                }
+            }, 50);
+        }
+        // Resolve the ready promise
+        req.resolveReady?.({ devicePath: req.devicePath, controlSignalsSupported: req.controlSignalsSupported, usbVendorId: null, usbProductId: null });
+        req.resolveReady = null;
+        req.rejectReady = null;
+        console.log(`[serial] Browser connected for request ${requestId}, device=${req.devicePath}, controlSignals=${req.controlSignalsSupported}`);
+        return true;
+    }
+    handleBrowserData(requestId, data) {
+        const req = this.requests.get(requestId);
+        if (!req || req.device.closed)
+            return;
+        req.device.write(data);
+    }
+    handleBrowserControl(requestId, msg) {
+        const req = this.requests.get(requestId);
+        if (!req)
+            return;
+        if (msg.type === 'ready') {
+            // Browser has opened the serial port - handled in connectBrowser
+        }
+        else if (msg.type === 'error' || msg.type === 'closed') {
+            console.log(`[serial] Browser reported ${msg.type} for ${requestId}: ${msg.message || ''}`);
+            this.closeRequest(requestId);
+        }
+    }
+    rejectRequest(requestId, err) {
+        const req = this.requests.get(requestId);
+        if (!req)
+            return;
+        req.rejectReady?.(err);
+        this.closeRequest(requestId);
+    }
+    closeRequest(requestId) {
+        const req = this.requests.get(requestId);
+        if (!req)
+            return;
+        console.log(`[serial] Closing request ${requestId}`);
+        if (req.readPollInterval)
+            clearInterval(req.readPollInterval);
+        if (req.modemPollInterval)
+            clearInterval(req.modemPollInterval);
+        if (!req.device.closed)
+            req.device.close();
+        if (req.browserWs && req.browserWs.readyState === WebSocket.OPEN) {
+            try {
+                req.browserWs.send(JSON.stringify({ type: 'close' }));
+            }
+            catch { }
+            try {
+                req.browserWs.close();
+            }
+            catch { }
+        }
+        // Reject if still pending
+        req.rejectReady?.(new Error('Serial request closed'));
+        req.status = 'closed';
+        this.requests.delete(requestId);
+        // Broadcast serial_closed to all browsers
+        const msg = JSON.stringify({ type: 'serial_closed', requestId });
+        for (const ws of store.statusClients) {
+            if (ws.readyState === 1)
+                ws.send(msg);
+        }
+    }
+    getActiveRequests() {
+        return Array.from(this.requests.values()).map(r => ({
+            requestId: r.requestId,
+            devicePath: r.devicePath,
+            status: r.status,
+            controlSignalsSupported: r.controlSignalsSupported,
+        }));
+    }
+}
+export const serialManager = new SerialManager();

package/dist/src/serial/pty-pair.d.ts

@@ -0,0 +1,16 @@
+export declare function isPtyAvailable(): boolean;
+export interface PtyPair {
+    masterFd: number;
+    slavePath: string;
+    write(data: Buffer): number;
+    read(): Buffer | null;
+    getModemBits(): {
+        dtr: boolean;
+        rts: boolean;
+    };
+    setModemBits(dtr: boolean, rts: boolean): void;
+    close(): void;
+    closed: boolean;
+    controlSignalsSupported: false;
+}
+export declare function createPtyPair(): PtyPair;

package/dist/src/serial/pty-pair.js

@@ -0,0 +1,68 @@
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+let native = null;
+function loadNative() {
+    if (native)
+        return native;
+    try {
+        native = require(path.join(__dirname, 'native', 'build', 'Release', 'pty_pair.node'));
+    }
+    catch {
+        // Fallback: when running from dist/, the native dir is at the source location
+        native = require(path.join(__dirname, '..', '..', '..', 'src', 'serial', 'native', 'build', 'Release', 'pty_pair.node'));
+    }
+    return native;
+}
+export function isPtyAvailable() {
+    try {
+        loadNative();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const READ_BUF_SIZE = 4096;
+export function createPtyPair() {
+    const n = loadNative();
+    const { masterFd, slavePath } = n.createPtyPair();
+    const readBuf = Buffer.alloc(READ_BUF_SIZE);
+    let closed = false;
+    return {
+        masterFd,
+        slavePath,
+        controlSignalsSupported: false,
+        get closed() { return closed; },
+        write(data) {
+            if (closed)
+                return -1;
+            return n.writeMaster(masterFd, data, data.length);
+        },
+        read() {
+            if (closed)
+                return null;
+            const nr = n.readMaster(masterFd, readBuf);
+            if (nr <= 0)
+                return null; // 0 = EAGAIN, -1 = closed/error
+            return Buffer.from(readBuf.subarray(0, nr));
+        },
+        getModemBits() {
+            if (closed)
+                return { dtr: false, rts: false };
+            return n.getModemBits(masterFd);
+        },
+        setModemBits(dtr, rts) {
+            if (!closed)
+                n.setModemBits(masterFd, dtr, rts);
+        },
+        close() {
+            if (!closed) {
+                closed = true;
+                n.closeFd(masterFd);
+            }
+        },
+    };
+}

package/dist/src/services/fs-browser.d.ts

@@ -0,0 +1,14 @@
+interface FileNode {
+    name: string;
+    type: 'file' | 'dir';
+    children?: FileNode[];
+}
+export declare function getFileTree(dirPath: string, depth?: number, showHidden?: boolean, maxDepth?: number): Promise<FileNode[]>;
+export declare function isBinaryFile(filePath: string): boolean;
+export declare function readFileContent(filePath: string): {
+    content: string;
+    lang: string;
+    isBinary?: boolean;
+    size?: number;
+};
+export {};