genbox 1.0.180 → 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

@@ -233,20 +233,125 @@ class LocalOrchestrator {
         }
     }
     /**
-     * Send a prompt to a local session
-     * @deprecated dtach doesn't support programmatic prompt sending like tmux
+     * 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) {
-        console.log(chalk_1.default.yellow(`Warning: Programmatic prompt sending is not supported with dtach sessions`));
-        console.log(chalk_1.default.dim(`Please attach to the session manually and enter your prompt.`));
+        const os = require('os');
+        const path = require('path');
+        try {
+            switch (session.isolation) {
+                case 'docker':
+                    if (!session.containerId)
+                        return;
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    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));
+                    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`);
+                    this.sendKeysDirect(socketPath, prompt);
+                    break;
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.yellow(`Warning: Could not send prompt to ${session.name}: ${error.message}`));
+        }
     }
     /**
-     * Send a prompt to a cloud session
-     * @deprecated dtach doesn't support programmatic prompt sending like tmux
+     * Send a prompt to a cloud session via SSH + dtach -p
+     * Uses direct stdin forwarding to bypass shell interpretation
      */
     async sendPromptToCloudSession(session, prompt) {
-        console.log(chalk_1.default.yellow(`Warning: Programmatic prompt sending is not supported with dtach sessions`));
-        console.log(chalk_1.default.dim(`Please attach to the session manually and enter your prompt.`));
+        if (!session.ipAddress) {
+            console.log(chalk_1.default.yellow(`Warning: Cloud session ${session.name} has no IP address`));
+            return;
+        }
+        const socketPath = `/home/dev/.genbox/sockets/${session.name}.sock`;
+        try {
+            const keyPath = this.getPrivateSshKey();
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            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}`));
+        }
     }
     /**
      * Get SSH key path for cloud sessions

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
      */
@@ -866,13 +940,26 @@ final_message: "Cloud-init completed successfully"
         this.unregisterSession(sessionId);
     }
     /**
-     * Send a prompt to a session
-     * Note: dtach doesn't support send-keys like tmux, so this functionality is limited.
-     * This method is kept for API compatibility but may not work as expected.
-     * @deprecated dtach doesn't support programmatic prompt sending
+     * Send a prompt to a session via dtach -p (push mode)
+     * Uses direct stdin write (inspired by tmux's send-keys) to bypass shell interpretation
      */
     async sendPromptToSession(session, prompt) {
-        console.warn('Warning: sendPromptToSession is not fully supported with dtach sessions');
+        switch (session.isolation) {
+            case 'docker':
+                if (!session.containerId)
+                    throw new Error('Session has no container ID');
+                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');
+                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`);
+                this.sendKeysDirect(socketPath, prompt);
+                break;
+        }
         // Update last activity
         session.lastActivityAt = new Date();
         this.updateSession(session);

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.180",
+  "version": "1.0.182",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {