@the-open-engine/zeroshot 6.38.1 → 6.39.0

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnPty = spawnPty;
+const node_module_1 = require("node:module");
+const requireFromHere = (0, node_module_1.createRequire)(__filename);
+let ptyModule;
+try {
+    ptyModule = requireFromHere('node-pty');
+}
+catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`AttachServer: node-pty not installed. Run: npm install node-pty\nOriginal error: ${reason}`);
+}
+function isPtyModule(value) {
+    return ((typeof value === 'object' || typeof value === 'function') &&
+        value !== null &&
+        typeof Reflect.get(value, 'spawn') === 'function');
+}
+function isPtyProcess(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return (typeof Reflect.get(value, 'pid') === 'number' &&
+        typeof Reflect.get(value, 'kill') === 'function' &&
+        typeof Reflect.get(value, 'resize') === 'function' &&
+        typeof Reflect.get(value, 'write') === 'function' &&
+        typeof Reflect.get(value, 'onData') === 'function' &&
+        typeof Reflect.get(value, 'onExit') === 'function');
+}
+function spawnPty(host) {
+    if (!isPtyModule(ptyModule))
+        throw new TypeError('pty.spawn is not a function');
+    const process = ptyModule.spawn(host.command, host.args, {
+        name: 'xterm-256color',
+        cols: host.cols,
+        rows: host.rows,
+        cwd: host.cwd,
+        env: host.env,
+    });
+    if (!isPtyProcess(process))
+        throw new TypeError('node-pty returned an invalid process');
+    host.pty = process;
+    host.pid = process.pid;
+    process.onData((data) => host._handlePtyOutput(data));
+    process.onExit(({ exitCode, signal }) => host._onProcessExit(exitCode, signal));
+}

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

@@ -0,0 +1,64 @@
+import { createRequire } from 'node:module';
+
+import type { AttachServerHost, PtyProcess } from './attach-server-types';
+
+interface PtyModule {
+  spawn(
+    command: string,
+    args: string[],
+    options: {
+      name: string;
+      cols: number;
+      rows: number;
+      cwd: string;
+      env: NodeJS.ProcessEnv;
+    }
+  ): unknown;
+}
+
+const requireFromHere = createRequire(__filename);
+let ptyModule: unknown;
+try {
+  ptyModule = requireFromHere('node-pty');
+} catch (error: unknown) {
+  const reason = error instanceof Error ? error.message : String(error);
+  throw new Error(
+    `AttachServer: node-pty not installed. Run: npm install node-pty\nOriginal error: ${reason}`
+  );
+}
+
+function isPtyModule(value: unknown): value is PtyModule {
+  return (
+    (typeof value === 'object' || typeof value === 'function') &&
+    value !== null &&
+    typeof Reflect.get(value, 'spawn') === 'function'
+  );
+}
+
+function isPtyProcess(value: unknown): value is PtyProcess {
+  if (typeof value !== 'object' || value === null) return false;
+  return (
+    typeof Reflect.get(value, 'pid') === 'number' &&
+    typeof Reflect.get(value, 'kill') === 'function' &&
+    typeof Reflect.get(value, 'resize') === 'function' &&
+    typeof Reflect.get(value, 'write') === 'function' &&
+    typeof Reflect.get(value, 'onData') === 'function' &&
+    typeof Reflect.get(value, 'onExit') === 'function'
+  );
+}
+
+export function spawnPty(host: AttachServerHost): void {
+  if (!isPtyModule(ptyModule)) throw new TypeError('pty.spawn is not a function');
+  const process = ptyModule.spawn(host.command, host.args, {
+    name: 'xterm-256color',
+    cols: host.cols,
+    rows: host.rows,
+    cwd: host.cwd,
+    env: host.env,
+  });
+  if (!isPtyProcess(process)) throw new TypeError('node-pty returned an invalid process');
+  host.pty = process;
+  host.pid = process.pid;
+  process.onData((data) => host._handlePtyOutput(data));
+  process.onExit(({ exitCode, signal }) => host._onProcessExit(exitCode, signal));
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopPty = stopPty;
+exports.sendPtySignal = sendPtySignal;
+exports.resizePty = resizePty;
+exports.writePty = writePty;
+async function stopPty(host, signal) {
+    if (host.state !== 'running')
+        return;
+    host.state = 'exiting';
+    try {
+        host.pty?.kill(signal);
+    }
+    catch {
+        // Process may already be dead.
+    }
+    await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            try {
+                host.pty?.kill('SIGKILL');
+            }
+            catch {
+                // Ignore force-kill failures.
+            }
+            resolve();
+        }, 5000);
+        const checkExit = () => {
+            if (host.state === 'exited') {
+                clearTimeout(timeout);
+                resolve();
+            }
+            else {
+                setTimeout(checkExit, 100);
+            }
+        };
+        checkExit();
+    });
+    await host._cleanup();
+}
+function sendPtySignal(host, signal) {
+    if (!host.pty || host.state !== 'running')
+        return false;
+    try {
+        host.pty.kill(signal);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resizePty(host, cols, rows) {
+    if (!host.pty || host.state !== 'running')
+        return;
+    host.cols = cols;
+    host.rows = rows;
+    try {
+        host.pty.resize(cols, rows);
+    }
+    catch {
+        // Ignore resize errors.
+    }
+}
+function writePty(host, data) {
+    if (!host.pty || host.state !== 'running')
+        return false;
+    try {
+        host.pty.write(data);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,62 @@
+import type { AttachServerHost } from './attach-server-types';
+
+export async function stopPty(host: AttachServerHost, signal: string): Promise<void> {
+  if (host.state !== 'running') return;
+  host.state = 'exiting';
+  try {
+    host.pty?.kill(signal);
+  } catch {
+    // Process may already be dead.
+  }
+  await new Promise<void>((resolve) => {
+    const timeout = setTimeout(() => {
+      try {
+        host.pty?.kill('SIGKILL');
+      } catch {
+        // Ignore force-kill failures.
+      }
+      resolve();
+    }, 5000);
+    const checkExit = (): void => {
+      if (host.state === 'exited') {
+        clearTimeout(timeout);
+        resolve();
+      } else {
+        setTimeout(checkExit, 100);
+      }
+    };
+    checkExit();
+  });
+  await host._cleanup();
+}
+
+export function sendPtySignal(host: AttachServerHost, signal: string): boolean {
+  if (!host.pty || host.state !== 'running') return false;
+  try {
+    host.pty.kill(signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resizePty(host: AttachServerHost, cols: number, rows: number): void {
+  if (!host.pty || host.state !== 'running') return;
+  host.cols = cols;
+  host.rows = rows;
+  try {
+    host.pty.resize(cols, rows);
+  } catch {
+    // Ignore resize errors.
+  }
+}
+
+export function writePty(host: AttachServerHost, data: Buffer | string): boolean {
+  if (!host.pty || host.state !== 'running') return false;
+  try {
+    host.pty.write(data);
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSocketServer = startSocketServer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+function startSocketServer(host) {
+    return new Promise((resolve, reject) => {
+        const server = node_net_1.default.createServer((socket) => host._handleClientConnection(socket));
+        host.server = server;
+        server.on('error', host._onServerError);
+        server.listen(host.socketPath, () => {
+            try {
+                node_fs_1.default.chmodSync(host.socketPath, 0o600);
+            }
+            catch {
+                // Ignore permission errors.
+            }
+            resolve();
+        });
+        server.on('error', (error) => {
+            if (host.state === 'starting')
+                reject(error);
+        });
+    });
+}

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

@@ -0,0 +1,23 @@
+import fs from 'node:fs';
+import net from 'node:net';
+
+import type { AttachServerHost } from './attach-server-types';
+
+export function startSocketServer(host: AttachServerHost): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer((socket) => host._handleClientConnection(socket));
+    host.server = server;
+    server.on('error', host._onServerError);
+    server.listen(host.socketPath, () => {
+      try {
+        fs.chmodSync(host.socketPath, 0o600);
+      } catch {
+        // Ignore permission errors.
+      }
+      resolve();
+    });
+    server.on('error', (error: Error) => {
+      if (host.state === 'starting') reject(error);
+    });
+  });
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,82 @@
+import type { EventEmitter } from 'node:events';
+import type net from 'node:net';
+
+import type RingBuffer from './ring-buffer';
+
+export type AttachServerState = 'stopped' | 'starting' | 'running' | 'exiting' | 'exited';
+export type ExitSignal = string | number | undefined | null;
+
+export interface AttachServerOptions {
+  id: string;
+  socketPath: string;
+  command: string;
+  args?: string[];
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  cols?: number;
+  rows?: number;
+  bufferSize?: number;
+}
+
+export interface MessageDecoder {
+  feed(data: Buffer): unknown[];
+}
+
+export interface AttachClientConnection {
+  socket: net.Socket;
+  decoder: MessageDecoder;
+}
+
+export interface PtyExitEvent {
+  exitCode: number;
+  signal?: number;
+}
+
+export interface PtyProcess {
+  pid: number;
+  kill(signal: string): void;
+  resize(cols: number, rows: number): void;
+  write(data: Buffer | string): void;
+  onData(handler: (data: string) => void): unknown;
+  onExit(handler: (event: PtyExitEvent) => void): unknown;
+}
+
+export interface AttachServerRuntimeState {
+  id: string;
+  socketPath: string;
+  command: string;
+  args: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  cols: number;
+  rows: number;
+  outputBuffer: RingBuffer;
+  clients: Map<unknown, AttachClientConnection>;
+  pty: PtyProcess | null;
+  server: net.Server | null;
+  state: AttachServerState;
+  exitCode: number | null;
+  exitSignal: ExitSignal;
+  pid: number | null;
+}
+
+export interface AttachServerOperations extends EventEmitter {
+  sendSignal(signal: string): boolean;
+  resize(cols: number, rows: number): void;
+  write(data: Buffer | string): boolean;
+  getState(): Record<string, unknown>;
+  _handleClientConnection(socket: net.Socket): void;
+  _handleClientMessage(
+    socket: net.Socket,
+    message: unknown,
+    setClientId: (id: unknown) => void
+  ): void;
+  _removeClient(clientId: unknown): void;
+  _sendError(socket: net.Socket, message: string): void;
+  _handlePtyOutput(data: Buffer | string): void;
+  _onProcessExit(exitCode: number, signal: ExitSignal): void;
+  _onServerError(error: Error): void;
+  _cleanup(): Promise<void>;
+}
+
+export type AttachServerHost = AttachServerRuntimeState & AttachServerOperations;