@wrongstack/tools 0.295.0 → 0.296.2

package/dist/exec.js

@@ -1206,6 +1206,7 @@ function emitStructuredLog(level, event, message, error) {
 }
 var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_THRESHOLD_MS = 3e4;
+var LOCK_STALE_MS = 3e4;
 var LOCKFILE = ".process-registry.lock";
 function generateInstanceId() {
   const hostname2 = os2.hostname();
@@ -1234,21 +1235,26 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
         try {
           const content = await fs2.readFile(lockfilePath, "utf-8");
           const parts = content.split(":");
-          const lockPidStr = parts[0] ?? "0";
-          const lockPid = parseInt(lockPidStr, 10);
-          if (process.platform !== "win32") {
+          const lockPid = parseInt(parts[0] ?? "0", 10);
+          const lockTs = Number(parts[parts.length - 1]);
+          const staleByAge = Number.isFinite(lockTs) && Date.now() - lockTs > LOCK_STALE_MS;
+          let holderDead = false;
+          if (process.platform !== "win32" && Number.isFinite(lockPid) && lockPid > 0) {
             try {
               process.kill(lockPid, 0);
             } catch {
-              await fs2.unlink(lockfilePath);
-              continue;
+              holderDead = true;
             }
           }
-        } catch {
-          try {
-            await fs2.unlink(lockfilePath);
-          } catch {
+          if (holderDead || staleByAge) {
+            await fs2.unlink(lockfilePath).catch(() => {
+            });
+            continue;
           }
+        } catch {
+          await fs2.unlink(lockfilePath).catch(() => {
+          });
+          continue;
         }
         await new Promise((r) => setTimeout(r, 100));
         continue;
@@ -1258,25 +1264,35 @@ async function acquireLock(lockfilePath, timeoutMs = 5e3) {
   }
   throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
 }
+function freshRegistryData() {
+  return {
+    version: 1,
+    instances: /* @__PURE__ */ new Map(),
+    protectedPatterns: ["wrongstack", "node"],
+    lastCleanup: Date.now()
+  };
+}
 async function readRegistryFile(filePath) {
+  let content;
   try {
-    const content = await fs2.readFile(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed.instances && Array.isArray(parsed.instances)) {
-      parsed.instances = new Map(parsed.instances);
-    }
-    return parsed;
+    content = await fs2.readFile(filePath, "utf-8");
   } catch (err) {
-    if (isNodeError(err) && err.code === "ENOENT") {
-      return {
-        version: 1,
-        instances: /* @__PURE__ */ new Map(),
-        protectedPatterns: ["wrongstack", "node"],
-        lastCleanup: Date.now()
-      };
-    }
+    if (isNodeError(err) && err.code === "ENOENT") return freshRegistryData();
     throw err;
   }
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object") return freshRegistryData();
+    const base = freshRegistryData();
+    return {
+      version: 1,
+      instances: Array.isArray(parsed.instances) ? new Map(parsed.instances) : base.instances,
+      protectedPatterns: Array.isArray(parsed.protectedPatterns) ? parsed.protectedPatterns : base.protectedPatterns,
+      lastCleanup: typeof parsed.lastCleanup === "number" ? parsed.lastCleanup : base.lastCleanup
+    };
+  } catch {
+    return freshRegistryData();
+  }
 }
 async function writeRegistryFile(filePath, data) {
   const tmpPath = `${filePath}.tmp.${process.pid}`;
@@ -1300,7 +1316,11 @@ var PersistentProcessRegistry = class {
   cleanupRunning = false;
   isShuttingDown = false;
   onProcessExit = () => {
-    void this.syncToPersistent();
+    this.runInBackground(
+      this.syncToPersistent(),
+      "process_registry.exit_sync_failed",
+      "PersistentProcessRegistry: exit sync failed"
+    );
   };
   constructor(baseRegistry) {
     this.instanceId = generateInstanceId();
@@ -1320,6 +1340,11 @@ var PersistentProcessRegistry = class {
       if (!isNodeError(err) || err.code !== "EEXIST") throw err;
     }
   }
+  runInBackground(operation, event, message) {
+    void operation.catch((err) => {
+      emitStructuredLog("warn", event, message, err);
+    });
+  }
   /**
    * Start the heartbeat and periodic cleanup tasks.
    */
@@ -1352,26 +1377,34 @@ var PersistentProcessRegistry = class {
       this.cleanupInterval = null;
     }
     process.off("exit", this.onProcessExit);
-    void this.syncToPersistent();
+    this.runInBackground(
+      this.syncToPersistent(),
+      "process_registry.stop_sync_failed",
+      "PersistentProcessRegistry: stop sync failed"
+    );
   }
   /**
    * Register the main WrongStack process as protected.
    */
   registerMainProcess() {
     const mainPid = process.pid;
-    this.updatePersistentEntry({
-      pid: mainPid,
-      name: "wrongstack-main",
-      command: process.argv.slice(0, 3).join(" "),
-      startedAt: Date.now(),
-      lastHeartbeat: Date.now(),
-      instanceId: this.instanceId,
-      hostname: os2.hostname(),
-      protected: true,
-      spawnMode: "main",
-      parentPid: process.ppid,
-      platform: process.platform
-    });
+    this.runInBackground(
+      this.updatePersistentEntry({
+        pid: mainPid,
+        name: "wrongstack-main",
+        command: process.argv.slice(0, 3).join(" "),
+        startedAt: Date.now(),
+        lastHeartbeat: Date.now(),
+        instanceId: this.instanceId,
+        hostname: os2.hostname(),
+        protected: true,
+        spawnMode: "main",
+        parentPid: process.ppid,
+        platform: process.platform
+      }),
+      "process_registry.main_register_failed",
+      "PersistentProcessRegistry: failed to register main process"
+    );
   }
   /**
    * Register a spawned child process with the persistent registry.
@@ -1394,7 +1427,11 @@ var PersistentProcessRegistry = class {
     if (sessionId) {
       entry.sessionId = sessionId;
     }
-    this.updatePersistentEntry(entry);
+    this.runInBackground(
+      this.updatePersistentEntry(entry),
+      "process_registry.child_register_failed",
+      "PersistentProcessRegistry: failed to register child process"
+    );
   }
   /**
    * Update or add an entry in the persistent registry.
@@ -1438,14 +1475,28 @@ var PersistentProcessRegistry = class {
   heartbeat() {
     if (this.isShuttingDown || this.heartbeatRunning) return;
     this.heartbeatRunning = true;
-    void this.syncToPersistent().finally(() => {
+    void this.syncToPersistent().catch((err) => {
+      emitStructuredLog(
+        "warn",
+        "process_registry.heartbeat_failed",
+        "PersistentProcessRegistry: heartbeat failed",
+        err
+      );
+    }).finally(() => {
       this.heartbeatRunning = false;
     });
   }
   cleanup() {
     if (this.isShuttingDown || this.cleanupRunning) return;
     this.cleanupRunning = true;
-    void this.cleanupStaleEntries().finally(() => {
+    void this.cleanupStaleEntries().catch((err) => {
+      emitStructuredLog(
+        "warn",
+        "process_registry.periodic_cleanup_failed",
+        "PersistentProcessRegistry: periodic cleanup failed",
+        err
+      );
+    }).finally(() => {
       this.cleanupRunning = false;
     });
   }