@engineeros/connector 0.6.0 → 0.6.2

package/bin/engineeros-connector.mjs

@@ -19,6 +19,11 @@ import {
   stopProcess,
   workspaceSnapshot,
 } from "../src/runner.mjs";
+import {
+  describeWebSocketError,
+  startConnectionWatchdog,
+} from "../src/connection.mjs";
+import { advertisedCapabilities } from "../src/capabilities.mjs";
 
 const { command, positional, flags } = parseArgs(process.argv.slice(2));
 
@@ -59,13 +64,7 @@ if (command === "pair") {
     type: "pair",
     pairing_code: pairingCode,
     name: config.name,
-    capabilities: {
-      agent_protocols: flags["agent-command"] ? ["acp"] : ["codex"],
-      coding_agent: true,
-      codex_cli: !flags["agent-command"],
-      platform: process.platform,
-      workspace_name: path.basename(config.workspace),
-    },
+    capabilities: {},
   };
 } else if (command === "start") {
   config = await loadConfig(flags.workspace || process.cwd());
@@ -89,10 +88,8 @@ try {
   fail(error instanceof Error ? error.message : String(error));
 }
 console.log(`Using ${codingAgent.name} through ${codingAgent.protocol} (${codingAgent.version}).`);
-if (firstMessage.type === "pair") {
-  firstMessage.capabilities.agent_name = codingAgent.name;
-  firstMessage.capabilities.agent_version = codingAgent.version;
-}
+const capabilities = advertisedCapabilities(config, codingAgent);
+firstMessage.capabilities = capabilities;
 
 let stopped = false;
 let active = null;
@@ -101,12 +98,18 @@ const assessments = [];
 const prompts = [];
 let socket;
 let pingTimer;
+let reconnectTimer;
+let clearConnectionWatchdog;
 let reconnectDelay = 1_000;
 let connectionRejected = false;
+let lastConnectionError;
 let snapshotInFlight = false;
 
 process.on("SIGINT", async () => {
   stopped = true;
+  clearConnectionWatchdog?.();
+  clearTimeout(reconnectTimer);
+  clearInterval(pingTimer);
   await stopProcess(active?.child);
   socket?.close();
   process.exit(0);
@@ -117,13 +120,22 @@ await connect();
 async function connect() {
   console.log(`Connecting ${config.name} to ${config.server_url}`);
   connectionRejected = false;
+  lastConnectionError = undefined;
   socket = new WebSocket(config.server_url);
+  clearConnectionWatchdog = startConnectionWatchdog(socket, config.server_url, {
+    onTimeout: (message) => {
+      lastConnectionError = message;
+      console.error(message);
+      scheduleReconnect();
+    },
+  });
   socket.addEventListener("open", () =>
     socket.send(JSON.stringify(firstMessage)),
   );
   socket.addEventListener("message", async (event) => {
     const message = JSON.parse(String(event.data));
     if (message.type === "paired") {
+      clearConnectionWatchdog?.();
       config = {
         ...config,
         connector_id: message.connector.id,
@@ -134,6 +146,7 @@ async function connect() {
         type: "authenticate",
         connector_id: config.connector_id,
         token: config.token,
+        capabilities,
       };
       console.log(`Paired. Connector ${config.connector_id} is online.`);
       reconnectDelay = 1_000;
@@ -142,6 +155,7 @@ async function connect() {
       return;
     }
     if (message.type === "authenticated") {
+      clearConnectionWatchdog?.();
       console.log("Connected and waiting for EngineerOS runs.");
       reconnectDelay = 1_000;
       startPings();
@@ -220,6 +234,7 @@ async function connect() {
     }
   });
   socket.addEventListener("close", () => {
+    clearConnectionWatchdog?.();
     clearInterval(pingTimer);
     if (active?.kind === "prompt") {
       active.cancelled = true;
@@ -233,13 +248,27 @@ async function connect() {
       return;
     }
     if (stopped) return;
+    scheduleReconnect();
+  });
+  socket.addEventListener("error", (event) => {
+    lastConnectionError = describeWebSocketError(event);
     console.error(
-      `Connection lost. Retrying in ${Math.round(reconnectDelay / 1_000)}s.`,
+      `WebSocket connection to ${config.server_url} failed: ${lastConnectionError}`,
     );
-    setTimeout(connect, reconnectDelay);
-    reconnectDelay = Math.min(30_000, reconnectDelay * 2);
   });
-  socket.addEventListener("error", () => {});
+}
+
+function scheduleReconnect() {
+  if (stopped || connectionRejected || reconnectTimer) return;
+  const detail = lastConnectionError ? ` Last error: ${lastConnectionError}` : "";
+  console.error(
+    `Connection unavailable.${detail} Retrying in ${Math.round(reconnectDelay / 1_000)}s.`,
+  );
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = undefined;
+    void connect();
+  }, reconnectDelay);
+  reconnectDelay = Math.min(30_000, reconnectDelay * 2);
 }
 
 async function submitWorkspaceSnapshot() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@engineeros/connector",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Connect a local coding agent to EngineerOS, using ACP when supported.",
   "private": false,
   "type": "module",
@@ -16,7 +16,7 @@
   "scripts": {
     "start": "node ./bin/engineeros-connector.mjs",
     "test": "node --test --test-concurrency=1",
-    "type-check": "node --check ./bin/engineeros-connector.mjs && node --check ./src/runner.mjs"
+    "type-check": "node --check ./bin/engineeros-connector.mjs && node --check ./src/capabilities.mjs && node --check ./src/connection.mjs && node --check ./src/runner.mjs"
   },
   "engines": {
     "node": ">=22"

package/src/capabilities.mjs

@@ -0,0 +1,13 @@
+import path from "node:path";
+
+export function advertisedCapabilities(config, codingAgent) {
+  return {
+    agent_protocols: [codingAgent.protocol],
+    coding_agent: true,
+    codex_cli: codingAgent.protocol === "codex",
+    platform: process.platform,
+    workspace_name: path.basename(config.workspace),
+    agent_name: codingAgent.name,
+    agent_version: codingAgent.version,
+  };
+}

package/src/connection.mjs

@@ -0,0 +1,26 @@
+export function describeWebSocketError(event) {
+  return (
+    event?.error?.message ||
+    event?.message ||
+    "The WebSocket connection failed without providing an error detail."
+  );
+}
+
+export function startConnectionWatchdog(
+  socket,
+  url,
+  { timeoutMs = 15_000, onTimeout = console.error } = {},
+) {
+  const timer = setTimeout(() => {
+    onTimeout(
+      `EngineerOS did not complete the WebSocket handshake at ${url} within ${Math.round(timeoutMs / 1_000)} seconds. Check that the backend is running and the URL is reachable from this machine.`,
+    );
+    try {
+      socket.close();
+    } catch {
+      // Reconnect scheduling is owned by the caller.
+    }
+  }, timeoutMs);
+
+  return () => clearTimeout(timer);
+}