openclaw-tools 0.2.1

package/dist/chunk-FUWKRMIF.js

@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/dashboard/server.ts
+import { createServer } from "http";
+import chalk2 from "chalk";
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join as join2, resolve } from "path";
+
+// src/brand.ts
+import { basename } from "path";
+import { homedir } from "os";
+import { join } from "path";
+var bin = basename(process.argv[1] ?? "openclaw-doctor").replace(/\.[cm]?js$/, "");
+var KNOWN_BINS = [
+  "openclaw-cli",
+  "openclaw-manage",
+  "openclaw-doctor",
+  "openclaw-service",
+  "openclaw-daemon",
+  "openclaw-monitor",
+  "openclaw-helper",
+  "openclaw-tools",
+  "openclaw-utils",
+  "openclaw-gateway",
+  "openclaw-setup",
+  "openclaw-install",
+  "openclaw-run",
+  "openclaw-start",
+  "openclaw-watch",
+  "openclaw-health"
+];
+var BINARY_NAME = KNOWN_BINS.includes(bin) ? bin : "openclaw-doctor";
+var APP_HOME = join(homedir(), ".openclaw-doctor");
+var DISPLAY_NAMES = {
+  "openclaw-cli": "OpenClaw CLI",
+  "openclaw-manage": "OpenClaw Manage",
+  "openclaw-doctor": "OpenClaw Doctor",
+  "openclaw-service": "OpenClaw Service",
+  "openclaw-daemon": "OpenClaw Daemon",
+  "openclaw-monitor": "OpenClaw Monitor",
+  "openclaw-helper": "OpenClaw Helper",
+  "openclaw-tools": "OpenClaw Tools",
+  "openclaw-utils": "OpenClaw Utils",
+  "openclaw-gateway": "OpenClaw Gateway",
+  "openclaw-setup": "OpenClaw Setup",
+  "openclaw-install": "OpenClaw Install",
+  "openclaw-run": "OpenClaw Run",
+  "openclaw-start": "OpenClaw Start",
+  "openclaw-watch": "OpenClaw Watch",
+  "openclaw-health": "OpenClaw Health"
+};
+var DISPLAY_NAME = DISPLAY_NAMES[BINARY_NAME] ?? "OpenClaw Doctor";
+
+// src/config.ts
+var DOCTOR_HOME = APP_HOME;
+var CONFIG_PATH = join2(APP_HOME, "config.json");
+var DOCTOR_LOG_DIR = join2(APP_HOME, "logs");
+var PID_FILE = join2(APP_HOME, "daemon.pid");
+var defaults = {
+  checkInterval: 30,
+  failThreshold: 5,
+  dashboardPort: 9090,
+  maxRestartsPerHour: 5,
+  openclawProfile: "default",
+  notify: {
+    webhook: {
+      enabled: false,
+      url: "",
+      bodyTemplate: '{"msgtype":"text","text":{"content":"{{message}}"}}'
+    },
+    system: {
+      enabled: true
+    }
+  }
+};
+function ensureDoctorHome() {
+  if (!existsSync(DOCTOR_HOME)) {
+    mkdirSync(DOCTOR_HOME, { recursive: true });
+  }
+  if (!existsSync(DOCTOR_LOG_DIR)) {
+    mkdirSync(DOCTOR_LOG_DIR, { recursive: true });
+  }
+}
+var LOCAL_CONFIG = resolve(process.cwd(), "doctor.config.json");
+function resolveConfigPath(configPath) {
+  if (configPath) return configPath;
+  if (existsSync(LOCAL_CONFIG)) return LOCAL_CONFIG;
+  return CONFIG_PATH;
+}
+function loadConfig(configPath) {
+  const file = resolveConfigPath(configPath);
+  if (existsSync(file)) {
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    return {
+      ...defaults,
+      ...raw,
+      notify: {
+        webhook: { ...defaults.notify.webhook, ...raw.notify?.webhook ?? {} },
+        system: { ...defaults.notify.system, ...raw.notify?.system ?? {} }
+      }
+    };
+  }
+  ensureDoctorHome();
+  writeFileSync(CONFIG_PATH, JSON.stringify(defaults, null, 2) + "\n");
+  return { ...defaults };
+}
+
+// src/core/openclaw.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { execSync } from "child_process";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as http from "http";
+var execAsync = promisify(exec);
+function getOpenClawHome(profile) {
+  if (profile === "dev") return join3(homedir2(), ".openclaw-dev");
+  if (profile !== "default") return join3(homedir2(), `.openclaw-${profile}`);
+  return join3(homedir2(), ".openclaw");
+}
+function findOpenClawBin() {
+  const plistDir = join3(homedir2(), "Library", "LaunchAgents");
+  if (existsSync2(plistDir)) {
+    const plists = readdirSync(plistDir).filter(
+      (f) => f.includes("openclaw") && f.endsWith(".plist")
+    );
+    for (const plist of plists) {
+      const content = readFileSync2(join3(plistDir, plist), "utf-8");
+      const nodeMatch = content.match(
+        /<string>(\/[^<]*\/bin\/node)<\/string>/
+      );
+      const cliMatch = content.match(
+        /<string>(\/[^<]*openclaw[^<]*\.(?:js|mjs))<\/string>/
+      );
+      if (nodeMatch && cliMatch) {
+        return { nodePath: nodeMatch[1], cliBinPath: cliMatch[1] };
+      }
+    }
+  }
+  try {
+    const bin2 = execSync("which openclaw", { encoding: "utf-8" }).trim();
+    if (bin2) return { nodePath: process.execPath, cliBinPath: bin2 };
+  } catch {
+  }
+  return null;
+}
+function findLaunchdLabel() {
+  const plistDir = join3(homedir2(), "Library", "LaunchAgents");
+  if (!existsSync2(plistDir)) return "ai.openclaw.gateway";
+  const plists = readdirSync(plistDir).filter(
+    (f) => f.includes("openclaw") && f.endsWith(".plist")
+  );
+  if (plists.length > 0) {
+    return plists[0].replace(".plist", "");
+  }
+  return "ai.openclaw.gateway";
+}
+function detectOpenClaw(profile = "default") {
+  const home = getOpenClawHome(profile);
+  const configPath = join3(home, "openclaw.json");
+  const logDir2 = join3(home, "logs");
+  const defaults2 = {
+    configPath,
+    gatewayPort: 18789,
+    gatewayToken: "",
+    launchdLabel: findLaunchdLabel(),
+    nodePath: process.execPath,
+    cliBinPath: "",
+    logDir: logDir2,
+    profile,
+    channels: [],
+    agents: [],
+    version: null
+  };
+  const binInfo = findOpenClawBin();
+  if (binInfo) {
+    defaults2.nodePath = binInfo.nodePath;
+    defaults2.cliBinPath = binInfo.cliBinPath;
+  }
+  if (!existsSync2(configPath)) {
+    return defaults2;
+  }
+  try {
+    const raw = JSON.parse(readFileSync2(configPath, "utf-8"));
+    defaults2.gatewayPort = raw.gateway?.port ?? defaults2.gatewayPort;
+    defaults2.gatewayToken = raw.gateway?.auth?.token ?? "";
+    defaults2.version = raw.meta?.lastTouchedVersion ?? null;
+    if (raw.channels) {
+      defaults2.channels = Object.entries(raw.channels).filter(([, v]) => v.enabled !== false).map(([k]) => k);
+    }
+    if (raw.agents?.list) {
+      defaults2.agents = raw.agents.list.map(
+        (a) => ({
+          id: a.id,
+          name: a.name ?? a.id,
+          isDefault: a.default ?? false
+        })
+      );
+    }
+  } catch {
+  }
+  return defaults2;
+}
+async function runOpenClawCmd(info, args) {
+  if (!info.cliBinPath) return null;
+  try {
+    const { stdout } = await execAsync(`"${info.nodePath}" "${info.cliBinPath}" ${args}`, {
+      timeout: 3e4,
+      env: { ...process.env, NODE_NO_WARNINGS: "1" }
+    });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+async function getGatewayHealthHttp(info) {
+  return new Promise((resolve2) => {
+    const url = `http://127.0.0.1:${info.gatewayPort}/health`;
+    const req = http.get(url, { timeout: 5e3 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          resolve2(JSON.parse(data));
+        } catch {
+          resolve2(null);
+        }
+      });
+    });
+    req.on("error", () => resolve2(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve2(null);
+    });
+  });
+}
+async function getGatewayHealth(info) {
+  const raw = await runOpenClawCmd(info, "health --json");
+  if (!raw) return null;
+  try {
+    const jsonStart = raw.indexOf("{");
+    if (jsonStart === -1) return null;
+    return JSON.parse(raw.slice(jsonStart));
+  } catch {
+    return null;
+  }
+}
+function getRestartCommand(info) {
+  const uid = process.getuid?.() ?? 501;
+  return `launchctl kickstart -k gui/${uid}/${info.launchdLabel}`;
+}
+function getStopCommand(info) {
+  const uid = process.getuid?.() ?? 501;
+  return `launchctl kill SIGTERM gui/${uid}/${info.launchdLabel}`;
+}
+function getStartCommand(info) {
+  const uid = process.getuid?.() ?? 501;
+  return `launchctl kickstart gui/${uid}/${info.launchdLabel}`;
+}
+
+// src/core/logger.ts
+import { appendFileSync } from "fs";
+import { join as join4 } from "path";
+import chalk from "chalk";
+var logDir = DOCTOR_LOG_DIR;
+function initLogger(dir) {
+  logDir = dir ?? DOCTOR_LOG_DIR;
+  ensureDoctorHome();
+}
+function getLogFile() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join4(logDir, `${date}.log`);
+}
+function log(level, message) {
+  const time = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `[${time}] [${level.toUpperCase()}] ${message}`;
+  const colorFn = level === "error" ? chalk.red : level === "warn" ? chalk.yellow : level === "success" ? chalk.green : chalk.blue;
+  console.log(colorFn(line));
+  try {
+    appendFileSync(getLogFile(), line + "\n");
+  } catch {
+  }
+}
+var checkHistory = [];
+var restartHistory = [];
+var MAX_HISTORY = 100;
+function addCheckRecord(record) {
+  checkHistory.push(record);
+  if (checkHistory.length > MAX_HISTORY) checkHistory.shift();
+}
+function addRestartRecord(record) {
+  restartHistory.push(record);
+  if (restartHistory.length > MAX_HISTORY) restartHistory.shift();
+}
+function getCheckHistory() {
+  return [...checkHistory];
+}
+function getRestartHistory() {
+  return [...restartHistory];
+}
+
+// src/core/health-checker.ts
+async function checkHealth(info) {
+  const start = Date.now();
+  let health = await getGatewayHealthHttp(info);
+  if (!health) {
+    log("warn", "HTTP probe failed, falling back to CLI health check");
+    health = await getGatewayHealth(info);
+  }
+  const durationMs = Date.now() - start;
+  if (!health) {
+    const error = "Gateway unreachable (openclaw health failed)";
+    addCheckRecord({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      healthy: false,
+      error,
+      responseTime: durationMs
+    });
+    log("error", `Health check failed: ${error} (${durationMs}ms)`);
+    return { healthy: false, gateway: false, channels: [], durationMs, error };
+  }
+  const channels = health.channels ? Object.entries(health.channels).map(([name, ch]) => ({
+    name,
+    ok: ch.probe?.ok ?? false
+  })) : [];
+  const healthy = health.ok;
+  addCheckRecord({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    healthy,
+    responseTime: durationMs
+  });
+  if (healthy) {
+    log("success", `Health OK \u2014 gateway up, ${channels.length} channels (${durationMs}ms)`);
+  } else {
+    log("warn", `Health degraded \u2014 gateway responded but ok=false (${durationMs}ms)`);
+  }
+  return { healthy, gateway: true, channels, durationMs, raw: health };
+}
+
+// src/dashboard/server.ts
+async function renderHTML(info) {
+  const checks = getCheckHistory();
+  const restarts = getRestartHistory();
+  const live = await checkHealth(info);
+  const statusText = live.healthy ? "HEALTHY" : live.gateway ? "DEGRADED" : "UNREACHABLE";
+  const statusColor = live.healthy ? "#22c55e" : live.gateway ? "#eab308" : "#ef4444";
+  const channelRows = live.channels.map(
+    (c) => `
+      <tr>
+        <td>${c.name}</td>
+        <td style="color:${c.ok ? "#22c55e" : "#ef4444"}">${c.ok ? "OK" : "FAIL"}</td>
+      </tr>`
+  ).join("");
+  const agentList = info.agents.map((a) => `${a.name}${a.isDefault ? " (default)" : ""}`).join(", ");
+  const checksRows = checks.slice().reverse().slice(0, 30).map(
+    (c) => `
+      <tr>
+        <td>${c.timestamp}</td>
+        <td style="color:${c.healthy ? "#22c55e" : "#ef4444"}">${c.healthy ? "OK" : "FAIL"}</td>
+        <td>${c.responseTime ?? "-"}ms</td>
+        <td>${c.error ?? ""}</td>
+      </tr>`
+  ).join("");
+  const restartsRows = restarts.slice().reverse().slice(0, 20).map(
+    (r) => `
+      <tr>
+        <td>${r.timestamp}</td>
+        <td>${r.reason}</td>
+        <td style="color:${r.success ? "#22c55e" : "#ef4444"}">${r.success ? "OK" : "FAIL"}</td>
+      </tr>`
+  ).join("");
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>OpenClaw Doctor</title>
+  <meta http-equiv="refresh" content="10">
+  <style>
+    * { margin:0; padding:0; box-sizing:border-box; }
+    body { font-family:-apple-system,system-ui,sans-serif; background:#0f172a; color:#e2e8f0; padding:2rem; }
+    h1 { font-size:1.5rem; margin-bottom:0.5rem; }
+    .subtitle { color:#64748b; margin-bottom:1.5rem; font-size:0.85rem; }
+    .status { font-size:2rem; font-weight:bold; color:${statusColor}; margin-bottom:0.5rem; }
+    .meta { color:#64748b; font-size:0.8rem; margin-bottom:2rem; }
+    h2 { font-size:1.1rem; margin:1.5rem 0 0.5rem; color:#94a3b8; }
+    table { width:100%; border-collapse:collapse; margin-bottom:1rem; }
+    th,td { text-align:left; padding:0.4rem 0.8rem; border-bottom:1px solid #1e293b; font-size:0.85rem; }
+    th { color:#64748b; }
+    .grid { display:grid; grid-template-columns:1fr 1fr; gap:2rem; }
+    @media (max-width:768px) { .grid { grid-template-columns:1fr; } }
+  </style>
+</head>
+<body>
+  <h1>OpenClaw Doctor</h1>
+  <div class="subtitle">Gateway :${info.gatewayPort} | OpenClaw ${info.version ?? "?"} | ${info.profile} profile</div>
+  <div class="status">${statusText}</div>
+  <div class="meta">${live.durationMs}ms | Agents: ${agentList || "none"}</div>
+
+  <div class="grid">
+    <div>
+      <h2>Channels</h2>
+      <table>
+        <tr><th>Channel</th><th>Status</th></tr>
+        ${channelRows || "<tr><td colspan=2>No channels</td></tr>"}
+      </table>
+
+      <h2>Restart History</h2>
+      <table>
+        <tr><th>Time</th><th>Reason</th><th>Result</th></tr>
+        ${restartsRows || "<tr><td colspan=3>No restarts</td></tr>"}
+      </table>
+    </div>
+    <div>
+      <h2>Health Check History</h2>
+      <table>
+        <tr><th>Time</th><th>Status</th><th>Latency</th><th>Error</th></tr>
+        ${checksRows || "<tr><td colspan=4>No checks yet</td></tr>"}
+      </table>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+function startDashboard(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const port = config.dashboardPort;
+  const server = createServer(async (_req, res) => {
+    const html = await renderHTML(info);
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(html);
+  });
+  server.listen(port, () => {
+    log("info", `Dashboard running at http://localhost:${port}`);
+    console.log(chalk2.green.bold(`
+  Dashboard: http://localhost:${port}
+`));
+  });
+}
+
+export {
+  __require,
+  BINARY_NAME,
+  DISPLAY_NAME,
+  DOCTOR_LOG_DIR,
+  PID_FILE,
+  ensureDoctorHome,
+  loadConfig,
+  initLogger,
+  log,
+  addRestartRecord,
+  detectOpenClaw,
+  runOpenClawCmd,
+  getRestartCommand,
+  getStopCommand,
+  getStartCommand,
+  checkHealth,
+  startDashboard
+};

package/dist/index.d.ts

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