openclaw-service 0.4.0 → 0.6.1

package/dist/index.js

@@ -1,48 +1,1379 @@
 #!/usr/bin/env node
-import {
-  APP_HOME,
-  BINARY_NAME,
-  DISPLAY_NAME,
-  DOCTOR_LOG_DIR,
-  PID_FILE,
-  RestartThrottle,
-  __require,
-  checkHealth,
-  detectOpenClaw,
-  ensureDoctorHome,
-  initLogger,
-  loadConfig,
-  log,
-  restartGateway,
-  runOpenClawCmd,
-  startDashboard,
-  startGateway,
-  stopGateway
-} from "./chunk-UXL57WT4.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/brand.ts
+import { basename, join } from "path";
+import { homedir } from "os";
+function toDisplayName(bin) {
+  if (bin === "openclaw-cli") return "OpenClaw CLI";
+  if (bin === "openclaw-doctor") return "OpenClaw Doctor";
+  return bin.split("-").map((s) => s ? s[0].toUpperCase() + s.slice(1) : s).join(" ");
+}
+var detectedBin, BINARY_NAME, APP_HOME, DISPLAY_NAME;
+var init_brand = __esm({
+  "src/brand.ts"() {
+    "use strict";
+    detectedBin = basename(process.argv[1] ?? "openclaw-cli").replace(/\.[cm]?js$/, "");
+    BINARY_NAME = detectedBin || "openclaw-cli";
+    APP_HOME = join(homedir(), ".openclaw-doctor");
+    DISPLAY_NAME = toDisplayName(BINARY_NAME);
+  }
+});
+
+// src/config.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join as join2, resolve } from "path";
+function ensureDoctorHome() {
+  if (!existsSync(DOCTOR_HOME)) {
+    mkdirSync(DOCTOR_HOME, { recursive: true });
+  }
+  if (!existsSync(DOCTOR_LOG_DIR)) {
+    mkdirSync(DOCTOR_LOG_DIR, { recursive: true });
+  }
+}
+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 };
+}
+var DOCTOR_HOME, CONFIG_PATH, DOCTOR_LOG_DIR, PID_FILE, STOP_FLAG_FILE, defaults, LOCAL_CONFIG;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    init_brand();
+    DOCTOR_HOME = APP_HOME;
+    CONFIG_PATH = join2(APP_HOME, "config.json");
+    DOCTOR_LOG_DIR = join2(APP_HOME, "logs");
+    PID_FILE = join2(APP_HOME, "daemon.pid");
+    STOP_FLAG_FILE = join2(APP_HOME, "gateway.stopped");
+    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
+        }
+      }
+    };
+    LOCAL_CONFIG = resolve(process.cwd(), "doctor.config.json");
+  }
+});
+
+// src/core/logger.ts
+import { appendFileSync } from "fs";
+import { join as join3 } from "path";
+import chalk from "chalk";
+function initLogger(dir) {
+  logDir = dir ?? DOCTOR_LOG_DIR;
+  ensureDoctorHome();
+}
+function getLogFile() {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return join3(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 {
+  }
+}
+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];
+}
+var logDir, checkHistory, restartHistory, MAX_HISTORY;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    init_config();
+    logDir = DOCTOR_LOG_DIR;
+    checkHistory = [];
+    restartHistory = [];
+    MAX_HISTORY = 100;
+  }
+});
+
+// src/core/openclaw.ts
+import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync } from "fs";
+import { join as join4 } 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";
+function getOpenClawHome(profile) {
+  if (profile === "dev") return join4(homedir2(), ".openclaw-dev");
+  if (profile !== "default") return join4(homedir2(), `.openclaw-${profile}`);
+  return join4(homedir2(), ".openclaw");
+}
+function findOpenClawBin() {
+  const plistDir = join4(homedir2(), "Library", "LaunchAgents");
+  if (existsSync3(plistDir)) {
+    const plists = readdirSync(plistDir).filter(
+      (f) => f.includes("openclaw") && f.endsWith(".plist")
+    );
+    for (const plist of plists) {
+      const content = readFileSync2(join4(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 bin = execSync("which openclaw", { encoding: "utf-8" }).trim();
+    if (bin) return { nodePath: process.execPath, cliBinPath: bin };
+  } catch {
+  }
+  return null;
+}
+function findLaunchdLabel() {
+  const plistDir = join4(homedir2(), "Library", "LaunchAgents");
+  if (!existsSync3(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 = join4(home, "openclaw.json");
+  const logDir2 = join4(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 (!existsSync3(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,
+          model: typeof a.model === "string" ? a.model : a.model?.primary ?? raw.agents?.defaults?.model?.primary ?? void 0,
+          workspace: a.workspace
+        })
+      );
+    }
+  } 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((resolve3) => {
+    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 {
+          resolve3(JSON.parse(data));
+        } catch {
+          resolve3(null);
+        }
+      });
+    });
+    req.on("error", () => resolve3(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve3(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 bootout gui/${uid}/${info.launchdLabel} 2>/dev/null || launchctl kill SIGTERM gui/${uid}/${info.launchdLabel} 2>/dev/null || true`;
+}
+function getStartCommand(info) {
+  const uid = process.getuid?.() ?? 501;
+  const plistDir = `${process.env.HOME}/Library/LaunchAgents`;
+  return `(launchctl bootstrap gui/${uid} ${plistDir}/${info.launchdLabel}.plist 2>/dev/null || true) && launchctl kickstart gui/${uid}/${info.launchdLabel}`;
+}
+var execAsync;
+var init_openclaw = __esm({
+  "src/core/openclaw.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+  }
+});
+
+// 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: [], agentRuntimes: [], durationMs, error };
+  }
+  const channels = health.channels ? Object.entries(health.channels).map(([name, ch]) => ({
+    name,
+    ok: ch.probe?.ok ?? false
+  })) : [];
+  const healthy = health.ok;
+  const agentRuntimes = health.agents ?? [];
+  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, agentRuntimes, durationMs, raw: health };
+}
+var init_health_checker = __esm({
+  "src/core/health-checker.ts"() {
+    "use strict";
+    init_logger();
+    init_openclaw();
+  }
+});
+
+// src/core/process-manager.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+async function runShell(command) {
+  try {
+    const { stdout } = await execAsync2(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 execAsync2, RestartThrottle;
+var init_process_manager = __esm({
+  "src/core/process-manager.ts"() {
+    "use strict";
+    init_logger();
+    init_openclaw();
+    execAsync2 = promisify2(exec2);
+    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/core/workspace-scanner.ts
+import { existsSync as existsSync5, statSync, readdirSync as readdirSync2 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir3 } from "os";
+function expandHome(p) {
+  return p.startsWith("~/") ? join6(homedir3(), p.slice(2)) : p;
+}
+function dirSizeKB(dir, depth = 0) {
+  if (depth > 4 || !existsSync5(dir)) return 0;
+  let total = 0;
+  try {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (["node_modules", ".git", ".DS_Store"].includes(entry.name)) continue;
+      const full = join6(dir, entry.name);
+      if (entry.isDirectory()) {
+        total += dirSizeKB(full, depth + 1);
+      } else {
+        try {
+          total += statSync(full).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return Math.round(total / 1024);
+}
+function scanWorkspaces(info) {
+  const results = [];
+  for (const agent of info.agents) {
+    const workspaceRaw = agent.workspace;
+    if (!workspaceRaw) continue;
+    const workspacePath = expandHome(workspaceRaw);
+    let memoryFileSizeKB = 0;
+    try {
+      const memPath = join6(workspacePath, "MEMORY.md");
+      if (existsSync5(memPath)) {
+        memoryFileSizeKB = Math.round(statSync(memPath).size / 1024);
+      }
+    } catch {
+    }
+    let totalWorkspaceSizeKB = 0;
+    try {
+      totalWorkspaceSizeKB = dirSizeKB(workspacePath);
+    } catch {
+    }
+    let sessionCount = 0;
+    try {
+      const sessDir = join6(homedir3(), ".openclaw", "agents", agent.id, "sessions");
+      if (existsSync5(sessDir)) {
+        sessionCount = readdirSync2(sessDir).filter((f) => f.endsWith(".jsonl") || f.endsWith(".json")).length;
+      }
+    } catch {
+    }
+    results.push({
+      agentId: agent.id,
+      agentName: agent.name,
+      workspacePath,
+      memoryFileSizeKB,
+      memoryWarning: memoryFileSizeKB > 50,
+      totalWorkspaceSizeKB,
+      sessionCount,
+      model: agent.model
+    });
+  }
+  return results;
+}
+var init_workspace_scanner = __esm({
+  "src/core/workspace-scanner.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/cost-scanner.ts
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+function parseSessionCosts(filePath, sinceMs) {
+  let cost = 0;
+  let tokens = 0;
+  try {
+    const lines = readFileSync4(filePath, "utf-8").split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.type !== "message" || !msg.message?.usage?.cost) continue;
+        const ts = msg.timestamp ? new Date(msg.timestamp).getTime() : msg.message?.timestamp ?? 0;
+        if (ts < sinceMs) continue;
+        cost += msg.message.usage.cost.total ?? 0;
+        tokens += msg.message.usage.totalTokens ?? 0;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return { cost, tokens };
+}
+function scanCosts(agents) {
+  const now = Date.now();
+  const todayStart = /* @__PURE__ */ new Date();
+  todayStart.setHours(0, 0, 0, 0);
+  const weekStart = now - 7 * 24 * 3600 * 1e3;
+  const result = [];
+  for (const agent of agents) {
+    const sessDir = join7(homedir4(), ".openclaw", "agents", agent.id, "sessions");
+    if (!existsSync6(sessDir)) continue;
+    let todayCost = 0, weekCost = 0, totalTokens = 0, sessionCount = 0;
+    const files = readdirSync3(sessDir).filter((f) => f.endsWith(".jsonl"));
+    sessionCount = files.length;
+    for (const file of files) {
+      const fpath = join7(sessDir, file);
+      try {
+        const mtime = statSync2(fpath).mtimeMs;
+        if (mtime < weekStart) continue;
+      } catch {
+        continue;
+      }
+      const week = parseSessionCosts(fpath, weekStart);
+      weekCost += week.cost;
+      totalTokens += week.tokens;
+      const today = parseSessionCosts(fpath, todayStart.getTime());
+      todayCost += today.cost;
+    }
+    result.push({ agentId: agent.id, agentName: agent.name, todayCost, weekCost, totalTokens, sessionCount });
+  }
+  return {
+    agents: result,
+    todayTotal: result.reduce((s, a) => s + a.todayCost, 0),
+    weekTotal: result.reduce((s, a) => s + a.weekCost, 0),
+    currency: "USD"
+  };
+}
+var init_cost_scanner = __esm({
+  "src/core/cost-scanner.ts"() {
+    "use strict";
+  }
+});
+
+// src/dashboard/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startDashboard: () => startDashboard
+});
+import { createServer } from "http";
+import { readFileSync as readFileSync5, existsSync as existsSync7, readdirSync as readdirSync4 } from "fs";
+import { join as join8 } from "path";
+import chalk2 from "chalk";
+import { hostname as osHostname } from "os";
+function readDoctorLogs(maxLines = 50) {
+  if (!existsSync7(DOCTOR_LOG_DIR)) return [];
+  const files = readdirSync4(DOCTOR_LOG_DIR).filter((f) => f.endsWith(".log")).sort().reverse();
+  if (files.length === 0) return [];
+  const content = readFileSync5(join8(DOCTOR_LOG_DIR, files[0]), "utf-8");
+  const lines = content.trim().split("\n");
+  return lines.slice(-maxLines);
+}
+function renderShell() {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>OpenClaw Doctor</title>
+  <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
+  <style>
+    * { margin:0; padding:0; box-sizing:border-box; }
+    body { font-family:system-ui,-apple-system,sans-serif; background:#050810; color:#f0f4ff; min-height:100vh; }
+
+    /* Navbar */
+    .navbar { display:flex; align-items:center; justify-content:space-between; padding:0.75rem 1.5rem; background:#0d1424; border-bottom:1px solid #1a2744; flex-wrap:wrap; gap:0.5rem; }
+    .nav-left { display:flex; align-items:center; gap:0.5rem; font-weight:700; font-size:1rem; white-space:nowrap; }
+    .nav-left .ver { font-weight:400; color:#6b7fa3; font-size:0.8rem; }
+    .nav-center { display:flex; align-items:center; gap:0.5rem; }
+    .status-dot { width:10px; height:10px; border-radius:50%; display:inline-block; }
+    .status-label { font-weight:600; font-size:0.9rem; }
+    .nav-right { color:#6b7fa3; font-size:0.75rem; white-space:nowrap; }
+
+    /* Tabs */
+    .tabs { display:flex; border-bottom:1px solid #1a2744; background:#0d1424; overflow-x:auto; }
+    .tab { padding:0.65rem 1.25rem; cursor:pointer; color:#6b7fa3; font-size:0.85rem; border-bottom:2px solid transparent; white-space:nowrap; transition:color 0.15s; }
+    .tab:hover { color:#f0f4ff; }
+    .tab.active { color:#f0f4ff; border-bottom-color:#007AFF; }
+
+    /* Content */
+    .content { padding:1.5rem; max-width:1200px; margin:0 auto; }
+
+    /* Cards */
+    .card { background:#0d1424; border:1px solid #1a2744; border-radius:12px; padding:1.25rem; margin-bottom:1rem; }
+    .card-title { color:#6b7fa3; font-size:0.75rem; text-transform:uppercase; letter-spacing:0.05em; margin-bottom:0.5rem; }
+
+    .big-status { font-size:2rem; font-weight:700; }
+    .meta-row { color:#6b7fa3; font-size:0.8rem; margin-top:0.25rem; }
+
+    .grid2 { display:grid; grid-template-columns:1fr 1fr; gap:1rem; }
+    @media (max-width:768px) { .grid2 { grid-template-columns:1fr; } }
+
+    /* Tables */
+    table { width:100%; border-collapse:collapse; }
+    th, td { text-align:left; padding:0.4rem 0.75rem; border-bottom:1px solid #1a2744; font-size:0.8rem; }
+    th { color:#6b7fa3; font-size:0.7rem; text-transform:uppercase; letter-spacing:0.05em; }
+
+    /* Tags */
+    .tag { display:inline-block; padding:0.15rem 0.5rem; border-radius:9999px; font-size:0.7rem; font-weight:600; }
+    .tag-ok { background:rgba(0,166,126,0.15); color:#00A67E; }
+    .tag-fail { background:#ef444422; color:#ef4444; }
+    .tag-default { background:rgba(0,122,255,0.15); color:#007AFF; font-size:0.65rem; margin-left:0.35rem; }
+
+    /* Buttons */
+    .btn { padding:0.5rem 1rem; border:none; border-radius:0.375rem; cursor:pointer; font-size:0.8rem; font-weight:600; transition:opacity 0.15s; }
+    .btn:hover { opacity:0.85; }
+    .btn:disabled { opacity:0.5; cursor:not-allowed; }
+    .btn-blue { background:#007AFF; color:#fff; }
+    .btn-amber { background:#f59e0b; color:#fff; }
+    .btn-group { display:flex; gap:0.5rem; flex-wrap:wrap; }
+
+    /* Result box */
+    .result-box { margin-top:0.75rem; padding:0.75rem; background:#030609; border-radius:8px; font-size:0.75rem; font-family:ui-monospace,monospace; white-space:pre-wrap; word-break:break-all; max-height:200px; overflow-y:auto; }
+
+    /* Logs */
+    .log-line { font-family:ui-monospace,monospace; font-size:0.75rem; padding:0.2rem 0; line-height:1.4; word-break:break-all; }
+    .log-info { color:#6b7fa3; }
+    .log-warn { color:#eab308; }
+    .log-error { color:#ef4444; }
+    .log-success { color:#00A67E; }
+
+    /* Config */
+    .cfg-row { display:flex; justify-content:space-between; padding:0.5rem 0; border-bottom:1px solid #1a2744; font-size:0.85rem; }
+    .cfg-key { color:#6b7fa3; }
+    .cfg-val { color:#f0f4ff; font-family:ui-monospace,monospace; }
+
+    /* Loading */
+    .loading { color:#6b7fa3; text-align:center; padding:3rem 0; }
+  </style>
+</head>
+<body x-data="dashboard()" x-init="init()">
+
+  <!-- Navbar -->
+  <div class="navbar">
+    <div class="nav-left">
+      <span>&#129438; OpenClaw Doctor</span>
+      <span class="ver">v${pkgVersion}</span>
+    </div>
+    <div class="nav-center">
+      <span class="status-dot" :style="'background:' + statusColor"></span>
+      <span class="status-label" :style="'color:' + statusColor" x-text="statusText"></span>
+    </div>
+    <div class="nav-actions" style="display:flex;gap:0.5rem;align-items:center;">
+      <button class="btn" style="background:#00A67E;color:#fff;padding:0.35rem 0.75rem;font-size:0.75rem;" :disabled="actionLoading" @click="doStart()">\u25B6 Start</button>
+      <button class="btn btn-blue" style="padding:0.35rem 0.75rem;font-size:0.75rem;" :disabled="actionLoading" @click="doRestart()">\u21BA Restart</button>
+      <button class="btn" style="background:#ef4444;color:#fff;padding:0.35rem 0.75rem;font-size:0.75rem;" :disabled="actionLoading" @click="doStop()">\u25A0 Stop</button>
+    </div>
+    <div class="nav-right" x-text="lastCheck ? 'Updated ' + lastCheck : 'Loading...'"></div>
+  </div>
+
+  <!-- Tabs -->
+  <div class="tabs">
+    <template x-for="t in ['Overview','Cost','Restarts','Logs','Config']">
+      <div class="tab" :class="{ active: tab === t }" @click="tab = t" x-text="t"></div>
+    </template>
+  </div>
+
+  <!-- Content -->
+  <div class="content">
+
+    <!-- Loading state -->
+    <template x-if="!loaded">
+      <div class="loading">Loading...</div>
+    </template>
+
+    <!-- Overview Tab -->
+    <template x-if="loaded && tab === 'Overview'">
+      <div>
+        <div class="card">
+          <div class="big-status" :style="'color:' + statusColor" x-text="statusText"></div>
+          <div class="meta-row">
+            Gateway :<span x-text="data.info?.gatewayPort ?? '?'"></span>
+            &nbsp;|&nbsp; Latency: <span x-text="(data.durationMs ?? '-') + 'ms'"></span>
+            &nbsp;|&nbsp; Profile: <span x-text="data.info?.profile ?? '?'"></span>
+            &nbsp;|&nbsp; OpenClaw <span x-text="data.info?.version ?? '?'"></span>
+          </div>
+        </div>
+
+        <div class="grid2">
+          <!-- Channels -->
+          <div class="card">
+            <div class="card-title">Channels</div>
+            <template x-if="data.channels && data.channels.length > 0">
+              <table>
+                <thead><tr><th>Name</th><th>Status</th></tr></thead>
+                <tbody>
+                  <template x-for="c in data.channels" :key="c.name">
+                    <tr>
+                      <td x-text="c.name"></td>
+                      <td><span class="tag" :class="c.ok ? 'tag-ok' : 'tag-fail'" x-text="c.ok ? 'OK' : 'FAIL'"></span></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </template>
+            <template x-if="!data.channels || data.channels.length === 0">
+              <div style="color:#6b7fa3;font-size:0.8rem;">No channels</div>
+            </template>
+          </div>
+
+          <!-- Agents -->
+          <div class="card">
+            <div class="card-title">Agents</div>
+            <template x-if="data.agents && data.agents.length > 0">
+              <table>
+                <thead><tr><th>Name</th><th>Model</th><th>Sessions</th><th>Last Active</th><th></th></tr></thead>
+                <tbody>
+                  <template x-for="a in data.agents" :key="a.id">
+                    <tr x-data="{ rt() { return (data.agentRuntimes||[]).find(r=>r.agentId===a.id) } }">
+                      <td x-text="a.name"></td>
+                      <td style="color:#6b7fa3;font-size:0.78rem;" x-text="a.model ? a.model.replace('anthropic/','').replace('openai/','') : '\u2014'"></td>
+                      <td style="color:#6b7fa3;font-size:0.78rem;" x-text="rt()?.sessions?.count ?? '\u2014'"></td>
+                      <td style="font-size:0.78rem;" x-text="rt()?.sessions?.recent?.[0]?.age != null ? (rt().sessions.recent[0].age < 60000 ? 'just now' : rt().sessions.recent[0].age < 3600000 ? Math.floor(rt().sessions.recent[0].age/60000)+'m ago' : Math.floor(rt().sessions.recent[0].age/3600000)+'h ago') : '\u2014'"></td>
+                      <td><template x-if="a.isDefault"><span class="tag tag-default">default</span></template></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </template>
+            <template x-if="!data.agents || data.agents.length === 0">
+              <div style="color:#6b7fa3;font-size:0.8rem;">No agents</div>
+            </template>
+          </div>
+        </div>
+
+        <!-- Recent checks -->
+        <div class="card">
+          <div class="card-title">Recent Health Checks</div>
+          <template x-if="data.checks && data.checks.length > 0">
+            <div style="overflow-x:auto;">
+              <table>
+                <thead><tr><th>Time</th><th>Status</th><th>Latency</th><th>Error</th></tr></thead>
+                <tbody>
+                  <template x-for="c in data.checks.slice().reverse().slice(0, 10)" :key="c.timestamp">
+                    <tr>
+                      <td x-text="fmtTime(c.timestamp)"></td>
+                      <td><span class="tag" :class="c.healthy ? 'tag-ok' : 'tag-fail'" x-text="c.healthy ? 'OK' : 'FAIL'"></span></td>
+                      <td x-text="(c.responseTime ?? '-') + 'ms'"></td>
+                      <td style="color:#ef4444;" x-text="c.error ?? ''"></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </div>
+          </template>
+          <template x-if="!data.checks || data.checks.length === 0">
+            <div style="color:#6b7fa3;font-size:0.8rem;">No checks yet</div>
+          </template>
+        </div>
+      </div>
+    </template>
+
+    
+        <!-- Workspace Health -->
+        <div class="card">
+          <div class="card-title">Workspace Health</div>
+          <template x-if="data.workspaces && data.workspaces.length > 0">
+            <table>
+              <thead><tr><th>Agent</th><th>MEMORY.md</th><th>Sessions</th><th>Workspace Size</th><th></th></tr></thead>
+              <tbody>
+                <template x-for="w in data.workspaces" :key="w.agentId">
+                  <tr>
+                    <td x-text="w.agentName"></td>
+                    <td x-text="w.memoryFileSizeKB + ' KB'"></td>
+                    <td x-text="w.sessionCount"></td>
+                    <td x-text="w.totalWorkspaceSizeKB + ' KB'"></td>
+                    <td>
+                      <template x-if="w.memoryWarning">
+                        <span class="tag" style="background:rgba(245,158,11,0.15);color:#f59e0b;">\u26A0 Large</span>
+                      </template>
+                    </td>
+                  </tr>
+                </template>
+              </tbody>
+            </table>
+          </template>
+          <template x-if="!data.workspaces || data.workspaces.length === 0">
+            <div style="color:#6b7fa3;font-size:0.8rem;">No workspace data</div>
+          </template>
+        </div>
+
+        <!-- Restarts Tab -->
+    <template x-if="loaded && tab === 'Restarts'">
+      <div>
+        <div class="card">
+          <div class="card-title">Actions</div>
+          <div class="btn-group">
+            <button class="btn btn-blue" :disabled="actionLoading" @click="doRestart()">Restart Gateway</button>
+            <button class="btn btn-amber" :disabled="actionLoading" @click="doDoctor()">Run Doctor Fix</button>
+          </div>
+          <template x-if="actionResult">
+            <div class="result-box" x-text="actionResult"></div>
+          </template>
+        </div>
+
+        <div class="card">
+          <div class="card-title">Restart History</div>
+          <template x-if="data.restarts && data.restarts.length > 0">
+            <div style="overflow-x:auto;">
+              <table>
+                <thead><tr><th>Time</th><th>Reason</th><th>Result</th></tr></thead>
+                <tbody>
+                  <template x-for="r in data.restarts.slice().reverse()" :key="r.timestamp">
+                    <tr>
+                      <td x-text="fmtTime(r.timestamp)"></td>
+                      <td x-text="r.reason"></td>
+                      <td><span class="tag" :class="r.success ? 'tag-ok' : 'tag-fail'" x-text="r.success ? 'OK' : 'FAIL'"></span></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </div>
+          </template>
+          <template x-if="!data.restarts || data.restarts.length === 0">
+            <div style="color:#6b7fa3;font-size:0.8rem;">No restarts</div>
+          </template>
+        </div>
+      </div>
+    </template>
+
+    <!-- Logs Tab -->
+    <template x-if="loaded && tab === 'Logs'">
+      <div>
+        <div class="card">
+          <div class="card-title">Doctor Logs (latest 50)</div>
+          <template x-if="logs.length > 0">
+            <div style="max-height:600px;overflow-y:auto;">
+              <template x-for="(line, i) in logs" :key="i">
+                <div class="log-line" :class="logClass(line)" x-text="line"></div>
+              </template>
+            </div>
+          </template>
+          <template x-if="logs.length === 0">
+            <div style="color:#6b7fa3;font-size:0.8rem;">No logs yet</div>
+          </template>
+        </div>
+      </div>
+    </template>
+
+    <!-- Cost Tab -->
+    <template x-if="loaded && tab === 'Cost'">
+      <div>
+        <template x-if="costData">
+          <div>
+            <div style="display:grid;grid-template-columns:1fr 1fr;gap:1rem;margin-bottom:1rem;">
+              <div class="card" style="text-align:center;">
+                <div class="card-title">Today</div>
+                <div style="font-size:2rem;font-weight:700;color:#f0f4ff;" x-text="'$' + (costData.todayTotal||0).toFixed(4)"></div>
+              </div>
+              <div class="card" style="text-align:center;">
+                <div class="card-title">This Week</div>
+                <div style="font-size:2rem;font-weight:700;color:#f0f4ff;" x-text="'$' + (costData.weekTotal||0).toFixed(4)"></div>
+              </div>
+            </div>
+            <div class="card">
+              <div class="card-title">By Agent</div>
+              <table>
+                <thead><tr><th>Agent</th><th>Today</th><th>This Week</th><th>Sessions</th></tr></thead>
+                <tbody>
+                  <template x-for="a in costData.agents" :key="a.agentId">
+                    <tr>
+                      <td x-text="a.agentName"></td>
+                      <td x-text="'$' + (a.todayCost||0).toFixed(4)"></td>
+                      <td x-text="'$' + (a.weekCost||0).toFixed(4)"></td>
+                      <td style="color:#6b7fa3;" x-text="a.sessionCount"></td>
+                    </tr>
+                  </template>
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </template>
+        <template x-if="!costData">
+          <div class="loading">Loading cost data...</div>
+        </template>
+      </div>
+    </template>
+
+    <!-- Config Tab -->
+    <template x-if="loaded && tab === 'Config'">
+      <div>
+        <div class="card">
+          <div class="card-title">Current Configuration</div>
+          <template x-if="data.config">
+            <div>
+              <div class="cfg-row"><span class="cfg-key">checkInterval</span><span class="cfg-val" x-text="data.config.checkInterval + 's'"></span></div>
+              <div class="cfg-row"><span class="cfg-key">failThreshold</span><span class="cfg-val" x-text="data.config.failThreshold"></span></div>
+              <div class="cfg-row"><span class="cfg-key">dashboardPort</span><span class="cfg-val" x-text="data.config.dashboardPort"></span></div>
+              <div class="cfg-row"><span class="cfg-key">maxRestartsPerHour</span><span class="cfg-val" x-text="data.config.maxRestartsPerHour"></span></div>
+              <div class="cfg-row"><span class="cfg-key">openclawProfile</span><span class="cfg-val" x-text="data.config.openclawProfile"></span></div>
+              <div class="cfg-row"><span class="cfg-key">notify.webhook.enabled</span><span class="cfg-val" x-text="data.config.notify?.webhook?.enabled ?? false"></span></div>
+              <div class="cfg-row"><span class="cfg-key">notify.system.enabled</span><span class="cfg-val" x-text="data.config.notify?.system?.enabled ?? false"></span></div>
+            </div>
+          </template>
+        </div>
+      </div>
+    </template>
+
+  </div>
+
+  <script>
+    function dashboard() {
+      return {
+        tab: 'Overview',
+        costData: null,
+        loaded: false,
+        data: {},
+        logs: [],
+        lastCheck: '',
+        actionLoading: false,
+        actionResult: '',
+
+        get statusText() {
+          if (!this.data || !this.loaded) return 'LOADING';
+          if (this.data.healthy) return 'HEALTHY';
+          if (this.data.gateway) return 'DEGRADED';
+          return 'UNREACHABLE';
+        },
+
+        get statusColor() {
+          if (!this.data || !this.loaded) return '#64748b';
+          if (this.data.healthy) return '#00A67E';
+          if (this.data.gateway) return '#f59e0b';
+          return '#ef4444';
+        },
+
+        async init() {
+          await this.refresh();
+          await this.refreshLogs();
+          setInterval(() => this.refresh(), 10000);
+          setInterval(() => this.refreshLogs(), 10000);
+        },
+
+        async refresh() {
+          try {
+            const res = await fetch('/api/status');
+            this.data = await res.json();
+            this.lastCheck = new Date().toLocaleTimeString();
+            this.loaded = true;
+          } catch (e) {
+            console.error('Failed to fetch status', e);
+          }
+        },
+
+        async refreshCost() {
+          try {
+            const r = await fetch('/api/cost');
+            this.costData = await r.json();
+          } catch {}
+        },
+        async refreshLogs() {
+          try {
+            const res = await fetch('/api/logs');
+            const d = await res.json();
+            this.logs = d.lines ?? [];
+          } catch (e) {
+            console.error('Failed to fetch logs', e);
+          }
+        },
+
+        async doRestart() {
+          this.actionLoading = true;
+          this.actionResult = '';
+          try {
+            const res = await fetch('/api/restart', { method: 'POST' });
+            const d = await res.json();
+            this.actionResult = d.success ? 'Gateway restarted successfully.' : ('Restart failed: ' + (d.error ?? 'unknown'));
+            await this.refresh();
+          } catch (e) {
+            this.actionResult = 'Request failed: ' + e.message;
+          }
+          this.actionLoading = false;
+        },
+
+        async doStart() {
+          this.actionLoading = true;
+          this.actionResult = '';
+          try {
+            const res = await fetch('/api/gateway/start', { method: 'POST' });
+            const d = await res.json();
+            this.actionResult = d.success ? 'Gateway started.' : ('Start failed: ' + (d.message ?? 'unknown'));
+            await this.refresh();
+          } catch (e) {
+            this.actionResult = 'Request failed: ' + e.message;
+          }
+          this.actionLoading = false;
+        },
+
+        async doStop() {
+          this.actionLoading = true;
+          this.actionResult = '';
+          try {
+            const res = await fetch('/api/gateway/stop', { method: 'POST' });
+            const d = await res.json();
+            this.actionResult = d.success ? 'Gateway stopped.' : ('Stop failed: ' + (d.message ?? 'unknown'));
+            await this.refresh();
+          } catch (e) {
+            this.actionResult = 'Request failed: ' + e.message;
+          }
+          this.actionLoading = false;
+        },
+
+        async doDoctor() {
+          this.actionLoading = true;
+          this.actionResult = '';
+          try {
+            const res = await fetch('/api/doctor', { method: 'POST' });
+            const d = await res.json();
+            this.actionResult = d.output ?? 'No output';
+          } catch (e) {
+            this.actionResult = 'Request failed: ' + e.message;
+          }
+          this.actionLoading = false;
+        },
+
+        fmtTime(iso) {
+          if (!iso) return '';
+          try { return new Date(iso).toLocaleString(); } catch { return iso; }
+        },
+
+        logClass(line) {
+          if (line.includes('[ERROR]')) return 'log-error';
+          if (line.includes('[WARN]')) return 'log-warn';
+          if (line.includes('[SUCCESS]')) return 'log-success';
+          return 'log-info';
+        }
+      };
+    }
+  </script>
+</body>
+</html>`;
+}
+async function handleApiStatus(info, configPath, res) {
+  try {
+    const live = await checkHealth(info);
+    const config = loadConfig(configPath);
+    const workspaces = scanWorkspaces(info);
+    const agentRuntimes = live.agentRuntimes ?? [];
+    const payload = {
+      healthy: live.healthy,
+      gateway: live.gateway,
+      channels: live.channels,
+      agents: info.agents,
+      agentRuntimes,
+      durationMs: live.durationMs,
+      checks: getCheckHistory(),
+      restarts: getRestartHistory(),
+      config,
+      workspaces,
+      info: {
+        version: info.version,
+        gatewayPort: info.gatewayPort,
+        profile: info.profile
+      }
+    };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(payload));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+async function handleApiRestart(info, res) {
+  try {
+    const result = await restartGateway(info);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: result.success, message: result.output ?? result.error ?? "" }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: false, message: String(err) }));
+  }
+}
+async function handleApiGatewayStart(info, res) {
+  try {
+    const result = await startGateway(info);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: result.success, message: result.output ?? result.error ?? "" }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: false, message: String(err) }));
+  }
+}
+async function handleApiGatewayStop(info, res) {
+  try {
+    const result = await stopGateway(info);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: result.success, message: result.output ?? result.error ?? "" }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ success: false, message: String(err) }));
+  }
+}
+async function handleApiDoctor(info, res) {
+  try {
+    const output = await runOpenClawCmd(info, "doctor --non-interactive");
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ output: output ?? "No output" }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ output: "Error: " + String(err) }));
+  }
+}
+async function handleApiCost(info, res) {
+  try {
+    const costs = scanCosts(info.agents);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(costs));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+function handleApiLogs(res) {
+  const lines = readDoctorLogs(50);
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ lines }));
+}
+function startDashboard(options) {
+  const config = loadConfig(options.config);
+  const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  const port = config.dashboardPort;
+  const shell = renderShell();
+  const server = createServer(async (req, res) => {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    if (method === "GET" && url === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(shell);
+    } else if (method === "GET" && url === "/api/status") {
+      await handleApiStatus(info, options.config, res);
+    } else if (method === "GET" && url === "/api/cost") {
+      await handleApiCost(info, res);
+    } else if (method === "GET" && url === "/api/logs") {
+      handleApiLogs(res);
+    } else if (method === "POST" && url === "/api/restart") {
+      await handleApiRestart(info, res);
+    } else if (method === "POST" && url === "/api/gateway/start") {
+      await handleApiGatewayStart(info, res);
+    } else if (method === "POST" && url === "/api/gateway/stop") {
+      await handleApiGatewayStop(info, res);
+    } else if (method === "POST" && url === "/api/doctor") {
+      await handleApiDoctor(info, res);
+    } else {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found" }));
+    }
+  });
+  server.listen(port, () => {
+    log("info", `Dashboard running at http://localhost:${port}`);
+    console.log(chalk2.green.bold(`
+  Dashboard: http://localhost:${port}
+`));
+  });
+  const REMOTE_CONFIG_PATH = join8(DOCTOR_HOME, "remote.json");
+  const REMOTE_API_URL2 = "https://api.openclaw-cli.app";
+  let gatewayStartTime = null;
+  const proxyFetch2 = async (url, opts) => {
+    const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.ALL_PROXY || process.env.all_proxy;
+    if (proxyUrl) {
+      try {
+        const { ProxyAgent, fetch: uf } = await import("undici");
+        return uf(url, { ...opts, dispatcher: new ProxyAgent(proxyUrl) });
+      } catch {
+      }
+    }
+    return fetch(url, opts);
+  };
+  const HEARTBEAT_INTERVAL_MS = 10 * 60 * 1e3;
+  const POLL_INTERVAL_MS = 3e4;
+  let lastReportedHealthy = null;
+  let lastReportedChannels = "";
+  let lastReportedAt = 0;
+  const doReport = async (reason) => {
+    try {
+      if (!existsSync7(REMOTE_CONFIG_PATH)) return;
+      const cfg = JSON.parse(readFileSync5(REMOTE_CONFIG_PATH, "utf-8"));
+      if (!cfg.enabled || !cfg.machineToken) return;
+      const status = await checkHealth(info);
+      if (status.healthy) {
+        if (!gatewayStartTime) gatewayStartTime = Date.now();
+      } else {
+        gatewayStartTime = null;
+      }
+      const uptimeSeconds = gatewayStartTime ? Math.floor((Date.now() - gatewayStartTime) / 1e3) : 0;
+      const body = {
+        machineId: cfg.machineId,
+        hostname: osHostname(),
+        os: process.platform + "/" + process.arch,
+        version: pkgVersion ?? "unknown",
+        gateway: {
+          healthy: status.healthy,
+          port: info.gatewayPort,
+          durationMs: status.durationMs ?? 0,
+          label: info.launchdLabel ?? "",
+          uptimeSeconds
+        },
+        agents: info.agents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          isDefault: a.isDefault
+        })),
+        channels: status.channels ?? [],
+        ts: Date.now()
+      };
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 5e3);
+      await proxyFetch2(cfg.reportUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + cfg.machineToken
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      lastReportedHealthy = status.healthy;
+      lastReportedChannels = JSON.stringify(status.channels ?? []);
+      lastReportedAt = Date.now();
+      log("info", `[remote-report] sent (reason=${reason})`);
+    } catch {
+    }
+  };
+  setInterval(async () => {
+    try {
+      if (!existsSync7(REMOTE_CONFIG_PATH)) return;
+      const cfg = JSON.parse(readFileSync5(REMOTE_CONFIG_PATH, "utf-8"));
+      if (!cfg.enabled || !cfg.machineToken) return;
+      const status = await checkHealth(info);
+      const channelsKey = JSON.stringify(status.channels ?? []);
+      const now = Date.now();
+      const healthChanged = lastReportedHealthy !== status.healthy;
+      const channelsChanged = lastReportedChannels !== channelsKey;
+      const heartbeatDue = now - lastReportedAt >= HEARTBEAT_INTERVAL_MS;
+      if (healthChanged || channelsChanged || heartbeatDue) {
+        const reason = healthChanged ? "health-change" : channelsChanged ? "channels-change" : "heartbeat";
+        await doReport(reason);
+      }
+    } catch {
+    }
+  }, POLL_INTERVAL_MS);
+  const executedCommands = /* @__PURE__ */ new Set();
+  setInterval(async () => {
+    try {
+      if (!existsSync7(REMOTE_CONFIG_PATH)) return;
+      const cfg = JSON.parse(readFileSync5(REMOTE_CONFIG_PATH, "utf-8"));
+      if (!cfg.enabled || !cfg.machineToken) return;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), 3e3);
+      const res = await proxyFetch2(REMOTE_API_URL2 + "/v1/control/pending", {
+        headers: { Authorization: "Bearer " + cfg.machineToken },
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!res.ok) return;
+      const data = await res.json();
+      const cmd = data.command;
+      if (!cmd || executedCommands.has(cmd.commandId)) return;
+      executedCommands.add(cmd.commandId);
+      log("info", `[remote-control] action=${cmd.action} commandId=${cmd.commandId}`);
+      let ok = true;
+      let error;
+      try {
+        if (cmd.action === "start") {
+          await startGateway(info);
+          gatewayStartTime = Date.now();
+        } else if (cmd.action === "stop") {
+          await stopGateway(info);
+          gatewayStartTime = null;
+        } else if (cmd.action === "restart") {
+          await restartGateway(info);
+          gatewayStartTime = Date.now();
+        }
+      } catch (err) {
+        ok = false;
+        error = String(err);
+        log("warn", `[remote-control] failed: ${error}`);
+      }
+      const ackCtrl = new AbortController();
+      const ackTimer = setTimeout(() => ackCtrl.abort(), 3e3);
+      await proxyFetch2(REMOTE_API_URL2 + "/v1/control/ack", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer " + cfg.machineToken
+        },
+        body: JSON.stringify({ commandId: cmd.commandId, ok, error }),
+        signal: ackCtrl.signal
+      }).catch(() => {
+      });
+      clearTimeout(ackTimer);
+    } catch {
+    }
+  }, 15e3);
+}
+var _PKG_VER, pkgVersion;
+var init_server = __esm({
+  "src/dashboard/server.ts"() {
+    "use strict";
+    init_config();
+    init_openclaw();
+    init_health_checker();
+    init_logger();
+    init_process_manager();
+    init_workspace_scanner();
+    init_cost_scanner();
+    _PKG_VER = true ? "0.6.1" : "0.2.1";
+    pkgVersion = _PKG_VER;
+  }
+});
 
 // src/index.ts
+init_brand();
 import { spawnSync } from "child_process";
 import { Command } from "commander";
 
 // src/commands/watch.ts
+init_config();
+init_logger();
+init_health_checker();
+init_process_manager();
+init_openclaw();
 import { spawn } from "child_process";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, unlinkSync, openSync } from "fs";
-import chalk from "chalk";
-import { join as join2 } from "path";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync6, existsSync as existsSync8, unlinkSync, openSync } from "fs";
+import chalk3 from "chalk";
+import { join as join9 } from "path";
 
 // src/telemetry.ts
+init_brand();
 import { createHash, randomUUID } from "crypto";
-import { execSync } from "child_process";
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 var MEASUREMENT_ID = "G-B46J8RT804";
 var API_SECRET = "qkqms1nURj2S02Q3WqO7GQ";
 var ENDPOINT = `https://www.google-analytics.com/mp/collect?measurement_id=${MEASUREMENT_ID}&api_secret=${API_SECRET}`;
-var TELEMETRY_FILE = join(APP_HOME, "telemetry.json");
+var TELEMETRY_FILE = join5(APP_HOME, "telemetry.json");
 function loadState() {
-  if (existsSync(TELEMETRY_FILE)) {
+  if (existsSync4(TELEMETRY_FILE)) {
     try {
-      return JSON.parse(readFileSync(TELEMETRY_FILE, "utf-8"));
+      return JSON.parse(readFileSync3(TELEMETRY_FILE, "utf-8"));
     } catch {
     }
   }
@@ -56,7 +1387,7 @@ function loadState() {
 }
 function saveState(state) {
   try {
-    writeFileSync(TELEMETRY_FILE, JSON.stringify(state, null, 2) + "\n");
+    writeFileSync2(TELEMETRY_FILE, JSON.stringify(state, null, 2) + "\n");
   } catch {
   }
 }
@@ -65,7 +1396,7 @@ function sha256(input) {
 }
 function tryExec(cmd) {
   try {
-    return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }).toString().trim();
+    return execSync2(cmd, { stdio: ["ignore", "pipe", "ignore"], timeout: 2e3 }).toString().trim();
   } catch {
     return null;
   }
@@ -165,7 +1496,7 @@ async function watchDaemon(options) {
   initLogger();
   ensureDoctorHome();
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
-  writeFileSync2(PID_FILE, String(process.pid));
+  writeFileSync3(PID_FILE, String(process.pid));
   trackCommand("watch start", true).catch(() => {
   });
   log("info", "OpenClaw Doctor started (foreground)");
@@ -174,7 +1505,7 @@ async function watchDaemon(options) {
   log("info", `Check interval: ${config.checkInterval}s`);
   log("info", `PID: ${process.pid}`);
   if (options.dashboard) {
-    const { startDashboard: startDashboard2 } = await import("./server-GZ3MD6AH.js");
+    const { startDashboard: startDashboard2 } = await Promise.resolve().then(() => (init_server(), server_exports));
     startDashboard2({ config: options.config });
   }
   const throttle = new RestartThrottle(config.maxRestartsPerHour);
@@ -182,6 +1513,10 @@ async function watchDaemon(options) {
   let isRestarting = false;
   async function tick() {
     if (isRestarting) return;
+    if (existsSync8(STOP_FLAG_FILE)) {
+      log("info", "Gateway is manually stopped \u2014 skipping auto-restart");
+      return;
+    }
     const result = await checkHealth(info);
     if (result.healthy) {
       consecutiveFailures = 0;
@@ -204,7 +1539,7 @@ async function watchDaemon(options) {
       consecutiveFailures = 0;
       throttle.record();
       await restartGateway(info);
-      log("info", "Waiting 30s for gateway to start...");
+      log("info", "Waiting 60s for gateway to start...");
       await new Promise((r) => setTimeout(r, 6e4));
       isRestarting = false;
     }
@@ -226,7 +1561,7 @@ function daemonize(options) {
   ensureDoctorHome();
   const existingPid = readDaemonPid();
   if (existingPid && isProcessAlive(existingPid)) {
-    console.log(chalk.yellow(`Doctor is already running (PID ${existingPid})`));
+    console.log(chalk3.yellow(`Doctor is already running (PID ${existingPid})`));
     return;
   }
   const execArgv = process.execArgv.filter(
@@ -236,8 +1571,8 @@ function daemonize(options) {
     (a) => a !== "-d" && a !== "--daemon"
   );
   const fullArgs = [...execArgv, ...scriptArgs];
-  const outLog = join2(DOCTOR_LOG_DIR, "daemon.out.log");
-  const errLog = join2(DOCTOR_LOG_DIR, "daemon.err.log");
+  const outLog = join9(DOCTOR_LOG_DIR, "daemon.out.log");
+  const errLog = join9(DOCTOR_LOG_DIR, "daemon.err.log");
   const out = openSync(outLog, "a");
   const err = openSync(errLog, "a");
   const child = spawn(process.execPath, fullArgs, {
@@ -246,20 +1581,20 @@ function daemonize(options) {
     env: { ...process.env, OPENCLAW_DOCTOR_DAEMON: "1" }
   });
   const pid = child.pid;
-  writeFileSync2(PID_FILE, String(pid));
+  writeFileSync3(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`));
+  console.log(chalk3.green(`Doctor started in background (PID ${pid})`));
+  console.log(chalk3.gray(`  Logs: ${outLog}`));
+  console.log(chalk3.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)"));
+    console.log(chalk3.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)`));
+    console.log(chalk3.yellow(`Doctor is not running (PID ${pid} is dead, cleaning up)`));
     try {
       unlinkSync(PID_FILE);
     } catch {
@@ -268,11 +1603,11 @@ async function stopDaemon(options) {
   }
   try {
     process.kill(pid, "SIGTERM");
-    console.log(chalk.green(`Doctor stopped (PID ${pid})`));
+    console.log(chalk3.green(`Doctor stopped (PID ${pid})`));
     trackCommand("watch stop", true).catch(() => {
     });
   } catch (err) {
-    console.log(chalk.red(`Failed to stop Doctor (PID ${pid}): ${err}`));
+    console.log(chalk3.red(`Failed to stop Doctor (PID ${pid}): ${err}`));
     trackCommand("watch stop", false).catch(() => {
     });
   }
@@ -283,8 +1618,8 @@ async function stopDaemon(options) {
   }
 }
 function readDaemonPid() {
-  if (!existsSync2(PID_FILE)) return null;
-  const raw = readFileSync2(PID_FILE, "utf-8").trim();
+  if (!existsSync8(PID_FILE)) return null;
+  const raw = readFileSync6(PID_FILE, "utf-8").trim();
   const pid = parseInt(raw, 10);
   return isNaN(pid) ? null : pid;
 }
@@ -298,7 +1633,10 @@ function isProcessAlive(pid) {
 }
 
 // src/commands/status.ts
-import chalk2 from "chalk";
+init_config();
+init_openclaw();
+init_health_checker();
+import chalk4 from "chalk";
 async function showStatus(options) {
   const config = loadConfig(options.config);
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
@@ -332,32 +1670,32 @@ async function showStatus(options) {
     process.exit(result.healthy ? 0 : 1);
     return;
   }
-  console.log(chalk2.bold("\n  OpenClaw Doctor\n"));
+  console.log(chalk4.bold("\n  OpenClaw Doctor\n"));
   if (result.healthy) {
     console.log(
-      chalk2.green.bold(`  Gateway: HEALTHY`) + chalk2.gray(` (port ${info.gatewayPort}, ${result.durationMs}ms)`)
+      chalk4.green.bold(`  Gateway: HEALTHY`) + chalk4.gray(` (port ${info.gatewayPort}, ${result.durationMs}ms)`)
     );
   } else if (result.gateway) {
-    console.log(chalk2.yellow.bold(`  Gateway: DEGRADED`) + chalk2.gray(` (responded but ok=false)`));
+    console.log(chalk4.yellow.bold(`  Gateway: DEGRADED`) + chalk4.gray(` (responded but ok=false)`));
   } else {
-    console.log(chalk2.red.bold(`  Gateway: UNREACHABLE`));
-    if (result.error) console.log(chalk2.red(`  ${result.error}`));
+    console.log(chalk4.red.bold(`  Gateway: UNREACHABLE`));
+    if (result.error) console.log(chalk4.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}`);
+      const icon = ch.ok ? chalk4.green("ok") : chalk4.red("fail");
+      console.log(`  ${chalk4.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(chalk4.gray(`  Agents: ${agentList}`));
   }
   console.log();
-  console.log(chalk2.gray(`  OpenClaw ${info.version ?? "unknown"}`));
-  console.log(chalk2.gray(`  Config: ${info.configPath}`));
+  console.log(chalk4.gray(`  OpenClaw ${info.version ?? "unknown"}`));
+  console.log(chalk4.gray(`  Config: ${info.configPath}`));
   console.log();
   trackCommand("status", true).catch(() => {
   });
@@ -365,13 +1703,16 @@ async function showStatus(options) {
 }
 
 // src/commands/doctor.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3 } from "fs";
-import chalk3 from "chalk";
+init_config();
+init_openclaw();
+init_health_checker();
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9 } from "fs";
+import chalk5 from "chalk";
 function findConfigIssues(configPath) {
-  if (!existsSync3(configPath)) return [];
+  if (!existsSync9(configPath)) return [];
   let raw;
   try {
-    raw = JSON.parse(readFileSync3(configPath, "utf-8"));
+    raw = JSON.parse(readFileSync7(configPath, "utf-8"));
   } catch {
     return [{ path: "root", message: "Config file is not valid JSON", fix: () => {
     } }];
@@ -398,7 +1739,7 @@ function findConfigIssues(configPath) {
       const origFix = originalFixes[i];
       issues[i].fix = () => {
         origFix();
-        writeFileSync3(configPath, JSON.stringify(raw, null, 2) + "\n");
+        writeFileSync4(configPath, JSON.stringify(raw, null, 2) + "\n");
       };
     }
   }
@@ -407,53 +1748,53 @@ function findConfigIssues(configPath) {
 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"));
+  console.log(chalk5.bold("\n  OpenClaw Doctor \u2014 Full Diagnostics\n"));
+  console.log(chalk5.gray("  [0/4] Config validation"));
   const issues = findConfigIssues(info.configPath);
   if (issues.length === 0) {
-    console.log(chalk3.green("    Config: valid"));
+    console.log(chalk5.green("    Config: valid"));
   } else {
     for (const issue of issues) {
-      console.log(chalk3.red(`    ${issue.path}: ${issue.message}`));
+      console.log(chalk5.red(`    ${issue.path}: ${issue.message}`));
     }
     if (options.fix) {
       for (const issue of issues) {
         issue.fix();
-        console.log(chalk3.green(`    Fixed: ${issue.path}`));
+        console.log(chalk5.green(`    Fixed: ${issue.path}`));
       }
-      console.log(chalk3.green(`    Config saved: ${info.configPath}`));
+      console.log(chalk5.green(`    Config saved: ${info.configPath}`));
     } else {
-      console.log(chalk3.yellow("    Run with --fix to auto-repair"));
+      console.log(chalk5.yellow("    Run with --fix to auto-repair"));
     }
   }
-  console.log(chalk3.gray("\n  [1/4] OpenClaw binary"));
+  console.log(chalk5.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}`));
+    console.log(chalk5.green(`    Found: ${info.cliBinPath}`));
+    console.log(chalk5.gray(`    Node: ${info.nodePath}`));
+    if (info.version) console.log(chalk5.gray(`    Version: ${info.version}`));
   } else {
-    console.log(chalk3.red("    Not found \u2014 openclaw CLI is not installed or not in PATH"));
+    console.log(chalk5.red("    Not found \u2014 openclaw CLI is not installed or not in PATH"));
   }
-  console.log(chalk3.gray("\n  [2/4] Gateway health"));
+  console.log(chalk5.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)`));
+    console.log(chalk5.green(`    Gateway: healthy (port ${info.gatewayPort}, ${result.durationMs}ms)`));
   } else if (result.gateway) {
-    console.log(chalk3.yellow(`    Gateway: responded but degraded`));
+    console.log(chalk5.yellow(`    Gateway: responded but degraded`));
   } else {
-    console.log(chalk3.red(`    Gateway: unreachable`));
-    if (result.error) console.log(chalk3.red(`    ${result.error}`));
+    console.log(chalk5.red(`    Gateway: unreachable`));
+    if (result.error) console.log(chalk5.red(`    ${result.error}`));
   }
-  console.log(chalk3.gray("\n  [3/4] Channels"));
+  console.log(chalk5.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");
+      const status = ch.ok ? chalk5.green("ok") : chalk5.red("fail");
       console.log(`    ${ch.name}: ${status}`);
     }
   } else {
-    console.log(chalk3.yellow("    No channel data available"));
+    console.log(chalk5.yellow("    No channel data available"));
   }
-  console.log(chalk3.gray("\n  [4/4] OpenClaw built-in doctor"));
+  console.log(chalk5.gray("\n  [4/4] OpenClaw built-in doctor"));
   const doctorOutput = await runOpenClawCmd(info, "doctor");
   if (doctorOutput) {
     const lines = doctorOutput.split("\n");
@@ -463,24 +1804,24 @@ async function runDoctor(options) {
       console.log(`    ${line}`);
     }
   } else {
-    console.log(chalk3.yellow("    Could not run openclaw doctor"));
+    console.log(chalk5.yellow("    Could not run openclaw doctor"));
   }
   if (options.fix) {
-    console.log(chalk3.gray("\n  [5/5] Auto-repair"));
+    console.log(chalk5.gray("\n  [5/5] Auto-repair"));
     if (!result.healthy) {
-      console.log(chalk3.yellow("    Gateway unhealthy \u2014 running openclaw doctor --repair --non-interactive"));
+      console.log(chalk5.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"));
+        console.log(chalk5.green("    Repair completed"));
       } else {
-        console.log(chalk3.yellow("    Could not run repair (openclaw CLI unavailable)"));
+        console.log(chalk5.yellow("    Could not run repair (openclaw CLI unavailable)"));
       }
     } else {
-      console.log(chalk3.green("    Gateway healthy \u2014 no repair needed"));
+      console.log(chalk5.green("    Gateway healthy \u2014 no repair needed"));
     }
   }
   trackCommand("doctor", true).catch(() => {
@@ -489,8 +1830,11 @@ async function runDoctor(options) {
 }
 
 // src/commands/logs.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
-import chalk4 from "chalk";
+init_config();
+init_openclaw();
+init_config();
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import chalk6 from "chalk";
 function showLogs(options) {
   const config = loadConfig(options.config);
   const maxLines = parseInt(options.lines ?? "50", 10);
@@ -500,74 +1844,85 @@ function showLogs(options) {
   }
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
   const logFile = options.error ? `${info.logDir}/gateway.err.log` : `${info.logDir}/gateway.log`;
-  if (!existsSync4(logFile)) {
-    console.log(chalk4.yellow(`Log file not found: ${logFile}`));
+  if (!existsSync10(logFile)) {
+    console.log(chalk6.yellow(`Log file not found: ${logFile}`));
     return;
   }
-  console.log(chalk4.blue.bold(`
+  console.log(chalk6.blue.bold(`
   ${logFile}
 `));
-  const content = readFileSync4(logFile, "utf-8");
+  const content = readFileSync8(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));
+      console.log(chalk6.red(line));
     } else if (line.includes("[warn]") || line.includes("[WARN]")) {
-      console.log(chalk4.yellow(line));
+      console.log(chalk6.yellow(line));
     } else {
-      console.log(chalk4.gray(line));
+      console.log(chalk6.gray(line));
     }
   }
   console.log();
 }
 function showDoctorLogs(maxLines) {
-  const { readdirSync } = __require("fs");
-  const { join: join4 } = __require("path");
-  if (!existsSync4(DOCTOR_LOG_DIR)) {
-    console.log(chalk4.yellow("No doctor logs found."));
+  const { readdirSync: readdirSync5 } = __require("fs");
+  const { join: join12 } = __require("path");
+  if (!existsSync10(DOCTOR_LOG_DIR)) {
+    console.log(chalk6.yellow("No doctor logs found."));
     return;
   }
-  const files = readdirSync(DOCTOR_LOG_DIR).filter((f) => f.endsWith(".log")).sort().reverse();
+  const files = readdirSync5(DOCTOR_LOG_DIR).filter((f) => f.endsWith(".log")).sort().reverse();
   if (files.length === 0) {
-    console.log(chalk4.yellow("No doctor log files found."));
+    console.log(chalk6.yellow("No doctor log files found."));
     return;
   }
   const latest = files[0];
-  console.log(chalk4.blue.bold(`
-  ${join4(DOCTOR_LOG_DIR, latest)}
+  console.log(chalk6.blue.bold(`
+  ${join12(DOCTOR_LOG_DIR, latest)}
 `));
-  const content = readFileSync4(join4(DOCTOR_LOG_DIR, latest), "utf-8");
+  const content = readFileSync8(join12(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));
+      console.log(chalk6.red(line));
     } else if (line.includes("[WARN]")) {
-      console.log(chalk4.yellow(line));
+      console.log(chalk6.yellow(line));
     } else if (line.includes("[SUCCESS]")) {
-      console.log(chalk4.green(line));
+      console.log(chalk6.green(line));
     } else {
-      console.log(chalk4.gray(line));
+      console.log(chalk6.gray(line));
     }
   }
   console.log();
 }
 
 // src/commands/gateway.ts
-import chalk5 from "chalk";
-var _VER = true ? "0.4.0" : void 0;
+init_config();
+init_config();
+init_openclaw();
+init_process_manager();
+init_logger();
+import chalk7 from "chalk";
+import { writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
+var _VER = true ? "0.6.1" : void 0;
 async function gatewayStart(options) {
   const config = loadConfig(options.config);
   initLogger();
+  ensureDoctorHome();
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  try {
+    unlinkSync2(STOP_FLAG_FILE);
+  } catch {
+  }
   const result = await startGateway(info);
   if (result.success) {
-    console.log(chalk5.green("Gateway started"));
+    console.log(chalk7.green("Gateway started (auto-restart resumed)"));
     trackCommand("gateway start", true, _VER).catch(() => {
     });
   } else {
-    console.log(chalk5.red(`Failed to start gateway: ${result.error}`));
+    console.log(chalk7.red(`Failed to start gateway: ${result.error}`));
     trackCommand("gateway start", false, _VER).catch(() => {
     });
     process.exit(1);
@@ -576,14 +1931,17 @@ async function gatewayStart(options) {
 async function gatewayStop(options) {
   const config = loadConfig(options.config);
   initLogger();
+  ensureDoctorHome();
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
   const result = await stopGateway(info);
   if (result.success) {
-    console.log(chalk5.green("Gateway stopped"));
+    writeFileSync5(STOP_FLAG_FILE, (/* @__PURE__ */ new Date()).toISOString());
+    console.log(chalk7.green("Gateway stopped (auto-restart paused)"));
+    console.log(chalk7.gray("  Run `gateway start` to resume."));
     trackCommand("gateway stop", true, _VER).catch(() => {
     });
   } else {
-    console.log(chalk5.red(`Failed to stop gateway: ${result.error}`));
+    console.log(chalk7.red(`Failed to stop gateway: ${result.error}`));
     trackCommand("gateway stop", false, _VER).catch(() => {
     });
     process.exit(1);
@@ -592,14 +1950,19 @@ async function gatewayStop(options) {
 async function gatewayRestart(options) {
   const config = loadConfig(options.config);
   initLogger();
+  ensureDoctorHome();
   const info = detectOpenClaw(options.profile ?? config.openclawProfile);
+  try {
+    unlinkSync2(STOP_FLAG_FILE);
+  } catch {
+  }
   const result = await restartGateway(info);
   if (result.success) {
-    console.log(chalk5.green("Gateway restarted"));
+    console.log(chalk7.green("Gateway restarted (auto-restart resumed)"));
     trackCommand("gateway restart", true, _VER).catch(() => {
     });
   } else {
-    console.log(chalk5.red(`Failed to restart gateway: ${result.error}`));
+    console.log(chalk7.red(`Failed to restart gateway: ${result.error}`));
     trackCommand("gateway restart", false, _VER).catch(() => {
     });
     process.exit(1);
@@ -607,42 +1970,44 @@ async function gatewayRestart(options) {
 }
 
 // src/commands/memory.ts
-import chalk6 from "chalk";
-import { existsSync as existsSync5, statSync } from "fs";
-import { join as join3 } from "path";
-import { homedir } from "os";
-function expandHome(p) {
-  return p.startsWith("~/") ? join3(homedir(), p.slice(2)) : p;
+init_config();
+init_openclaw();
+import chalk8 from "chalk";
+import { existsSync as existsSync12, statSync as statSync3 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir5 } from "os";
+function expandHome2(p) {
+  return p.startsWith("~/") ? join10(homedir5(), 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"));
+  console.log(chalk8.bold("\n  Memory Status\n"));
   for (const agent of info.agents) {
     const ws = agent.workspace;
     if (!ws) continue;
-    const wsPath = expandHome(ws);
-    const memPath = join3(wsPath, "MEMORY.md");
-    const exists = existsSync5(memPath);
-    const sizeKB = exists ? Math.round(statSync(memPath).size / 1024) : 0;
+    const wsPath = expandHome2(ws);
+    const memPath = join10(wsPath, "MEMORY.md");
+    const exists = existsSync12(memPath);
+    const sizeKB = exists ? Math.round(statSync3(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") : ""}`);
+    const indicator = warn ? chalk8.yellow("\u26A0") : chalk8.green("\u2713");
+    const sizeStr = warn ? chalk8.yellow(`${sizeKB}KB`) : chalk8.gray(`${sizeKB}KB`);
+    console.log(`  ${indicator} ${agent.name.padEnd(16)} MEMORY.md: ${sizeStr}${warn ? chalk8.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(`
+  console.log(chalk8.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(chalk8.yellow("  No results or openclaw memory search unavailable"));
   }
   console.log();
 }
@@ -650,41 +2015,276 @@ 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(`
+  console.log(chalk8.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(chalk8.yellow("  openclaw memory compact not available"));
   }
   console.log();
 }
 
+// src/index.ts
+init_server();
+init_openclaw();
+
 // src/commands/telemetry.ts
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 function telemetryOn() {
   setOptOut(false);
-  console.log(chalk7.green("\u2713 Telemetry enabled. Thanks for helping improve OpenClaw!"));
+  console.log(chalk9.green("\u2713 Telemetry enabled. Thanks for helping improve OpenClaw!"));
 }
 function telemetryOff() {
   setOptOut(true);
-  console.log(chalk7.yellow("\u2713 Telemetry disabled. Set OPENCLAW_NO_TELEMETRY=1 to suppress permanently."));
+  console.log(chalk9.yellow("\u2713 Telemetry disabled. Set OPENCLAW_NO_TELEMETRY=1 to suppress permanently."));
 }
 function telemetryStatus() {
   const { optOut, clientId } = getTelemetryStatus();
-  const status = optOut ? chalk7.red("disabled") : chalk7.green("enabled");
+  const status = optOut ? chalk9.red("disabled") : chalk9.green("enabled");
   console.log(`Telemetry: ${status}`);
-  console.log(`Client ID: ${chalk7.dim(clientId)}`);
+  console.log(`Client ID: ${chalk9.dim(clientId)}`);
+  console.log();
+  console.log(chalk9.dim("Toggle: openclaw telemetry on/off"));
+  console.log(chalk9.dim("Env:    OPENCLAW_NO_TELEMETRY=1"));
+}
+
+// src/commands/remote.ts
+init_config();
+import chalk10 from "chalk";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync13, mkdirSync as mkdirSync3 } from "fs";
+import { join as join11 } from "path";
+import { randomUUID as randomUUID2, randomBytes, createHash as createHash2 } from "crypto";
+import { createServer as createServer2 } from "http";
+import { exec as exec3 } from "child_process";
+import { hostname } from "os";
+async function proxyFetch(url, init) {
+  const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.ALL_PROXY || process.env.all_proxy;
+  if (proxyUrl) {
+    try {
+      const { ProxyAgent, fetch: undiciFetch } = await import("undici");
+      const dispatcher = new ProxyAgent(proxyUrl);
+      return undiciFetch(url, { ...init, dispatcher });
+    } catch {
+    }
+  }
+  return fetch(url, init);
+}
+var REMOTE_API_URL = "https://api.openclaw-cli.app";
+var REMOTE_CONFIG_FILE = join11(DOCTOR_HOME, "remote.json");
+function loadRemoteConfig() {
+  try {
+    if (existsSync13(REMOTE_CONFIG_FILE)) {
+      return JSON.parse(readFileSync10(REMOTE_CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {
+    enabled: false,
+    machineId: randomUUID2(),
+    machineToken: "",
+    reportUrl: REMOTE_API_URL + "/v1/report",
+    lastReport: null
+  };
+}
+function saveRemoteConfig(config) {
+  const dir = join11(REMOTE_CONFIG_FILE, "..");
+  if (!existsSync13(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync6(REMOTE_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+var OAUTH_CLIENT_ID = Buffer.from(
+  "MjM5NDk1OTI0Nzk4LTJtZWFhaTllcjZybTR1bnN0bW4zZmRldHRqZHM2bGJjLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29t",
+  "base64"
+).toString();
+var _OCS = Buffer.from("R09DU1BYLUNaUU9jN1RKYnp3dk1TNWRxMU91N0IwcFBRU1U=", "base64").toString();
+var OAUTH_REDIRECT_URI = "http://localhost:9876/callback";
+var OAUTH_AUTH_ENDPOINT = "https://accounts.google.com/o/oauth2/v2/auth";
+var OAUTH_TOKEN_ENDPOINT = "https://oauth2.googleapis.com/token";
+var OAUTH_SCOPE = "openid email profile";
+var OAUTH_TIMEOUT_MS = 6e4;
+function generateCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash2("sha256").update(verifier).digest("base64url");
+}
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec3(cmd);
+}
+function waitForOAuthCallback(codeVerifier) {
+  return new Promise((resolve3, reject) => {
+    const server = createServer2(async (req, res) => {
+      if (!req.url?.startsWith("/callback")) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const url = new URL(req.url, "http://localhost:9876");
+      const code = url.searchParams.get("code");
+      const error = url.searchParams.get("error");
+      if (error || !code) {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(
+          `<html><body style='text-align:center;padding:40px;font-family:system-ui'><h2 style='color:#e53e3e'>Login failed</h2><p>${error || "No authorization code received."}</p></body></html>`
+        );
+        clearTimeout(timeout);
+        server.close();
+        reject(new Error(error || "No authorization code received"));
+        return;
+      }
+      try {
+        const tokenRes = await proxyFetch(OAUTH_TOKEN_ENDPOINT, {
+          method: "POST",
+          headers: { "Content-Type": "application/x-www-form-urlencoded" },
+          body: new URLSearchParams({
+            code,
+            client_id: OAUTH_CLIENT_ID,
+            redirect_uri: OAUTH_REDIRECT_URI,
+            grant_type: "authorization_code",
+            code_verifier: codeVerifier,
+            client_secret: _OCS
+          }).toString()
+        });
+        if (!tokenRes.ok) {
+          const errText = await tokenRes.text();
+          throw new Error(`Token exchange failed: ${tokenRes.status} ${errText}`);
+        }
+        const tokenData = await tokenRes.json();
+        const payload = JSON.parse(
+          Buffer.from(tokenData.id_token.split(".")[1], "base64url").toString()
+        );
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(
+          "<html><head><meta charset='utf-8'></head><body style='text-align:center;padding:40px;font-family:system-ui;background:#0d0f14;color:#e2e8f0'><h2 style='color:#38a169'>&#10003; Logged in! This tab will close in <span id='c'>5</span>s...</h2><script>var n=5;var t=setInterval(function(){n--;document.getElementById('c').textContent=n;if(n<=0){clearInterval(t);window.close();}},1000);</script></body></html>"
+        );
+        clearTimeout(timeout);
+        server.close();
+        resolve3({ idToken: tokenData.id_token, email: payload.email });
+      } catch (err) {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(
+          `<html><body style='text-align:center;padding:40px;font-family:system-ui'><h2 style='color:#e53e3e'>Login failed</h2><p>${String(err)}</p></body></html>`
+        );
+        clearTimeout(timeout);
+        server.close();
+        reject(err);
+      }
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Login timed out \u2014 no callback received within 60 seconds"));
+    }, OAUTH_TIMEOUT_MS);
+    server.listen(9876, "127.0.0.1");
+  });
+}
+async function remoteLogin(_options) {
+  const config = loadRemoteConfig();
+  console.log(chalk10.cyan.bold("\n  Remote Monitoring Login\n"));
+  console.log(chalk10.gray("  Opening browser for Google sign-in...\n"));
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const authUrl = OAUTH_AUTH_ENDPOINT + "?" + new URLSearchParams({
+    client_id: OAUTH_CLIENT_ID,
+    redirect_uri: OAUTH_REDIRECT_URI,
+    response_type: "code",
+    scope: OAUTH_SCOPE,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256",
+    access_type: "offline"
+  }).toString();
+  openBrowser(authUrl);
+  let idToken;
+  let email;
+  try {
+    const result = await waitForOAuthCallback(codeVerifier);
+    idToken = result.idToken;
+    email = result.email;
+  } catch (err) {
+    console.log(chalk10.red(`  ${String(err)}`));
+    return;
+  }
+  console.log(chalk10.gray("  Registering this machine..."));
+  try {
+    const host = hostname();
+    const os = process.platform + "/" + process.arch;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1e4);
+    const res = await proxyFetch(REMOTE_API_URL + "/v1/machines/register", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + idToken
+      },
+      body: JSON.stringify({ hostname: host, os, version: "unknown" }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) {
+      const err = await res.text();
+      console.log(chalk10.red(`  Registration failed: ${res.status} ${err}`));
+      return;
+    }
+    const data = await res.json();
+    config.machineId = data.machineId;
+    config.machineToken = data.machineToken;
+    config.enabled = true;
+    config.reportUrl = REMOTE_API_URL + "/v1/report";
+    saveRemoteConfig(config);
+    console.log(chalk10.green.bold(`
+  Logged in as ${email}`));
+    console.log(chalk10.gray(`  Machine registered: ${host}`));
+    console.log(
+      chalk10.gray("  Remote monitoring ready. Run: openclaw-cli remote enable\n")
+    );
+  } catch (err) {
+    console.log(chalk10.red(`  Error: ${err}`));
+  }
+}
+async function remoteEnable(_options) {
+  const config = loadRemoteConfig();
+  if (!config.machineToken) {
+    console.log(
+      chalk10.red("  \u2717 Not logged in. Run: openclaw-cli remote login")
+    );
+    return;
+  }
+  config.enabled = true;
+  saveRemoteConfig(config);
+  console.log(chalk10.green("  Remote reporting enabled."));
+}
+async function remoteDisable(_options) {
+  const config = loadRemoteConfig();
+  config.enabled = false;
+  saveRemoteConfig(config);
+  console.log(chalk10.yellow("  Remote reporting disabled."));
+}
+async function remoteStatus(_options) {
+  const config = loadRemoteConfig();
+  console.log(chalk10.cyan.bold("\n  Remote Monitoring Status\n"));
+  console.log(
+    `  Enabled:       ${config.enabled ? chalk10.green("yes") : chalk10.gray("no")}`
+  );
+  console.log(
+    `  Machine ID:    ${chalk10.white(config.machineId || "(none)")}`
+  );
+  console.log(
+    `  Token:         ${config.machineToken ? chalk10.green("configured") : chalk10.red("not set")}`
+  );
+  console.log(
+    `  Report URL:    ${chalk10.gray(config.reportUrl)}`
+  );
+  console.log(
+    `  Last Report:   ${config.lastReport ? chalk10.gray(config.lastReport) : chalk10.gray("never")}`
+  );
   console.log();
-  console.log(chalk7.dim("Toggle: openclaw telemetry on/off"));
-  console.log(chalk7.dim("Env:    OPENCLAW_NO_TELEMETRY=1"));
 }
 
 // src/index.ts
-var _PKG_VER = true ? "0.4.0" : "0.2.1";
-var version = _PKG_VER;
+var _PKG_VER2 = true ? "0.6.1" : "0.2.1";
+var version = _PKG_VER2;
 printFirstRunNotice();
 var program = new Command();
 program.name(BINARY_NAME).description(`${DISPLAY_NAME} \u2014 health monitor and management for OpenClaw services`).version(version);
@@ -720,6 +2320,11 @@ addGlobalOpts(
 addGlobalOpts(
   mem.command("compact").description("Compact agent memory (proxies to openclaw memory compact)").option("--dry-run", "Preview without applying")
 ).action(memoryCompact);
+var remote = program.command("remote").description("Remote monitoring \u2014 report gateway status to openclaw-cli.app");
+addGlobalOpts(remote.command("login").description("Authenticate and register this machine")).action(remoteLogin);
+addGlobalOpts(remote.command("enable").description("Enable remote reporting")).action(remoteEnable);
+addGlobalOpts(remote.command("disable").description("Disable remote reporting")).action(remoteDisable);
+addGlobalOpts(remote.command("status").description("Show remote monitoring config")).action(remoteStatus);
 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) => {