@phystack/cli 4.5.19-dev → 4.5.20-dev

package/dist/commands/dev/cp.js

@@ -0,0 +1,764 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = cp;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const net_1 = __importDefault(require("net"));
+const utils_1 = require("../../utils");
+const admin_api_1 = require("../../services/admin-api");
+/**
+ * Checks if a string is an IP address
+ */
+const isIpAddress = (name) => {
+    const octetPattern = '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)';
+    const ipPattern = new RegExp(`^${octetPattern}\\.${octetPattern}\\.${octetPattern}\\.${octetPattern}$`);
+    return ipPattern.test(name);
+};
+/**
+ * Parses a device path string (e.g., "device-name:/path/to/file")
+ */
+function parseDevicePath(devicePath) {
+    const colonIndex = devicePath.indexOf(':');
+    if (colonIndex === -1) {
+        return null;
+    }
+    const deviceName = devicePath.substring(0, colonIndex);
+    const remotePath = devicePath.substring(colonIndex + 1);
+    if (!deviceName || !remotePath) {
+        return null;
+    }
+    return { deviceName, remotePath };
+}
+/**
+ * File copy utility using SSH tunnel with base64 encoding for reliable binary transfer.
+ */
+class FileCopy {
+    constructor(debug = false) {
+        this.keyfile = '';
+        this.debug = false;
+        this.debug = debug;
+    }
+    debugLog(message) {
+        if (this.debug) {
+            console.log(chalk_1.default.dim(message));
+        }
+    }
+    async copyFromDevice(deviceName, remotePath, localPath) {
+        return new Promise(async (resolve, reject) => {
+            console.log(chalk_1.default.blue(`Copying from device: ${deviceName}`));
+            console.log(chalk_1.default.dim(`  Remote: ${remotePath}`));
+            console.log(chalk_1.default.dim(`  Local: ${localPath}`));
+            let targetPath = localPath;
+            if (fs_1.default.existsSync(localPath) && fs_1.default.statSync(localPath).isDirectory()) {
+                const remoteFileName = path_1.default.basename(remotePath);
+                targetPath = path_1.default.join(localPath, remoteFileName);
+                console.log(chalk_1.default.dim(`  Target: ${targetPath}`));
+            }
+            const localDir = path_1.default.dirname(targetPath);
+            if (!fs_1.default.existsSync(localDir)) {
+                fs_1.default.mkdirSync(localDir, { recursive: true });
+            }
+            this.keyfile = path_1.default.join(os_1.default.tmpdir(), `gridapp-cp-${Math.floor(Math.random() * 1000)}.key`);
+            if (fs_1.default.existsSync(this.keyfile)) {
+                fs_1.default.unlinkSync(this.keyfile);
+            }
+            if (fs_1.default.existsSync(`${this.keyfile}.pub`)) {
+                fs_1.default.unlinkSync(`${this.keyfile}.pub`);
+            }
+            (0, child_process_1.execSync)(`ssh-keygen -t ed25519 -f ${this.keyfile} -N ""`, { stdio: 'ignore' });
+            const key = fs_1.default.readFileSync(`${this.keyfile}.pub`).toString();
+            let stream;
+            let isPhyos = true;
+            try {
+                this.debugLog('[DEBUG] Starting PhyHub connection...');
+                const { stream: curStream, isPhyos: isPhyosDevice } = (0, utils_1.openStream)(await (0, admin_api_1.adminApi)().devices.startPhyHubDeviceShellSession(deviceName, { key }));
+                stream = curStream;
+                isPhyos = isPhyosDevice;
+                this.debugLog(`[DEBUG] PhyHub stream connected, isPhyos: ${isPhyos}`);
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.log(chalk_1.default.red(`[DEBUG] PhyHub connection failed: ${err.message}`));
+                }
+                if (err.message && err.message.includes('Unauthorized')) {
+                    reject(new Error(`Unauthorized. Please run "phy login" to use this command.`));
+                }
+                else {
+                    reject(new Error(`Unable to establish connection to the device. ${err}`));
+                }
+                return;
+            }
+            const port = Math.floor(10000 + ((Math.random() * 100000) % 10000));
+            this.debugLog(`[DEBUG] Creating local TCP server on port ${port}...`);
+            let tcpServer = null;
+            const connPromise = new Promise((resolveConn) => {
+                tcpServer = net_1.default.createServer((client) => {
+                    this.debugLog('[DEBUG] TCP client connected');
+                    if (tcpServer) {
+                        tcpServer.close();
+                        tcpServer = null;
+                    }
+                    resolveConn(client);
+                });
+                tcpServer.listen(port, () => {
+                    this.debugLog(`[DEBUG] TCP server listening on port ${port}`);
+                });
+            });
+            this.debugLog(`[DEBUG] Spawning SSH tunnel to ${isPhyos ? 'phystack' : 'ombori'}@localhost:${port}...`);
+            const sshTunnel = (0, child_process_1.spawn)('ssh', [
+                '-qtt',
+                `${isPhyos ? 'phystack' : 'ombori'}@localhost`,
+                '-p',
+                `${port}`,
+                '-o',
+                'UserKnownHostsFile=/dev/null',
+                '-o',
+                'StrictHostKeyChecking=no',
+                '-o',
+                'ServerAliveInterval=30',
+                '-i',
+                this.keyfile,
+            ], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                detached: false,
+            });
+            const conn = await connPromise;
+            this.debugLog('[DEBUG] TCP connection established, piping streams...');
+            conn.pipe(stream);
+            stream.pipe(conn);
+            this.debugLog('[DEBUG] Tunnel established, waiting for shell...');
+            const fileStream = fs_1.default.createWriteStream(targetPath);
+            let outputBuffer = '';
+            let menuHandled = false;
+            let commandSent = false;
+            let dataReceived = false;
+            let bytesWritten = 0;
+            let transferComplete = false;
+            let resolved = false; // Flag to prevent multiple resolutions
+            let expectedFileSize = null;
+            let base64Buffer = ''; // Buffer for accumulating base64 data
+            sshTunnel.stdout.on('data', (data) => {
+                const output = data.toString();
+                if (!dataReceived) {
+                    outputBuffer += output;
+                }
+                if (!menuHandled) {
+                    if (outputBuffer.includes('Press ENTER to open the menu') ||
+                        output.includes('Press ENTER to open the menu')) {
+                        this.debugLog('[DEBUG] Detected menu prompt, sending ENTER...');
+                        sshTunnel.stdin?.write('\n');
+                        outputBuffer = '';
+                        return;
+                    }
+                    if (outputBuffer.includes('Select an option') ||
+                        output.includes('Select an option') ||
+                        outputBuffer.includes('Shell (Open shell)') ||
+                        output.includes('Shell (Open shell)') ||
+                        outputBuffer.includes('Main menu') ||
+                        output.includes('Main menu')) {
+                        menuHandled = true;
+                        this.debugLog('[DEBUG] Detected menu, selecting shell...');
+                        sshTunnel.stdin?.write('s\n');
+                        outputBuffer = '';
+                        return;
+                    }
+                    return;
+                }
+                if (!commandSent) {
+                    const promptPattern = /[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+[:~]*[\$#]\s*$/;
+                    const veryEnd = outputBuffer.slice(-50);
+                    const promptAtVeryEnd = veryEnd.match(promptPattern);
+                    if (promptAtVeryEnd) {
+                        commandSent = true;
+                        this.debugLog('[DEBUG] Shell prompt detected, getting file size...');
+                        outputBuffer = '';
+                        process.stdout.write(`Progress: 0% (starting download...)\r`);
+                        const escapedPath = remotePath.replace(/'/g, "'\\''");
+                        sshTunnel.stdin?.write(`stat -c%s '${escapedPath}' 2>/dev/null || echo 0\n`);
+                        return;
+                    }
+                }
+                if (commandSent) {
+                    const outputStr = output.toString();
+                    if (expectedFileSize === null && !dataReceived) {
+                        const sizeMatch = outputStr.match(/^(\d+)\s*$/m);
+                        if (sizeMatch) {
+                            expectedFileSize = parseInt(sizeMatch[1], 10);
+                            this.debugLog(`[DEBUG] Expected file size: ${expectedFileSize} bytes`);
+                            const escapedPath = remotePath.replace(/'/g, "'\\''");
+                            sshTunnel.stdin?.write(`base64 < '${escapedPath}'\n`);
+                            return;
+                        }
+                        const promptPattern = /[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+[:~]*[\$#]\s*$/;
+                        if (promptPattern.test(outputStr) && outputStr.trim().length < 100) {
+                            this.debugLog('[DEBUG] No file size received, proceeding with base64...');
+                            const escapedPath = remotePath.replace(/'/g, "'\\''");
+                            sshTunnel.stdin?.write(`base64 < '${escapedPath}'\n`);
+                            return;
+                        }
+                    }
+                    if (expectedFileSize !== null) {
+                        dataReceived = true;
+                        const escapedPath = remotePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                        let cleanBase64 = outputStr
+                            .replace(/stat.*?\n/g, '')
+                            .replace(new RegExp(`base64.*?${escapedPath}.*?\\n?`, 'gi'), '') // Remove command echo with path
+                            .replace(/base64.*?<.*?\\n?/g, '') // Remove "base64 < 'path'" patterns
+                            .replace(/base64.*?\\n?/g, '') // Remove any remaining "base64" command echoes
+                            .replace(/[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+[:~]*[\$#]\s*/g, '')
+                            .replace(/[\r\n]+$/, '')
+                            .replace(/^[\r\n]+/, '');
+                        cleanBase64 = cleanBase64.replace(/[^A-Za-z0-9+\/=]/g, '');
+                        if (cleanBase64.length > 0) {
+                            base64Buffer += cleanBase64;
+                            const minVerifyLength = 8;
+                            if (base64Buffer.length >= minVerifyLength && bytesWritten === 0) {
+                                let foundStart = false;
+                                for (let offset = 0; offset <= Math.min(20, base64Buffer.length - minVerifyLength); offset += 4) {
+                                    try {
+                                        const testChunk = base64Buffer.slice(offset, offset + 8);
+                                        const testDecoded = Buffer.from(testChunk, 'base64');
+                                        if (testDecoded.length >= 4) {
+                                            const magic = testDecoded.slice(0, 4);
+                                            if (magic[0] === 0x7f &&
+                                                magic[1] === 0x45 &&
+                                                magic[2] === 0x4c &&
+                                                magic[3] === 0x46) {
+                                                this.debugLog(`[DEBUG] Found ELF magic at offset ${offset}, removing ${offset} chars of garbage`);
+                                                base64Buffer = base64Buffer.slice(offset);
+                                                foundStart = true;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    catch (error) {
+                                        this.debugLog(`[DEBUG] Error searching for ELF magic: ${error}`);
+                                    }
+                                }
+                                if (!foundStart && base64Buffer.length > 50) {
+                                    if (this.debug) {
+                                        console.log(chalk_1.default.yellow(`[DEBUG] Warning: Could not find ELF magic in first ${base64Buffer.length} base64 chars`));
+                                        this.debugLog(`[DEBUG] First 50 chars: ${base64Buffer.slice(0, 50)}`);
+                                    }
+                                }
+                                else if (foundStart) {
+                                    this.debugLog(`[DEBUG] Note: Removed ${base64Buffer.length === 0 ? 'garbage' : 'initial garbage'} from base64 stream`);
+                                }
+                            }
+                            const decodeLength = Math.floor(base64Buffer.length / 4) * 4;
+                            if (decodeLength > 0) {
+                                try {
+                                    const toDecode = base64Buffer.slice(0, decodeLength);
+                                    const decoded = Buffer.from(toDecode, 'base64');
+                                    if (bytesWritten === 0 && decoded.length >= 4) {
+                                        const firstBytes = Array.from(decoded.slice(0, 4))
+                                            .map((byte) => '0x' + byte.toString(16).padStart(2, '0'))
+                                            .join(' ');
+                                        this.debugLog(`[DEBUG] First decoded bytes: ${firstBytes} (should be 0x7f 0x45 0x4c 0x46 for ELF)`);
+                                        this.debugLog(`[DEBUG] First 20 base64 chars were: ${toDecode.slice(0, 20)}`);
+                                    }
+                                    if (decoded.length > 0) {
+                                        if (bytesWritten + decoded.length >= expectedFileSize) {
+                                            const bytesToWrite = expectedFileSize - bytesWritten;
+                                            if (bytesToWrite > 0) {
+                                                this.debugLog(`[DEBUG] Reached expected size, truncating (writing ${bytesToWrite} of ${decoded.length} bytes, total: ${bytesWritten +
+                                                    bytesToWrite}/${expectedFileSize})`);
+                                                fileStream.write(decoded.slice(0, bytesToWrite));
+                                                bytesWritten = expectedFileSize;
+                                                transferComplete = true;
+                                                fileStream.end();
+                                                if (!resolved) {
+                                                    resolved = true;
+                                                    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                                                    stream.destroy();
+                                                    conn.destroy();
+                                                    if (tcpServer) {
+                                                        tcpServer.close();
+                                                        tcpServer = null;
+                                                    }
+                                                    try {
+                                                        sshTunnel.kill('SIGTERM');
+                                                    }
+                                                    catch (error) {
+                                                        this.debugLog(`[DEBUG] Error killing SSH process: ${error}`);
+                                                    }
+                                                    setTimeout(() => {
+                                                        try {
+                                                            if (!sshTunnel.killed) {
+                                                                sshTunnel.kill('SIGKILL');
+                                                            }
+                                                        }
+                                                        catch (error) {
+                                                            this.debugLog(`[DEBUG] Error force killing SSH process: ${error}`);
+                                                        }
+                                                    }, 100);
+                                                    console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                                                    resolve();
+                                                }
+                                                return;
+                                            }
+                                            else {
+                                                if (!resolved) {
+                                                    resolved = true;
+                                                    transferComplete = true;
+                                                    fileStream.end();
+                                                    setTimeout(() => {
+                                                        sshTunnel.kill();
+                                                        stream.destroy();
+                                                        console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                                                        resolve();
+                                                    }, 100);
+                                                }
+                                                return;
+                                            }
+                                        }
+                                        else {
+                                            fileStream.write(decoded);
+                                            bytesWritten += decoded.length;
+                                            const percentage = (bytesWritten / expectedFileSize) * 100;
+                                            const lastLoggedPercentage = Math.floor(((bytesWritten - decoded.length) / expectedFileSize) * 100);
+                                            const currentPercentage = Math.floor(percentage);
+                                            if (currentPercentage !== lastLoggedPercentage &&
+                                                currentPercentage % 5 === 0) {
+                                                process.stdout.write(`\rProgress: ${currentPercentage.toFixed(0)}% (${bytesWritten}/${expectedFileSize} bytes)`);
+                                            }
+                                            else if (bytesWritten % 102400 < decoded.length) {
+                                                this.debugLog(`[DEBUG] Written ${bytesWritten}/${expectedFileSize} bytes (${percentage.toFixed(1)}%)`);
+                                            }
+                                        }
+                                    }
+                                    base64Buffer = base64Buffer.slice(decodeLength);
+                                }
+                                catch (err) {
+                                    if (this.debug) {
+                                        console.log(chalk_1.default.red(`[DEBUG] Base64 decode error: ${err}`));
+                                        this.debugLog(`[DEBUG] Base64 buffer length: ${base64Buffer.length}, decodeLength: ${decodeLength}`);
+                                        this.debugLog(`[DEBUG] First 100 chars of buffer: ${base64Buffer.slice(0, 100)}`);
+                                    }
+                                }
+                            }
+                        }
+                        const promptPattern = /[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+[:~]*[\$#]\s*$/;
+                        if (promptPattern.test(outputStr) &&
+                            bytesWritten >= expectedFileSize &&
+                            !transferComplete &&
+                            !resolved) {
+                            this.debugLog('[DEBUG] Detected prompt after expected size, transfer complete');
+                            if (!resolved) {
+                                resolved = true;
+                                transferComplete = true;
+                                fileStream.end();
+                                // Clear progress line and show completion
+                                process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                                // Destroy streams immediately
+                                stream.destroy();
+                                conn.destroy();
+                                if (tcpServer) {
+                                    tcpServer.close();
+                                    tcpServer = null;
+                                }
+                                // Kill SSH process immediately
+                                try {
+                                    sshTunnel.kill('SIGTERM');
+                                }
+                                catch (error) {
+                                    this.debugLog(`[DEBUG] Error killing SSH process: ${error}`);
+                                }
+                                setTimeout(() => {
+                                    try {
+                                        if (!sshTunnel.killed) {
+                                            sshTunnel.kill('SIGKILL');
+                                        }
+                                    }
+                                    catch (error) {
+                                        this.debugLog(`[DEBUG] Error force killing SSH process: ${error}`);
+                                    }
+                                }, 100);
+                                console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                                resolve();
+                            }
+                            return;
+                        }
+                        return;
+                    }
+                }
+            });
+            sshTunnel.stderr.on('data', (data) => {
+                const output = data.toString();
+                if (!output.includes('phyhub') && !output.includes('connect()')) {
+                    if (output.trim()) {
+                        this.debugLog(`[DEBUG] SSH stderr: ${output.substring(0, 200)}`);
+                    }
+                }
+            });
+            sshTunnel.on('error', (error) => {
+                if (this.debug) {
+                    console.log(chalk_1.default.red(`[DEBUG] SSH error: ${error.message}`));
+                }
+                fileStream.close();
+                stream.destroy();
+                reject(error);
+            });
+            setTimeout(() => {
+                if (!commandSent) {
+                    sshTunnel.kill();
+                    fileStream.close();
+                    stream.destroy();
+                    reject(new Error('Timeout waiting for shell prompt'));
+                }
+            }, 300000);
+            sshTunnel.on('close', (code) => {
+                this.debugLog(`[DEBUG] SSH process closed with code ${code}`);
+                if (!resolved) {
+                    if (!fileStream.destroyed) {
+                        fileStream.end();
+                    }
+                    stream.destroy();
+                    conn.destroy();
+                    if (tcpServer) {
+                        tcpServer.close();
+                        tcpServer = null;
+                    }
+                    setTimeout(() => {
+                        try {
+                            if (fs_1.default.existsSync(this.keyfile)) {
+                                fs_1.default.unlinkSync(this.keyfile);
+                            }
+                            if (fs_1.default.existsSync(`${this.keyfile}.pub`)) {
+                                fs_1.default.unlinkSync(`${this.keyfile}.pub`);
+                            }
+                        }
+                        catch (error) {
+                            this.debugLog(`[DEBUG] Error cleaning up key file: ${error}`);
+                        }
+                    }, 1000);
+                    if (code !== 0 && code !== null && !commandSent) {
+                        fileStream.close();
+                        reject(new Error(`SSH exited with code ${code}`));
+                    }
+                    else if (!dataReceived) {
+                        reject(new Error(`No data received. File may not exist or be empty.`));
+                    }
+                    else {
+                        setTimeout(() => {
+                            try {
+                                if (fs_1.default.existsSync(targetPath)) {
+                                    const fileContent = fs_1.default.readFileSync(targetPath);
+                                    if (expectedFileSize !== null &&
+                                        fileContent.length !== expectedFileSize) {
+                                        if (fileContent.length > expectedFileSize) {
+                                            const trimmed = fileContent.slice(0, expectedFileSize);
+                                            fs_1.default.writeFileSync(targetPath, trimmed);
+                                            this.debugLog(`[DEBUG] Trimmed file to expected size (${fileContent.length} -> ${expectedFileSize} bytes)`);
+                                        }
+                                        else {
+                                            if (this.debug) {
+                                                console.log(chalk_1.default.yellow(`[DEBUG] Warning: File is ${expectedFileSize -
+                                                    fileContent.length} bytes smaller than expected`));
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                this.debugLog(`[DEBUG] Error in final cleanup: ${err}`);
+                            }
+                            if (!resolved) {
+                                resolved = true;
+                                console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                                resolve();
+                            }
+                        }, 200);
+                    }
+                }
+            });
+        });
+    }
+    async copyToDevice(deviceName, localPath, remotePath) {
+        return new Promise(async (resolve, reject) => {
+            console.log(chalk_1.default.blue(`Copying to device: ${deviceName}`));
+            console.log(chalk_1.default.dim(`  Local: ${localPath}`));
+            console.log(chalk_1.default.dim(`  Remote: ${remotePath}`));
+            if (!fs_1.default.existsSync(localPath)) {
+                reject(new Error(`Local file not found: ${localPath}`));
+                return;
+            }
+            let targetRemotePath = remotePath;
+            if (remotePath.endsWith('/')) {
+                const localFileName = path_1.default.basename(localPath);
+                targetRemotePath = path_1.default.join(remotePath, localFileName).replace(/\\/g, '/');
+                console.log(chalk_1.default.dim(`  Target: ${targetRemotePath}`));
+            }
+            this.keyfile = path_1.default.join(os_1.default.tmpdir(), `gridapp-cp-${Math.floor(Math.random() * 1000)}.key`);
+            if (fs_1.default.existsSync(this.keyfile)) {
+                fs_1.default.unlinkSync(this.keyfile);
+            }
+            if (fs_1.default.existsSync(`${this.keyfile}.pub`)) {
+                fs_1.default.unlinkSync(`${this.keyfile}.pub`);
+            }
+            (0, child_process_1.execSync)(`ssh-keygen -t ed25519 -f ${this.keyfile} -N ""`, { stdio: 'ignore' });
+            const key = fs_1.default.readFileSync(`${this.keyfile}.pub`).toString();
+            let stream;
+            let isPhyos = true;
+            try {
+                this.debugLog('[DEBUG] Starting PhyHub connection...');
+                const { stream: curStream, isPhyos: isPhyosDevice } = (0, utils_1.openStream)(await (0, admin_api_1.adminApi)().devices.startPhyHubDeviceShellSession(deviceName, { key }));
+                stream = curStream;
+                isPhyos = isPhyosDevice;
+                this.debugLog(`[DEBUG] PhyHub stream connected, isPhyos: ${isPhyos}`);
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.log(chalk_1.default.red(`[DEBUG] PhyHub connection failed: ${err.message}`));
+                }
+                if (err.message && err.message.includes('Unauthorized')) {
+                    reject(new Error(`Unauthorized. Please run "phy login" to use this command.`));
+                }
+                else {
+                    reject(new Error(`Unable to establish connection to the device. ${err}`));
+                }
+                return;
+            }
+            const port = Math.floor(10000 + ((Math.random() * 100000) % 10000));
+            this.debugLog(`[DEBUG] Creating local TCP server on port ${port}...`);
+            let tcpServer = null;
+            const connPromise = new Promise((resolveConn) => {
+                tcpServer = net_1.default.createServer((client) => {
+                    this.debugLog('[DEBUG] TCP client connected');
+                    if (tcpServer) {
+                        tcpServer.close();
+                        tcpServer = null;
+                    }
+                    resolveConn(client);
+                });
+                tcpServer.listen(port, () => {
+                    this.debugLog(`[DEBUG] TCP server listening on port ${port}`);
+                });
+            });
+            this.debugLog(`[DEBUG] Spawning SSH tunnel to ${isPhyos ? 'phystack' : 'ombori'}@localhost:${port}...`);
+            const sshTunnel = (0, child_process_1.spawn)('ssh', [
+                '-qtt',
+                `${isPhyos ? 'phystack' : 'ombori'}@localhost`,
+                '-p',
+                `${port}`,
+                '-o',
+                'UserKnownHostsFile=/dev/null',
+                '-o',
+                'StrictHostKeyChecking=no',
+                '-o',
+                'ServerAliveInterval=30',
+                '-i',
+                this.keyfile,
+            ], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                detached: false,
+            });
+            const conn = await connPromise;
+            this.debugLog('[DEBUG] TCP connection established, piping streams...');
+            conn.pipe(stream);
+            stream.pipe(conn);
+            this.debugLog('[DEBUG] Tunnel established, waiting for shell...');
+            let outputBuffer = '';
+            let menuHandled = false;
+            let commandSent = false;
+            let transferComplete = false; // Flag to prevent multiple completions
+            let resolved = false; // Flag to prevent multiple resolutions
+            const fileContent = fs_1.default.readFileSync(localPath);
+            const fileSize = fileContent.length;
+            const fileBase64 = fileContent.toString('base64');
+            let bytesSent = 0; // Track bytes sent for progress
+            sshTunnel.stdout.on('data', (data) => {
+                const output = data.toString();
+                if (!commandSent) {
+                    outputBuffer += output;
+                }
+                if (!menuHandled) {
+                    if (outputBuffer.includes('Press ENTER to open the menu') ||
+                        output.includes('Press ENTER to open the menu')) {
+                        this.debugLog('[DEBUG] Detected menu prompt, sending ENTER...');
+                        sshTunnel.stdin?.write('\n');
+                        outputBuffer = '';
+                        return;
+                    }
+                    if (outputBuffer.includes('Select an option') ||
+                        output.includes('Select an option') ||
+                        outputBuffer.includes('Shell (Open shell)') ||
+                        output.includes('Shell (Open shell)') ||
+                        outputBuffer.includes('Main menu') ||
+                        output.includes('Main menu')) {
+                        menuHandled = true;
+                        this.debugLog('[DEBUG] Detected menu, selecting shell...');
+                        sshTunnel.stdin?.write('s\n');
+                        outputBuffer = '';
+                        return;
+                    }
+                    return;
+                }
+                if (!commandSent) {
+                    const promptPattern = /[a-zA-Z0-9_-]+@[a-zA-Z0-9_.-]+[:~]*[\$#]\s*$/;
+                    const veryEnd = outputBuffer.slice(-50);
+                    const promptAtVeryEnd = veryEnd.match(promptPattern);
+                    if (promptAtVeryEnd) {
+                        commandSent = true;
+                        this.debugLog('[DEBUG] Shell prompt detected, copying file...');
+                        outputBuffer = '';
+                        process.stdout.write(`Progress: 0% (sending file...)\r`);
+                        const escapedPath = targetRemotePath.replace(/'/g, "'\\''");
+                        const script = `cat > /tmp/cp_script.sh << 'EOFSCRIPT'
+#!/bin/bash
+echo '${fileBase64}' | base64 -d > '${escapedPath}'
+EOFSCRIPT
+chmod +x /tmp/cp_script.sh
+/tmp/cp_script.sh
+rm /tmp/cp_script.sh
+echo "DONE"
+`;
+                        sshTunnel.stdin?.write(script);
+                        return;
+                    }
+                }
+                if (commandSent && output.includes('DONE') && !transferComplete) {
+                    transferComplete = true;
+                    this.debugLog('[DEBUG] File copy completed on remote side');
+                    if (!resolved) {
+                        resolved = true;
+                        // Clear progress line and show completion
+                        process.stdout.write('\r' + ' '.repeat(80) + '\r');
+                        // Destroy streams immediately
+                        stream.destroy();
+                        conn.destroy();
+                        if (tcpServer) {
+                            tcpServer.close();
+                            tcpServer = null;
+                        }
+                        try {
+                            sshTunnel.kill('SIGTERM');
+                        }
+                        catch (error) {
+                            this.debugLog(`[DEBUG] Error killing SSH process: ${error}`);
+                        }
+                        setTimeout(() => {
+                            try {
+                                if (!sshTunnel.killed) {
+                                    sshTunnel.kill('SIGKILL');
+                                }
+                            }
+                            catch (error) {
+                                this.debugLog(`[DEBUG] Error force killing SSH process: ${error}`);
+                            }
+                        }, 100);
+                        console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                        resolve();
+                    }
+                }
+                if (commandSent &&
+                    !transferComplete &&
+                    output.length > 0 &&
+                    !output.includes('DONE')) {
+                    bytesSent += output.length;
+                    const estimatedProgress = Math.min(95, (bytesSent / (fileBase64.length * 1.2)) * 100);
+                    const lastProgress = Math.floor(((bytesSent - output.length) / (fileBase64.length * 1.2)) * 100);
+                    const currentProgress = Math.floor(estimatedProgress);
+                    if (currentProgress !== lastProgress && currentProgress % 5 === 0) {
+                        process.stdout.write(`\rProgress: ${currentProgress.toFixed(0)}% (sending file...)`);
+                    }
+                }
+            });
+            sshTunnel.stderr.on('data', (data) => {
+                const output = data.toString();
+                if (!output.includes('phyhub') && !output.includes('connect()')) {
+                    if (output.trim()) {
+                        this.debugLog(`[DEBUG] SSH stderr: ${output.substring(0, 200)}`);
+                    }
+                }
+            });
+            sshTunnel.on('error', (error) => {
+                if (this.debug) {
+                    console.log(chalk_1.default.red(`[DEBUG] SSH error: ${error.message}`));
+                }
+                stream.destroy();
+                reject(error);
+            });
+            setTimeout(() => {
+                if (!commandSent) {
+                    sshTunnel.kill();
+                    stream.destroy();
+                    reject(new Error('Timeout waiting for shell prompt'));
+                }
+            }, 300000);
+            sshTunnel.on('close', (code) => {
+                this.debugLog(`[DEBUG] SSH process closed with code ${code}`);
+                if (!resolved) {
+                    stream.destroy();
+                    conn.destroy();
+                    if (tcpServer) {
+                        tcpServer.close();
+                        tcpServer = null;
+                    }
+                    setTimeout(() => {
+                        try {
+                            if (fs_1.default.existsSync(this.keyfile)) {
+                                fs_1.default.unlinkSync(this.keyfile);
+                            }
+                            if (fs_1.default.existsSync(`${this.keyfile}.pub`)) {
+                                fs_1.default.unlinkSync(`${this.keyfile}.pub`);
+                            }
+                        }
+                        catch (error) {
+                            this.debugLog(`[DEBUG] Error cleaning up key file: ${error}`);
+                        }
+                    }, 1000);
+                    if (code !== 0 && code !== null && !commandSent) {
+                        reject(new Error(`SSH exited with code ${code}`));
+                    }
+                    else if (commandSent && !outputBuffer.includes('DONE') && !transferComplete) {
+                        reject(new Error(`File copy may have failed. Check remote path: ${targetRemotePath}`));
+                    }
+                    else if (!resolved && transferComplete) {
+                        resolved = true;
+                        console.log(chalk_1.default.green('✓ Copy completed successfully'));
+                        resolve();
+                    }
+                }
+            });
+        });
+    }
+}
+async function cp(source, destination, options = {}) {
+    try {
+        const fileCopy = new FileCopy(options.verbose || false);
+        const sourceDevice = parseDevicePath(source);
+        if (sourceDevice) {
+            await fileCopy.copyFromDevice(sourceDevice.deviceName, sourceDevice.remotePath, destination);
+            setTimeout(() => {
+                process.exit(0);
+            }, 500);
+            return;
+        }
+        const destDevice = parseDevicePath(destination);
+        if (destDevice) {
+            await fileCopy.copyToDevice(destDevice.deviceName, source, destDevice.remotePath);
+            setTimeout(() => {
+                process.exit(0);
+            }, 500);
+            return;
+        }
+        throw new Error('At least one path must be a device path (format: device-name:/path/to/file)');
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Failed to copy: ${error.message}`));
+        if (error.message.includes('file not found')) {
+            console.error(chalk_1.default.yellow('Hint: Make sure the file exists and you have permission to access it.'));
+        }
+        setTimeout(() => {
+            process.exit(1);
+        }, 500);
+    }
+}
+//# sourceMappingURL=cp.js.map