@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/attach/attach-client.ts

@@ -0,0 +1,300 @@
+/** Terminal client for attaching to a running task or agent. */
+import crypto from 'node:crypto';
+import { EventEmitter } from 'node:events';
+import net from 'node:net';
+
+import protocol from './protocol';
+
+const CTRL_B = '\x02';
+const CTRL_C = '\x03';
+const CTRL_Z = '\x1a';
+const DETACH_TIMEOUT = 500;
+
+interface AttachInput extends NodeJS.ReadableStream {
+  isRaw?: boolean;
+  isTTY?: boolean;
+  setRawMode?: (mode: boolean) => AttachInput;
+}
+
+interface AttachOutput extends NodeJS.WritableStream {
+  columns: number;
+  isTTY?: boolean;
+  rows: number;
+}
+
+interface AttachClientOptions {
+  socketPath: string;
+  stdin?: AttachInput;
+  stdout?: AttachOutput;
+}
+
+interface ServerMessage {
+  code: unknown;
+  data: unknown;
+  message: unknown;
+  signal: unknown;
+  type: unknown;
+}
+
+function readServerMessage(message: unknown): ServerMessage {
+  if ((typeof message !== 'object' && typeof message !== 'function') || message === null) {
+    throw new TypeError(`Cannot read properties of ${message}`);
+  }
+  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: unknown): { data?: string | null } {
+  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 EventEmitter {
+  readonly socketPath: string;
+  readonly stdin: AttachInput;
+  readonly stdout: AttachOutput;
+  readonly clientId: string;
+  socket: net.Socket | null = null;
+  decoder = new protocol.MessageDecoder();
+  connected = false;
+  wasRawMode: boolean | undefined | null = null;
+  ctrlBPressed = false;
+  ctrlBTimeout: NodeJS.Timeout | null = null;
+
+  constructor(options: AttachClientOptions) {
+    super();
+    if (!options.socketPath) {
+      throw new Error('AttachClient: socketPath is required');
+    }
+    this.socketPath = options.socketPath;
+    this.stdin = options.stdin || process.stdin;
+    this.stdout = options.stdout || process.stdout;
+    this.clientId = crypto.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);
+  }
+
+  connect(): Promise<void> {
+    if (this.connected) {
+      throw new Error('AttachClient: Already connected');
+    }
+
+    return new Promise((resolve, reject) => {
+      const socket = net.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.encode(protocol.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: 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));
+    });
+  }
+
+  disconnect(): void {
+    if (!this.connected) return;
+    try {
+      this.socket?.write(protocol.encode(protocol.createDetachMessage(this.clientId)));
+    } catch {
+      // Ignore transport failures during detach.
+    }
+    this._cleanup();
+    this.emit('detach');
+  }
+
+  sendSignal(signal: string): void {
+    if (!this.connected) return;
+    try {
+      this.socket?.write(protocol.encode(protocol.createSignalMessage(signal)));
+    } catch {
+      // Ignore transport failures while signaling.
+    }
+  }
+
+  private _setupTerminal(): void {
+    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);
+    });
+  }
+
+  private _restoreTerminal(): void {
+    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();
+  }
+
+  private _onSocketData(data: Buffer): void {
+    try {
+      for (const message of this.decoder.feed(data)) this._handleMessage(message);
+    } catch (error: unknown) {
+      const reason = error instanceof Error ? error.message : String(error);
+      this.emit('error', new Error(`Protocol error: ${reason}`));
+      this._cleanup();
+    }
+  }
+
+  private _handleMessage(message: unknown): void {
+    const serverMessage = readServerMessage(message);
+    switch (serverMessage.type) {
+      case protocol.MessageType.OUTPUT:
+      case protocol.MessageType.HISTORY: {
+        const data = protocol.decodeData(dataMessage(serverMessage.data));
+        if (data) this.stdout.write(data);
+        break;
+      }
+      case protocol.MessageType.STATE:
+        this.emit('state', message);
+        break;
+      case protocol.MessageType.EXIT: {
+        const { code, signal } = serverMessage;
+        this.emit('exit', { code, signal });
+        this._cleanup();
+        break;
+      }
+      case protocol.MessageType.ERROR:
+        this.emit(
+          'error',
+          new Error(serverMessage.message === undefined ? undefined : String(serverMessage.message))
+        );
+        break;
+    }
+  }
+
+  private _onStdinData(data: Buffer | string): void {
+    const input = data.toString();
+    if (this.ctrlBPressed) {
+      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;
+    }
+
+    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);
+  }
+
+  private _forwardInput(data: Buffer | string): void {
+    if (!this.connected) return;
+    try {
+      this.socket?.write(protocol.encode(protocol.createStdinMessage(data)));
+    } catch {
+      // Ignore transport failures while forwarding terminal input.
+    }
+  }
+
+  private _onResize(): void {
+    if (!this.connected) return;
+    try {
+      this.socket?.write(
+        protocol.encode(protocol.createResizeMessage(this.stdout.columns, this.stdout.rows))
+      );
+    } catch {
+      // Ignore transport failures while forwarding terminal size.
+    }
+  }
+
+  private _onSocketClose(): void {
+    if (this.connected) {
+      this.emit('close');
+      this._cleanup();
+    }
+  }
+
+  private _onSocketError(error: Error): void {
+    this.emit('error', error);
+    this._cleanup();
+  }
+
+  private _showHelp(): void {
+    const horizontal = '─'.repeat(58);
+    this.stdout.write(`
+\r\n╭${horizontal}╮
+\r\n│              Vibe Attach - Key Bindings                  │
+\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╰${horizontal}╯
+\r\n`);
+  }
+
+  private _cleanup(): void {
+    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;
+    }
+  }
+}
+
+export = AttachClient;

package/src/attach/attach-server-cleanup.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupAttachServer = cleanupAttachServer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+async function cleanupAttachServer(host) {
+    for (const [, client] of host.clients) {
+        try {
+            client.socket.destroy();
+        }
+        catch {
+            // Ignore client cleanup failures.
+        }
+    }
+    host.clients.clear();
+    if (host.server) {
+        const server = host.server;
+        await new Promise((resolve) => server.close(() => resolve()));
+        host.server = null;
+    }
+    if (node_fs_1.default.existsSync(host.socketPath)) {
+        try {
+            node_fs_1.default.unlinkSync(host.socketPath);
+        }
+        catch {
+            // Ignore socket cleanup failures.
+        }
+    }
+    const socketDir = node_path_1.default.dirname(host.socketPath);
+    if (socketDir.includes('cluster-')) {
+        try {
+            if (node_fs_1.default.readdirSync(socketDir).length === 0)
+                node_fs_1.default.rmdirSync(socketDir);
+        }
+        catch {
+            // Ignore directory cleanup failures.
+        }
+    }
+    host.emit('cleanup');
+}

package/src/attach/attach-server-cleanup.ts

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { AttachServerHost } from './attach-server-types';
+
+export async function cleanupAttachServer(host: AttachServerHost): Promise<void> {
+  for (const [, client] of host.clients) {
+    try {
+      client.socket.destroy();
+    } catch {
+      // Ignore client cleanup failures.
+    }
+  }
+  host.clients.clear();
+
+  if (host.server) {
+    const server = host.server;
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    host.server = null;
+  }
+
+  if (fs.existsSync(host.socketPath)) {
+    try {
+      fs.unlinkSync(host.socketPath);
+    } catch {
+      // Ignore socket cleanup failures.
+    }
+  }
+
+  const socketDir = path.dirname(host.socketPath);
+  if (socketDir.includes('cluster-')) {
+    try {
+      if (fs.readdirSync(socketDir).length === 0) fs.rmdirSync(socketDir);
+    } catch {
+      // Ignore directory cleanup failures.
+    }
+  }
+  host.emit('cleanup');
+}

package/src/attach/attach-server-clients.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleClientConnection = handleClientConnection;
+exports.handleClientMessage = handleClientMessage;
+exports.removeClient = removeClient;
+exports.sendClientError = sendClientError;
+const protocol_1 = __importDefault(require("./protocol"));
+function messageField(message, field) {
+    if ((typeof message !== 'object' && typeof message !== 'function') || message === null) {
+        throw new TypeError(`Cannot read properties of ${message}`);
+    }
+    return Reflect.get(message, field);
+}
+function decodeClientData(data) {
+    if (!data)
+        return null;
+    if (typeof data !== 'string') {
+        throw new TypeError('Attach protocol data must be a base64 string');
+    }
+    return Buffer.from(data, 'base64');
+}
+function attachClient(host, socket, message, setClientId) {
+    const clientId = messageField(message, 'clientId');
+    if (!clientId) {
+        host._sendError(socket, 'ATTACH requires clientId');
+        return;
+    }
+    host.clients.set(clientId, { socket, decoder: new protocol_1.default.MessageDecoder() });
+    setClientId(clientId);
+    const history = host.outputBuffer.read();
+    if (history.length > 0) {
+        socket.write(protocol_1.default.encode(protocol_1.default.createHistoryMessage(history)));
+    }
+    socket.write(protocol_1.default.encode(protocol_1.default.createStateMessage(host.getState())));
+    const cols = messageField(message, 'cols');
+    const rows = messageField(message, 'rows');
+    if (cols && rows)
+        Reflect.apply(host.resize, host, [cols, rows]);
+    host.emit('clientAttach', { clientId });
+}
+function resizeClient(host, message) {
+    const cols = messageField(message, 'cols');
+    const rows = messageField(message, 'rows');
+    if (cols && rows)
+        Reflect.apply(host.resize, host, [cols, rows]);
+}
+function writeClientInput(host, message) {
+    const data = decodeClientData(messageField(message, 'data'));
+    if (data)
+        host.write(data);
+}
+function handleClientConnection(host, socket) {
+    const decoder = new protocol_1.default.MessageDecoder();
+    let clientId = null;
+    socket.on('data', (data) => {
+        try {
+            for (const message of decoder.feed(data)) {
+                host._handleClientMessage(socket, message, (id) => {
+                    clientId = id;
+                });
+            }
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            host._sendError(socket, `Protocol error: ${reason}`);
+            socket.end();
+        }
+    });
+    socket.on('close', () => {
+        if (clientId)
+            host._removeClient(clientId);
+    });
+    socket.on('error', () => {
+        if (clientId)
+            host._removeClient(clientId);
+    });
+}
+function handleClientMessage(host, socket, message, setClientId) {
+    const type = messageField(message, 'type');
+    switch (type) {
+        case protocol_1.default.MessageType.ATTACH:
+            attachClient(host, socket, message, setClientId);
+            break;
+        case protocol_1.default.MessageType.DETACH:
+            host._removeClient(messageField(message, 'clientId'));
+            socket.end();
+            break;
+        case protocol_1.default.MessageType.RESIZE:
+            resizeClient(host, message);
+            break;
+        case protocol_1.default.MessageType.SIGNAL:
+            Reflect.apply(host.sendSignal, host, [messageField(message, 'signal')]);
+            break;
+        case protocol_1.default.MessageType.STDIN:
+            writeClientInput(host, message);
+            break;
+        default:
+            host._sendError(socket, `Unknown message type: ${type}`);
+    }
+}
+function removeClient(host, clientId) {
+    if (host.clients.has(clientId)) {
+        host.clients.delete(clientId);
+        host.emit('clientDetach', { clientId });
+    }
+}
+function sendClientError(socket, message) {
+    try {
+        socket.write(protocol_1.default.encode(protocol_1.default.createErrorMessage(message)));
+    }
+    catch {
+        // Client disconnected.
+    }
+}

package/src/attach/attach-server-clients.ts

@@ -0,0 +1,122 @@
+import type net from 'node:net';
+
+import protocol from './protocol';
+import type { AttachServerHost } from './attach-server-types';
+
+function messageField(message: unknown, field: string): unknown {
+  if ((typeof message !== 'object' && typeof message !== 'function') || message === null) {
+    throw new TypeError(`Cannot read properties of ${message}`);
+  }
+  return Reflect.get(message, field);
+}
+
+function decodeClientData(data: unknown): Buffer | null {
+  if (!data) return null;
+  if (typeof data !== 'string') {
+    throw new TypeError('Attach protocol data must be a base64 string');
+  }
+  return Buffer.from(data, 'base64');
+}
+
+function attachClient(
+  host: AttachServerHost,
+  socket: net.Socket,
+  message: unknown,
+  setClientId: (id: unknown) => void
+): void {
+  const clientId = messageField(message, 'clientId');
+  if (!clientId) {
+    host._sendError(socket, 'ATTACH requires clientId');
+    return;
+  }
+  host.clients.set(clientId, { socket, decoder: new protocol.MessageDecoder() });
+  setClientId(clientId);
+  const history = host.outputBuffer.read();
+  if (history.length > 0) {
+    socket.write(protocol.encode(protocol.createHistoryMessage(history)));
+  }
+  socket.write(protocol.encode(protocol.createStateMessage(host.getState())));
+  const cols = messageField(message, 'cols');
+  const rows = messageField(message, 'rows');
+  if (cols && rows) Reflect.apply(host.resize, host, [cols, rows]);
+  host.emit('clientAttach', { clientId });
+}
+
+function resizeClient(host: AttachServerHost, message: unknown): void {
+  const cols = messageField(message, 'cols');
+  const rows = messageField(message, 'rows');
+  if (cols && rows) Reflect.apply(host.resize, host, [cols, rows]);
+}
+
+function writeClientInput(host: AttachServerHost, message: unknown): void {
+  const data = decodeClientData(messageField(message, 'data'));
+  if (data) host.write(data);
+}
+
+export function handleClientConnection(host: AttachServerHost, socket: net.Socket): void {
+  const decoder = new protocol.MessageDecoder();
+  let clientId: unknown = null;
+  socket.on('data', (data: Buffer) => {
+    try {
+      for (const message of decoder.feed(data)) {
+        host._handleClientMessage(socket, message, (id) => {
+          clientId = id;
+        });
+      }
+    } catch (error: unknown) {
+      const reason = error instanceof Error ? error.message : String(error);
+      host._sendError(socket, `Protocol error: ${reason}`);
+      socket.end();
+    }
+  });
+  socket.on('close', () => {
+    if (clientId) host._removeClient(clientId);
+  });
+  socket.on('error', () => {
+    if (clientId) host._removeClient(clientId);
+  });
+}
+
+export function handleClientMessage(
+  host: AttachServerHost,
+  socket: net.Socket,
+  message: unknown,
+  setClientId: (id: unknown) => void
+): void {
+  const type = messageField(message, 'type');
+  switch (type) {
+    case protocol.MessageType.ATTACH:
+      attachClient(host, socket, message, setClientId);
+      break;
+    case protocol.MessageType.DETACH:
+      host._removeClient(messageField(message, 'clientId'));
+      socket.end();
+      break;
+    case protocol.MessageType.RESIZE:
+      resizeClient(host, message);
+      break;
+    case protocol.MessageType.SIGNAL:
+      Reflect.apply(host.sendSignal, host, [messageField(message, 'signal')]);
+      break;
+    case protocol.MessageType.STDIN:
+      writeClientInput(host, message);
+      break;
+    default:
+      host._sendError(socket, `Unknown message type: ${type}`);
+  }
+}
+
+export function removeClient(host: AttachServerHost, clientId: unknown): void {
+  if (host.clients.has(clientId)) {
+    host.clients.delete(clientId);
+    host.emit('clientDetach', { clientId });
+  }
+}
+
+export function sendClientError(socket: net.Socket, message: string): void {
+  try {
+    socket.write(protocol.encode(protocol.createErrorMessage(message)));
+  } catch {
+    // Client disconnected.
+  }
+}

package/src/attach/attach-server-events.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePtyOutput = handlePtyOutput;
+exports.handleProcessExit = handleProcessExit;
+const protocol_1 = __importDefault(require("./protocol"));
+function handlePtyOutput(host, data) {
+    host.outputBuffer.write(data);
+    const message = protocol_1.default.encode(protocol_1.default.createOutputMessage(data));
+    for (const [clientId, client] of host.clients) {
+        try {
+            client.socket.write(message);
+        }
+        catch {
+            host._removeClient(clientId);
+        }
+    }
+    host.emit('output', data);
+}
+function handleProcessExit(host, exitCode, signal) {
+    host.exitCode = exitCode;
+    host.exitSignal = signal;
+    host.state = 'exited';
+    const exitMessage = protocol_1.default.encode(protocol_1.default.createExitMessage(exitCode, signal));
+    for (const [, client] of host.clients) {
+        try {
+            client.socket.write(exitMessage);
+            client.socket.end();
+        }
+        catch {
+            // Client already disconnected.
+        }
+    }
+    host.emit('exit', { exitCode, signal });
+    setTimeout(() => void host._cleanup(), 500);
+}

package/src/attach/attach-server-events.ts

@@ -0,0 +1,36 @@
+import protocol from './protocol';
+import type { AttachServerHost, ExitSignal } from './attach-server-types';
+
+export function handlePtyOutput(host: AttachServerHost, data: Buffer | string): void {
+  host.outputBuffer.write(data);
+  const message = protocol.encode(protocol.createOutputMessage(data));
+  for (const [clientId, client] of host.clients) {
+    try {
+      client.socket.write(message);
+    } catch {
+      host._removeClient(clientId);
+    }
+  }
+  host.emit('output', data);
+}
+
+export function handleProcessExit(
+  host: AttachServerHost,
+  exitCode: number,
+  signal: ExitSignal
+): void {
+  host.exitCode = exitCode;
+  host.exitSignal = signal;
+  host.state = 'exited';
+  const exitMessage = protocol.encode(protocol.createExitMessage(exitCode, signal));
+  for (const [, client] of host.clients) {
+    try {
+      client.socket.write(exitMessage);
+      client.socket.end();
+    } catch {
+      // Client already disconnected.
+    }
+  }
+  host.emit('exit', { exitCode, signal });
+  setTimeout(() => void host._cleanup(), 500);
+}