volclaw 0.3.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,582 @@
+#!/usr/bin/env node
+import {
+  BINARY_NAME,
+  DISPLAY_NAME,
+  DOCTOR_LOG_DIR,
+  PID_FILE,
+  RestartThrottle,
+  __require,
+  checkHealth,
+  detectOpenClaw,
+  ensureDoctorHome,
+  initLogger,
+  loadConfig,
+  log,
+  restartGateway,
+  runOpenClawCmd,
+  startDashboard,
+  startGateway,
+  stopGateway
+} from "./chunk-LIZ6XXW3.js";
+
+// src/index.ts
+import { spawnSync } from "child_process";
+import { Command } from "commander";
+
+// src/commands/watch.ts
+import { spawn } from "child_process";
+import { writeFileSync, readFileSync, existsSync, unlinkSync, openSync } from "fs";
+import chalk from "chalk";
+import { join } from "path";
+async function watchDaemon(options) {
+  if (options.daemon) {
+    return daemonize(options);
+  }
+  const config = loadConfig(options.config);
+  initLogger();
+  ensureDoctorHome();
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  writeFileSync(PID_FILE, String(process.pid));
+  log("info", "OpenClaw Doctor started (foreground)");
+  log("info", `Gateway port: ${info.gatewayPort}`);
+  log("info", `Channels: ${info.channels.join(", ") || "none detected"}`);
+  log("info", `Check interval: ${config.checkInterval}s`);
+  log("info", `PID: ${process.pid}`);
+  if (options.dashboard) {
+    const { startDashboard: startDashboard2 } = await import("./server-ZYSNFLSO.js");
+    startDashboard2({ config: options.config });
+  }
+  const throttle = new RestartThrottle(config.maxRestartsPerHour);
+  let consecutiveFailures = 0;
+  let isRestarting = false;
+  async function tick() {
+    if (isRestarting) return;
+    const result = await checkHealth(info);
+    if (result.healthy) {
+      consecutiveFailures = 0;
+      return;
+    }
+    consecutiveFailures++;
+    log(
+      "warn",
+      `Consecutive failures: ${consecutiveFailures}/${config.failThreshold}`
+    );
+    if (consecutiveFailures >= config.failThreshold) {
+      if (!throttle.canRestart()) {
+        log(
+          "error",
+          `Restart throttled: ${throttle.recentCount()} restarts in the last hour (max ${config.maxRestartsPerHour})`
+        );
+        return;
+      }
+      isRestarting = true;
+      consecutiveFailures = 0;
+      throttle.record();
+      await restartGateway(info);
+      log("info", "Waiting 30s for gateway to start...");
+      await new Promise((r) => setTimeout(r, 6e4));
+      isRestarting = false;
+    }
+  }
+  await tick();
+  setInterval(tick, config.checkInterval * 1e3);
+  const cleanup = () => {
+    log("info", "OpenClaw Doctor stopped");
+    try {
+      unlinkSync(PID_FILE);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+function daemonize(options) {
+  ensureDoctorHome();
+  const existingPid = readDaemonPid();
+  if (existingPid && isProcessAlive(existingPid)) {
+    console.log(chalk.yellow(`Doctor is already running (PID ${existingPid})`));
+    return;
+  }
+  const execArgv = process.execArgv.filter(
+    (a) => !a.includes("--eval")
+  );
+  const scriptArgs = process.argv.slice(1).filter(
+    (a) => a !== "-d" && a !== "--daemon"
+  );
+  const fullArgs = [...execArgv, ...scriptArgs];
+  const outLog = join(DOCTOR_LOG_DIR, "daemon.out.log");
+  const errLog = join(DOCTOR_LOG_DIR, "daemon.err.log");
+  const out = openSync(outLog, "a");
+  const err = openSync(errLog, "a");
+  const child = spawn(process.execPath, fullArgs, {
+    detached: true,
+    stdio: ["ignore", out, err],
+    env: { ...process.env, OPENCLAW_DOCTOR_DAEMON: "1" }
+  });
+  const pid = child.pid;
+  writeFileSync(PID_FILE, String(pid));
+  child.unref();
+  console.log(chalk.green(`Doctor started in background (PID ${pid})`));
+  console.log(chalk.gray(`  Logs: ${outLog}`));
+  console.log(chalk.gray(`  Stop: openclaw-doctor stop`));
+}
+async function stopDaemon(options) {
+  const pid = readDaemonPid();
+  if (!pid) {
+    console.log(chalk.yellow("Doctor is not running (no PID file)"));
+    return;
+  }
+  if (!isProcessAlive(pid)) {
+    console.log(chalk.yellow(`Doctor is not running (PID ${pid} is dead, cleaning up)`));
+    try {
+      unlinkSync(PID_FILE);
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(chalk.green(`Doctor stopped (PID ${pid})`));
+  } catch (err) {
+    console.log(chalk.red(`Failed to stop Doctor (PID ${pid}): ${err}`));
+  }
+  await new Promise((r) => setTimeout(r, 1e3));
+  try {
+    unlinkSync(PID_FILE);
+  } catch {
+  }
+}
+function readDaemonPid() {
+  if (!existsSync(PID_FILE)) return null;
+  const raw = readFileSync(PID_FILE, "utf-8").trim();
+  const pid = parseInt(raw, 10);
+  return isNaN(pid) ? null : pid;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+async function showStatus(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const result = await checkHealth(info);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          gateway: {
+            healthy: result.healthy,
+            reachable: result.gateway,
+            port: info.gatewayPort,
+            durationMs: result.durationMs
+          },
+          channels: result.channels,
+          agents: info.agents,
+          openclaw: {
+            version: info.version,
+            profile: info.profile,
+            configPath: info.configPath
+          },
+          doctor: {
+            checkInterval: config.checkInterval,
+            failThreshold: config.failThreshold
+          }
+        },
+        null,
+        2
+      )
+    );
+    process.exit(result.healthy ? 0 : 1);
+    return;
+  }
+  console.log(chalk2.bold("\n  OpenClaw Doctor\n"));
+  if (result.healthy) {
+    console.log(
+      chalk2.green.bold(`  Gateway: HEALTHY`) + chalk2.gray(` (port ${info.gatewayPort}, ${result.durationMs}ms)`)
+    );
+  } else if (result.gateway) {
+    console.log(chalk2.yellow.bold(`  Gateway: DEGRADED`) + chalk2.gray(` (responded but ok=false)`));
+  } else {
+    console.log(chalk2.red.bold(`  Gateway: UNREACHABLE`));
+    if (result.error) console.log(chalk2.red(`  ${result.error}`));
+  }
+  if (result.channels && result.channels.length > 0) {
+    console.log();
+    for (const ch of result.channels ?? []) {
+      const icon = ch.ok ? chalk2.green("ok") : chalk2.red("fail");
+      console.log(`  ${chalk2.gray("Channel")} ${ch.name}: ${icon}`);
+    }
+  }
+  if (info.agents.length > 0) {
+    console.log();
+    const agentList = info.agents.map((a) => a.isDefault ? `${a.name} (default)` : a.name).join(", ");
+    console.log(chalk2.gray(`  Agents: ${agentList}`));
+  }
+  console.log();
+  console.log(chalk2.gray(`  OpenClaw ${info.version ?? "unknown"}`));
+  console.log(chalk2.gray(`  Config: ${info.configPath}`));
+  console.log();
+  process.exit(result.healthy ? 0 : 1);
+}
+
+// src/commands/doctor.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import chalk3 from "chalk";
+function findConfigIssues(configPath) {
+  if (!existsSync2(configPath)) return [];
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(configPath, "utf-8"));
+  } catch {
+    return [{ path: "root", message: "Config file is not valid JSON", fix: () => {
+    } }];
+  }
+  const issues = [];
+  if (Array.isArray(raw.agents?.list)) {
+    for (let i = 0; i < raw.agents.list.length; i++) {
+      const agent = raw.agents.list[i];
+      if (Array.isArray(agent.workspace)) {
+        const idx = i;
+        issues.push({
+          path: `agents.list.${i}.workspace`,
+          message: `Invalid input: expected string, received array`,
+          fix: () => {
+            raw.agents.list[idx].workspace = raw.agents.list[idx].workspace[0];
+          }
+        });
+      }
+    }
+  }
+  if (issues.length > 0) {
+    const originalFixes = issues.map((issue) => issue.fix);
+    for (let i = 0; i < issues.length; i++) {
+      const origFix = originalFixes[i];
+      issues[i].fix = () => {
+        origFix();
+        writeFileSync2(configPath, JSON.stringify(raw, null, 2) + "\n");
+      };
+    }
+  }
+  return issues;
+}
+async function runDoctor(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  console.log(chalk3.bold("\n  OpenClaw Doctor \u2014 Full Diagnostics\n"));
+  console.log(chalk3.gray("  [0/4] Config validation"));
+  const issues = findConfigIssues(info.configPath);
+  if (issues.length === 0) {
+    console.log(chalk3.green("    Config: valid"));
+  } else {
+    for (const issue of issues) {
+      console.log(chalk3.red(`    ${issue.path}: ${issue.message}`));
+    }
+    if (options.fix) {
+      for (const issue of issues) {
+        issue.fix();
+        console.log(chalk3.green(`    Fixed: ${issue.path}`));
+      }
+      console.log(chalk3.green(`    Config saved: ${info.configPath}`));
+    } else {
+      console.log(chalk3.yellow("    Run with --fix to auto-repair"));
+    }
+  }
+  console.log(chalk3.gray("\n  [1/4] OpenClaw binary"));
+  if (info.cliBinPath) {
+    console.log(chalk3.green(`    Found: ${info.cliBinPath}`));
+    console.log(chalk3.gray(`    Node: ${info.nodePath}`));
+    if (info.version) console.log(chalk3.gray(`    Version: ${info.version}`));
+  } else {
+    console.log(chalk3.red("    Not found \u2014 openclaw CLI is not installed or not in PATH"));
+  }
+  console.log(chalk3.gray("\n  [2/4] Gateway health"));
+  const result = await checkHealth(info);
+  if (result.healthy) {
+    console.log(chalk3.green(`    Gateway: healthy (port ${info.gatewayPort}, ${result.durationMs}ms)`));
+  } else if (result.gateway) {
+    console.log(chalk3.yellow(`    Gateway: responded but degraded`));
+  } else {
+    console.log(chalk3.red(`    Gateway: unreachable`));
+    if (result.error) console.log(chalk3.red(`    ${result.error}`));
+  }
+  console.log(chalk3.gray("\n  [3/4] Channels"));
+  if (result.channels.length > 0) {
+    for (const ch of result.channels) {
+      const status = ch.ok ? chalk3.green("ok") : chalk3.red("fail");
+      console.log(`    ${ch.name}: ${status}`);
+    }
+  } else {
+    console.log(chalk3.yellow("    No channel data available"));
+  }
+  console.log(chalk3.gray("\n  [4/4] OpenClaw built-in doctor"));
+  const doctorOutput = await runOpenClawCmd(info, "doctor");
+  if (doctorOutput) {
+    const lines = doctorOutput.split("\n");
+    const startIdx = lines.findIndex((l) => l.includes("OpenClaw doctor") || l.includes("Gateway service"));
+    const relevant = startIdx >= 0 ? lines.slice(startIdx) : lines;
+    for (const line of relevant) {
+      console.log(`    ${line}`);
+    }
+  } else {
+    console.log(chalk3.yellow("    Could not run openclaw doctor"));
+  }
+  if (options.fix) {
+    console.log(chalk3.gray("\n  [5/5] Auto-repair"));
+    if (!result.healthy) {
+      console.log(chalk3.yellow("    Gateway unhealthy \u2014 running openclaw doctor --repair --non-interactive"));
+      const repairOutput = await runOpenClawCmd(info, "doctor --repair --non-interactive");
+      if (repairOutput) {
+        const lines = repairOutput.split("\n");
+        for (const line of lines.slice(0, 30)) {
+          if (line.trim()) console.log(`    ${line}`);
+        }
+        console.log(chalk3.green("    Repair completed"));
+      } else {
+        console.log(chalk3.yellow("    Could not run repair (openclaw CLI unavailable)"));
+      }
+    } else {
+      console.log(chalk3.green("    Gateway healthy \u2014 no repair needed"));
+    }
+  }
+  console.log();
+}
+
+// src/commands/logs.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import chalk4 from "chalk";
+function showLogs(options) {
+  const config = loadConfig(options.config);
+  const maxLines = parseInt(options.lines ?? "50", 10);
+  if (options.doctor) {
+    showDoctorLogs(maxLines);
+    return;
+  }
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const logFile = options.error ? `${info.logDir}/gateway.err.log` : `${info.logDir}/gateway.log`;
+  if (!existsSync3(logFile)) {
+    console.log(chalk4.yellow(`Log file not found: ${logFile}`));
+    return;
+  }
+  console.log(chalk4.blue.bold(`
+  ${logFile}
+`));
+  const content = readFileSync3(logFile, "utf-8");
+  const lines = content.trim().split("\n");
+  const tail = lines.slice(-maxLines);
+  for (const line of tail) {
+    if (line.includes("[error]") || line.includes("[ERROR]")) {
+      console.log(chalk4.red(line));
+    } else if (line.includes("[warn]") || line.includes("[WARN]")) {
+      console.log(chalk4.yellow(line));
+    } else {
+      console.log(chalk4.gray(line));
+    }
+  }
+  console.log();
+}
+function showDoctorLogs(maxLines) {
+  const { readdirSync } = __require("fs");
+  const { join: join3 } = __require("path");
+  if (!existsSync3(DOCTOR_LOG_DIR)) {
+    console.log(chalk4.yellow("No doctor logs found."));
+    return;
+  }
+  const files = readdirSync(DOCTOR_LOG_DIR).filter((f) => f.endsWith(".log")).sort().reverse();
+  if (files.length === 0) {
+    console.log(chalk4.yellow("No doctor log files found."));
+    return;
+  }
+  const latest = files[0];
+  console.log(chalk4.blue.bold(`
+  ${join3(DOCTOR_LOG_DIR, latest)}
+`));
+  const content = readFileSync3(join3(DOCTOR_LOG_DIR, latest), "utf-8");
+  const lines = content.trim().split("\n");
+  const tail = lines.slice(-maxLines);
+  for (const line of tail) {
+    if (line.includes("[ERROR]")) {
+      console.log(chalk4.red(line));
+    } else if (line.includes("[WARN]")) {
+      console.log(chalk4.yellow(line));
+    } else if (line.includes("[SUCCESS]")) {
+      console.log(chalk4.green(line));
+    } else {
+      console.log(chalk4.gray(line));
+    }
+  }
+  console.log();
+}
+
+// src/commands/gateway.ts
+import chalk5 from "chalk";
+async function gatewayStart(options) {
+  const config = loadConfig(options.config);
+  initLogger();
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const result = await startGateway(info);
+  if (result.success) {
+    console.log(chalk5.green("Gateway started"));
+  } else {
+    console.log(chalk5.red(`Failed to start gateway: ${result.error}`));
+    process.exit(1);
+  }
+}
+async function gatewayStop(options) {
+  const config = loadConfig(options.config);
+  initLogger();
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const result = await stopGateway(info);
+  if (result.success) {
+    console.log(chalk5.green("Gateway stopped"));
+  } else {
+    console.log(chalk5.red(`Failed to stop gateway: ${result.error}`));
+    process.exit(1);
+  }
+}
+async function gatewayRestart(options) {
+  const config = loadConfig(options.config);
+  initLogger();
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const result = await restartGateway(info);
+  if (result.success) {
+    console.log(chalk5.green("Gateway restarted"));
+  } else {
+    console.log(chalk5.red(`Failed to restart gateway: ${result.error}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/memory.ts
+import chalk6 from "chalk";
+import { existsSync as existsSync4, statSync } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+function expandHome(p) {
+  return p.startsWith("~/") ? join2(homedir(), p.slice(2)) : p;
+}
+async function memoryStatus(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  console.log(chalk6.bold("\n  Memory Status\n"));
+  for (const agent of info.agents) {
+    const ws = agent.workspace;
+    if (!ws) continue;
+    const wsPath = expandHome(ws);
+    const memPath = join2(wsPath, "MEMORY.md");
+    const exists = existsSync4(memPath);
+    const sizeKB = exists ? Math.round(statSync(memPath).size / 1024) : 0;
+    const warn = sizeKB > 50;
+    const indicator = warn ? chalk6.yellow("\u26A0") : chalk6.green("\u2713");
+    const sizeStr = warn ? chalk6.yellow(`${sizeKB}KB`) : chalk6.gray(`${sizeKB}KB`);
+    console.log(`  ${indicator} ${agent.name.padEnd(16)} MEMORY.md: ${sizeStr}${warn ? chalk6.yellow("  \u2014 exceeds 50KB, may waste tokens") : ""}`);
+  }
+  console.log();
+}
+async function memorySearch(query, options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  console.log(chalk6.bold(`
+  Searching memory: "${query}"
+`));
+  const output = await runOpenClawCmd(info, `memory search "${query}"`);
+  if (output) {
+    console.log(output);
+  } else {
+    console.log(chalk6.yellow("  No results or openclaw memory search unavailable"));
+  }
+  console.log();
+}
+async function memoryCompact(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const flag = options.dryRun ? "--dry-run" : "";
+  console.log(chalk6.bold(`
+  Memory Compact${options.dryRun ? " (dry run)" : ""}
+`));
+  const output = await runOpenClawCmd(info, `memory compact ${flag}`);
+  if (output) {
+    console.log(output);
+  } else {
+    console.log(chalk6.yellow("  openclaw memory compact not available"));
+  }
+  console.log();
+}
+
+// src/index.ts
+var _PKG_VER = true ? "0.3.1" : "0.2.1";
+var version = _PKG_VER;
+var program = new Command();
+program.name(BINARY_NAME).description(`${DISPLAY_NAME} \u2014 health monitor and management for OpenClaw services`).version(version);
+var addGlobalOpts = (cmd) => cmd.option("-c, --config <path>", "Path to config file").option("--profile <name>", "OpenClaw profile (default, dev, ...)", "default");
+addGlobalOpts(
+  program.command("watch").description("Start health monitoring daemon").option("-d, --daemon", "Run in background").option("--dashboard", "Also start web dashboard")
+).action(watchDaemon);
+addGlobalOpts(
+  program.command("unwatch").description("Stop monitoring daemon")
+).action(stopDaemon);
+addGlobalOpts(
+  program.command("status").description("Show gateway and channel health").option("--json", "Machine-readable JSON output")
+).action(showStatus);
+addGlobalOpts(
+  program.command("doctor").description("Run full diagnostics (our checks + openclaw doctor)").option("--fix", "Auto-fix common config issues")
+).action(runDoctor);
+addGlobalOpts(
+  program.command("monitor").description("Start local monitoring web UI (http://localhost:9090)")
+).action(startDashboard);
+var gw = program.command("gateway").description("Manage the OpenClaw gateway service");
+addGlobalOpts(gw.command("start").description("Start the gateway")).action(gatewayStart);
+addGlobalOpts(gw.command("stop").description("Stop the gateway")).action(gatewayStop);
+addGlobalOpts(gw.command("restart").description("Restart the gateway")).action(gatewayRestart);
+var mem = program.command("memory").description("Memory file health and management");
+addGlobalOpts(mem.command("status").description("Show MEMORY.md size and health per agent")).action(memoryStatus);
+addGlobalOpts(
+  mem.command("search").description("Search agent memory files").argument("<query>", "Search query")
+).action((query, options) => memorySearch(query, options));
+addGlobalOpts(
+  mem.command("compact").description("Compact agent memory (proxies to openclaw memory compact)").option("--dry-run", "Preview without applying")
+).action(memoryCompact);
+addGlobalOpts(
+  program.command("logs").description("View logs (proxies to openclaw logs; use --doctor for our own logs)").option("-n, --lines <count>", "Number of lines to show", "50").option("--error", "Show gateway error logs").option("--doctor", "Show our own event logs").option("--tail", "Follow logs in real time").allowUnknownOption()
+).action((options, cmd) => {
+  if (options.doctor) {
+    showLogs({ ...options, doctor: true });
+  } else {
+    proxyToOpenclaw(cmd.args.length ? cmd.args : [], ["logs", ...process.argv.slice(3)]);
+  }
+});
+program.command("*", { hidden: true, isDefault: false }).allowUnknownOption().action(() => {
+});
+program.addHelpText("after", `
+Proxy: any unrecognized command is forwarded to the openclaw CLI.
+       e.g. "${BINARY_NAME} channels list" \u2192 "openclaw channels list"
+`);
+var knownCommands = program.commands.map((c) => c.name());
+var rawArgs = process.argv.slice(2);
+var firstArg = rawArgs[0];
+if (firstArg && !firstArg.startsWith("-") && !knownCommands.includes(firstArg)) {
+  proxyToOpenclaw(rawArgs);
+} else {
+  program.parse();
+}
+function proxyToOpenclaw(args, override) {
+  const info = detectOpenClaw("default");
+  const bin = info.cliBinPath;
+  if (!bin) {
+    console.error("openclaw CLI not found. Please install openclaw first.");
+    process.exit(1);
+  }
+  const passArgs = override ?? args;
+  const result = spawnSync(info.nodePath, [bin, ...passArgs], {
+    stdio: "inherit",
+    env: process.env
+  });
+  process.exit(result.status ?? 0);
+}

package/dist/server-ZYSNFLSO.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import {
+  startDashboard
+} from "./chunk-LIZ6XXW3.js";
+export {
+  startDashboard
+};

package/homebrew/README.md

@@ -0,0 +1,37 @@
+# Homebrew Tap — OpenClaw
+
+This directory contains Homebrew formulas for OpenClaw tools.
+
+## Setup
+
+1. Create a new GitHub repo: `Sobranier/homebrew-openclaw`
+2. Copy the `.rb` files from this directory into `Formula/` in that repo
+3. After creating a GitHub Release (e.g. `v0.3.0`), update the `sha256` in each formula:
+
+```bash
+curl -sL https://github.com/Sobranier/openclaw-doctor/archive/refs/tags/v0.3.0.tar.gz | shasum -a 256
+```
+
+## Installation (once published)
+
+```bash
+brew tap Sobranier/openclaw
+brew install openclaw-cli
+
+# Or the doctor alias (backward compat)
+brew install openclaw-doctor
+```
+
+## Update formula on new release
+
+When you publish a new version:
+
+1. Update `url` version tag in both `.rb` files
+2. Recalculate `sha256`:
+   ```bash
+   curl -sL https://github.com/Sobranier/openclaw-doctor/archive/refs/tags/vX.X.X.tar.gz | shasum -a 256
+   ```
+3. Update `sha256` in both `.rb` files
+4. Commit and push to `homebrew-openclaw` repo
+
+> Tip: Add this to `scripts/publish.sh` to automate the sha256 update.

package/homebrew/openclaw-cli.rb

@@ -0,0 +1,22 @@
+class OpenclasCli < Formula
+  desc "CLI and health-watch daemon for OpenClaw AI assistant gateway"
+  homepage "https://github.com/Sobranier/openclaw-doctor"
+  url "https://github.com/Sobranier/openclaw-doctor/archive/refs/tags/v0.3.0.tar.gz"
+  sha256 "REPLACE_WITH_SHA256_AFTER_RELEASE"
+  license "MIT"
+  head "https://github.com/Sobranier/openclaw-doctor.git", branch: "main"
+
+  depends_on "node"
+
+  def install
+    system "npm", "install", *std_npm_args
+    # Install the openclaw-cli binary
+    bin.install_symlink Dir["#{libexec}/bin/openclaw-cli"]
+    # Also provide openclaw-doctor alias for backward compatibility
+    bin.install_symlink Dir["#{libexec}/bin/openclaw-cli"] => "openclaw-doctor"
+  end
+
+  test do
+    assert_match version.to_s, shell_output("#{bin}/openclaw-cli --version")
+  end
+end

package/homebrew/openclaw-doctor.rb

@@ -0,0 +1,26 @@
+# openclaw-doctor is an alias for openclaw-cli.
+# The main formula is openclaw-cli — install that instead:
+#
+#   brew install Sobranier/openclaw/openclaw-cli
+#
+class OpenclawDoctor < Formula
+  desc "Alias for openclaw-cli — health-watch daemon for OpenClaw gateway"
+  homepage "https://github.com/Sobranier/openclaw-doctor"
+  url "https://github.com/Sobranier/openclaw-doctor/archive/refs/tags/v0.3.0.tar.gz"
+  sha256 "REPLACE_WITH_SHA256_AFTER_RELEASE"
+  license "MIT"
+
+  depends_on "node"
+  # Recommend the primary formula
+  deprecated_unless "openclaw-cli is now the primary package; this formula is kept for backward compatibility."
+
+  def install
+    system "npm", "install", *std_npm_args
+    bin.install_symlink Dir["#{libexec}/bin/openclaw-cli"] => "openclaw-doctor"
+    bin.install_symlink Dir["#{libexec}/bin/openclaw-cli"]
+  end
+
+  test do
+    assert_match version.to_s, shell_output("#{bin}/openclaw-doctor --version")
+  end
+end