@drakon-systems/multi-clawd 1.1.0 → 1.2.0

package/README.md

@@ -165,10 +165,15 @@ second Claude subscription you own.
 **Upgrading:**
 
 ```bash
-# Registry install (npm / ClawHub):
-openclaw plugins install @drakon-systems/multi-clawd@latest --force
-openclaw gateway restart
+npx @drakon-systems/multi-clawd update
+```
 
+One command: checks the registry, installs the new version with the right
+flags, offers the gateway restart, and finishes with a doctor health check.
+(`npm i -g @drakon-systems/multi-clawd` once, and it's just `multi-clawd
+update` — with `multi-clawd setup` and `multi-clawd doctor` alongside.)
+
+```bash
 # From source:
 cd multi-clawd && git pull && npm install && npm run build && npm run doctor
 ```

package/dist/update-core.js

@@ -0,0 +1,30 @@
+export function compareVersions(a, b) {
+    const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+    const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+export function decideUpdateAction(opts) {
+    if (opts.installed === undefined)
+        return "install";
+    if (opts.latest === undefined)
+        return "unknown";
+    return compareVersions(opts.installed, opts.latest) < 0 ? "update" : "up-to-date";
+}
+export function formatUpdateBanner(opts) {
+    const action = decideUpdateAction(opts);
+    switch (action) {
+        case "install":
+            return `not installed — latest is v${opts.latest}`;
+        case "update":
+            return `update available: v${opts.installed} → v${opts.latest}`;
+        case "up-to-date":
+            return `up to date (v${opts.installed})`;
+        case "unknown":
+            return `installed v${opts.installed} — could not reach the registry to check for updates`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.1.0",
+  "version": "1.2.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",
@@ -35,6 +35,9 @@
     }
   },
   "main": "./dist/index.js",
+  "bin": {
+    "multi-clawd": "./scripts/cli.mjs"
+  },
   "publishConfig": {
     "access": "public"
   },

package/scripts/cli.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+/**
+ * multi-clawd CLI — the friendly front door.
+ *
+ *   npx @drakon-systems/multi-clawd setup     guided setup wizard
+ *   npx @drakon-systems/multi-clawd update    update to the latest version
+ *   npx @drakon-systems/multi-clawd doctor    health check
+ *   npx @drakon-systems/multi-clawd version   versions (CLI + installed plugin)
+ *
+ * (Installed globally via `npm i -g @drakon-systems/multi-clawd`, the same
+ * commands are just `multi-clawd setup` / `multi-clawd update` / …)
+ *
+ * `update` wraps the whole upgrade dance — registry version check, the
+ * openclaw install with the right flags, gateway restart, doctor — so nobody
+ * has to remember `--pin --force`.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import readline from "node:readline/promises";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG = "@drakon-systems/multi-clawd";
+const HOME = homedir();
+const BOLD = process.stdout.isTTY ? "\x1b[1m" : "";
+const DIM = process.stdout.isTTY ? "\x1b[2m" : "";
+const RESET = process.stdout.isTTY ? "\x1b[0m" : "";
+
+const [cmd, ...rest] = process.argv.slice(2);
+
+function usage() {
+  console.log(`
+${BOLD}🦞 multi-clawd${RESET} — multi-account Claude failover for OpenClaw
+
+  ${BOLD}setup${RESET}     guided setup wizard (accounts, pool, watchdog)
+  ${BOLD}update${RESET}    update the plugin to the latest version
+  ${BOLD}doctor${RESET}    health check (add --probe for a live turn)
+  ${BOLD}version${RESET}   show CLI + installed plugin versions
+
+Run via npx (${DIM}npx ${PKG} <command>${RESET}) or install globally
+(${DIM}npm i -g ${PKG}${RESET}) for a bare ${DIM}multi-clawd <command>${RESET}.
+`);
+}
+
+/** Same resolution as the doctor: path install wins, else newest npm-project install. */
+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;
+  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;
+}
+
+function installedVersion() {
+  const dir = resolveInstallDir();
+  if (!dir) return undefined;
+  try {
+    return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
+function latestVersion() {
+  try {
+    return execFileSync("npm", ["view", PKG, "version"], { encoding: "utf8", timeout: 15000 })
+      .trim();
+  } catch {
+    return undefined;
+  }
+}
+
+function haveOpenclaw() {
+  try {
+    execFileSync("openclaw", ["--version"], { stdio: "pipe", timeout: 15000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runSibling(script, args) {
+  const r = spawnSync(process.execPath, [join(__dirname, script), ...args], { stdio: "inherit" });
+  process.exit(r.status ?? 1);
+}
+
+async function askYes(question, dflt = true) {
+  if (!process.stdin.isTTY) return dflt;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const a = (await rl.question(`${question} ${dflt ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+  rl.close();
+  if (!a) return dflt;
+  return a.startsWith("y");
+}
+
+async function update() {
+  let uc;
+  try {
+    uc = await import(resolve(__dirname, "..", "dist", "update-core.js"));
+  } catch {
+    console.error("update: built dist/ is missing — reinstall the package.");
+    process.exit(1);
+  }
+  console.log(`\n${BOLD}🦞 multi-clawd update${RESET}\n`);
+  if (!haveOpenclaw()) {
+    console.error("  ❌ the `openclaw` CLI is not on PATH — install OpenClaw first.");
+    process.exit(1);
+  }
+  const installed = installedVersion();
+  process.stdout.write(`  checking registry… `);
+  const latest = latestVersion();
+  console.log(latest ? `latest is v${latest}` : "unreachable");
+  const banner = uc.formatUpdateBanner({ installed, latest });
+  const action = uc.decideUpdateAction({ installed, latest });
+  console.log(`  ${action === "up-to-date" ? "✅" : action === "unknown" ? "⚠️ " : "⬆️ "} ${banner}\n`);
+  if (action === "up-to-date") return;
+  if (action === "unknown") {
+    console.log("  Check your network and try again.");
+    process.exit(1);
+  }
+  if (!(await askYes(`  ${action === "install" ? "Install" : "Update"} now?`))) return;
+
+  console.log(`\n  ${DIM}openclaw plugins install ${PKG} --pin --force${RESET}`);
+  const inst = spawnSync("openclaw", ["plugins", "install", PKG, "--pin", "--force"], {
+    stdio: "inherit",
+  });
+  if (inst.status !== 0) {
+    console.error("\n  ❌ install failed — see output above.");
+    process.exit(1);
+  }
+  if (await askYes("\n  Restart the gateway to load it? (briefly interrupts running turns)")) {
+    const r = spawnSync("openclaw", ["gateway", "restart"], { stdio: "inherit" });
+    if (r.status !== 0) console.log("  ⚠ restart failed — run `openclaw gateway restart` yourself.");
+  } else {
+    console.log("  ⏳ remember: the new version loads on the next gateway restart.");
+  }
+  console.log(`\n${BOLD}  health check${RESET}`);
+  const doc = spawnSync(process.execPath, [join(__dirname, "doctor.mjs")], { stdio: "inherit" });
+  if (doc.status !== 0) {
+    console.log(`\n  ⚠ doctor found problems — if it flagged the watchdog, run ${BOLD}multi-clawd setup${RESET} to repair it.`);
+    process.exit(doc.status ?? 1);
+  }
+  console.log(`\n  ✅ done — now on v${installedVersion() ?? "?"}`);
+}
+
+switch (cmd) {
+  case "setup":
+    runSibling("setup.mjs", rest);
+    break;
+  case "doctor":
+    runSibling("doctor.mjs", rest);
+    break;
+  case "update":
+    await update();
+    break;
+  case "version":
+  case "--version":
+  case "-v": {
+    const cliVersion = JSON.parse(
+      readFileSync(resolve(__dirname, "..", "package.json"), "utf8"),
+    ).version;
+    console.log(`cli: v${cliVersion}`);
+    console.log(`installed plugin: ${installedVersion() ? `v${installedVersion()}` : "(not installed)"}`);
+    break;
+  }
+  default:
+    usage();
+    process.exit(cmd === undefined || cmd === "help" || cmd === "--help" ? 0 : 1);
+}