orchestrating 0.1.25 → 0.1.26

package/bin/orch

@@ -221,6 +221,18 @@ async function handleDaemon() {
   process.stderr.write(`${GREEN}${PREFIX} Listening for remote sessions as "${hostname}"${RESET}\n`);
   process.stderr.write(`${DIM}${PREFIX} Tip: Use 'nohup orch daemon &' to run in background${RESET}\n`);
 
+  let reconnecting = false;
+
+  function scheduleReconnect(delaySec) {
+    if (reconnecting) return;
+    reconnecting = true;
+    if (reconnectTimer) clearTimeout(reconnectTimer);
+    reconnectTimer = setTimeout(() => {
+      reconnecting = false;
+      connect();
+    }, delaySec * 1000);
+  }
+
   async function connect() {
     // Refresh token if needed before connecting
     if (isTokenExpired()) {
@@ -230,15 +242,20 @@ async function handleDaemon() {
         process.stderr.write(`${DIM}${PREFIX} Token refreshed${RESET}\n`);
       } else {
         process.stderr.write(`${RED}${PREFIX} Token refresh failed — retrying in 10s${RESET}\n`);
-        reconnectTimer = setTimeout(connect, 10_000);
+        scheduleReconnect(10);
         return;
       }
     }
 
-    ws = new WebSocket(serverUrl);
+    if (ws) {
+      ws.removeAllListeners();
+      ws.close();
+    }
+    const sock = new WebSocket(serverUrl);
+    ws = sock;
 
-    ws.on("open", () => {
-      ws.send(JSON.stringify({
+    sock.on("open", () => {
+      sock.send(JSON.stringify({
         type: "register_daemon",
         token,
         hostname,
@@ -250,30 +267,31 @@ async function handleDaemon() {
       if (pingTimer) clearInterval(pingTimer);
       if (pongTimer) clearTimeout(pongTimer);
       pingTimer = setInterval(() => {
-        if (ws && ws.readyState === WebSocket.OPEN) {
-          ws.ping();
+        if (sock.readyState === WebSocket.OPEN) {
+          sock.ping();
           pongTimer = setTimeout(() => {
-            if (ws) ws.terminate();
+            sock.terminate();
           }, PONG_TIMEOUT_MS);
         }
       }, PING_INTERVAL_MS);
     });
 
-    ws.on("pong", () => {
+    sock.on("pong", () => {
       if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
     });
 
-    ws.on("message", (raw) => {
+    sock.on("message", (raw) => {
       let msg;
       try { msg = JSON.parse(raw.toString()); } catch { return; }
 
       if (msg.type === "error") {
         process.stderr.write(`${RED}${PREFIX} Server: ${msg.error}${RESET}\n`);
         if (/unauthorized|auth|token/i.test(msg.error || "")) {
+          // Don't reconnect from here — let the close handler do it after refreshing
           refreshAuthToken().then((refreshed) => {
             if (refreshed) {
               token = refreshed;
-              connect();
+              process.stderr.write(`${DIM}${PREFIX} Token refreshed — will reconnect${RESET}\n`);
             } else {
               process.stderr.write(`${RED}${PREFIX} Auth failed. Run 'orch login'.${RESET}\n`);
               process.exit(1);
@@ -284,15 +302,15 @@ async function handleDaemon() {
       }
 
       if (msg.type === "start_session") {
-        const { requestId, command, args, cwd, label, yolo } = msg;
-        const cmdStr = [command, ...args].join(" ");
+        const { requestId, command: cmd, args: cmdArgs, cwd, label: lbl, yolo } = msg;
+        const cmdStr = [cmd, ...cmdArgs].join(" ");
         process.stderr.write(`${GREEN}${PREFIX} Spawning: ${cmdStr}${RESET}\n`);
 
         try {
           const childArgs = [];
-          if (label) childArgs.push("-l", label);
+          if (lbl) childArgs.push("-l", lbl);
           if (yolo) childArgs.push("-y");
-          childArgs.push(command, ...args);
+          childArgs.push(cmd, ...cmdArgs);
 
           const child = spawn(process.execPath, [orchPath, ...childArgs], {
             stdio: "ignore",
@@ -302,8 +320,8 @@ async function handleDaemon() {
           });
           child.unref();
 
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({
+          if (sock.readyState === WebSocket.OPEN) {
+            sock.send(JSON.stringify({
               type: "session_started",
               requestId,
               success: true,
@@ -311,8 +329,8 @@ async function handleDaemon() {
           }
         } catch (err) {
           process.stderr.write(`${RED}${PREFIX} Spawn failed: ${err.message}${RESET}\n`);
-          if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({
+          if (sock.readyState === WebSocket.OPEN) {
+            sock.send(JSON.stringify({
               type: "session_started",
               requestId,
               success: false,
@@ -323,15 +341,15 @@ async function handleDaemon() {
       }
     });
 
-    ws.on("close", () => {
-      ws = null;
+    sock.on("close", () => {
+      if (ws === sock) ws = null;
       if (pingTimer) { clearInterval(pingTimer); pingTimer = null; }
       if (pongTimer) { clearTimeout(pongTimer); pongTimer = null; }
       process.stderr.write(`${DIM}${PREFIX} Disconnected — reconnecting in 2s${RESET}\n`);
-      reconnectTimer = setTimeout(connect, 2000);
+      scheduleReconnect(2);
     });
 
-    ws.on("error", () => {
+    sock.on("error", () => {
       // Will trigger close
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrating",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Stream terminal sessions to the orchestrat.ing dashboard",
   "type": "module",
   "bin": {