@memtensor/memos-cloud-openclaw-plugin 0.1.8-beta.7 → 0.1.8-beta.9

package/lib/check-update.js

@@ -2,14 +2,31 @@ import https from "https";
 import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { spawn } from "child_process";
+import { spawn, exec } from "child_process";
 import os from "os";
 
+/**
+ * Kill a spawned child process and its entire process tree.
+ */
+function killProcessTree(child) {
+  try {
+    if (process.platform === "win32") {
+      exec(`taskkill /pid ${child.pid} /T /F`, () => {});
+    } else {
+      // On Unix, kill the process group
+      process.kill(-child.pid, "SIGKILL");
+    }
+  } catch (e) {
+    // Fallback: try the basic kill
+    try { child.kill("SIGKILL"); } catch (_) {}
+  }
+}
+
 let isUpdating = false;
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const CHECK_INTERVAL = 5 * 60 * 1000; // 12 hours check interval
+const CHECK_INTERVAL = 12 * 60 * 60 * 1000; // 12 hours check interval
 const UPDATE_TIMEOUT = 3 * 60 * 1000; // 3 minutes timeout for the CLI update command to finish
 const PLUGIN_NAME = "@memtensor/memos-cloud-openclaw-plugin";
 const CHECK_FILE = path.join(os.tmpdir(), "memos_openclaw_update_check.json");
@@ -22,6 +39,36 @@ const ANSI = {
   RED: "\x1b[31m"
 };
 
+function canExecuteCli(cliName, timeoutMs = 8000) {
+  return new Promise((resolve) => {
+    let done = false;
+    const child = spawn(cliName, ["--version"], { shell: true });
+    const timer = setTimeout(() => {
+      if (done) return;
+      done = true;
+      killProcessTree(child);
+      resolve({ ok: false, reason: `timeout after ${timeoutMs}ms` });
+    }, timeoutMs);
+
+    child.on("error", (err) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ ok: false, reason: err?.message || String(err) });
+    });
+
+    child.on("close", (code) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({
+        ok: code === 0,
+        reason: code === 0 ? "" : `exit code ${code}`,
+      });
+    });
+  });
+}
+
 
 function getPackageVersion() {
   try {
@@ -141,6 +188,15 @@ export function startUpdateChecker(log) {
         return;
       }
 
+      // Check if we have write permission to the plugin directory before attempting update
+      const pluginDir = path.join(__dirname, "..");
+      try {
+        fs.accessSync(pluginDir, fs.constants.W_OK);
+      } catch (err) {
+        log.warn?.(`${ANSI.YELLOW}[memos-cloud] Update available (${latestVersion}), but skipping auto-update due to missing write permissions in ${pluginDir}. Please run manually with sudo.${ANSI.RESET}`);
+        return;
+      }
+
       log.info?.(`${ANSI.YELLOW}[memos-cloud] Update available: ${currentVersion} -> ${latestVersion}. Updating in background...${ANSI.RESET}`);
 
       let dotCount = 0;
@@ -160,19 +216,41 @@ export function startUpdateChecker(log) {
         return "openclaw";
       })();
 
+      const preflight = await canExecuteCli(cliName);
+      if (!preflight.ok) {
+        log.warn?.(
+          `${ANSI.YELLOW}[memos-cloud] Update available (${latestVersion}), but cannot execute CLI '${cliName}' (${preflight.reason}). Please update manually: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`,
+        );
+        return;
+      }
+
       isUpdating = true;
-      const child = spawn(cliName, ["plugins", "update", "memos-cloud-openclaw-plugin"], {
-        shell: true
-      });
+      const spawnOpts = { shell: true };
+      // On Unix, detach the process so we can kill the entire process group on timeout
+      if (process.platform !== "win32") {
+        spawnOpts.detached = true;
+      }
+      const child = spawn(cliName, ["plugins", "update", "memos-cloud-openclaw-plugin"], spawnOpts);
+      let finished = false;
+      const finishUpdateSequence = () => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(updateTimeout);
+        clearInterval(progressInterval);
+        isUpdating = false;
+      };
 
       // Timeout mechanism: forcefully kill the update process if it hangs for more than the configured timeout
       const updateTimeout = setTimeout(() => {
         log.warn?.(`${ANSI.RED}[memos-cloud] Update process timed out. Please try manually running: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`);
-        try {
-          child.kill("SIGKILL");
-        } catch (e) {
-          // Process might already be dead
-        }
+        killProcessTree(child);
+
+        // Fallback: if kill failed and the close event never fires, forcefully release the lock after 5 seconds
+        setTimeout(() => {
+          if (isUpdating) {
+            finishUpdateSequence();
+          }
+        }, 5000);
       }, UPDATE_TIMEOUT);
 
       child.stdout.on("data", (data) => {
@@ -196,9 +274,7 @@ export function startUpdateChecker(log) {
       });
 
       child.on("close", (code) => {
-        clearTimeout(updateTimeout);
-        clearInterval(progressInterval);
-        isUpdating = false;
+        finishUpdateSequence();
 
         // Wait for a brief moment to let file system sync if needed
         setTimeout(() => {
@@ -213,6 +289,13 @@ export function startUpdateChecker(log) {
         }, 1000); // Small 1-second buffer for file systems
       });
 
+      child.on("error", (err) => {
+        finishUpdateSequence();
+        log.warn?.(
+          `${ANSI.RED}[memos-cloud] Failed to start auto-update process: ${err?.message || String(err)}. Please run manually: ${cliName} plugins update memos-cloud-openclaw-plugin${ANSI.RESET}`,
+        );
+      });
+
     } catch (error) {
       log.warn?.(`${ANSI.RED}[memos-cloud] Update check failed entirely: ${error.message}${ANSI.RESET}`);
     }