@the-open-engine/zeroshot 6.38.1 → 6.39.0

package/src/attach/attach-client.js

@@ -1,438 +1,265 @@
-/**
- * AttachClient - Terminal client for attaching to running tasks/agents
- *
- * Key sequences:
- * - Ctrl+C: Clean detach (return to shell, task continues running)
- * - Ctrl+B d: Also detach (for tmux muscle memory)
- * - Ctrl+B ?: Show help
- * - Ctrl+B c: Send SIGINT to process (interrupt agent - USE WITH CAUTION)
- * - Ctrl+Z: Forward SIGTSTP to process
- *
- * Features:
- * - Raw terminal mode (passes through all input)
- * - Output history replay on attach
- * - Terminal resize forwarding
- * - Graceful cleanup on exit
- */
-
-const net = require('net');
-const EventEmitter = require('events');
-const crypto = require('crypto');
-
-const protocol = require('./protocol');
-
-// Key codes
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+/** Terminal client for attaching to a running task or agent. */
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_events_1 = require("node:events");
+const node_net_1 = __importDefault(require("node:net"));
+const protocol_1 = __importDefault(require("./protocol"));
 const CTRL_B = '\x02';
 const CTRL_C = '\x03';
 const CTRL_Z = '\x1a';
-
-// Detach timeout (ms) - how long to wait for second key after Ctrl+B
 const DETACH_TIMEOUT = 500;
-
-class AttachClient extends EventEmitter {
-  /**
-   * @param {object} options
-   * @param {string} options.socketPath - Unix socket path to connect to
-   * @param {object} [options.stdin] - Input stream (default process.stdin)
-   * @param {object} [options.stdout] - Output stream (default process.stdout)
-   */
-  constructor(options) {
-    super();
-
-    if (!options.socketPath) {
-      throw new Error('AttachClient: socketPath is required');
+function readServerMessage(message) {
+    if ((typeof message !== 'object' && typeof message !== 'function') || message === null) {
+        throw new TypeError(`Cannot read properties of ${message}`);
     }
-
-    this.socketPath = options.socketPath;
-    this.stdin = options.stdin || process.stdin;
-    this.stdout = options.stdout || process.stdout;
-
-    this.clientId = crypto.randomUUID();
-    this.socket = null;
-    this.decoder = new protocol.MessageDecoder();
-    this.connected = false;
-    this.wasRawMode = null;
-
-    // Ctrl+B sequence detection
-    this.ctrlBPressed = false;
-    this.ctrlBTimeout = null;
-
-    // Bind handlers
-    this._onSocketData = this._onSocketData.bind(this);
-    this._onSocketClose = this._onSocketClose.bind(this);
-    this._onSocketError = this._onSocketError.bind(this);
-    this._onStdinData = this._onStdinData.bind(this);
-    this._onResize = this._onResize.bind(this);
-  }
-
-  /**
-   * Connect to the attach server
-   * @returns {Promise<void>}
-   */
-  connect() {
-    if (this.connected) {
-      throw new Error('AttachClient: Already connected');
-    }
-
-    return new Promise((resolve, reject) => {
-      this.socket = net.createConnection(this.socketPath);
-
-      this.socket.on('connect', () => {
-        this.connected = true;
-
-        // Send attach message with terminal dimensions
-        const cols = this.stdout.columns || 80;
-        const rows = this.stdout.rows || 24;
-
-        this.socket.write(protocol.encode(protocol.createAttachMessage(this.clientId, cols, rows)));
-
-        // Set up terminal
-        this._setupTerminal();
-
-        // Set up socket handlers
-        this.socket.on('data', this._onSocketData);
-        this.socket.on('close', this._onSocketClose);
-        this.socket.on('error', this._onSocketError);
-
-        resolve();
-      });
-
-      this.socket.on('error', (err) => {
-        if (!this.connected) {
-          reject(err);
-        }
-      });
-
-      // Connection timeout
-      const timeout = setTimeout(() => {
-        if (!this.connected) {
-          this.socket.destroy();
-          reject(new Error('Connection timeout'));
+    return {
+        code: Reflect.get(message, 'code'),
+        data: Reflect.get(message, 'data'),
+        message: Reflect.get(message, 'message'),
+        signal: Reflect.get(message, 'signal'),
+        type: Reflect.get(message, 'type'),
+    };
+}
+function dataMessage(data) {
+    if (data === undefined || !data)
+        return {};
+    if (typeof data === 'string')
+        return { data };
+    throw new TypeError('Attach protocol data must be a base64 string');
+}
+class AttachClient extends node_events_1.EventEmitter {
+    socketPath;
+    stdin;
+    stdout;
+    clientId;
+    socket = null;
+    decoder = new protocol_1.default.MessageDecoder();
+    connected = false;
+    wasRawMode = null;
+    ctrlBPressed = false;
+    ctrlBTimeout = null;
+    constructor(options) {
+        super();
+        if (!options.socketPath) {
+            throw new Error('AttachClient: socketPath is required');
         }
-      }, 5000);
-
-      this.socket.on('connect', () => clearTimeout(timeout));
-    });
-  }
-
-  /**
-   * Disconnect from the server
-   */
-  disconnect() {
-    if (!this.connected) {
-      return;
+        this.socketPath = options.socketPath;
+        this.stdin = options.stdin || process.stdin;
+        this.stdout = options.stdout || process.stdout;
+        this.clientId = node_crypto_1.default.randomUUID();
+        this._onSocketData = this._onSocketData.bind(this);
+        this._onSocketClose = this._onSocketClose.bind(this);
+        this._onSocketError = this._onSocketError.bind(this);
+        this._onStdinData = this._onStdinData.bind(this);
+        this._onResize = this._onResize.bind(this);
     }
-
-    // Send detach message
-    try {
-      this.socket.write(protocol.encode(protocol.createDetachMessage(this.clientId)));
-    } catch {
-      // Ignore
-    }
-
-    this._cleanup();
-    this.emit('detach');
-  }
-
-  /**
-   * Send a signal to the remote process
-   * @param {string} signal - Signal name
-   */
-  sendSignal(signal) {
-    if (!this.connected) {
-      return;
-    }
-
-    try {
-      this.socket.write(protocol.encode(protocol.createSignalMessage(signal)));
-    } catch {
-      // Ignore
-    }
-  }
-
-  // ─────────────────────────────────────────────────────────────────
-  // Private methods
-  // ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Set up terminal for raw mode
-   * @private
-   */
-  _setupTerminal() {
-    // Enable raw mode if stdin is a TTY
-    if (this.stdin.isTTY && this.stdin.setRawMode) {
-      this.wasRawMode = this.stdin.isRaw;
-      this.stdin.setRawMode(true);
+    connect() {
+        if (this.connected) {
+            throw new Error('AttachClient: Already connected');
+        }
+        return new Promise((resolve, reject) => {
+            const socket = node_net_1.default.createConnection(this.socketPath);
+            this.socket = socket;
+            socket.on('connect', () => {
+                this.connected = true;
+                const cols = this.stdout.columns || 80;
+                const rows = this.stdout.rows || 24;
+                socket.write(protocol_1.default.encode(protocol_1.default.createAttachMessage(this.clientId, cols, rows)));
+                this._setupTerminal();
+                socket.on('data', this._onSocketData);
+                socket.on('close', this._onSocketClose);
+                socket.on('error', this._onSocketError);
+                resolve();
+            });
+            socket.on('error', (error) => {
+                if (!this.connected)
+                    reject(error);
+            });
+            const timeout = setTimeout(() => {
+                if (!this.connected) {
+                    socket.destroy();
+                    reject(new Error('Connection timeout'));
+                }
+            }, 5000);
+            socket.on('connect', () => clearTimeout(timeout));
+        });
     }
-
-    // Resume stdin (may be paused)
-    this.stdin.resume();
-
-    // Listen for input
-    this.stdin.on('data', this._onStdinData);
-
-    // Listen for resize events
-    if (this.stdout.isTTY) {
-      this.stdout.on('resize', this._onResize);
+    disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            this.socket?.write(protocol_1.default.encode(protocol_1.default.createDetachMessage(this.clientId)));
+        }
+        catch {
+            // Ignore transport failures during detach.
+        }
+        this._cleanup();
+        this.emit('detach');
     }
-
-    // Handle process signals for cleanup
-    process.on('SIGINT', () => {
-      // Clean detach on Ctrl+C - task continues running
-      this.disconnect();
-    });
-
-    process.on('SIGTERM', () => {
-      this._cleanup();
-      process.exit(0);
-    });
-  }
-
-  /**
-   * Restore terminal state
-   * @private
-   */
-  _restoreTerminal() {
-    // Restore raw mode
-    if (this.stdin.isTTY && this.stdin.setRawMode && this.wasRawMode !== null) {
-      this.stdin.setRawMode(this.wasRawMode);
+    sendSignal(signal) {
+        if (!this.connected)
+            return;
+        try {
+            this.socket?.write(protocol_1.default.encode(protocol_1.default.createSignalMessage(signal)));
+        }
+        catch {
+            // Ignore transport failures while signaling.
+        }
     }
-
-    // Remove listeners
-    this.stdin.removeListener('data', this._onStdinData);
-    if (this.stdout.isTTY) {
-      this.stdout.removeListener('resize', this._onResize);
+    _setupTerminal() {
+        if (this.stdin.isTTY && this.stdin.setRawMode) {
+            this.wasRawMode = this.stdin.isRaw;
+            this.stdin.setRawMode(true);
+        }
+        this.stdin.resume();
+        this.stdin.on('data', this._onStdinData);
+        if (this.stdout.isTTY)
+            this.stdout.on('resize', this._onResize);
+        process.on('SIGINT', () => this.disconnect());
+        process.on('SIGTERM', () => {
+            this._cleanup();
+            process.exit(0);
+        });
     }
-
-    // Pause stdin
-    this.stdin.pause();
-  }
-
-  /**
-   * Handle data from socket
-   * @private
-   */
-  _onSocketData(data) {
-    try {
-      const messages = this.decoder.feed(data);
-      for (const msg of messages) {
-        this._handleMessage(msg);
-      }
-    } catch (e) {
-      this.emit('error', new Error(`Protocol error: ${e.message}`));
-      this._cleanup();
+    _restoreTerminal() {
+        if (this.stdin.isTTY && this.stdin.setRawMode && this.wasRawMode !== null) {
+            Reflect.apply(this.stdin.setRawMode, this.stdin, [this.wasRawMode]);
+        }
+        this.stdin.removeListener('data', this._onStdinData);
+        if (this.stdout.isTTY)
+            this.stdout.removeListener('resize', this._onResize);
+        this.stdin.pause();
     }
-  }
-
-  /**
-   * Handle message from server
-   * @private
-   */
-  _handleMessage(message) {
-    switch (message.type) {
-      case protocol.MessageType.OUTPUT: {
-        const data = protocol.decodeData(message);
-        if (data) {
-          this.stdout.write(data);
+    _onSocketData(data) {
+        try {
+            for (const message of this.decoder.feed(data))
+                this._handleMessage(message);
         }
-        break;
-      }
-
-      case protocol.MessageType.HISTORY: {
-        const data = protocol.decodeData(message);
-        if (data) {
-          this.stdout.write(data);
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.emit('error', new Error(`Protocol error: ${reason}`));
+            this._cleanup();
         }
-        break;
-      }
-
-      case protocol.MessageType.STATE: {
-        this.emit('state', message);
-        break;
-      }
-
-      case protocol.MessageType.EXIT: {
-        const { code, signal } = message;
-        this.emit('exit', { code, signal });
-        this._cleanup();
-        break;
-      }
-
-      case protocol.MessageType.ERROR: {
-        this.emit('error', new Error(message.message));
-        break;
-      }
     }
-  }
-
-  /**
-   * Handle stdin data
-   * @private
-   */
-  _onStdinData(data) {
-    const str = data.toString();
-
-    // Handle Ctrl+B sequence
-    if (this.ctrlBPressed) {
-      this.ctrlBPressed = false;
-      if (this.ctrlBTimeout) {
-        clearTimeout(this.ctrlBTimeout);
-        this.ctrlBTimeout = null;
-      }
-
-      // Check for command keys
-      if (str === 'd' || str === 'D') {
-        // Detach
-        this.disconnect();
-        return;
-      }
-
-      if (str === 'c' || str === 'C') {
-        // Send SIGINT to process (interrupt agent - USE WITH CAUTION)
-        this.stdout.write('\r\n⚠️  Sending SIGINT to agent (interrupting task)...\r\n');
-        this.sendSignal('SIGINT');
-        return;
-      }
-
-      if (str === '?') {
-        // Show help
-        this._showHelp();
-        return;
-      }
-
-      // Not a recognized command, forward Ctrl+B + this key
-      this._forwardInput(Buffer.from([0x02]));
-      this._forwardInput(data);
-      return;
+    _handleMessage(message) {
+        const serverMessage = readServerMessage(message);
+        switch (serverMessage.type) {
+            case protocol_1.default.MessageType.OUTPUT:
+            case protocol_1.default.MessageType.HISTORY: {
+                const data = protocol_1.default.decodeData(dataMessage(serverMessage.data));
+                if (data)
+                    this.stdout.write(data);
+                break;
+            }
+            case protocol_1.default.MessageType.STATE:
+                this.emit('state', message);
+                break;
+            case protocol_1.default.MessageType.EXIT: {
+                const { code, signal } = serverMessage;
+                this.emit('exit', { code, signal });
+                this._cleanup();
+                break;
+            }
+            case protocol_1.default.MessageType.ERROR:
+                this.emit('error', new Error(serverMessage.message === undefined ? undefined : String(serverMessage.message)));
+                break;
+        }
     }
-
-    // Check for Ctrl+B
-    if (str === CTRL_B) {
-      this.ctrlBPressed = true;
-
-      // Set timeout to forward if no follow-up key
-      this.ctrlBTimeout = setTimeout(() => {
+    _onStdinData(data) {
+        const input = data.toString();
         if (this.ctrlBPressed) {
-          this.ctrlBPressed = false;
-          this._forwardInput(data);
+            this.ctrlBPressed = false;
+            if (this.ctrlBTimeout) {
+                clearTimeout(this.ctrlBTimeout);
+                this.ctrlBTimeout = null;
+            }
+            if (input === 'd' || input === 'D')
+                return this.disconnect();
+            if (input === 'c' || input === 'C') {
+                this.stdout.write('\r\n⚠️  Sending SIGINT to agent (interrupting task)...\r\n');
+                return this.sendSignal('SIGINT');
+            }
+            if (input === '?')
+                return this._showHelp();
+            this._forwardInput(Buffer.from([0x02]));
+            this._forwardInput(data);
+            return;
         }
-      }, DETACH_TIMEOUT);
-      return;
-    }
-
-    // Check for Ctrl+C - clean detach (task continues running)
-    if (str === CTRL_C) {
-      this.disconnect();
-      return;
-    }
-
-    // Check for Ctrl+Z
-    if (str === CTRL_Z) {
-      this.sendSignal('SIGTSTP');
-      return;
-    }
-
-    // Forward other input (future interactive mode)
-    this._forwardInput(data);
-  }
-
-  /**
-   * Forward input to remote process
-   * @private
-   */
-  _forwardInput(data) {
-    if (!this.connected) {
-      return;
+        if (input === CTRL_B) {
+            this.ctrlBPressed = true;
+            this.ctrlBTimeout = setTimeout(() => {
+                if (this.ctrlBPressed) {
+                    this.ctrlBPressed = false;
+                    this._forwardInput(data);
+                }
+            }, DETACH_TIMEOUT);
+            return;
+        }
+        if (input === CTRL_C)
+            return this.disconnect();
+        if (input === CTRL_Z)
+            return this.sendSignal('SIGTSTP');
+        this._forwardInput(data);
     }
-
-    try {
-      this.socket.write(protocol.encode(protocol.createStdinMessage(data)));
-    } catch {
-      // Ignore
+    _forwardInput(data) {
+        if (!this.connected)
+            return;
+        try {
+            this.socket?.write(protocol_1.default.encode(protocol_1.default.createStdinMessage(data)));
+        }
+        catch {
+            // Ignore transport failures while forwarding terminal input.
+        }
     }
-  }
-
-  /**
-   * Handle terminal resize
-   * @private
-   */
-  _onResize() {
-    if (!this.connected) {
-      return;
+    _onResize() {
+        if (!this.connected)
+            return;
+        try {
+            this.socket?.write(protocol_1.default.encode(protocol_1.default.createResizeMessage(this.stdout.columns, this.stdout.rows)));
+        }
+        catch {
+            // Ignore transport failures while forwarding terminal size.
+        }
     }
-
-    const cols = this.stdout.columns;
-    const rows = this.stdout.rows;
-
-    try {
-      this.socket.write(protocol.encode(protocol.createResizeMessage(cols, rows)));
-    } catch {
-      // Ignore
+    _onSocketClose() {
+        if (this.connected) {
+            this.emit('close');
+            this._cleanup();
+        }
     }
-  }
-
-  /**
-   * Handle socket close
-   * @private
-   */
-  _onSocketClose() {
-    if (this.connected) {
-      this.emit('close');
-      this._cleanup();
+    _onSocketError(error) {
+        this.emit('error', error);
+        this._cleanup();
     }
-  }
-
-  /**
-   * Handle socket error
-   * @private
-   */
-  _onSocketError(err) {
-    this.emit('error', err);
-    this._cleanup();
-  }
-
-  /**
-   * Show help message
-   * @private
-   */
-  _showHelp() {
-    const help = `
-\r\n╭──────────────────────────────────────────────────────────╮
+    _showHelp() {
+        const horizontal = '─'.repeat(58);
+        this.stdout.write(`
+\r\n╭${horizontal}╮
 \r\n│              Vibe Attach - Key Bindings                  │
-\r\n├──────────────────────────────────────────────────────────┤
+\r\n├${horizontal}┤
 \r\n│  Ctrl+C      Detach (task continues running)             │
 \r\n│  Ctrl+B d    Also detach (for tmux muscle memory)        │
 \r\n│  Ctrl+B ?    Show this help                              │
 \r\n│  Ctrl+B c    ⚠️  Interrupt agent (sends SIGINT)           │
 \r\n│  Ctrl+Z      Suspend process (sends SIGTSTP)             │
-\r\n╰──────────────────────────────────────────────────────────╯
-\r\n`;
-    this.stdout.write(help);
-  }
-
-  /**
-   * Clean up resources
-   * @private
-   */
-  _cleanup() {
-    this.connected = false;
-
-    // Clear Ctrl+B timeout
-    if (this.ctrlBTimeout) {
-      clearTimeout(this.ctrlBTimeout);
-      this.ctrlBTimeout = null;
+\r\n╰${horizontal}╯
+\r\n`);
     }
-
-    // Restore terminal
-    this._restoreTerminal();
-
-    // Close socket
-    if (this.socket) {
-      this.socket.removeAllListeners();
-      this.socket.destroy();
-      this.socket = null;
+    _cleanup() {
+        this.connected = false;
+        if (this.ctrlBTimeout) {
+            clearTimeout(this.ctrlBTimeout);
+            this.ctrlBTimeout = null;
+        }
+        this._restoreTerminal();
+        if (this.socket) {
+            this.socket.removeAllListeners();
+            this.socket.destroy();
+            this.socket = null;
+        }
     }
-  }
 }
-
 module.exports = AttachClient;