genbox 1.0.181 → 1.0.182

package/dist/commands/session/index.js

@@ -508,6 +508,226 @@ function getDtachSocketDir() {
 function getDtachSocketPath(sessionName) {
     return path.join(getDtachSocketDir(), `${sessionName}.sock`);
 }
+/**
+ * Special key mappings (inspired by tmux's key-string.c)
+ * Maps key names to their terminal byte sequences
+ */
+const SPECIAL_KEYS = {
+    'Enter': '\r',
+    'Return': '\r',
+    'Tab': '\t',
+    'Escape': '\x1b',
+    'Space': ' ',
+    'Backspace': '\x7f',
+    'Delete': '\x1b[3~',
+    'Up': '\x1b[A',
+    'Down': '\x1b[B',
+    'Right': '\x1b[C',
+    'Left': '\x1b[D',
+    'Home': '\x1b[H',
+    'End': '\x1b[F',
+    'PageUp': '\x1b[5~',
+    'PageDown': '\x1b[6~',
+    'Insert': '\x1b[2~',
+    'F1': '\x1bOP',
+    'F2': '\x1bOQ',
+    'F3': '\x1bOR',
+    'F4': '\x1bOS',
+    'F5': '\x1b[15~',
+    'F6': '\x1b[17~',
+    'F7': '\x1b[18~',
+    'F8': '\x1b[19~',
+    'F9': '\x1b[20~',
+    'F10': '\x1b[21~',
+    'F11': '\x1b[23~',
+    'F12': '\x1b[24~',
+};
+/**
+ * Convert control key notation to byte (e.g., C-c -> \x03)
+ * Follows tmux convention: C-a through C-z map to 0x01-0x1a
+ */
+function parseControlKey(key) {
+    const match = key.match(/^[Cc]-([a-zA-Z@\[\]\\^_])$/);
+    if (!match)
+        return null;
+    const char = match[1].toLowerCase();
+    if (char >= 'a' && char <= 'z') {
+        return String.fromCharCode(char.charCodeAt(0) - 96); // a=1, z=26
+    }
+    // Special control chars
+    const specials = {
+        '@': 0, '[': 27, '\\': 28, ']': 29, '^': 30, '_': 31
+    };
+    if (specials[char] !== undefined) {
+        return String.fromCharCode(specials[char]);
+    }
+    return null;
+}
+/**
+ * Send keys to a dtach session (inspired by tmux's send-keys)
+ *
+ * This function writes directly to dtach's stdin, bypassing shell interpretation.
+ * Like tmux, it supports:
+ * - Literal text
+ * - Special keys (Enter, Tab, Escape, etc.)
+ * - Control sequences (C-c, C-d, etc.)
+ *
+ * @param socketPath - Path to the dtach socket
+ * @param keys - Array of keys/text to send. Each element can be:
+ *               - A string of literal text
+ *               - A special key name like "Enter", "Tab", "Escape"
+ *               - A control sequence like "C-c"
+ * @param options - Optional: addNewline (append Enter after all keys)
+ */
+function sendKeysToDtach(socketPath, keys, options = {}) {
+    // Build the byte sequence to send
+    let data = '';
+    for (const key of keys) {
+        // Check for special key
+        if (SPECIAL_KEYS[key]) {
+            data += SPECIAL_KEYS[key];
+            continue;
+        }
+        // Check for control key notation
+        const ctrlKey = parseControlKey(key);
+        if (ctrlKey) {
+            data += ctrlKey;
+            continue;
+        }
+        // Literal text
+        data += key;
+    }
+    // Optionally add newline
+    if (options.addNewline) {
+        data += '\r';
+    }
+    // Write directly to dtach via spawn (bypasses shell interpretation)
+    // This is the key insight from tmux: write bytes directly, don't go through shell
+    const proc = (0, child_process_1.spawnSync)('dtach', ['-p', socketPath], {
+        input: data,
+        timeout: 5000,
+        stdio: ['pipe', 'ignore', 'ignore'],
+    });
+    if (proc.error) {
+        throw new Error(`Failed to send keys: ${proc.error.message}`);
+    }
+}
+/**
+ * Send keys to a remote dtach session via SSH
+ * Uses the same direct-write approach as local, but through SSH stdin forwarding
+ */
+function sendKeysToRemoteDtach(ipAddress, keyPath, socketPath, keys, options = {}) {
+    // Build the byte sequence
+    let data = '';
+    for (const key of keys) {
+        if (SPECIAL_KEYS[key]) {
+            data += SPECIAL_KEYS[key];
+            continue;
+        }
+        const ctrlKey = parseControlKey(key);
+        if (ctrlKey) {
+            data += ctrlKey;
+            continue;
+        }
+        data += key;
+    }
+    if (options.addNewline) {
+        data += '\r';
+    }
+    // SSH with stdin forwarding to dtach -p
+    const proc = (0, child_process_1.spawnSync)('ssh', [
+        '-i', keyPath,
+        '-o', 'StrictHostKeyChecking=no',
+        '-o', 'UserKnownHostsFile=/dev/null',
+        '-o', 'ConnectTimeout=5',
+        `dev@${ipAddress}`,
+        `dtach -p ${socketPath}`
+    ], {
+        input: data,
+        timeout: 30000,
+        stdio: ['pipe', 'ignore', 'ignore'],
+    });
+    if (proc.error) {
+        throw new Error(`Failed to send keys to remote: ${proc.error.message}`);
+    }
+}
+/**
+ * Legacy escape function for cases where shell command is unavoidable
+ * Handles special shell characters that could cause issues
+ */
+function escapeForShell(str) {
+    return str
+        .replace(/\\/g, '\\\\') // Backslashes first
+        .replace(/'/g, "'\\''") // Single quotes
+        .replace(/\$/g, '\\$') // Dollar signs
+        .replace(/`/g, '\\`') // Backticks
+        .replace(/!/g, '\\!') // History expansion
+        .replace(/"/g, '\\"'); // Double quotes
+}
+/**
+ * Check if a dtach socket is actually alive (not just file exists)
+ * Attempts a brief connection to verify the process is running
+ */
+function isDtachSocketAlive(socketPath) {
+    if (!fs.existsSync(socketPath)) {
+        return false;
+    }
+    try {
+        // Try to send an empty string to test if socket is alive
+        // Using timeout to avoid hanging on dead sockets
+        (0, child_process_1.execSync)(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+            timeout: 2000,
+            stdio: 'ignore'
+        });
+        return true;
+    }
+    catch {
+        // Socket exists but is stale - clean it up
+        try {
+            fs.unlinkSync(socketPath);
+            console.log(chalk_1.default.dim(`Cleaned up stale socket: ${path.basename(socketPath)}`));
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        return false;
+    }
+}
+/**
+ * Check if a remote dtach socket is alive via SSH
+ */
+function isRemoteDtachSocketAlive(ipAddress, keyPath, socketPath) {
+    try {
+        (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=3 dev@${ipAddress} "echo -n '' | dtach -p ${socketPath}" 2>/dev/null`, { timeout: 5000, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Clean up all stale sockets in the local sockets directory
+ * Called on startup to ensure clean state
+ */
+function cleanupAllStaleSockets() {
+    const socketsDir = getDtachSocketDir();
+    let cleaned = 0;
+    try {
+        const files = fs.readdirSync(socketsDir);
+        for (const file of files) {
+            if (file.endsWith('.sock')) {
+                const socketPath = path.join(socketsDir, file);
+                if (!isDtachSocketAlive(socketPath)) {
+                    cleaned++;
+                }
+            }
+        }
+    }
+    catch {
+        // Directory might not exist yet
+    }
+    return cleaned;
+}
 /**
  * Ensure local dtach is available or get user choice
  * Returns: 'available' | 'skip' | 'cancel'
@@ -1603,12 +1823,12 @@ async function createNativeSession(options) {
     });
 }
 /**
- * Check if a dtach session is running locally (by checking if socket file exists)
+ * Check if a dtach session is running locally (verifies socket is actually alive)
  */
 function isDtachSessionRunning(sessionName) {
     try {
         const socketPath = getDtachSocketPath(sessionName);
-        return fs.existsSync(socketPath);
+        return isDtachSocketAlive(socketPath);
     }
     catch {
         return false;
@@ -1970,6 +2190,11 @@ exports.sessionCommand = new commander_1.Command('session')
     .addCommand(migrate_1.sessionMigrateCommand)
     .action(async (sessionArg, providerArgs, options) => {
     try {
+        // Clean up stale sockets on startup (silently)
+        const cleaned = cleanupAllStaleSockets();
+        if (cleaned > 0) {
+            console.log(chalk_1.default.dim(`Cleaned up ${cleaned} stale socket${cleaned > 1 ? 's' : ''}`));
+        }
         // Multi-session orchestration mode
         if (options.multi) {
             // If sessionArg looks like a provider spec, treat it as part of providers

package/dist/lib/local-orchestrator.js

@@ -13,7 +13,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalOrchestrator = void 0;
 exports.parseProviderSpec = parseProviderSpec;
 exports.getLocalOrchestrator = getLocalOrchestrator;
-const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const local_session_manager_1 = require("./local-session-manager");
 /**
@@ -233,11 +232,81 @@ class LocalOrchestrator {
             await this.sendPromptToCloudSession(orchSession.session, prompt);
         }
     }
+    /**
+     * Send keys directly to dtach stdin (inspired by tmux's send-keys)
+     * Bypasses shell interpretation by writing directly to the process
+     */
+    sendKeysDirect(socketPath, data) {
+        const { spawnSync } = require('child_process');
+        const proc = spawnSync('dtach', ['-p', socketPath], {
+            input: data + '\r',
+            timeout: 5000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys: ${proc.error.message}`);
+        }
+    }
+    /**
+     * Send keys to Docker container's dtach session
+     */
+    sendKeysToDocker(containerId, socketPath, data) {
+        const { spawnSync } = require('child_process');
+        const proc = spawnSync('docker', [
+            'exec', '-i', containerId,
+            'dtach', '-p', socketPath
+        ], {
+            input: data + '\r',
+            timeout: 10000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys to docker: ${proc.error.message}`);
+        }
+    }
+    /**
+     * Send keys to Multipass VM's dtach session
+     */
+    sendKeysToMultipass(vmName, socketPath, data) {
+        const { spawnSync } = require('child_process');
+        const proc = spawnSync('multipass', [
+            'exec', vmName, '--',
+            'dtach', '-p', socketPath
+        ], {
+            input: data + '\r',
+            timeout: 10000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys to multipass: ${proc.error.message}`);
+        }
+    }
+    /**
+     * Send keys to remote dtach session via SSH stdin forwarding
+     */
+    sendKeysToRemote(ipAddress, keyPath, socketPath, data) {
+        const { spawnSync } = require('child_process');
+        const proc = spawnSync('ssh', [
+            '-i', keyPath,
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=5',
+            `dev@${ipAddress}`,
+            `dtach -p ${socketPath}`
+        ], {
+            input: data + '\r',
+            timeout: 30000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys to remote: ${proc.error.message}`);
+        }
+    }
     /**
      * Send a prompt to a local session via dtach -p (push mode)
+     * Uses direct stdin write (inspired by tmux's send-keys) to bypass shell interpretation
      */
     async sendPromptToLocalSession(session, prompt) {
-        const escapedPrompt = prompt.replace(/'/g, "'\\''");
         const os = require('os');
         const path = require('path');
         try {
@@ -246,18 +315,18 @@ class LocalOrchestrator {
                     if (!session.containerId)
                         return;
                     await new Promise(resolve => setTimeout(resolve, 2000));
-                    (0, child_process_1.execSync)(`echo '${escapedPrompt}' | docker exec -i ${session.containerId} dtach -p /home/dev/.genbox/sockets/${session.name}.sock`, { stdio: 'ignore' });
+                    this.sendKeysToDocker(session.containerId, `/home/dev/.genbox/sockets/${session.name}.sock`, prompt);
                     break;
                 case 'multipass':
                     if (!session.vmName)
                         return;
                     await new Promise(resolve => setTimeout(resolve, 2000));
-                    (0, child_process_1.execSync)(`echo '${escapedPrompt}' | multipass exec ${session.vmName} -- dtach -p /home/ubuntu/.genbox/sockets/${session.name}.sock`, { stdio: 'ignore' });
+                    this.sendKeysToMultipass(session.vmName, `/home/ubuntu/.genbox/sockets/${session.name}.sock`, prompt);
                     break;
                 case 'native':
                     await new Promise(resolve => setTimeout(resolve, 1000));
                     const socketPath = path.join(os.homedir(), '.genbox', 'sockets', `${session.name}.sock`);
-                    (0, child_process_1.execSync)(`echo '${escapedPrompt}' | dtach -p "${socketPath}"`, { stdio: 'ignore' });
+                    this.sendKeysDirect(socketPath, prompt);
                     break;
             }
         }
@@ -267,18 +336,18 @@ class LocalOrchestrator {
     }
     /**
      * Send a prompt to a cloud session via SSH + dtach -p
+     * Uses direct stdin forwarding to bypass shell interpretation
      */
     async sendPromptToCloudSession(session, prompt) {
         if (!session.ipAddress) {
             console.log(chalk_1.default.yellow(`Warning: Cloud session ${session.name} has no IP address`));
             return;
         }
-        const escapedPrompt = prompt.replace(/'/g, "'\\''");
         const socketPath = `/home/dev/.genbox/sockets/${session.name}.sock`;
         try {
             const keyPath = this.getPrivateSshKey();
             await new Promise(resolve => setTimeout(resolve, 2000));
-            (0, child_process_1.execSync)(`ssh -i "${keyPath}" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null dev@${session.ipAddress} "echo '${escapedPrompt}' | dtach -p ${socketPath}" 2>/dev/null`, { stdio: 'ignore', timeout: 30000 });
+            this.sendKeysToRemote(session.ipAddress, keyPath, socketPath, prompt);
         }
         catch (error) {
             console.log(chalk_1.default.yellow(`Warning: Could not send prompt to cloud session ${session.name}: ${error.message}`));

package/dist/lib/local-session-manager.js

@@ -293,7 +293,7 @@ class LocalSessionManager {
     checkNativeStatus(session) {
         try {
             const socketPath = path.join(os.homedir(), '.genbox', 'sockets', `${session.name}.sock`);
-            if (fs.existsSync(socketPath)) {
+            if (this.isDtachSocketAlive(socketPath)) {
                 return 'running';
             }
             return 'stopped';
@@ -302,6 +302,80 @@ class LocalSessionManager {
             return 'stopped';
         }
     }
+    /**
+     * Check if a dtach socket is actually alive (not just file exists)
+     */
+    isDtachSocketAlive(socketPath) {
+        if (!fs.existsSync(socketPath)) {
+            return false;
+        }
+        try {
+            // Try to send an empty string to test if socket is alive
+            (0, child_process_1.execSync)(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+                timeout: 2000,
+                stdio: 'ignore'
+            });
+            return true;
+        }
+        catch {
+            // Socket exists but is stale - clean it up
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return false;
+        }
+    }
+    /**
+     * Send keys directly to dtach stdin (inspired by tmux's send-keys)
+     * Bypasses shell interpretation by writing directly to the process
+     */
+    sendKeysDirect(socketPath, data) {
+        const proc = (0, child_process_1.spawnSync)('dtach', ['-p', socketPath], {
+            input: data + '\r', // Add Enter key
+            timeout: 5000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys: ${proc.error.message}`);
+        }
+    }
+    /**
+     * Send keys to Docker container's dtach session
+     * Uses docker exec with stdin forwarding
+     */
+    sendKeysToDocker(containerId, socketPath, data) {
+        const proc = (0, child_process_1.spawnSync)('docker', [
+            'exec', '-i', containerId,
+            'dtach', '-p', socketPath
+        ], {
+            input: data + '\r',
+            timeout: 10000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys to docker: ${proc.error.message}`);
+        }
+    }
+    /**
+     * Send keys to Multipass VM's dtach session
+     * Uses multipass exec with stdin forwarding
+     */
+    sendKeysToMultipass(vmName, socketPath, data) {
+        const proc = (0, child_process_1.spawnSync)('multipass', [
+            'exec', vmName, '--',
+            'dtach', '-p', socketPath
+        ], {
+            input: data + '\r',
+            timeout: 10000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        if (proc.error) {
+            throw new Error(`Failed to send keys to multipass: ${proc.error.message}`);
+        }
+    }
     /**
      * List all local sessions
      */
@@ -867,25 +941,23 @@ final_message: "Cloud-init completed successfully"
     }
     /**
      * Send a prompt to a session via dtach -p (push mode)
-     * dtach -p allows writing to the session's stdin without attaching
+     * Uses direct stdin write (inspired by tmux's send-keys) to bypass shell interpretation
      */
     async sendPromptToSession(session, prompt) {
-        // Escape the prompt for shell and add Enter key
-        const escapedPrompt = prompt.replace(/'/g, "'\\''");
         switch (session.isolation) {
             case 'docker':
                 if (!session.containerId)
                     throw new Error('Session has no container ID');
-                (0, child_process_1.execSync)(`echo '${escapedPrompt}' | docker exec -i ${session.containerId} dtach -p /home/dev/.genbox/sockets/${session.name}.sock`, { stdio: 'ignore' });
+                this.sendKeysToDocker(session.containerId, `/home/dev/.genbox/sockets/${session.name}.sock`, prompt);
                 break;
             case 'multipass':
                 if (!session.vmName)
                     throw new Error('Session has no VM name');
-                (0, child_process_1.execSync)(`echo '${escapedPrompt}' | multipass exec ${session.vmName} -- dtach -p /home/ubuntu/.genbox/sockets/${session.name}.sock`, { stdio: 'ignore' });
+                this.sendKeysToMultipass(session.vmName, `/home/ubuntu/.genbox/sockets/${session.name}.sock`, prompt);
                 break;
             case 'native':
                 const socketPath = path.join(os.homedir(), '.genbox', 'sockets', `${session.name}.sock`);
-                (0, child_process_1.execSync)(`echo '${escapedPrompt}' | dtach -p "${socketPath}"`, { stdio: 'ignore' });
+                this.sendKeysDirect(socketPath, prompt);
                 break;
         }
         // Update last activity

package/dist/lib/native-session-manager.js

@@ -233,17 +233,44 @@ class NativeSessionManager {
         return this.listSessions().filter(s => this.isSessionRunning(s.dtachSocketName || s.name));
     }
     /**
-     * Check if a dtach session is running (by checking if socket file exists)
+     * Check if a dtach session is running (verifies socket is actually alive)
      */
     isSessionRunning(sessionName) {
         try {
             const socketPath = path.join(os.homedir(), '.genbox', 'sockets', `${sessionName}.sock`);
-            return fs.existsSync(socketPath);
+            return this.isDtachSocketAlive(socketPath);
         }
         catch {
             return false;
         }
     }
+    /**
+     * Check if a dtach socket is actually alive (not just file exists)
+     */
+    isDtachSocketAlive(socketPath) {
+        if (!fs.existsSync(socketPath)) {
+            return false;
+        }
+        try {
+            // Try to send an empty string to test if socket is alive
+            const { execSync } = require('child_process');
+            execSync(`echo -n "" | dtach -p "${socketPath}" 2>/dev/null`, {
+                timeout: 2000,
+                stdio: 'ignore'
+            });
+            return true;
+        }
+        catch {
+            // Socket exists but is stale - clean it up
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return false;
+        }
+    }
     /**
      * Update session status
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.181",
+  "version": "1.0.182",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {