squad-openclaw 2026.2.2024 → 2026.2.2203

package/dist/index.js

@@ -215,6 +215,7 @@ var RelayClient = class {
   localConnectAttempts = /* @__PURE__ */ new Map();
   reconnectAttempts = 0;
   maxReconnectAttempts = 100;
+  autoConnectCounter = 0;
   reconnectTimer = null;
   shouldReconnect = true;
   destroyed = false;
@@ -482,6 +483,21 @@ var RelayClient = class {
     }
     if (!conn.connectHandshakeComplete) {
       conn.pendingMessages.push(msg);
+      if (!conn.pendingConnect) {
+        const autoConnect = this.buildAutoConnectRequest();
+        conn.pendingConnect = autoConnect;
+        console.log(`[relay-client] Auto-starting local connect handshake for ${userId} (${String(autoConnect.id)})`);
+        if (conn.challengeNonce) {
+          const pending = conn.pendingConnect;
+          conn.pendingConnect = null;
+          if (pending) {
+            this.injectDeviceIdentity(conn, pending);
+            if (conn.localWs.readyState === NodeWebSocket.OPEN) {
+              conn.localWs.send(JSON.stringify(pending));
+            }
+          }
+        }
+      }
       return;
     }
     if (conn.localWs.readyState === NodeWebSocket.CONNECTING) {
@@ -492,6 +508,26 @@ var RelayClient = class {
     }
     conn.localWs.send(JSON.stringify(msg));
   }
+  buildAutoConnectRequest() {
+    return {
+      type: "req",
+      id: `connect-auto-${++this.autoConnectCounter}`,
+      method: "connect",
+      params: {
+        minProtocol: 3,
+        maxProtocol: 3,
+        client: {
+          id: "cli",
+          version: "relay-client-auto",
+          platform: "gateway",
+          mode: "ui"
+        },
+        role: "operator",
+        scopes: ["operator.admin", "operator.read", "operator.write"],
+        auth: {}
+      }
+    };
+  }
   /**
    * Inject auth token and device identity into a connect request.
    *
@@ -2147,7 +2183,7 @@ function registerSqlTools(api) {
 }
 
 // src/version.ts
-import { execSync as execSync2 } from "child_process";
+import { spawn } from "child_process";
 import fs9 from "fs";
 import path10 from "path";
 import { fileURLToPath } from "url";
@@ -2157,6 +2193,9 @@ var updateInProgress = false;
 var VERIFY_TIMEOUT_MS = 2e4;
 var VERIFY_INTERVAL_MS = 500;
 var RESTART_BUFFER_MS = 5e3;
+var REGISTRY_TIMEOUT_MS = 2500;
+var COMMAND_OUTPUT_LIMIT = 8e3;
+var COMMAND_KILL_GRACE_MS = 2e3;
 function readInstalledVersionFromConfig() {
   try {
     const raw = fs9.readFileSync(CONFIG_PATH, "utf-8");
@@ -2207,9 +2246,9 @@ function getCurrentVersion() {
     return "0.0.0";
   }
 }
-async function fetchLatestVersion() {
+async function fetchLatestVersion(timeoutMs = REGISTRY_TIMEOUT_MS) {
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 1e4);
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}`, {
       signal: controller.signal
@@ -2221,14 +2260,64 @@ async function fetchLatestVersion() {
     clearTimeout(timeout);
   }
 }
-function runDoctorFixSilently() {
-  try {
-    execSync2("openclaw doctor --fix 2>/dev/null || true", {
-      timeout: 3e4,
-      encoding: "utf-8"
+async function runCommand(args, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn("openclaw", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: true
     });
-  } catch {
-  }
+    let output = "";
+    let timedOut = false;
+    let resolved = false;
+    let killGraceTimer = null;
+    const append = (chunk) => {
+      output += chunk.toString();
+      if (output.length > COMMAND_OUTPUT_LIMIT) {
+        output = output.slice(output.length - COMMAND_OUTPUT_LIMIT);
+      }
+    };
+    const finalize = (result) => {
+      if (resolved) return;
+      resolved = true;
+      if (killGraceTimer) clearTimeout(killGraceTimer);
+      clearTimeout(timeout);
+      resolve(result);
+    };
+    child.stdout?.on("data", append);
+    child.stderr?.on("data", append);
+    child.on("error", (err2) => {
+      append(String(err2));
+      finalize({
+        ok: false,
+        timedOut,
+        exitCode: null,
+        signal: null,
+        output
+      });
+    });
+    child.on("close", (code, signal) => {
+      finalize({
+        ok: !timedOut && code === 0,
+        timedOut,
+        exitCode: code,
+        signal,
+        output
+      });
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+      }
+      killGraceTimer = setTimeout(() => {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+        }
+      }, COMMAND_KILL_GRACE_MS);
+    }, timeoutMs);
+  });
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -2363,13 +2452,25 @@ async function waitForVerifiedInstall() {
 function registerVersionMethods(api) {
   api.registerGatewayMethod(
     "squad.version.check",
-    async ({ respond }) => {
+    async ({ respond, params }) => {
       try {
+        const checkParams = params ?? {};
         const current = getCurrentVersion();
+        if (checkParams.skipRegistry) {
+          console.log("[version_check_local] returning local version only");
+          respond(true, {
+            current,
+            latest: null,
+            updateAvailable: false,
+            registrySkipped: true
+          });
+          return;
+        }
         let latest;
         try {
           latest = await fetchLatestVersion();
         } catch {
+          console.log("[version_check_registry_timeout] npm registry unavailable");
           respond(true, {
             current,
             latest: null,
@@ -2397,6 +2498,7 @@ function registerVersionMethods(api) {
         return;
       }
       updateInProgress = true;
+      const updateAttemptId = `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
       try {
         const before = getCurrentVersion();
         const beforeInstalledVersion = readInstalledVersionFromConfig();
@@ -2412,19 +2514,25 @@ function registerVersionMethods(api) {
           configBackup = fs9.readFileSync(CONFIG_PATH, "utf-8");
         } catch {
         }
-        runDoctorFixSilently();
+        await runCommand(["doctor", "--fix"], 3e4);
         try {
-          updateOutput = execSync2(
-            `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
-            { timeout: 12e4, encoding: "utf-8" }
-          );
+          const first = await runCommand(["plugins", "update", PACKAGE_NAME], 12e4);
+          updateOutput = first.output;
+          if (!first.ok) {
+            throw new Error(
+              first.timedOut ? "UPDATE_TIMEOUT: plugins update timed out" : `UPDATE_FAILED: plugins update exited with code ${String(first.exitCode)}`
+            );
+          }
         } catch (firstErr) {
-          runDoctorFixSilently();
+          await runCommand(["doctor", "--fix"], 3e4);
           try {
-            updateOutput = execSync2(
-              `openclaw plugins update ${PACKAGE_NAME} 2>&1`,
-              { timeout: 12e4, encoding: "utf-8" }
-            );
+            const retry = await runCommand(["plugins", "update", PACKAGE_NAME], 12e4);
+            updateOutput = retry.output;
+            if (!retry.ok) {
+              throw new Error(
+                retry.timedOut ? "UPDATE_TIMEOUT: plugins update timed out after retry" : `UPDATE_FAILED: plugins update retry exited with code ${String(retry.exitCode)}`
+              );
+            }
           } catch (installErr) {
             if (configBackup) {
               try {
@@ -2435,9 +2543,11 @@ function registerVersionMethods(api) {
             const firstMsg = firstErr instanceof Error ? firstErr.message : String(firstErr);
             const retryMsg = installErr instanceof Error ? installErr.message : String(installErr);
             respond(false, {
+              code: /UPDATE_TIMEOUT/.test(retryMsg) ? "UPDATE_TIMEOUT" : "UPDATE_FAILED",
               error: `Update failed after doctor fix retry: ${retryMsg}`,
               output: updateOutput,
-              firstError: firstMsg
+              firstError: firstMsg,
+              updateAttemptId
             });
             return;
           }
@@ -2451,9 +2561,11 @@ function registerVersionMethods(api) {
             }
           }
           respond(false, {
+            code: "VERIFY_FAILED",
             error: `Update verification failed: ${verification.reason ?? "unknown error"}`,
             output: updateOutput.slice(0, 500),
-            verification
+            verification,
+            updateAttemptId
           });
           return;
         }
@@ -2462,10 +2574,12 @@ function registerVersionMethods(api) {
         if (beforeInstalledVersion && verificationAfterReconcile.packageVersion && beforeInstalledVersion === verificationAfterReconcile.packageVersion) {
           const alreadyLatest = !!latestVersion && compareVersions(verificationAfterReconcile.packageVersion, latestVersion) >= 0;
           respond(false, {
+            code: "UPDATE_FAILED",
             error: alreadyLatest ? `Already at latest version (${verificationAfterReconcile.packageVersion}).` : `Update command completed but installed version did not change (${verificationAfterReconcile.packageVersion}).`,
             output: updateOutput.slice(0, 500),
             verification: verificationAfterReconcile,
-            latestVersion
+            latestVersion,
+            updateAttemptId
           });
           return;
         }
@@ -2478,22 +2592,27 @@ function registerVersionMethods(api) {
           restartInMs: RESTART_BUFFER_MS,
           verification: verificationAfterReconcile,
           latestVersion,
-          output: updateOutput.slice(0, 500)
+          output: updateOutput.slice(0, 500),
+          updateAttemptId
         });
         await sleep(RESTART_BUFFER_MS);
         console.log(
           `[version] Plugin update verified (was ${before}), restarting gateway...`
         );
-        try {
-          execSync2("openclaw gateway restart 2>&1", {
-            timeout: 3e4,
-            encoding: "utf-8"
+        const restartResult = await runCommand(["gateway", "restart"], 3e4);
+        if (!restartResult.ok && !restartResult.timedOut) {
+          console.log("[update_cmd_timeout] restart command failed unexpectedly", {
+            updateAttemptId,
+            exitCode: restartResult.exitCode,
+            signal: restartResult.signal
           });
-        } catch {
         }
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        respond(false, { error: msg });
+        respond(false, {
+          code: /VERIFY_FAILED/.test(msg) ? "VERIFY_FAILED" : /UPDATE_TIMEOUT/.test(msg) ? "UPDATE_TIMEOUT" : "UPDATE_FAILED",
+          error: msg
+        });
       } finally {
         updateInProgress = false;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "squad-openclaw",
-  "version": "2026.2.2024",
+  "version": "2026.2.2203",
   "description": "Entity registry, filesystem tools, and version management plugin for OpenClaw gateway",
   "type": "module",
   "main": "./dist/index.js",