@drakon-systems/multi-clawd 1.2.1 → 1.2.2

package/dist/watchdog-schedule.js

@@ -56,7 +56,7 @@ WantedBy=timers.target
     return [];
 }
 export function extractWatchdogTarget(unitText) {
-    const m = unitText.match(/[^<>\s="']*eviction-watchdog\.mjs/);
+    const m = unitText.match(/[^<>\s="']*(?:eviction-watchdog|watchdog-launcher)\.mjs/);
     return m ? m[0] : undefined;
 }
 export function classifyWatchdogUnit(targetPath, exists) {
@@ -64,3 +64,52 @@ export function classifyWatchdogUnit(targetPath, exists) {
         return "absent";
     return exists(targetPath) ? "ok" : "orphaned";
 }
+export function isFragileWatchdogTarget(target) {
+    return target.includes("/.openclaw/npm/projects/");
+}
+export function renderWatchdogLauncher() {
+    return `#!/usr/bin/env node
+// multi-clawd watchdog launcher — the STABLE target for scheduler units.
+// Installs move on every update (the npm project dir is regenerated), so the
+// unit points HERE; this launcher finds the current install at runtime and
+// runs its eviction watchdog. Managed by the setup wizard / update command.
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+
+const HOME = homedir();
+
+function installDir() {
+  const ext = join(HOME, ".openclaw", "extensions", "multi-clawd");
+  if (existsSync(join(ext, "openclaw.plugin.json"))) return ext;
+  const projects = join(HOME, ".openclaw", "npm", "projects");
+  let best;
+  let bestM = -1;
+  try {
+    for (const p of readdirSync(projects)) {
+      if (!p.startsWith("drakon-systems-multi-clawd-")) continue;
+      const dir = join(projects, p, "node_modules", "@drakon-systems", "multi-clawd");
+      const manifest = join(dir, "openclaw.plugin.json");
+      if (!existsSync(manifest)) continue;
+      const t = statSync(manifest).mtimeMs;
+      if (t > bestM) { bestM = t; best = dir; }
+    }
+  } catch {}
+  return best;
+}
+
+const dir = installDir();
+if (!dir) {
+  console.error("[watchdog-launcher] no multi-clawd install found — nothing to do");
+  process.exit(0);
+}
+const script = join(dir, "scripts", "eviction-watchdog.mjs");
+if (!existsSync(script)) {
+  console.error("[watchdog-launcher] " + script + " missing — nothing to do");
+  process.exit(0);
+}
+const r = spawnSync(process.execPath, [script], { stdio: "inherit" });
+process.exit(r.status ?? 0);
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Multi-account Claude Code failover for OpenClaw — register additional Claude (Max/Pro) logins as first-class CLI backends and keep the full skills/MCP harness across every account.",
   "type": "module",
   "license": "MIT",

package/scripts/_shared.mjs

@@ -1,11 +1,11 @@
 /**
  * Shared helpers for the CLI scripts (cli.mjs, setup.mjs).
  *
- * resolveWatchdogScript exists because of a real footgun: run via `npx`, a
- * script's __dirname is the EPHEMERAL npx cache — pointing a scheduled unit
- * there breaks on the next cache clean. The watchdog target must be the
- * INSTALLED plugin's copy whenever one exists; the __dirname sibling is only
- * correct for a source checkout with no install.
+ * Two real footguns shaped this file: run via `npx`, a script's __dirname is
+ * the EPHEMERAL npx cache; and the npm install dir itself is regenerated on
+ * every update. So nothing durable (scheduler units) may point at either —
+ * they point at the stable WATCHDOG_LAUNCHER, which resolves the current
+ * install at runtime.
  */
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
@@ -37,12 +37,16 @@ export function resolveInstallDir() {
   return best;
 }
 
-/** The watchdog script a scheduled unit should point at. */
-export function resolveWatchdogScript(fallbackDir) {
-  const inst = resolveInstallDir();
-  if (inst) {
-    const p = join(inst, "scripts", "eviction-watchdog.mjs");
-    if (existsSync(p)) return p;
-  }
-  return join(fallbackDir, "eviction-watchdog.mjs");
-}
+/**
+ * The stable launcher path scheduler units point at. Lives in the state dir
+ * (never moved by installs); its content is rendered by
+ * watchdog-schedule.ts#renderWatchdogLauncher and resolves the current
+ * install at runtime.
+ */
+export const WATCHDOG_LAUNCHER = join(
+  homedir(),
+  ".openclaw",
+  "state",
+  "multi-clawd",
+  "watchdog-launcher.mjs",
+);

package/scripts/cli.mjs

@@ -127,6 +127,7 @@ async function update() {
   } else {
     console.log("  ⏳ remember: the new version loads on the next gateway restart.");
   }
+  await healWatchdogUnit();
   console.log(`\n${BOLD}  health check${RESET}`);
   const doc = spawnSync(process.execPath, [join(__dirname, "doctor.mjs")], { stdio: "inherit" });
   if (doc.status !== 0) {
@@ -136,6 +137,73 @@ async function update() {
   console.log(`\n  ✅ done — now on v${installedVersion() ?? "?"}`);
 }
 
+/**
+ * Self-heal the scheduled watchdog after an update: the npm install dir is
+ * regenerated on every update, so a unit pointing into it just orphaned.
+ * Move any broken-or-fragile unit onto the stable launcher; refresh the
+ * launcher's content when a unit already uses it. Never fatal.
+ */
+async function healWatchdogUnit() {
+  try {
+    const wds = await import(resolve(__dirname, "..", "dist", "watchdog-schedule.js"));
+    const { WATCHDOG_LAUNCHER } = await import(join(__dirname, "_shared.mjs"));
+    const { existsSync, readdirSync, readFileSync: rf, writeFileSync, mkdirSync } = await import("node:fs");
+    const { homedir } = await import("node:os");
+    const { dirname: dn } = await import("node:path");
+    for (const d of [
+      join(homedir(), "Library", "LaunchAgents"),
+      join(homedir(), ".config", "systemd", "user"),
+    ]) {
+      let files = [];
+      try {
+        files = readdirSync(d);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!/\.(plist|service|timer)$/.test(f)) continue;
+        const file = join(d, f);
+        let text;
+        try {
+          text = rf(file, "utf8");
+        } catch {
+          continue;
+        }
+        const target = wds.extractWatchdogTarget(text);
+        if (!target) continue;
+        const refreshLauncher = () => {
+          mkdirSync(dn(WATCHDOG_LAUNCHER), { recursive: true });
+          writeFileSync(WATCHDOG_LAUNCHER, wds.renderWatchdogLauncher());
+        };
+        if (target === WATCHDOG_LAUNCHER) {
+          refreshLauncher();
+          continue;
+        }
+        if (!existsSync(target) || wds.isFragileWatchdogTarget(target)) {
+          refreshLauncher();
+          writeFileSync(file, text.split(target).join(WATCHDOG_LAUNCHER));
+          if (d.endsWith("LaunchAgents")) {
+            try {
+              execFileSync("/bin/sh", ["-c", `launchctl unload "${file}" 2>/dev/null; launchctl load "${file}" 2>&1 || true`]);
+            } catch {
+              /* manual load needed */
+            }
+          } else {
+            try {
+              execFileSync("systemctl", ["--user", "daemon-reload"]);
+            } catch {
+              /* manual reload needed */
+            }
+          }
+          console.log(`  🔧 watchdog unit ${f} → stable launcher (survives future updates)`);
+        }
+      }
+    }
+  } catch {
+    /* healing is best-effort; doctor still reports the truth */
+  }
+}
+
 switch (cmd) {
   case "setup":
     runSibling("setup.mjs", rest);

package/scripts/doctor.mjs

@@ -371,8 +371,13 @@ if (watchdogFound) {
       } catch {
         continue;
       }
-      const target = text.match(/[^<>\s="']*eviction-watchdog\.mjs/)?.[0];
+      const target = text.match(/[^<>\s="']*(?:eviction-watchdog|watchdog-launcher)\.mjs/)?.[0];
       if (target && !existsSync(target)) orphan = { file: join(d, f), target };
+      else if (target && target.includes("/.openclaw/npm/projects/")) {
+        warn(
+          `watchdog unit ${join(d, f)} points INTO the npm install dir — regenerated on every update, so it WILL orphan. Run the setup wizard (or \`update\`) to move it to the stable launcher.`,
+        );
+      }
     }
   }
   if (orphan) {

package/scripts/setup.mjs

@@ -229,10 +229,16 @@ async function watchdogStep() {
     console.log("  (auto-scheduling not supported on this platform — see README for manual setup)");
     return;
   }
-  // Install-aware: under npx, __dirname is the EPHEMERAL npx cache — the unit
-  // must point at the installed plugin's copy whenever one exists.
-  const { resolveWatchdogScript } = await import(resolve(__dirname, "_shared.mjs"));
-  const scriptPath = resolveWatchdogScript(__dirname);
+  // Units point at the STABLE LAUNCHER, never at an install path: the npm
+  // install dir is regenerated on every update (orphaning any unit that
+  // points into it), and under npx our own __dirname is an ephemeral cache.
+  // The launcher lives in the state dir and finds the install at runtime.
+  const { WATCHDOG_LAUNCHER } = await import(resolve(__dirname, "_shared.mjs"));
+  const scriptPath = WATCHDOG_LAUNCHER;
+  const refreshLauncher = () => {
+    mkdirSync(dirname(WATCHDOG_LAUNCHER), { recursive: true });
+    writeFileSync(WATCHDOG_LAUNCHER, wds.renderWatchdogLauncher());
+  };
   const scanDir =
     platform === "darwin"
       ? join(homedir(), "Library", "LaunchAgents")
@@ -260,19 +266,37 @@ async function watchdogStep() {
     /* scan dir missing — treated as absent */
   }
   const state = wds.classifyWatchdogUnit(found?.target, existsSync);
-  if (state === "ok") {
+  if (state === "ok" && !wds.isFragileWatchdogTarget(found.target)) {
+    if (found.target === WATCHDOG_LAUNCHER && !DRY_RUN) refreshLauncher();
     console.log(`  ✅ already scheduled and healthy → ${found.target}`);
     return;
   }
+  if (state === "ok") {
+    // Exists today, but points INTO the npm install — orphans on next update.
+    console.log(
+      `  ⚠ ${found.file}\n    points INTO the npm install dir:\n    ${found.target}\n    That directory is regenerated on every update — the unit will orphan.`,
+    );
+    if (DRY_RUN) {
+      console.log(`  dry-run: would move it to the stable launcher ${scriptPath}`);
+      return;
+    }
+    if (!(await yes("  Move it to the stable launcher (survives every update)?"))) return;
+    refreshLauncher();
+    writeFileSync(found.file, found.text.split(found.target).join(scriptPath));
+    reloadWatchdogUnit(platform, found.file);
+    console.log(`  ✅ now → ${scriptPath}`);
+    return;
+  }
   if (state === "orphaned") {
     console.log(
       `  ⚠ ${found.file}\n    points at a MISSING script: ${found.target}\n    (an old install dir — the watchdog has been failing silently)`,
     );
     if (DRY_RUN) {
-      console.log(`  dry-run: would repoint it at ${scriptPath}`);
+      console.log(`  dry-run: would repoint it at the stable launcher ${scriptPath}`);
       return;
     }
-    if (!(await yes("  Repoint it at this install?"))) return;
+    if (!(await yes("  Repoint it at the stable launcher (survives every update)?"))) return;
+    refreshLauncher();
     writeFileSync(found.file, found.text.split(found.target).join(scriptPath));
     reloadWatchdogUnit(platform, found.file);
     console.log(`  ✅ repointed → ${scriptPath}`);
@@ -283,6 +307,7 @@ async function watchdogStep() {
     return;
   }
   if (!(await yes("  Not scheduled. Schedule it now (runs every 5 min)?"))) return;
+  refreshLauncher();
   const unitFiles = wds.renderWatchdogUnit({ platform, nodePath: process.execPath, scriptPath });
   for (const uf of unitFiles) {
     const abs = join(homedir(), uf.path);