@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/attach/attach-server.ts

@@ -0,0 +1,158 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import type net from 'node:net';
+import path from 'node:path';
+
+import RingBuffer from './ring-buffer';
+import socketDiscovery from './socket-discovery';
+import {
+  handleClientConnection,
+  handleClientMessage,
+  removeClient,
+  sendClientError,
+} from './attach-server-clients';
+import { cleanupAttachServer } from './attach-server-cleanup';
+import { handleProcessExit, handlePtyOutput } from './attach-server-events';
+import { spawnPty } from './attach-server-pty';
+import { resizePty, sendPtySignal, stopPty, writePty } from './attach-server-runtime';
+import { startSocketServer } from './attach-server-socket';
+import type {
+  AttachClientConnection,
+  AttachServerHost,
+  AttachServerOptions,
+  AttachServerState,
+  ExitSignal,
+  PtyProcess,
+} from './attach-server-types';
+
+const DEFAULT_BUFFER_SIZE = 1024 * 1024;
+const { cleanupStaleSocket } = socketDiscovery;
+
+class AttachServer extends EventEmitter implements AttachServerHost {
+  id: string;
+  socketPath: string;
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  cols: number;
+  rows: number;
+  outputBuffer: RingBuffer;
+  clients = new Map<unknown, AttachClientConnection>();
+  pty: PtyProcess | null = null;
+  server: net.Server | null = null;
+  state: AttachServerState = 'stopped';
+  exitCode: number | null = null;
+  exitSignal: ExitSignal = null;
+  pid: number | null = null;
+
+  constructor(options: AttachServerOptions) {
+    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._onProcessExit = this._onProcessExit.bind(this);
+    this._onServerError = this._onServerError.bind(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.state !== 'stopped') {
+      throw new Error(`AttachServer: Cannot start from state '${this.state}'`);
+    }
+    this.state = 'starting';
+    const socketDir = path.dirname(this.socketPath);
+    if (!fs.existsSync(socketDir)) fs.mkdirSync(socketDir, { recursive: true });
+    await cleanupStaleSocket(this.socketPath);
+    if (fs.existsSync(this.socketPath)) {
+      throw new Error(`AttachServer: Socket already in use: ${this.socketPath}`);
+    }
+    await this._startServer();
+    await this._spawnPty();
+    this.state = 'running';
+    this.emit('start', { id: this.id, pid: this.pid });
+  }
+
+  async stop(signal = 'SIGTERM'): Promise<void> {
+    await stopPty(this, signal);
+  }
+
+  sendSignal(signal: string): boolean {
+    return sendPtySignal(this, signal);
+  }
+
+  resize(cols: number, rows: number): void {
+    resizePty(this, cols, rows);
+  }
+
+  write(data: Buffer | string): boolean {
+    return writePty(this, data);
+  }
+
+  getState(): Record<string, unknown> {
+    return {
+      id: this.id,
+      state: this.state,
+      pid: this.pid,
+      exitCode: this.exitCode,
+      exitSignal: this.exitSignal,
+      clientCount: this.clients.size,
+      bufferSize: this.outputBuffer.getSize(),
+    };
+  }
+
+  _startServer(): Promise<void> {
+    return startSocketServer(this);
+  }
+
+  _spawnPty(): void {
+    spawnPty(this);
+  }
+
+  _handlePtyOutput(data: Buffer | string): void {
+    handlePtyOutput(this, data);
+  }
+
+  _handleClientConnection(socket: net.Socket): void {
+    handleClientConnection(this, socket);
+  }
+
+  _handleClientMessage(
+    socket: net.Socket,
+    message: unknown,
+    setClientId: (id: unknown) => void
+  ): void {
+    handleClientMessage(this, socket, message, setClientId);
+  }
+
+  _removeClient(clientId: unknown): void {
+    removeClient(this, clientId);
+  }
+
+  _sendError(socket: net.Socket, message: string): void {
+    sendClientError(socket, message);
+  }
+
+  _onProcessExit(exitCode: number, signal: ExitSignal): void {
+    handleProcessExit(this, exitCode, signal);
+  }
+
+  _onServerError(error: Error): void {
+    this.emit('error', error);
+  }
+
+  async _cleanup(): Promise<void> {
+    await cleanupAttachServer(this);
+  }
+}
+
+export = AttachServer;

package/src/attach/index.js

@@ -1,37 +1,20 @@
-/**
- * Attach/Detach System - tmux-style session management for zeroshot tasks and clusters
- *
- * Usage:
- *   const { AttachServer, AttachClient, socketDiscovery } = require('./attach');
- *
- *   // Server side (in watcher.js or agent-wrapper.js)
- *   const server = new AttachServer({
- *     id: 'task-xxx',
- *     socketPath: socketDiscovery.getTaskSocketPath('task-xxx'),
- *     command: 'claude',
- *     args: ['--print', '--output-format', 'stream-json', prompt],
- *   });
- *   await server.start();
- *
- *   // Client side (in CLI attach command)
- *   const client = new AttachClient({
- *     socketPath: socketDiscovery.getTaskSocketPath('task-xxx'),
- *   });
- *   await client.connect();
- */
-
-const AttachServer = require('./attach-server');
-const AttachClient = require('./attach-client');
-const RingBuffer = require('./ring-buffer');
-const protocol = require('./protocol');
-const socketDiscovery = require('./socket-discovery');
-const { sendInput } = require('./send-input');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+/** tmux-style attach/detach session management for tasks and clusters. */
+const attach_client_1 = __importDefault(require("./attach-client"));
+const attach_server_1 = __importDefault(require("./attach-server"));
+const protocol_1 = __importDefault(require("./protocol"));
+const ring_buffer_1 = __importDefault(require("./ring-buffer"));
+const send_input_1 = __importDefault(require("./send-input"));
+const socket_discovery_1 = __importDefault(require("./socket-discovery"));
+const { sendInput } = send_input_1.default;
 module.exports = {
-  AttachServer,
-  AttachClient,
-  RingBuffer,
-  protocol,
-  socketDiscovery,
-  sendInput,
+    AttachServer: attach_server_1.default,
+    AttachClient: attach_client_1.default,
+    RingBuffer: ring_buffer_1.default,
+    protocol: protocol_1.default,
+    socketDiscovery: socket_discovery_1.default,
+    sendInput,
 };

package/src/attach/index.ts

@@ -0,0 +1,18 @@
+/** tmux-style attach/detach session management for tasks and clusters. */
+import AttachClient from './attach-client';
+import AttachServer from './attach-server';
+import protocol from './protocol';
+import RingBuffer from './ring-buffer';
+import sendInputModule from './send-input';
+import socketDiscovery from './socket-discovery';
+
+const { sendInput } = sendInputModule;
+
+export = {
+  AttachServer,
+  AttachClient,
+  RingBuffer,
+  protocol,
+  socketDiscovery,
+  sendInput,
+};

package/src/attach/protocol.js

@@ -1,220 +1,131 @@
+"use strict";
 /**
  * Protocol - Message framing for attach/detach IPC
  *
  * Uses length-prefixed JSON messages over Unix sockets.
  * Format: [4-byte length (BE)] [JSON payload]
- *
- * Message Types:
- *
- * Client → Server:
- *   ATTACH    { type: 'attach', clientId, cols, rows }
- *   DETACH    { type: 'detach', clientId }
- *   RESIZE    { type: 'resize', cols, rows }
- *   SIGNAL    { type: 'signal', signal: 'SIGINT' | 'SIGTERM' }
- *   STDIN     { type: 'stdin', data: base64 }  (future interactive mode)
- *
- * Server → Client:
- *   OUTPUT    { type: 'output', data: base64, timestamp }
- *   HISTORY   { type: 'history', data: base64 }
- *   STATE     { type: 'state', status, pid, ... }
- *   EXIT      { type: 'exit', code, signal }
- *   ERROR     { type: 'error', message }
  */
-
 const MAX_MESSAGE_SIZE = 10 * 1024 * 1024; // 10MB max message
-
-/**
- * Encode a message for transmission
- * @param {object} message - Message object to encode
- * @returns {Buffer} - Length-prefixed encoded message
- */
+const MessageType = {
+    // Client → Server
+    ATTACH: 'attach',
+    DETACH: 'detach',
+    RESIZE: 'resize',
+    SIGNAL: 'signal',
+    STDIN: 'stdin',
+    // Server → Client
+    OUTPUT: 'output',
+    HISTORY: 'history',
+    STATE: 'state',
+    EXIT: 'exit',
+    ERROR: 'error',
+};
+/** Encode a message for transmission. */
 function encode(message) {
-  const json = JSON.stringify(message);
-  const payload = Buffer.from(json, 'utf8');
-
-  if (payload.length > MAX_MESSAGE_SIZE) {
-    throw new Error(`Message too large: ${payload.length} bytes (max ${MAX_MESSAGE_SIZE})`);
-  }
-
-  const frame = Buffer.alloc(4 + payload.length);
-  frame.writeUInt32BE(payload.length, 0);
-  payload.copy(frame, 4);
-
-  return frame;
+    const json = JSON.stringify(message);
+    const payload = Buffer.from(json, 'utf8');
+    if (payload.length > MAX_MESSAGE_SIZE) {
+        throw new Error(`Message too large: ${payload.length} bytes (max ${MAX_MESSAGE_SIZE})`);
+    }
+    const frame = Buffer.alloc(4 + payload.length);
+    frame.writeUInt32BE(payload.length, 0);
+    payload.copy(frame, 4);
+    return frame;
 }
-
-/**
- * MessageDecoder - Streaming decoder for framed messages
- *
- * Handles partial reads and message reassembly.
- */
+/** Streaming decoder for framed messages. */
 class MessageDecoder {
-  constructor() {
-    this.buffer = Buffer.alloc(0);
-  }
-
-  /**
-   * Feed data into the decoder
-   * @param {Buffer} data - Received data chunk
-   * @returns {object[]} - Array of decoded messages (may be empty)
-   */
-  feed(data) {
-    this.buffer = Buffer.concat([this.buffer, data]);
-    const messages = [];
-
-    while (this.buffer.length >= 4) {
-      const length = this.buffer.readUInt32BE(0);
-
-      if (length > MAX_MESSAGE_SIZE) {
-        throw new Error(`Message too large: ${length} bytes (max ${MAX_MESSAGE_SIZE})`);
-      }
-
-      if (this.buffer.length < 4 + length) {
-        // Incomplete message, wait for more data
-        break;
-      }
-
-      const payload = this.buffer.slice(4, 4 + length);
-      this.buffer = this.buffer.slice(4 + length);
-
-      try {
-        const message = JSON.parse(payload.toString('utf8'));
-        messages.push(message);
-      } catch (e) {
-        throw new Error(`Invalid JSON in message: ${e.message}`);
-      }
+    buffer;
+    constructor() {
+        this.buffer = Buffer.alloc(0);
+    }
+    /** Feed a received data chunk into the decoder. */
+    feed(data) {
+        this.buffer = Buffer.concat([this.buffer, data]);
+        const messages = [];
+        while (this.buffer.length >= 4) {
+            const length = this.buffer.readUInt32BE(0);
+            if (length > MAX_MESSAGE_SIZE) {
+                throw new Error(`Message too large: ${length} bytes (max ${MAX_MESSAGE_SIZE})`);
+            }
+            if (this.buffer.length < 4 + length) {
+                // Incomplete message, wait for more data
+                break;
+            }
+            const payload = this.buffer.slice(4, 4 + length);
+            this.buffer = this.buffer.slice(4 + length);
+            try {
+                const message = JSON.parse(payload.toString('utf8'));
+                messages.push(message);
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new Error(`Invalid JSON in message: ${reason}`);
+            }
+        }
+        return messages;
+    }
+    /** Reset decoder state. */
+    reset() {
+        this.buffer = Buffer.alloc(0);
     }
-
-    return messages;
-  }
-
-  /**
-   * Reset decoder state
-   */
-  reset() {
-    this.buffer = Buffer.alloc(0);
-  }
 }
-
-// Message type constants
-const MessageType = {
-  // Client → Server
-  ATTACH: 'attach',
-  DETACH: 'detach',
-  RESIZE: 'resize',
-  SIGNAL: 'signal',
-  STDIN: 'stdin',
-
-  // Server → Client
-  OUTPUT: 'output',
-  HISTORY: 'history',
-  STATE: 'state',
-  EXIT: 'exit',
-  ERROR: 'error',
-};
-
-// Helper functions to create messages
-
-/**
- * Create an ATTACH message
- */
 function createAttachMessage(clientId, cols, rows) {
-  return { type: MessageType.ATTACH, clientId, cols, rows };
+    return { type: MessageType.ATTACH, clientId, cols, rows };
 }
-
-/**
- * Create a DETACH message
- */
 function createDetachMessage(clientId) {
-  return { type: MessageType.DETACH, clientId };
+    return { type: MessageType.DETACH, clientId };
 }
-
-/**
- * Create a RESIZE message
- */
 function createResizeMessage(cols, rows) {
-  return { type: MessageType.RESIZE, cols, rows };
+    return { type: MessageType.RESIZE, cols, rows };
 }
-
-/**
- * Create a SIGNAL message
- */
 function createSignalMessage(signal) {
-  if (!['SIGINT', 'SIGTERM', 'SIGKILL', 'SIGTSTP'].includes(signal)) {
-    throw new Error(`Invalid signal: ${signal}`);
-  }
-  return { type: MessageType.SIGNAL, signal };
+    if (!['SIGINT', 'SIGTERM', 'SIGKILL', 'SIGTSTP'].includes(signal)) {
+        throw new Error(`Invalid signal: ${signal}`);
+    }
+    return { type: MessageType.SIGNAL, signal };
 }
-
-/**
- * Create a STDIN message (for future interactive mode)
- */
 function createStdinMessage(data) {
-  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-  return { type: MessageType.STDIN, data: buf.toString('base64') };
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    return { type: MessageType.STDIN, data: buf.toString('base64') };
 }
-
-/**
- * Create an OUTPUT message
- */
 function createOutputMessage(data, timestamp = Date.now()) {
-  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-  return { type: MessageType.OUTPUT, data: buf.toString('base64'), timestamp };
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    return { type: MessageType.OUTPUT, data: buf.toString('base64'), timestamp };
 }
-
-/**
- * Create a HISTORY message
- */
 function createHistoryMessage(data) {
-  const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-  return { type: MessageType.HISTORY, data: buf.toString('base64') };
+    const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    return { type: MessageType.HISTORY, data: buf.toString('base64') };
 }
-
-/**
- * Create a STATE message
- */
 function createStateMessage(state) {
-  return { type: MessageType.STATE, ...state };
+    return { type: MessageType.STATE, ...state };
 }
-
-/**
- * Create an EXIT message
- */
 function createExitMessage(code, signal) {
-  return { type: MessageType.EXIT, code, signal };
+    return { type: MessageType.EXIT, code, signal };
 }
-
-/**
- * Create an ERROR message
- */
 function createErrorMessage(message) {
-  return { type: MessageType.ERROR, message };
+    return { type: MessageType.ERROR, message };
 }
-
-/**
- * Decode base64 data field from OUTPUT/HISTORY/STDIN messages
- */
+/** Decode the base64 data field from OUTPUT/HISTORY/STDIN messages. */
 function decodeData(message) {
-  if (message.data) {
-    return Buffer.from(message.data, 'base64');
-  }
-  return null;
+    if (message.data) {
+        return Buffer.from(message.data, 'base64');
+    }
+    return null;
 }
-
 module.exports = {
-  encode,
-  MessageDecoder,
-  MessageType,
-  createAttachMessage,
-  createDetachMessage,
-  createResizeMessage,
-  createSignalMessage,
-  createStdinMessage,
-  createOutputMessage,
-  createHistoryMessage,
-  createStateMessage,
-  createExitMessage,
-  createErrorMessage,
-  decodeData,
-  MAX_MESSAGE_SIZE,
+    encode,
+    MessageDecoder,
+    MessageType,
+    createAttachMessage,
+    createDetachMessage,
+    createResizeMessage,
+    createSignalMessage,
+    createStdinMessage,
+    createOutputMessage,
+    createHistoryMessage,
+    createStateMessage,
+    createExitMessage,
+    createErrorMessage,
+    decodeData,
+    MAX_MESSAGE_SIZE,
 };