@openagents-org/agent-launcher 0.2.191 → 0.2.193

package/src/node-pty-perms.js

@@ -0,0 +1,111 @@
+/**
+ * Restore the execute bit on node-pty's `spawn-helper`.
+ *
+ * node-pty 1.1.0 publishes its macOS/Linux prebuilds with
+ * `prebuilds/<platform>/spawn-helper` at mode 0644, and npm does not fix it
+ * (the package has no install script to). pty.spawn() execs that helper, so
+ * every terminal the CLI opens dies with "posix_spawnp failed." — seen with
+ * Kimi Code, whose optional `node-pty` dependency resolves to 1.1.0. Every
+ * node-pty fork that ships a spawn-helper is treated the same, so the next CLI
+ * that pulls one in is covered too.
+ *
+ * Nothing to do on Windows: there is no spawn-helper and no mode bits.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+/** Nested node_modules deeper than this are not worth walking. */
+const MAX_DEPTH = 6;
+
+/** Packages whose spawn-helper this module restores. */
+const PTY_PACKAGES = [
+  'node-pty',
+  // @lydell keeps its prebuilds in a per-platform package.
+  `@lydell/node-pty-${process.platform}-${process.arch}`,
+];
+
+function readDir(dir) {
+  try { return fs.readdirSync(dir); } catch { return []; }
+}
+
+/**
+ * chmod +x every spawn-helper inside one package directory.
+ * @returns {string[]} the helpers that were fixed
+ */
+function fixPackage(pkgDir) {
+  const helpers = [path.join(pkgDir, 'build', 'Release', 'spawn-helper')];
+  const prebuilds = path.join(pkgDir, 'prebuilds');
+  for (const plat of readDir(prebuilds)) {
+    helpers.push(path.join(prebuilds, plat, 'spawn-helper'));
+  }
+  const fixed = [];
+  for (const helper of helpers) {
+    try {
+      const { mode } = fs.statSync(helper);
+      if ((mode & 0o111) === 0o111) continue;
+      fs.chmodSync(helper, mode | 0o755);
+      fixed.push(helper);
+    } catch {}
+  }
+  return fixed;
+}
+
+/**
+ * Walk an npm prefix's node_modules (nested ones included) and fix every
+ * package that carries a spawn-helper. Run after an npm install.
+ * @param {string} prefixDir - the `--prefix` the agent was installed into
+ * @returns {string[]} the helpers that were fixed
+ */
+function fixSpawnHelpers(prefixDir) {
+  if (IS_WINDOWS) return [];
+  const fixed = [];
+  const visit = (modulesDir, depth) => {
+    if (depth > MAX_DEPTH) return;
+    for (const entry of readDir(modulesDir)) {
+      if (entry.startsWith('.')) continue;
+      const dirs = entry.startsWith('@')
+        ? readDir(path.join(modulesDir, entry)).map((s) => path.join(modulesDir, entry, s))
+        : [path.join(modulesDir, entry)];
+      for (const pkgDir of dirs) {
+        fixed.push(...fixPackage(pkgDir));
+        visit(path.join(pkgDir, 'node_modules'), depth + 1);
+      }
+    }
+  };
+  visit(path.join(prefixDir, 'node_modules'), 0);
+  return fixed;
+}
+
+/**
+ * Fix the node-pty a CLI would load, resolved the way Node resolves it from
+ * the CLI's own location — for an install that predates fixSpawnHelpers, or
+ * one the user made themselves.
+ * @param {string} fromPath - the CLI binary or entry script
+ * @returns {string[]} the helpers that were fixed
+ */
+function fixSpawnHelpersFor(fromPath) {
+  if (IS_WINDOWS || !fromPath) return [];
+  let start;
+  try { start = path.dirname(fs.realpathSync(fromPath)); } catch { return []; }
+  // Node's lookup by hand: the nearest node_modules/<name> going up. Not
+  // require.resolve — a package with an `exports` map refuses package.json.
+  const fixed = [];
+  for (const name of PTY_PACKAGES) {
+    for (let dir = start; ; dir = path.dirname(dir)) {
+      const pkgDir = path.join(dir, 'node_modules', name);
+      if (fs.existsSync(path.join(pkgDir, 'package.json'))) {
+        fixed.push(...fixPackage(pkgDir));
+        break;
+      }
+      if (path.dirname(dir) === dir) break;
+    }
+  }
+  return fixed;
+}
+
+module.exports = { fixSpawnHelpers, fixSpawnHelpersFor };

package/src/workspace-client.js

@@ -5,6 +5,29 @@ const http = require('http');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
+/**
+ * The error a request deadline produces. Every request carries a hard
+ * AbortSignal.timeout deadline (see _get), and when it fires Node rejects with
+ * a bare "AbortError: The operation was aborted" — which reads like somebody
+ * cancelled the call and names no cause. The socket-inactivity timeout said
+ * "Request timed out". Both now say the same thing, with the deadline, and
+ * carry ETIMEDOUT so callers can tell a slow network from a bug.
+ */
+function requestTimeoutError(timeout) {
+  const after = timeout >= 1000 ? `${Math.round(timeout / 1000)}s` : `${timeout}ms`;
+  const err = new Error(`Request timed out after ${after}`);
+  err.code = 'ETIMEDOUT';
+  return err;
+}
+
+/** A request 'error' handler that reports a fired deadline as a timeout. */
+function rejectWithDeadline(reject, timeout) {
+  return (err) => {
+    const aborted = err && (err.name === 'AbortError' || err.code === 'ABORT_ERR');
+    reject(aborted ? requestTimeoutError(timeout) : err);
+  };
+}
+
 /**
  * Thrown when the workspace rejects a request because our session_id has
  * been revoked by a newer /v1/join as the same agent. Callers should
@@ -967,18 +990,25 @@ class WorkspaceClient {
           try {
             const parsed = JSON.parse(data);
             if (res.statusCode >= 400) {
-              reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+              const err = new Error(parsed.message || `HTTP ${res.statusCode}`);
+              // Lets the poll loop tell a rejected credential (401/403) and an
+              // overloaded server (5xx) apart from a bug.
+              err.status = res.statusCode;
+              reject(err);
             } else {
               resolve(parsed);
             }
           } catch {
-            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+            // A proxy's HTML error page (502/504) lands here.
+            const err = new Error(`Invalid response: ${data.slice(0, 200)}`);
+            if (res.statusCode >= 400) err.status = res.statusCode;
+            reject(err);
           }
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.end();
     });
   }
@@ -1008,8 +1038,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.end();
     });
   }
@@ -1058,8 +1088,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1101,8 +1131,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1139,8 +1169,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, timeout));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(timeout)); });
       req.write(jsonBody);
       req.end();
     });
@@ -1175,8 +1205,8 @@ class WorkspaceClient {
         });
       });
 
-      req.on('error', reject);
-      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.on('error', rejectWithDeadline(reject, 15000));
+      req.on('timeout', () => { req.destroy(); reject(requestTimeoutError(15000)); });
       req.end();
     });
   }