@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/attach/send-input.ts

@@ -0,0 +1,94 @@
+/**
+ * sendInput - write stdin data to a live attach socket
+ *
+ * Uses the attach protocol's STDIN message to forward input to the PTY.
+ * Returns { ok, error } instead of throwing on transport failures.
+ */
+
+import fs from 'node:fs';
+import net from 'node:net';
+
+import protocol from './protocol';
+
+const DEFAULT_TIMEOUT_MS = 1500;
+
+interface SendInputOptions {
+  socketPath?: string;
+  data?: Buffer | string | null;
+  timeoutMs?: number;
+}
+
+interface SendInputResult {
+  ok: boolean;
+  error: string | null;
+}
+
+/** Send input to an attach socket via STDIN message. */
+function sendInput(options: SendInputOptions = {}): Promise<SendInputResult> | SendInputResult {
+  const { socketPath, data, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+
+  if (!socketPath) {
+    throw new Error('sendInput: socketPath is required');
+  }
+
+  if (data === undefined || data === null) {
+    throw new Error('sendInput: data is required');
+  }
+
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error(`sendInput: timeoutMs must be positive (got ${timeoutMs})`);
+  }
+
+  if (!fs.existsSync(socketPath)) {
+    return { ok: false, error: `Socket not found: ${socketPath}` };
+  }
+
+  return new Promise((resolve) => {
+    let settled = false;
+    let timeout: NodeJS.Timeout | undefined;
+    const socket = net.createConnection(socketPath);
+
+    const finish = (result: SendInputResult): void => {
+      if (settled) return;
+      settled = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      try {
+        socket.end();
+        socket.destroy();
+      } catch (cleanupError: unknown) {
+        console.warn('[sendInput] socket cleanup failed:', cleanupError);
+      }
+      resolve(result);
+    };
+
+    timeout = setTimeout(() => {
+      finish({ ok: false, error: 'Timeout waiting for socket connection' });
+    }, timeoutMs);
+
+    socket.on('connect', () => {
+      try {
+        const encoded = protocol.encode(protocol.createStdinMessage(data));
+        socket.write(encoded, (error?: Error | null) => {
+          if (error) {
+            finish({ ok: false, error: error.message });
+          } else {
+            finish({ ok: true, error: null });
+          }
+        });
+      } catch (error: unknown) {
+        const reason = error instanceof Error ? error.message : String(error);
+        finish({ ok: false, error: reason });
+      }
+    });
+
+    socket.on('error', (error: Error) => {
+      finish({ ok: false, error: error.message });
+    });
+  });
+}
+
+export = {
+  sendInput,
+};

package/src/attach/socket-discovery.js

@@ -1,256 +1,202 @@
+"use strict";
 /**
  * Socket Discovery - Utilities for socket path management
  *
  * Socket locations are allocated by socket-paths.js under a short, per-user
  * runtime directory so long HOME paths cannot exceed Unix socket limits.
  */
-
-const path = require('path');
-const fs = require('fs');
-const net = require('net');
-const { readClustersFileSync } = require('../../lib/clusters-registry');
-const socketPaths = require('./socket-paths');
-
-const ZEROSHOT_DIR = path.join(socketPaths.resolveHomeDir(), '.zeroshot');
-const SOCKET_DIR = socketPaths.getSocketDir();
-
-/**
- * Check if an ID is a known cluster by looking up clusters.json
- * Cluster IDs don't have prefix (e.g., 'steady-pulse-42'), unlike task IDs ('task-xxx')
- * @param {string} id - ID to check
- * @returns {boolean} True if ID is a cluster
- */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const node_path_1 = __importDefault(require("node:path"));
+const socket_paths_1 = __importDefault(require("./socket-paths"));
+function isClustersRegistryModule(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'readClustersFileSync' in value &&
+        typeof value.readClustersFileSync === 'function');
+}
+const clustersRegistryModule = require('../../lib/clusters-registry');
+if (!isClustersRegistryModule(clustersRegistryModule)) {
+    throw new TypeError('clusters registry must export readClustersFileSync');
+}
+const { readClustersFileSync } = clustersRegistryModule;
+const ZEROSHOT_DIR = node_path_1.default.join(socket_paths_1.default.resolveHomeDir(), '.zeroshot');
+const SOCKET_DIR = socket_paths_1.default.getSocketDir();
+/** Check if an ID is a known cluster by looking up clusters.json. */
 function isKnownCluster(id) {
-  try {
-    const clusters = readClustersFileSync(ZEROSHOT_DIR);
-    return id in clusters;
-  } catch {
-    return false;
-  }
+    try {
+        const clusters = readClustersFileSync(ZEROSHOT_DIR);
+        return typeof clusters === 'object' && clusters !== null && id in clusters;
+    }
+    catch {
+        return false;
+    }
 }
-
-/**
- * Ensure socket directory exists
- */
+/** Ensure socket directory exists. */
 function ensureSocketDir() {
-  socketPaths.ensureSocketDir();
+    socket_paths_1.default.ensureSocketDir();
 }
-
-/**
- * Get socket path for a task
- * @param {string} taskId - Task ID (e.g., 'task-swift-falcon')
- * @returns {string} - Socket path
- */
+/** Get socket path for a task. */
 function getTaskSocketPath(taskId) {
-  return socketPaths.getTaskSocketPath(taskId);
+    return socket_paths_1.default.getTaskSocketPath(taskId);
 }
-
-/**
- * Get socket path for a cluster agent
- * @param {string} clusterId - Cluster ID (e.g., 'cluster-bold-eagle')
- * @param {string} agentId - Agent ID (e.g., 'worker')
- * @returns {string} - Socket path
- */
+/** Get socket path for a cluster agent. */
 function getAgentSocketPath(clusterId, agentId) {
-  return socketPaths.getAgentSocketPath(clusterId, agentId);
+    return socket_paths_1.default.getAgentSocketPath(clusterId, agentId);
 }
-
-/**
- * Get socket path for any ID (auto-detects task vs cluster)
- * @param {string} id - Task or cluster ID
- * @param {string} [agentId] - Optional agent ID for clusters
- * @returns {string} - Socket path
- */
+/** Get socket path for any ID, auto-detecting task versus cluster. */
 function getSocketPath(id, agentId = null) {
-  if (id.startsWith('task-')) {
-    return getTaskSocketPath(id);
-  }
-  // Check for explicit 'cluster-' prefix OR known cluster in registry
-  // Cluster IDs are generated without prefix (e.g., 'steady-pulse-42')
-  if (id.startsWith('cluster-') || isKnownCluster(id)) {
-    if (agentId) {
-      return getAgentSocketPath(id, agentId);
+    if (id.startsWith('task-')) {
+        return getTaskSocketPath(id);
+    }
+    // Check for explicit 'cluster-' prefix OR known cluster in registry
+    // Cluster IDs are generated without prefix (e.g., 'steady-pulse-42')
+    if (id.startsWith('cluster-') || isKnownCluster(id)) {
+        if (agentId) {
+            return getAgentSocketPath(id, agentId);
+        }
+        // Cluster-level socket (future use)
+        return socket_paths_1.default.getClusterSocketPath(id);
     }
-    // Cluster-level socket (future use)
-    return socketPaths.getClusterSocketPath(id);
-  }
-  // Unknown format, treat as task
-  return getTaskSocketPath(id);
+    // Unknown format, treat as task
+    return getTaskSocketPath(id);
 }
-
-/**
- * Check if a socket exists and is connectable
- * @param {string} socketPath - Path to socket file
- * @returns {Promise<boolean>} - True if socket is live
- */
+/** Check if a socket exists and is connectable. */
 function isSocketAlive(socketPath) {
-  if (!fs.existsSync(socketPath)) {
-    return Promise.resolve(false);
-  }
-
-  return new Promise((resolve) => {
-    const socket = net.createConnection(socketPath);
-    const timeout = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, 1000);
-
-    socket.on('connect', () => {
-      clearTimeout(timeout);
-      socket.end();
-      resolve(true);
-    });
-
-    socket.on('error', () => {
-      clearTimeout(timeout);
-      resolve(false);
+    if (!node_fs_1.default.existsSync(socketPath)) {
+        return Promise.resolve(false);
+    }
+    return new Promise((resolve) => {
+        const socket = node_net_1.default.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            socket.destroy();
+            resolve(false);
+        }, 1000);
+        socket.on('connect', () => {
+            clearTimeout(timeout);
+            socket.end();
+            resolve(true);
+        });
+        socket.on('error', () => {
+            clearTimeout(timeout);
+            resolve(false);
+        });
     });
-  });
 }
-
-/**
- * Remove stale socket file if not connectable
- * @param {string} socketPath - Path to socket file
- * @returns {Promise<boolean>} - True if socket was removed (stale)
- */
+/** Remove a stale socket file if it is not connectable. */
 async function cleanupStaleSocket(socketPath) {
-  if (!fs.existsSync(socketPath)) {
-    return false;
-  }
-
-  const alive = await isSocketAlive(socketPath);
-  if (!alive) {
-    try {
-      fs.unlinkSync(socketPath);
-      return true;
-    } catch {
-      // Ignore errors (file may have been removed already)
+    if (!node_fs_1.default.existsSync(socketPath)) {
+        return false;
     }
-  }
-  return false;
+    const alive = await isSocketAlive(socketPath);
+    if (!alive) {
+        try {
+            node_fs_1.default.unlinkSync(socketPath);
+            return true;
+        }
+        catch {
+            // Ignore errors (file may have been removed already)
+        }
+    }
+    return false;
 }
-
-/**
- * List all attachable tasks
- * Task sockets are .sock files directly in SOCKET_DIR (not in subdirectories)
- * Excludes cluster-level sockets (cluster-xxx.sock) since those aren't tasks
- * @returns {Promise<string[]>} - Array of task IDs with live sockets
- */
+/** List task IDs with live sockets. */
 async function listAttachableTasks() {
-  ensureSocketDir();
-  const entries = fs.readdirSync(SOCKET_DIR, { withFileTypes: true });
-  const tasks = [];
-
-  for (const entry of entries) {
-    // Check socket files (Unix sockets report isSocket(), not isFile())
-    // Also accept regular files for compatibility
-    const isSocketFile = (entry.isSocket() || entry.isFile()) && entry.name.endsWith('.sock');
-    if (isSocketFile && !entry.isDirectory()) {
-      const id = entry.name.slice(0, -5); // Remove .sock
-
-      // Skip cluster-level sockets (cluster-xxx.sock)
-      if (id.startsWith('cluster-')) {
-        continue;
-      }
-
-      const socketPath = path.join(SOCKET_DIR, entry.name);
-      if (await isSocketAlive(socketPath)) {
-        tasks.push(id);
-      }
+    ensureSocketDir();
+    const entries = node_fs_1.default.readdirSync(SOCKET_DIR, { withFileTypes: true });
+    const tasks = [];
+    for (const entry of entries) {
+        // Check socket files (Unix sockets report isSocket(), not isFile())
+        // Also accept regular files for compatibility
+        const isSocketFile = (entry.isSocket() || entry.isFile()) && entry.name.endsWith('.sock');
+        if (isSocketFile && !entry.isDirectory()) {
+            const id = entry.name.slice(0, -5); // Remove .sock
+            // Skip cluster-level sockets (cluster-xxx.sock)
+            if (id.startsWith('cluster-')) {
+                continue;
+            }
+            const socketPath = node_path_1.default.join(SOCKET_DIR, entry.name);
+            if (await isSocketAlive(socketPath)) {
+                tasks.push(id);
+            }
+        }
     }
-  }
-
-  return tasks;
+    return tasks;
 }
-
-/**
- * List all attachable agents for a cluster
- * @param {string} clusterId - Cluster ID
- * @returns {Promise<string[]>} - Array of agent IDs with live sockets
- */
+/** List agent IDs with live sockets for a cluster. */
 async function listAttachableAgents(clusterId) {
-  const clusterDir = path.join(SOCKET_DIR, clusterId);
-  if (!fs.existsSync(clusterDir)) {
-    return [];
-  }
-
-  const files = fs.readdirSync(clusterDir);
-  const agents = [];
-
-  for (const file of files) {
-    if (file.endsWith('.sock')) {
-      const agentId = file.slice(0, -5); // Remove .sock
-      const socketPath = path.join(clusterDir, file);
-      if (await isSocketAlive(socketPath)) {
-        agents.push(agentId);
-      }
+    const clusterDir = node_path_1.default.join(SOCKET_DIR, clusterId);
+    if (!node_fs_1.default.existsSync(clusterDir)) {
+        return [];
     }
-  }
-
-  return agents;
+    const files = node_fs_1.default.readdirSync(clusterDir);
+    const agents = [];
+    for (const file of files) {
+        if (file.endsWith('.sock')) {
+            const agentId = file.slice(0, -5); // Remove .sock
+            const socketPath = node_path_1.default.join(clusterDir, file);
+            if (await isSocketAlive(socketPath)) {
+                agents.push(agentId);
+            }
+        }
+    }
+    return agents;
 }
-
-/**
- * List all attachable clusters
- * Checks both socket directories AND clusters.json for known clusters
- * @returns {Promise<string[]>} - Array of cluster IDs with at least one live agent socket
- */
+/** List cluster IDs with at least one live agent socket. */
 async function listAttachableClusters() {
-  ensureSocketDir();
-  const entries = fs.readdirSync(SOCKET_DIR, { withFileTypes: true });
-  const clusters = [];
-
-  // Check socket directories (both 'cluster-' prefix and plain cluster IDs)
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      // Accept directories with 'cluster-' prefix OR that are known clusters
-      if (entry.name.startsWith('cluster-') || isKnownCluster(entry.name)) {
-        const agents = await listAttachableAgents(entry.name);
-        if (agents.length > 0) {
-          clusters.push(entry.name);
+    ensureSocketDir();
+    const entries = node_fs_1.default.readdirSync(SOCKET_DIR, { withFileTypes: true });
+    const clusters = [];
+    // Check socket directories (both 'cluster-' prefix and plain cluster IDs)
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            // Accept directories with 'cluster-' prefix OR that are known clusters
+            if (entry.name.startsWith('cluster-') || isKnownCluster(entry.name)) {
+                const agents = await listAttachableAgents(entry.name);
+                if (agents.length > 0) {
+                    clusters.push(entry.name);
+                }
+            }
         }
-      }
     }
-  }
-
-  return clusters;
+    return clusters;
 }
-
-/**
- * Cleanup all sockets for a cluster (on cluster stop)
- * @param {string} clusterId - Cluster ID
- */
+/** Cleanup all sockets for a cluster when it stops. */
 function cleanupClusterSockets(clusterId) {
-  const clusterDir = path.join(SOCKET_DIR, clusterId);
-  if (fs.existsSync(clusterDir)) {
-    const files = fs.readdirSync(clusterDir);
-    for (const file of files) {
-      try {
-        fs.unlinkSync(path.join(clusterDir, file));
-      } catch {
-        // Ignore
-      }
-    }
-    try {
-      fs.rmdirSync(clusterDir);
-    } catch {
-      // Ignore
+    const clusterDir = node_path_1.default.join(SOCKET_DIR, clusterId);
+    if (node_fs_1.default.existsSync(clusterDir)) {
+        const files = node_fs_1.default.readdirSync(clusterDir);
+        for (const file of files) {
+            try {
+                node_fs_1.default.unlinkSync(node_path_1.default.join(clusterDir, file));
+            }
+            catch {
+                // Ignore
+            }
+        }
+        try {
+            node_fs_1.default.rmdirSync(clusterDir);
+        }
+        catch {
+            // Ignore
+        }
     }
-  }
 }
-
 module.exports = {
-  ZEROSHOT_DIR,
-  SOCKET_DIR,
-  ensureSocketDir,
-  getTaskSocketPath,
-  getAgentSocketPath,
-  getSocketPath,
-  isSocketAlive,
-  cleanupStaleSocket,
-  listAttachableTasks,
-  listAttachableAgents,
-  listAttachableClusters,
-  cleanupClusterSockets,
-  isKnownCluster,
+    ZEROSHOT_DIR,
+    SOCKET_DIR,
+    ensureSocketDir,
+    getTaskSocketPath,
+    getAgentSocketPath,
+    getSocketPath,
+    isSocketAlive,
+    cleanupStaleSocket,
+    listAttachableTasks,
+    listAttachableAgents,
+    listAttachableClusters,
+    cleanupClusterSockets,
+    isKnownCluster,
 };