openclaw-tools 0.2.1

package/dist/index.js

@@ -0,0 +1,567 @@
+#!/usr/bin/env node
+import {
+  BINARY_NAME,
+  DISPLAY_NAME,
+  DOCTOR_LOG_DIR,
+  PID_FILE,
+  __require,
+  addRestartRecord,
+  checkHealth,
+  detectOpenClaw,
+  ensureDoctorHome,
+  getRestartCommand,
+  getStartCommand,
+  getStopCommand,
+  initLogger,
+  loadConfig,
+  log,
+  runOpenClawCmd,
+  startDashboard
+} from "./chunk-FUWKRMIF.js";
+
+// src/index.ts
+import { createRequire } from "module";
+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";
+
+// src/core/process-manager.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function runShell(command) {
+  try {
+    const { stdout } = await execAsync(command, { timeout: 12e4 });
+    return { success: true, output: stdout.trim() };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    return { success: false, error };
+  }
+}
+async function restartGateway(info) {
+  const cmd = getRestartCommand(info);
+  log("warn", `Restarting gateway: ${cmd}`);
+  const result = await runShell(cmd);
+  if (result.success) {
+    log("success", "Gateway restarted");
+  } else {
+    log("error", `Gateway restart failed: ${result.error}`);
+  }
+  addRestartRecord({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    reason: "health check failed",
+    success: result.success
+  });
+  return result;
+}
+async function startGateway(info) {
+  const cmd = getStartCommand(info);
+  log("info", `Starting gateway: ${cmd}`);
+  const result = await runShell(cmd);
+  if (result.success) log("success", "Gateway started");
+  else log("error", `Gateway start failed: ${result.error}`);
+  return result;
+}
+async function stopGateway(info) {
+  const cmd = getStopCommand(info);
+  log("info", `Stopping gateway: ${cmd}`);
+  const result = await runShell(cmd);
+  if (result.success) log("success", "Gateway stopped");
+  else log("error", `Gateway stop failed: ${result.error}`);
+  return result;
+}
+var RestartThrottle = class {
+  constructor(maxPerHour) {
+    this.maxPerHour = maxPerHour;
+  }
+  timestamps = [];
+  canRestart() {
+    const oneHourAgo = Date.now() - 36e5;
+    this.timestamps = this.timestamps.filter((t) => t > oneHourAgo);
+    return this.timestamps.length < this.maxPerHour;
+  }
+  record() {
+    this.timestamps.push(Date.now());
+  }
+  recentCount() {
+    const oneHourAgo = Date.now() - 36e5;
+    return this.timestamps.filter((t) => t > oneHourAgo).length;
+  }
+};
+
+// src/commands/watch.ts
+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-PP5Y3LAF.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"));
+  }
+  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: join2 } = __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(`
+  ${join2(DOCTOR_LOG_DIR, latest)}
+`));
+  const content = readFileSync3(join2(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/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+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);
+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-PP5Y3LAF.js

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

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "openclaw-tools",
+  "version": "0.2.1",
+  "description": "Health check and auto-restart daemon for local OpenClaw services",
+  "type": "module",
+  "bin": {
+    "openclaw-tools": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [
+    "openclaw",
+    "health-check",
+    "daemon",
+    "doctor",
+    "cli"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sobranier/openclaw-doctor.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "author": "pdd <ywq1991@gmail.com>",
+  "bugs": {
+    "url": "https://github.com/Sobranier/openclaw-doctor/issues"
+  },
+  "homepage": "https://github.com/Sobranier/openclaw-doctor#readme"
+}