@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/attach/attach-server.js

@@ -1,543 +1,126 @@
-/**
- * AttachServer - PTY process manager with socket server for attach/detach
- *
- * Lifecycle:
- * 1. Created when task/agent spawns
- * 2. Spawns command via node-pty
- * 3. Listens on Unix socket for client connections
- * 4. Buffers output in ring buffer (for late-joining clients)
- * 5. Broadcasts output to all connected clients
- * 6. Cleans up when process exits
- *
- * Features:
- * - Multi-client support (multiple terminals can attach)
- * - Output history replay on attach
- * - Signal forwarding (SIGINT, SIGTERM)
- * - Window resize support
- * - Graceful cleanup on exit
- */
-
-const net = require('net');
-const fs = require('fs');
-const path = require('path');
-const EventEmitter = require('events');
-
-const RingBuffer = require('./ring-buffer');
-const protocol = require('./protocol');
-const { cleanupStaleSocket } = require('./socket-discovery');
-
-// FAIL FAST: Check for node-pty at module load time, not at spawn time
-let pty;
-try {
-  pty = require('node-pty');
-} catch (e) {
-  throw new Error(
-    `AttachServer: node-pty not installed. Run: npm install node-pty\n` +
-      `Original error: ${e.message}`
-  );
-}
-
-// Default output buffer size: 1MB
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_events_1 = require("node:events");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ring_buffer_1 = __importDefault(require("./ring-buffer"));
+const socket_discovery_1 = __importDefault(require("./socket-discovery"));
+const attach_server_clients_1 = require("./attach-server-clients");
+const attach_server_cleanup_1 = require("./attach-server-cleanup");
+const attach_server_events_1 = require("./attach-server-events");
+const attach_server_pty_1 = require("./attach-server-pty");
+const attach_server_runtime_1 = require("./attach-server-runtime");
+const attach_server_socket_1 = require("./attach-server-socket");
 const DEFAULT_BUFFER_SIZE = 1024 * 1024;
-
-class AttachServer extends EventEmitter {
-  /**
-   * @param {object} options
-   * @param {string} options.id - Task or agent ID
-   * @param {string} options.socketPath - Unix socket path
-   * @param {string} options.command - Command to spawn
-   * @param {string[]} options.args - Command arguments
-   * @param {string} [options.cwd] - Working directory
-   * @param {object} [options.env] - Environment variables
-   * @param {number} [options.cols] - Terminal columns (default 120)
-   * @param {number} [options.rows] - Terminal rows (default 30)
-   * @param {number} [options.bufferSize] - Output buffer size (default 1MB)
-   */
-  constructor(options) {
-    super();
-
-    if (!options.id) throw new Error('AttachServer: id is required');
-    if (!options.socketPath) throw new Error('AttachServer: socketPath is required');
-    if (!options.command) throw new Error('AttachServer: command is required');
-
-    this.id = options.id;
-    this.socketPath = options.socketPath;
-    this.command = options.command;
-    this.args = options.args || [];
-    this.cwd = options.cwd || process.cwd();
-    this.env = options.env || process.env;
-    this.cols = options.cols || 120;
-    this.rows = options.rows || 30;
-
-    this.outputBuffer = new RingBuffer(options.bufferSize || DEFAULT_BUFFER_SIZE);
-    this.clients = new Map(); // clientId -> { socket, decoder }
-    this.pty = null;
-    this.server = null;
-    this.state = 'stopped'; // stopped, starting, running, exiting, exited
-    this.exitCode = null;
-    this.exitSignal = null;
-    this.pid = null;
-
-    // Bind cleanup handlers
-    this._onProcessExit = this._onProcessExit.bind(this);
-    this._onServerError = this._onServerError.bind(this);
-  }
-
-  /**
-   * Start the PTY process and socket server
-   * @returns {Promise<void>}
-   */
-  async start() {
-    if (this.state !== 'stopped') {
-      throw new Error(`AttachServer: Cannot start from state '${this.state}'`);
-    }
-
-    this.state = 'starting';
-
-    // Ensure socket directory exists
-    const socketDir = path.dirname(this.socketPath);
-    if (!fs.existsSync(socketDir)) {
-      fs.mkdirSync(socketDir, { recursive: true });
-    }
-
-    // Clean up stale socket if exists
-    await cleanupStaleSocket(this.socketPath);
-
-    // Check if socket is still in use (another process)
-    if (fs.existsSync(this.socketPath)) {
-      throw new Error(`AttachServer: Socket already in use: ${this.socketPath}`);
-    }
-
-    // Start socket server FIRST (so clients can connect immediately)
-    await this._startServer();
-
-    // Spawn PTY process
-    await this._spawnPty();
-
-    this.state = 'running';
-    this.emit('start', { id: this.id, pid: this.pid });
-  }
-
-  /**
-   * Stop the server and kill the PTY process
-   * @param {string} [signal='SIGTERM'] - Signal to send
-   * @returns {Promise<void>}
-   */
-  async stop(signal = 'SIGTERM') {
-    if (this.state !== 'running') {
-      return;
-    }
-
-    this.state = 'exiting';
-
-    // Kill PTY process
-    if (this.pty) {
-      try {
-        this.pty.kill(signal);
-      } catch {
-        // Process may already be dead
-      }
-    }
-
-    // Wait for process to exit (with timeout)
-    await new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        // Force kill if still running
-        if (this.pty) {
-          try {
-            this.pty.kill('SIGKILL');
-          } catch {
-            // Ignore
-          }
+const { cleanupStaleSocket } = socket_discovery_1.default;
+class AttachServer extends node_events_1.EventEmitter {
+    id;
+    socketPath;
+    command;
+    args;
+    cwd;
+    env;
+    cols;
+    rows;
+    outputBuffer;
+    clients = new Map();
+    pty = null;
+    server = null;
+    state = 'stopped';
+    exitCode = null;
+    exitSignal = null;
+    pid = null;
+    constructor(options) {
+        super();
+        if (!options.id)
+            throw new Error('AttachServer: id is required');
+        if (!options.socketPath)
+            throw new Error('AttachServer: socketPath is required');
+        if (!options.command)
+            throw new Error('AttachServer: command is required');
+        this.id = options.id;
+        this.socketPath = options.socketPath;
+        this.command = options.command;
+        this.args = options.args || [];
+        this.cwd = options.cwd || process.cwd();
+        this.env = options.env || process.env;
+        this.cols = options.cols || 120;
+        this.rows = options.rows || 30;
+        this.outputBuffer = new ring_buffer_1.default(options.bufferSize || DEFAULT_BUFFER_SIZE);
+        this._onProcessExit = this._onProcessExit.bind(this);
+        this._onServerError = this._onServerError.bind(this);
+    }
+    async start() {
+        if (this.state !== 'stopped') {
+            throw new Error(`AttachServer: Cannot start from state '${this.state}'`);
         }
-        resolve();
-      }, 5000);
-
-      const checkExit = () => {
-        if (this.state === 'exited') {
-          clearTimeout(timeout);
-          resolve();
-        } else {
-          setTimeout(checkExit, 100);
+        this.state = 'starting';
+        const socketDir = node_path_1.default.dirname(this.socketPath);
+        if (!node_fs_1.default.existsSync(socketDir))
+            node_fs_1.default.mkdirSync(socketDir, { recursive: true });
+        await cleanupStaleSocket(this.socketPath);
+        if (node_fs_1.default.existsSync(this.socketPath)) {
+            throw new Error(`AttachServer: Socket already in use: ${this.socketPath}`);
         }
-      };
-      checkExit();
-    });
-
-    await this._cleanup();
-  }
-
-  /**
-   * Send a signal to the PTY process
-   * @param {string} signal - Signal name (SIGINT, SIGTERM, etc.)
-   */
-  sendSignal(signal) {
-    if (!this.pty || this.state !== 'running') {
-      return false;
+        await this._startServer();
+        await this._spawnPty();
+        this.state = 'running';
+        this.emit('start', { id: this.id, pid: this.pid });
     }
-
-    try {
-      this.pty.kill(signal);
-      return true;
-    } catch {
-      return false;
+    async stop(signal = 'SIGTERM') {
+        await (0, attach_server_runtime_1.stopPty)(this, signal);
     }
-  }
-
-  /**
-   * Resize the PTY
-   * @param {number} cols - Columns
-   * @param {number} rows - Rows
-   */
-  resize(cols, rows) {
-    if (!this.pty || this.state !== 'running') {
-      return;
+    sendSignal(signal) {
+        return (0, attach_server_runtime_1.sendPtySignal)(this, signal);
     }
-
-    this.cols = cols;
-    this.rows = rows;
-
-    try {
-      this.pty.resize(cols, rows);
-    } catch {
-      // Ignore resize errors
+    resize(cols, rows) {
+        (0, attach_server_runtime_1.resizePty)(this, cols, rows);
     }
-  }
-
-  /**
-   * Write to PTY stdin (for future interactive mode)
-   * @param {Buffer|string} data - Data to write
-   */
-  write(data) {
-    if (!this.pty || this.state !== 'running') {
-      return false;
+    write(data) {
+        return (0, attach_server_runtime_1.writePty)(this, data);
     }
-
-    try {
-      this.pty.write(data);
-      return true;
-    } catch {
-      return false;
+    getState() {
+        return {
+            id: this.id,
+            state: this.state,
+            pid: this.pid,
+            exitCode: this.exitCode,
+            exitSignal: this.exitSignal,
+            clientCount: this.clients.size,
+            bufferSize: this.outputBuffer.getSize(),
+        };
     }
-  }
-
-  /**
-   * Get current server state
-   * @returns {object}
-   */
-  getState() {
-    return {
-      id: this.id,
-      state: this.state,
-      pid: this.pid,
-      exitCode: this.exitCode,
-      exitSignal: this.exitSignal,
-      clientCount: this.clients.size,
-      bufferSize: this.outputBuffer.getSize(),
-    };
-  }
-
-  // ─────────────────────────────────────────────────────────────────
-  // Private methods
-  // ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Start the Unix socket server
-   * @private
-   */
-  _startServer() {
-    return new Promise((resolve, reject) => {
-      this.server = net.createServer((socket) => {
-        this._handleClientConnection(socket);
-      });
-
-      this.server.on('error', this._onServerError);
-
-      this.server.listen(this.socketPath, () => {
-        // Set socket permissions (owner read/write only)
-        try {
-          fs.chmodSync(this.socketPath, 0o600);
-        } catch {
-          // Ignore permission errors
-        }
-        resolve();
-      });
-
-      this.server.on('error', (err) => {
-        if (this.state === 'starting') {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  /**
-   * Spawn the PTY process
-   * @private
-   */
-  _spawnPty() {
-    this.pty = pty.spawn(this.command, this.args, {
-      name: 'xterm-256color',
-      cols: this.cols,
-      rows: this.rows,
-      cwd: this.cwd,
-      env: this.env,
-    });
-
-    this.pid = this.pty.pid;
-
-    // Handle PTY output
-    this.pty.onData((data) => {
-      this._handlePtyOutput(data);
-    });
-
-    // Handle PTY exit
-    this.pty.onExit(({ exitCode, signal }) => {
-      this._onProcessExit(exitCode, signal);
-    });
-  }
-
-  /**
-   * Handle PTY output
-   * @private
-   */
-  _handlePtyOutput(data) {
-    // Buffer output for late-joining clients
-    this.outputBuffer.write(data);
-
-    // Broadcast to all connected clients
-    const message = protocol.encode(protocol.createOutputMessage(data));
-
-    for (const [clientId, client] of this.clients) {
-      try {
-        client.socket.write(message);
-      } catch {
-        // Client disconnected, will be cleaned up
-        this._removeClient(clientId);
-      }
+    _startServer() {
+        return (0, attach_server_socket_1.startSocketServer)(this);
     }
-
-    // Emit for local listeners (e.g., logging)
-    this.emit('output', data);
-  }
-
-  /**
-   * Handle new client connection
-   * @private
-   */
-  _handleClientConnection(socket) {
-    const decoder = new protocol.MessageDecoder();
-    let clientId = null;
-
-    socket.on('data', (data) => {
-      try {
-        const messages = decoder.feed(data);
-        for (const msg of messages) {
-          this._handleClientMessage(socket, msg, (id) => {
-            clientId = id;
-          });
-        }
-      } catch (e) {
-        // Protocol error, close connection
-        this._sendError(socket, `Protocol error: ${e.message}`);
-        socket.end();
-      }
-    });
-
-    socket.on('close', () => {
-      if (clientId) {
-        this._removeClient(clientId);
-      }
-    });
-
-    socket.on('error', () => {
-      if (clientId) {
-        this._removeClient(clientId);
-      }
-    });
-  }
-
-  /**
-   * Handle message from client
-   * @private
-   */
-  _handleClientMessage(socket, message, setClientId) {
-    switch (message.type) {
-      case protocol.MessageType.ATTACH: {
-        const { clientId, cols, rows } = message;
-        if (!clientId) {
-          this._sendError(socket, 'ATTACH requires clientId');
-          return;
-        }
-
-        // Register client
-        this.clients.set(clientId, {
-          socket,
-          decoder: new protocol.MessageDecoder(),
-        });
-        setClientId(clientId);
-
-        // Send history (buffered output)
-        const history = this.outputBuffer.read();
-        if (history.length > 0) {
-          socket.write(protocol.encode(protocol.createHistoryMessage(history)));
-        }
-
-        // Send current state
-        socket.write(protocol.encode(protocol.createStateMessage(this.getState())));
-
-        // Resize PTY to client dimensions (if provided)
-        if (cols && rows) {
-          this.resize(cols, rows);
-        }
-
-        this.emit('clientAttach', { clientId });
-        break;
-      }
-
-      case protocol.MessageType.DETACH: {
-        const { clientId } = message;
-        this._removeClient(clientId);
-        socket.end();
-        break;
-      }
-
-      case protocol.MessageType.RESIZE: {
-        const { cols, rows } = message;
-        if (cols && rows) {
-          this.resize(cols, rows);
-        }
-        break;
-      }
-
-      case protocol.MessageType.SIGNAL: {
-        const { signal } = message;
-        this.sendSignal(signal);
-        break;
-      }
-
-      case protocol.MessageType.STDIN: {
-        // Future interactive mode
-        const data = protocol.decodeData(message);
-        if (data) {
-          this.write(data);
-        }
-        break;
-      }
-
-      default:
-        this._sendError(socket, `Unknown message type: ${message.type}`);
+    _spawnPty() {
+        (0, attach_server_pty_1.spawnPty)(this);
     }
-  }
-
-  /**
-   * Remove a client
-   * @private
-   */
-  _removeClient(clientId) {
-    const client = this.clients.get(clientId);
-    if (client) {
-      this.clients.delete(clientId);
-      this.emit('clientDetach', { clientId });
+    _handlePtyOutput(data) {
+        (0, attach_server_events_1.handlePtyOutput)(this, data);
     }
-  }
-
-  /**
-   * Send error message to client
-   * @private
-   */
-  _sendError(socket, message) {
-    try {
-      socket.write(protocol.encode(protocol.createErrorMessage(message)));
-    } catch {
-      // Client disconnected
+    _handleClientConnection(socket) {
+        (0, attach_server_clients_1.handleClientConnection)(this, socket);
     }
-  }
-
-  /**
-   * Handle PTY process exit
-   * @private
-   */
-  _onProcessExit(exitCode, signal) {
-    this.exitCode = exitCode;
-    this.exitSignal = signal;
-    this.state = 'exited';
-
-    // Notify all clients
-    const exitMessage = protocol.encode(protocol.createExitMessage(exitCode, signal));
-
-    for (const [, client] of this.clients) {
-      try {
-        client.socket.write(exitMessage);
-        client.socket.end();
-      } catch {
-        // Client already disconnected
-      }
+    _handleClientMessage(socket, message, setClientId) {
+        (0, attach_server_clients_1.handleClientMessage)(this, socket, message, setClientId);
     }
-
-    this.emit('exit', { exitCode, signal });
-
-    // Clean up after short delay (allow clients to receive exit message)
-    setTimeout(() => {
-      this._cleanup();
-    }, 500);
-  }
-
-  /**
-   * Handle server error
-   * @private
-   */
-  _onServerError(err) {
-    this.emit('error', err);
-  }
-
-  /**
-   * Clean up resources
-   * @private
-   */
-  async _cleanup() {
-    // Close all client connections
-    for (const [, client] of this.clients) {
-      try {
-        client.socket.destroy();
-      } catch {
-        // Ignore
-      }
+    _removeClient(clientId) {
+        (0, attach_server_clients_1.removeClient)(this, clientId);
     }
-    this.clients.clear();
-
-    // Close server
-    if (this.server) {
-      await new Promise((resolve) => {
-        this.server.close(() => resolve());
-      });
-      this.server = null;
+    _sendError(socket, message) {
+        (0, attach_server_clients_1.sendClientError)(socket, message);
     }
-
-    // Remove socket file
-    if (fs.existsSync(this.socketPath)) {
-      try {
-        fs.unlinkSync(this.socketPath);
-      } catch {
-        // Ignore
-      }
+    _onProcessExit(exitCode, signal) {
+        (0, attach_server_events_1.handleProcessExit)(this, exitCode, signal);
     }
-
-    // Clean up empty parent directory for cluster sockets
-    const socketDir = path.dirname(this.socketPath);
-    if (socketDir.includes('cluster-')) {
-      try {
-        const files = fs.readdirSync(socketDir);
-        if (files.length === 0) {
-          fs.rmdirSync(socketDir);
-        }
-      } catch {
-        // Ignore
-      }
+    _onServerError(error) {
+        this.emit('error', error);
+    }
+    async _cleanup() {
+        await (0, attach_server_cleanup_1.cleanupAttachServer)(this);
     }
-
-    this.emit('cleanup');
-  }
 }
-
 module.exports = AttachServer;