@drakon-systems/multi-clawd 1.0.0 → 1.1.0

package/README.md

@@ -10,7 +10,8 @@ Pool every Claude Max account you own into a single failover chain —
 same model, next account, full harness on every hop.
 
 [![OpenClaw plugin](https://img.shields.io/badge/OpenClaw-plugin-ff4f00)](https://docs.openclaw.ai/plugins)
-[![version](https://img.shields.io/badge/version-0.3.7-4c9aff)](package.json)
+[![npm](https://img.shields.io/badge/npm-%40drakon--systems%2Fmulti--clawd-cb3837)](https://www.npmjs.com/package/@drakon-systems/multi-clawd)
+[![version](https://img.shields.io/badge/version-1.0.1-4c9aff)](CHANGELOG.md)
 [![license: MIT](https://img.shields.io/badge/license-MIT-2ea44f)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6)](tsconfig.json)
 
@@ -112,7 +113,7 @@ Code backend runs.
 
 ## Install
 
-**From npm (recommended, v1.0+):**
+**From npm (recommended):**
 
 ```bash
 openclaw plugins install @drakon-systems/multi-clawd --pin
@@ -123,8 +124,9 @@ The gateway pulls the prebuilt package — no clone, no build step, nothing to
 keep in sync. `--pin` records the exact resolved version, so an upgrade is a
 deliberate `@latest`, never a surprise. `openclaw` itself is a *peer*
 dependency (the host provides it), so the install stays lean. Confirm with
-`openclaw plugins list` (expect `multi-clawd` enabled), then run the doctor:
-`node ~/.openclaw/extensions/multi-clawd/scripts/doctor.mjs`.
+`openclaw plugins list` (expect `multi-clawd` enabled) — it also shows the
+install path; run the doctor from there:
+`node <install-path>/scripts/doctor.mjs`.
 
 **From ClawHub (alternative registry):**
 

package/dist/watchdog-schedule.js

@@ -0,0 +1,66 @@
+export const WATCHDOG_LAUNCHD_LABEL = "com.multi-clawd.eviction-watchdog";
+export const WATCHDOG_SYSTEMD_NAME = "multi-clawd-eviction-watchdog";
+export function renderWatchdogUnit(opts) {
+    if (opts.platform === "darwin") {
+        return [
+            {
+                path: `Library/LaunchAgents/${WATCHDOG_LAUNCHD_LABEL}.plist`,
+                content: `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${WATCHDOG_LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${opts.nodePath}</string>
+    <string>${opts.scriptPath}</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>300</integer>
+  <key>RunAtLoad</key>
+  <true/>
+</dict>
+</plist>
+`,
+            },
+        ];
+    }
+    if (opts.platform === "linux") {
+        return [
+            {
+                path: `.config/systemd/user/${WATCHDOG_SYSTEMD_NAME}.service`,
+                content: `[Unit]
+Description=multi-clawd eviction watchdog (turn-safe; openclaw#107408 mitigation)
+
+[Service]
+Type=oneshot
+ExecStart=${opts.nodePath} ${opts.scriptPath}
+`,
+            },
+            {
+                path: `.config/systemd/user/${WATCHDOG_SYSTEMD_NAME}.timer`,
+                content: `[Unit]
+Description=Run the multi-clawd eviction watchdog every 5 minutes
+
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=5min
+
+[Install]
+WantedBy=timers.target
+`,
+            },
+        ];
+    }
+    return [];
+}
+export function extractWatchdogTarget(unitText) {
+    const m = unitText.match(/[^<>\s="']*eviction-watchdog\.mjs/);
+    return m ? m[0] : undefined;
+}
+export function classifyWatchdogUnit(targetPath, exists) {
+    if (targetPath === undefined)
+        return "absent";
+    return exists(targetPath) ? "ok" : "orphaned";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "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",
@@ -57,6 +57,11 @@
   "peerDependencies": {
     "openclaw": ">=2026.6"
   },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "openclaw": "2026.7.1",
     "typescript": "^5.9.0",

package/scripts/doctor.mjs

@@ -26,7 +26,38 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const HOME = homedir();
-const EXT_DIR = join(HOME, ".openclaw", "extensions", "multi-clawd");
+
+/**
+ * Where is the plugin actually installed? Path installs land in
+ * ~/.openclaw/extensions/multi-clawd; registry installs (npm spec) land in
+ * ~/.openclaw/npm/projects/<pkg-hash>/node_modules/@drakon-systems/multi-clawd.
+ * Prefer the extensions dir when both exist (it shadows), else the newest
+ * npm-project install carrying a manifest.
+ */
+function resolveInstallDir() {
+  const extDir = join(HOME, ".openclaw", "extensions", "multi-clawd");
+  if (existsSync(join(extDir, "openclaw.plugin.json"))) return extDir;
+  const projects = join(HOME, ".openclaw", "npm", "projects");
+  let best = extDir;
+  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 m = statSync(manifest).mtimeMs;
+      if (m > bestM) {
+        bestM = m;
+        best = dir;
+      }
+    }
+  } catch {
+    /* no npm projects dir */
+  }
+  return best;
+}
+const EXT_DIR = resolveInstallDir();
 const CONFIG_PATH = join(HOME, ".openclaw", "openclaw.json");
 const STATE_DIR = join(HOME, ".openclaw", "state", "multi-clawd");
 const REPO_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -313,8 +344,43 @@ try {
 } catch {
   /* not systemd */
 }
-if (watchdogFound) ok("watchdog scheduled");
-else warn("no watchdog found (needed until openclaw#107596 ships — see README)");
+if (watchdogFound) {
+  // "Scheduled" is not enough: the unit points at a script INSIDE an install
+  // dir, and installs move (path→registry migration, uninstall/reinstall).
+  // An orphaned unit fires every tick against a missing file — silently.
+  // Deliberately self-contained (no dist import): the check must work even
+  // when the install itself is the thing that went missing.
+  let orphan;
+  for (const d of [
+    join(HOME, "Library", "LaunchAgents"),
+    join(HOME, ".config", "systemd", "user"),
+  ]) {
+    let files = [];
+    try {
+      files = readdirSync(d);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      // Only real unit files — launchd loads *.plist, systemd *.service/*.timer;
+      // backups like *.plist.bak-... are inert and must not be flagged.
+      if (!/\.(plist|service|timer)$/.test(f)) continue;
+      let text;
+      try {
+        text = readFileSync(join(d, f), "utf8");
+      } catch {
+        continue;
+      }
+      const target = text.match(/[^<>\s="']*eviction-watchdog\.mjs/)?.[0];
+      if (target && !existsSync(target)) orphan = { file: join(d, f), target };
+    }
+  }
+  if (orphan) {
+    bad(
+      `watchdog unit ${orphan.file} points at a MISSING script (${orphan.target}) — it fails silently every tick. Repoint it at ${join(EXT_DIR, "scripts", "eviction-watchdog.mjs")} or run the setup wizard to repair.`,
+    );
+  } else ok("watchdog scheduled");
+} else warn("no watchdog found (needed until openclaw#107596 ships — see README)");
 
 // ── 9. optional live probe ──────────────────────────────────────────────────
 if (args.has("--probe")) {

package/scripts/setup.mjs

@@ -22,7 +22,7 @@
  * The wizard never sees or stores a token value. All scaffolding logic is
  * pure and unit-tested in src/setup-core.ts; this file owns prompts and IO.
  */
-import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -33,11 +33,12 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const DRY_RUN = process.argv.includes("--dry-run");
 const CONFIG_PATH = join(homedir(), ".openclaw", "openclaw.json");
 
-let core;
+let core, wds;
 try {
   core = await import(resolve(__dirname, "..", "dist", "setup-core.js"));
+  wds = await import(resolve(__dirname, "..", "dist", "watchdog-schedule.js"));
 } catch {
-  console.error("setup: dist/setup-core.js is missing — run `npm run build` first (source checkout) or reinstall the plugin.");
+  console.error("setup: built dist/ modules are missing — run `npm run build` first (source checkout) or reinstall the plugin.");
   process.exit(1);
 }
 const { buildMainAccount, buildSecondAccount, buildPool, validateSecondConfigDir, planFromExisting, mergeSetupIntoConfig } = core;
@@ -195,25 +196,145 @@ console.log("\nPlanned changes:");
 if (changes.length === 0) console.log("  (none — config already matches)");
 for (const c of changes) console.log(`  • ${c}`);
 
-if (DRY_RUN || changes.length === 0) {
-  console.log(DRY_RUN ? "\ndry-run: nothing written." : "");
-  rl.close();
-  process.exit(0);
+let wroteConfig = false;
+if (DRY_RUN) {
+  if (changes.length > 0) console.log("\ndry-run: config not written.");
+} else if (changes.length > 0) {
+  if (!(await yes(`\nWrite these to ${CONFIG_PATH}? (backup taken first)`))) {
+    console.log("Aborted — nothing written.");
+    rl.close();
+    process.exit(0);
+  }
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  if (existsSync(CONFIG_PATH)) {
+    const backup = `${CONFIG_PATH}.bak-setup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+    copyFileSync(CONFIG_PATH, backup);
+    console.log(`backup: ${backup}`);
+  }
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+  console.log(`wrote ${CONFIG_PATH}`);
+  wroteConfig = true;
+}
+
+// ── eviction watchdog: create, or repair an orphaned unit ────────────────────
+// The unit points at a script INSIDE an install dir, and installs move
+// (path→registry migration, uninstall/reinstall) — an orphaned unit fires
+// every 5 min against a missing file, silently. The wizard owns this now.
+await watchdogStep();
+
+async function watchdogStep() {
+  const platform = process.platform;
+  console.log("\nEviction watchdog (openclaw#107408 mitigation — see README):");
+  if (platform !== "darwin" && platform !== "linux") {
+    console.log("  (auto-scheduling not supported on this platform — see README for manual setup)");
+    return;
+  }
+  const scriptPath = join(__dirname, "eviction-watchdog.mjs");
+  const scanDir =
+    platform === "darwin"
+      ? join(homedir(), "Library", "LaunchAgents")
+      : join(homedir(), ".config", "systemd", "user");
+  let found;
+  try {
+    for (const f of readdirSync(scanDir)) {
+      // Only real unit files — backups like *.plist.bak-... are inert; never
+      // detect (or "repair") one of those instead of the live unit.
+      if (!/\.(plist|service|timer)$/.test(f)) continue;
+      const p = join(scanDir, f);
+      let text;
+      try {
+        text = readFileSync(p, "utf8");
+      } catch {
+        continue;
+      }
+      const target = wds.extractWatchdogTarget(text);
+      if (target) {
+        found = { file: p, target, text };
+        break;
+      }
+    }
+  } catch {
+    /* scan dir missing — treated as absent */
+  }
+  const state = wds.classifyWatchdogUnit(found?.target, existsSync);
+  if (state === "ok") {
+    console.log(`  ✅ already scheduled and healthy → ${found.target}`);
+    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}`);
+      return;
+    }
+    if (!(await yes("  Repoint it at this install?"))) return;
+    writeFileSync(found.file, found.text.split(found.target).join(scriptPath));
+    reloadWatchdogUnit(platform, found.file);
+    console.log(`  ✅ repointed → ${scriptPath}`);
+    return;
+  }
+  if (DRY_RUN) {
+    console.log(`  dry-run: not scheduled — would offer to schedule it → ${scriptPath}`);
+    return;
+  }
+  if (!(await yes("  Not scheduled. Schedule it now (runs every 5 min)?"))) return;
+  const unitFiles = wds.renderWatchdogUnit({ platform, nodePath: process.execPath, scriptPath });
+  for (const uf of unitFiles) {
+    const abs = join(homedir(), uf.path);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, uf.content);
+    console.log(`  wrote ${abs}`);
+  }
+  if (platform === "darwin") {
+    reloadWatchdogUnit(platform, join(homedir(), unitFiles[0].path));
+  } else {
+    try {
+      execFileSync("systemctl", ["--user", "daemon-reload"]);
+      execFileSync("systemctl", ["--user", "enable", "--now", `${wds.WATCHDOG_SYSTEMD_NAME}.timer`]);
+      console.log("  ✅ timer enabled");
+    } catch {
+      console.log(
+        `  ⚠ units written but enabling failed — run: systemctl --user enable --now ${wds.WATCHDOG_SYSTEMD_NAME}.timer`,
+      );
+    }
+  }
 }
 
-if (!(await yes(`\nWrite these to ${CONFIG_PATH}? (backup taken first)`))) {
-  console.log("Aborted — nothing written.");
+function reloadWatchdogUnit(platform, file) {
+  if (platform === "darwin") {
+    try {
+      execFileSync("launchctl", ["unload", file], { stdio: "ignore" });
+    } catch {
+      /* was not loaded */
+    }
+    try {
+      // launchctl can print "Load failed" to stderr and still exit 0 — merge
+      // the streams and check the text, not just the exit code.
+      const out = execFileSync("/bin/sh", ["-c", `launchctl load "${file}" 2>&1 || true`], {
+        encoding: "utf8",
+      });
+      if (/load failed|bootstrap failed/i.test(out)) throw new Error(out.trim());
+      console.log("  ✅ launchd agent (re)loaded");
+    } catch {
+      console.log(`  ⚠ plist written but load failed — run: launchctl load ${file}`);
+    }
+  } else {
+    try {
+      execFileSync("systemctl", ["--user", "daemon-reload"]);
+      console.log("  ✅ systemd reloaded");
+    } catch {
+      console.log("  ⚠ run: systemctl --user daemon-reload");
+    }
+  }
+}
+
+if (DRY_RUN || !wroteConfig) {
+  console.log(DRY_RUN ? "\ndry-run: nothing written." : "");
   rl.close();
   process.exit(0);
 }
-mkdirSync(dirname(CONFIG_PATH), { recursive: true });
-if (existsSync(CONFIG_PATH)) {
-  const backup = `${CONFIG_PATH}.bak-setup-${new Date().toISOString().replace(/[:.]/g, "-")}`;
-  copyFileSync(CONFIG_PATH, backup);
-  console.log(`backup: ${backup}`);
-}
-writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-console.log(`wrote ${CONFIG_PATH}`);
 
 // ── next steps ───────────────────────────────────────────────────────────────
 console.log(`