@clawops/cli 1.3.0 → 1.5.0

package/dist/chunk-R5S6IXBE.js

@@ -0,0 +1,771 @@
+#!/usr/bin/env node
+import {
+  buildContext
+} from "./chunk-T5EX55GP.js";
+import {
+  acquireSession,
+  drainPool
+} from "./chunk-ZVOEQCNW.js";
+import {
+  OPENCLAW_CONFIG,
+  atomicWriteConfig,
+  restartGateway
+} from "./chunk-ZFNPM2WG.js";
+import {
+  StateError
+} from "./chunk-KGXPLI7W.js";
+
+// src/cli/commands/monitor.ts
+import { defineCommand } from "citty";
+import process2 from "process";
+
+// src/output/human.ts
+import chalk from "chalk";
+import ora from "ora";
+function success(msg) {
+  console.log(chalk.green("\u2713") + "  " + msg);
+}
+function failure(msg) {
+  console.error(chalk.red("\u2717") + "  " + msg);
+}
+function warn(msg) {
+  console.warn(chalk.yellow("\u26A0") + "  " + msg);
+}
+function info(msg) {
+  console.log(chalk.blue("\u2139") + "  " + msg);
+}
+function spinner(text) {
+  return ora(text).start();
+}
+var REPO_URL = "https://github.com/dfridkin/clawops";
+function printCta() {
+  process.stdout.write(
+    "\n" + chalk.dim("  Thank you for using clawops! If it has been useful, star the project:") + "\n" + chalk.dim("  " + REPO_URL) + "\n\n" + chalk.dim("  Found a bug? Open an issue:") + "\n" + chalk.dim("  " + REPO_URL + "/issues") + "\n\n"
+  );
+}
+
+// src/cli/commands/monitor.ts
+var GATEWAY_PORT = 18789;
+function formatUptime(startedAt) {
+  if (!startedAt) return "\u2014";
+  const ms = Date.now() - new Date(startedAt).getTime();
+  if (ms < 0 || isNaN(ms)) return "\u2014";
+  const totalSecs = Math.floor(ms / 1e3);
+  const mins = Math.floor(totalSecs / 60);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h ${mins % 60}m`;
+  if (hours > 0) return `${hours}h ${mins % 60}m`;
+  return `${mins}m ${totalSecs % 60}s`;
+}
+async function gatherSnapshot(session, signal, tailLines = 10) {
+  const DOCKER = "PATH=/usr/local/bin:/opt/homebrew/bin:$PATH docker";
+  const [inspectRaw, statsRaw, healthRaw, configRaw, diskRaw, logsRaw] = await Promise.all([
+    session.exec(
+      `${DOCKER} inspect openclaw --format '{{.State.Status}}|{{.Config.Image}}|{{.State.StartedAt}}|{{.RestartCount}}' 2>/dev/null || echo 'not found|||0'`,
+      signal
+    ),
+    session.exec(
+      `${DOCKER} stats openclaw --no-stream --format '{{.MemUsage}}|{{.CPUPerc}}' 2>/dev/null || echo '\u2014|\u2014'`,
+      signal
+    ),
+    session.exec(
+      `curl -sf --connect-timeout 2 http://localhost:${GATEWAY_PORT}/health >/dev/null 2>&1 && echo ok || echo unreachable`,
+      signal
+    ),
+    session.exec(
+      `cat /home/clawops/openclaw.json 2>/dev/null || echo '{}'`,
+      signal
+    ),
+    session.exec(
+      `df -h /home/clawops 2>/dev/null | awk 'NR==2{print $5" used ("$3" of "$2")"}'`,
+      signal
+    ),
+    session.exec(
+      `${DOCKER} logs openclaw -n ${tailLines} 2>&1 || echo '(no logs)'`,
+      signal
+    )
+  ]);
+  const inspectParts = inspectRaw.stdout.trim().split("|");
+  const status = inspectParts[0] ?? "not found";
+  const image = inspectParts[1] ?? "";
+  const startedAt = inspectParts[2] ?? "";
+  const restartCount = parseInt(inspectParts[3] ?? "0", 10) || 0;
+  const statsParts = statsRaw.stdout.trim().split("|");
+  const memUsage = statsParts[0] ?? "\u2014";
+  const cpuPct = statsParts[1] ?? "\u2014";
+  let version = "unknown";
+  let authMode = "unknown";
+  try {
+    const cfg = JSON.parse(configRaw.stdout.trim());
+    version = cfg.meta?.lastTouchedVersion ?? "unknown";
+    authMode = cfg.gateway?.auth?.mode ?? "unknown";
+  } catch {
+  }
+  return {
+    container: { status, image, startedAt, restartCount, memUsage, cpuPct },
+    gateway: {
+      reachable: healthRaw.stdout.trim() === "ok",
+      version,
+      authMode
+    },
+    disk: diskRaw.stdout.trim() || "\u2014",
+    logLines: logsRaw.stdout.split("\n").filter((l) => l.trim().length > 0),
+    capturedAt: /* @__PURE__ */ new Date()
+  };
+}
+function renderSnapshot(snap, opts) {
+  const noColor = opts.noColor ?? false;
+  const g = noColor ? { green: (s) => s, red: (s) => s, yellow: (s) => s, dim: (s) => s, bold: (s) => s } : chalk;
+  const LINE = "\u2500".repeat(68);
+  const timeStr = snap.capturedAt.toLocaleTimeString();
+  const header = `clawops monitor \u2014 ${opts.stackName}`;
+  const padding = Math.max(1, 68 - header.length - `updated ${timeStr}`.length);
+  const gatewayStr = snap.gateway.reachable ? g.green("\u2713 healthy") : g.red("\u2717 unreachable");
+  const containerStr = snap.container.status === "running" ? g.green("\u2713 running") : snap.container.status === "not found" ? g.red("\u2717 not found") : g.yellow(`\u26A0 ${snap.container.status}`);
+  const uptime = formatUptime(snap.container.startedAt);
+  const shortImage = snap.container.image.replace("ghcr.io/openclaw/openclaw:", "") || "\u2014";
+  const lines = [
+    g.bold(header) + " ".repeat(padding) + g.dim(`updated ${timeStr}`),
+    LINE,
+    "",
+    `  Stack       ${g.bold(opts.stackName)}`,
+    `  Gateway     ${gatewayStr}   version ${g.bold(snap.gateway.version)}   auth ${snap.gateway.authMode}`,
+    `  Container   ${containerStr}   ${g.dim(snap.container.image)}`,
+    `  Image tag   ${shortImage}   uptime ${uptime}`,
+    `  Resources   CPU ${snap.container.cpuPct}   Memory ${snap.container.memUsage}`,
+    `  Restarts    ${snap.container.restartCount}   Disk ${snap.disk}`,
+    "",
+    LINE,
+    ""
+  ];
+  if (opts.showLogs) {
+    lines.push(`  Logs (last ${snap.logLines.length} lines)`);
+    for (const l of snap.logLines) {
+      lines.push("  " + g.dim(l));
+    }
+    lines.push("");
+    lines.push(LINE);
+    lines.push("");
+  }
+  const logToggle = opts.showLogs ? "hide logs" : "show logs";
+  const backHint = opts.menuMode ? "  [s] back" : "";
+  lines.push(g.dim(`  [r] refresh  [l] ${logToggle}  [q] quit${backHint}     interval: ${opts.intervalSec}s`));
+  return lines.join("\n");
+}
+async function probeEntries() {
+  const { buildContext: buildContext2 } = await import("./context-PSGEX2D7.js");
+  const { getConfig } = await import("./store-SDUR52Z5.js");
+  const config = getConfig();
+  if (!config) return [];
+  return Promise.all(
+    Object.entries(config.stacks).map(async ([name, stackCfg]) => {
+      const base = {
+        name,
+        provider: stackCfg.provider,
+        region: stackCfg.region ?? "\u2014",
+        deployed: false
+      };
+      try {
+        const ctx = buildContext2({ stack: name });
+        if (ctx.adapter.name === "local") {
+          return { ...base, deployed: !!ctx.localState };
+        }
+        const stack = await ctx.getStack();
+        const outputMap = await stack.outputs();
+        const outputs = Object.fromEntries(
+          Object.entries(outputMap).map(([k, v]) => [k, v.value])
+        );
+        return { ...base, deployed: !!outputs["publicIp"] };
+      } catch {
+        return base;
+      }
+    })
+  );
+}
+function renderMenu(entries, selectedIdx, showAll, noColor, confirmDelete) {
+  const g = noColor ? { green: (s) => s, red: (s) => s, dim: (s) => s, bold: (s) => s, yellow: (s) => s } : chalk;
+  const visible = showAll ? entries : entries.filter((e) => e.deployed);
+  const totalDeployed = entries.filter((e) => e.deployed).length;
+  const heading = showAll ? "clawops monitor \u2014 all stacks" : "clawops monitor \u2014 select a stack";
+  const countStr = showAll ? `(${totalDeployed} of ${entries.length} running)` : `(${totalDeployed} running \xB7 ${entries.length - totalDeployed} not deployed)`;
+  const lines = ["", `  ${g.bold(heading)}   ${g.dim(countStr)}`, ""];
+  if (visible.length === 0) {
+    if (showAll) {
+      lines.push("  No stacks configured. Run `clawops init` to set up.");
+    } else {
+      lines.push("  No deployed stacks found.");
+      lines.push("");
+      lines.push(g.dim("  [a] show all  [q] quit"));
+    }
+  } else {
+    for (let i = 0; i < visible.length; i++) {
+      const e = visible[i];
+      const cursor = i === selectedIdx ? "\u25B6" : " ";
+      const nameStr = i === selectedIdx ? g.bold(e.name.padEnd(24)) : e.name.padEnd(24);
+      const provStr = e.provider.padEnd(10);
+      const regStr = e.region.padEnd(14);
+      const statusStr = showAll ? e.deployed ? g.green("\u2713 running") : g.dim("\u2717 not deployed") : "";
+      lines.push(`  ${cursor}  ${nameStr}${provStr}${regStr}${statusStr}`);
+    }
+    lines.push("");
+    if (confirmDelete !== null) {
+      lines.push(`  ${g.yellow(`Delete "${confirmDelete}" from registry?`)} [y/n]`);
+    } else {
+      const sel = visible[selectedIdx];
+      const canDelete = showAll && sel !== void 0 && !sel.deployed;
+      const toggleLabel = showAll ? "[a] running only" : "[a] show all";
+      const deleteHint = canDelete ? "  [d] delete" : "";
+      lines.push(g.dim(`  [\u2191\u2193] navigate  [enter] select${deleteHint}  ${toggleLabel}  [q] quit`));
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+async function deleteFromRegistry(name) {
+  const { requireConfig, setConfig } = await import("./store-SDUR52Z5.js");
+  const config = requireConfig();
+  const newStacks = { ...config.stacks };
+  delete newStacks[name];
+  const updated = { ...config, stacks: newStacks };
+  if (name === config.defaults.stack) {
+    updated.defaults = { ...config.defaults, stack: Object.keys(newStacks)[0] };
+  }
+  setConfig(updated);
+}
+async function runStackMenu(ac, setKeyHandler, noColor) {
+  process2.stdout.write("\x1B[2J\x1B[H\n  Checking stacks...\n");
+  const entries = await probeEntries();
+  if (ac.signal.aborted) return null;
+  let selectedIdx = 0;
+  let showAll = false;
+  let confirmDelete = null;
+  function visible() {
+    return showAll ? entries : entries.filter((e) => e.deployed);
+  }
+  function redraw() {
+    process2.stdout.write("\x1B[2J\x1B[H" + renderMenu(entries, selectedIdx, showAll, noColor, confirmDelete));
+  }
+  redraw();
+  return new Promise((resolve) => {
+    if (ac.signal.aborted) {
+      resolve(null);
+      return;
+    }
+    ac.signal.addEventListener("abort", () => resolve(null), { once: true });
+    setKeyHandler((key) => {
+      if (confirmDelete !== null) {
+        if (key === "y" || key === "Y") {
+          const nameToDelete = confirmDelete;
+          confirmDelete = null;
+          void deleteFromRegistry(nameToDelete).then(() => {
+            const idx = entries.findIndex((e) => e.name === nameToDelete);
+            if (idx !== -1) entries.splice(idx, 1);
+            const vis2 = visible();
+            selectedIdx = Math.min(selectedIdx, Math.max(0, vis2.length - 1));
+            redraw();
+          }).catch(() => {
+            redraw();
+          });
+        } else {
+          confirmDelete = null;
+          redraw();
+        }
+        return;
+      }
+      if (key === "q" || key === "") {
+        resolve(null);
+        return;
+      }
+      const vis = visible();
+      if (key === "\x1B[A") {
+        if (vis.length > 0) selectedIdx = Math.max(0, selectedIdx - 1);
+        redraw();
+      } else if (key === "\x1B[B") {
+        if (vis.length > 0) selectedIdx = Math.min(vis.length - 1, selectedIdx + 1);
+        redraw();
+      } else if (key === "\r") {
+        const sel = vis[selectedIdx];
+        if (sel?.deployed) resolve(sel.name);
+      } else if (key === "a") {
+        showAll = !showAll;
+        selectedIdx = 0;
+        redraw();
+      } else if (key === "d" && showAll) {
+        const sel = vis[selectedIdx];
+        if (sel !== void 0 && !sel.deployed) {
+          confirmDelete = sel.name;
+          redraw();
+        }
+      }
+    });
+  });
+}
+async function runDashboard(session, stackName, opts, ac, setKeyHandler, menuMode) {
+  let showLogs = true;
+  let lastSnapshot = null;
+  let refreshTimer = null;
+  function scheduleRefresh() {
+    refreshTimer = setTimeout(() => void doRefresh(), opts.intervalSec * 1e3);
+  }
+  function cancelRefresh() {
+    if (refreshTimer !== null) {
+      clearTimeout(refreshTimer);
+      refreshTimer = null;
+    }
+  }
+  function redraw() {
+    if (!lastSnapshot) return;
+    const out = renderSnapshot(lastSnapshot, {
+      stackName,
+      intervalSec: opts.intervalSec,
+      showLogs,
+      noColor: opts.noColor,
+      menuMode
+    });
+    process2.stdout.write("\x1B[2J\x1B[H" + out + "\n");
+  }
+  async function doRefresh() {
+    cancelRefresh();
+    if (ac.signal.aborted) return;
+    try {
+      lastSnapshot = await gatherSnapshot(session, ac.signal, opts.tailLines);
+      redraw();
+    } catch (err) {
+      if (!ac.signal.aborted) {
+        process2.stdout.write("\x1B[2J\x1B[H  Error gathering snapshot: " + (err instanceof Error ? err.message : String(err)) + "\n");
+      }
+    }
+    if (!ac.signal.aborted) scheduleRefresh();
+  }
+  return new Promise((resolve) => {
+    if (ac.signal.aborted) {
+      resolve("quit");
+      return;
+    }
+    ac.signal.addEventListener("abort", () => {
+      cancelRefresh();
+      resolve("quit");
+    }, { once: true });
+    setKeyHandler((key) => {
+      if (key === "q" || key === "") {
+        ac.abort();
+        cancelRefresh();
+        resolve("quit");
+      } else if (key === "s" && menuMode) {
+        cancelRefresh();
+        resolve("back");
+      } else if (key === "r") {
+        void doRefresh();
+      } else if (key === "l") {
+        showLogs = !showLogs;
+        redraw();
+      }
+    });
+    void doRefresh();
+  });
+}
+var monitor_default = defineCommand({
+  meta: {
+    name: "monitor",
+    description: "Live dashboard: gateway health, container status, resource usage, log tail"
+  },
+  args: {
+    stack: { type: "string", description: "Target stack name (omit to pick from a list)" },
+    interval: { type: "string", description: "Refresh interval in seconds (default: 10)" },
+    tail: { type: "string", description: "Log lines to show (default: 10)" },
+    "no-color": { type: "boolean", description: "Disable ANSI colors (auto-detected when not a TTY)" }
+  },
+  async run({ args }) {
+    const intervalSec = Math.max(2, parseInt(String(args.interval ?? "10"), 10) || 10);
+    const tailLines = Math.max(1, parseInt(String(args.tail ?? "10"), 10) || 10);
+    const isTTY = Boolean(process2.stdout.isTTY);
+    const noColor = Boolean(args["no-color"]) || !isTTY;
+    const { buildContext: buildContext2 } = await import("./context-PSGEX2D7.js");
+    const { acquireSession: acquireSession2, drainPool: drainPool2 } = await import("./pool-FBFHATDG.js");
+    const ac = new AbortController();
+    process2.on("SIGINT", () => ac.abort());
+    process2.on("SIGTERM", () => ac.abort());
+    if (args.stack) {
+      const ctx = buildContext2(args);
+      let conn;
+      if (ctx.adapter.name === "local") {
+        if (!ctx.localState) {
+          failure("Stack is not bootstrapped. Run `clawops up` first.");
+          process2.exit(4);
+        }
+        const ls = ctx.localState;
+        conn = { host: ls.sshHost, port: ls.sshPort, user: ls.sshUser, privateKeyPath: ls.privateKeyPath, knownHostsPath: ls.knownHostsPath };
+      } else {
+        const { extractBaseOutputs } = await import("./outputs-DJHBY7EE.js");
+        const stack = await ctx.getStack();
+        const outputMap = await stack.outputs();
+        const outputs = Object.fromEntries(
+          Object.entries(outputMap).map(([k, v]) => [k, v.value])
+        );
+        if (!outputs["publicIp"]) {
+          failure("Stack has no outputs. Run `clawops up` first.");
+          process2.exit(4);
+        }
+        const base = extractBaseOutputs(outputs);
+        conn = ctx.adapter.getConnectionInfo({
+          ...base,
+          privateKeyPath: ctx.config.ssh.keyPath,
+          knownHostsPath: ctx.config.ssh.knownHostsPath
+        });
+      }
+      if (!isTTY) {
+        const { session: session2, release: release2 } = await acquireSession2({ ...conn, signal: ac.signal });
+        try {
+          const snap = await gatherSnapshot(session2, ac.signal, tailLines);
+          process2.stdout.write(
+            renderSnapshot(snap, { stackName: ctx.stackName, intervalSec, showLogs: true, noColor }) + "\n"
+          );
+        } finally {
+          release2();
+          drainPool2();
+        }
+        return;
+      }
+      const { session, release } = await acquireSession2({ ...conn, signal: ac.signal });
+      process2.stdin.setRawMode(true);
+      process2.stdin.resume();
+      process2.stdin.setEncoding("utf8");
+      process2.stdout.write("\x1B[?25l");
+      let keyHandler2 = () => {
+      };
+      process2.stdin.on("data", (key) => keyHandler2(key));
+      try {
+        await runDashboard(session, ctx.stackName, { intervalSec, tailLines, noColor }, ac, (fn) => {
+          keyHandler2 = fn;
+        }, false);
+      } finally {
+        process2.stdin.setRawMode(false);
+        process2.stdin.pause();
+        process2.stdout.write("\x1B[?25h\n");
+        release();
+        drainPool2();
+      }
+      return;
+    }
+    if (!isTTY) {
+      failure("Pass --stack <name> or run in a TTY for interactive stack selection.");
+      process2.exit(2);
+    }
+    process2.stdin.setRawMode(true);
+    process2.stdin.resume();
+    process2.stdin.setEncoding("utf8");
+    process2.stdout.write("\x1B[?25l");
+    let keyHandler = () => {
+    };
+    process2.stdin.on("data", (key) => keyHandler(key));
+    try {
+      while (!ac.signal.aborted) {
+        const stackName = await runStackMenu(ac, (fn) => {
+          keyHandler = fn;
+        }, noColor);
+        if (!stackName || ac.signal.aborted) break;
+        const ctx = buildContext2({ stack: stackName });
+        let conn = null;
+        if (ctx.adapter.name === "local") {
+          if (!ctx.localState) continue;
+          const ls = ctx.localState;
+          conn = { host: ls.sshHost, port: ls.sshPort, user: ls.sshUser, privateKeyPath: ls.privateKeyPath, knownHostsPath: ls.knownHostsPath };
+        } else {
+          try {
+            const { extractBaseOutputs } = await import("./outputs-DJHBY7EE.js");
+            const stack = await ctx.getStack();
+            const outputMap = await stack.outputs();
+            const outputs = Object.fromEntries(
+              Object.entries(outputMap).map(([k, v]) => [k, v.value])
+            );
+            if (!outputs["publicIp"]) continue;
+            const base = extractBaseOutputs(outputs);
+            conn = ctx.adapter.getConnectionInfo({
+              ...base,
+              privateKeyPath: ctx.config.ssh.keyPath,
+              knownHostsPath: ctx.config.ssh.knownHostsPath
+            });
+          } catch {
+            continue;
+          }
+        }
+        if (!conn) continue;
+        const { session, release } = await acquireSession2({ ...conn, signal: ac.signal });
+        try {
+          const result = await runDashboard(session, stackName, { intervalSec, tailLines, noColor }, ac, (fn) => {
+            keyHandler = fn;
+          }, true);
+          if (result === "quit") break;
+        } finally {
+          release();
+          drainPool2();
+        }
+      }
+    } finally {
+      process2.stdin.setRawMode(false);
+      process2.stdin.pause();
+      process2.stdout.write("\x1B[?25h\n");
+    }
+  }
+});
+
+// src/mcp/tools/_conn.ts
+async function resolveConn(ctx) {
+  if (ctx.adapter.name === "local") {
+    const state = ctx.localState;
+    if (!state) throw new StateError("Stack has no local state \u2014 run `clawops up` first.");
+    return {
+      host: state.sshHost,
+      port: state.sshPort,
+      user: state.sshUser,
+      privateKeyPath: state.privateKeyPath,
+      knownHostsPath: state.knownHostsPath
+    };
+  }
+  const { extractBaseOutputs } = await import("./outputs-DJHBY7EE.js");
+  const stack = await ctx.getStack();
+  const outputMap = await stack.outputs();
+  const outputs = Object.fromEntries(
+    Object.entries(outputMap).map(([k, v]) => [k, v.value])
+  );
+  if (!outputs["publicIp"]) {
+    throw new StateError("Stack has no outputs \u2014 run `clawops up` first.");
+  }
+  const base = extractBaseOutputs(outputs);
+  return ctx.adapter.getConnectionInfo({
+    ...base,
+    privateKeyPath: ctx.config.ssh.keyPath,
+    knownHostsPath: ctx.config.ssh.knownHostsPath
+  });
+}
+function errText(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function okText(t) {
+  return { content: [{ type: "text", text: t }] };
+}
+
+// src/mcp/tools/cli/config.ts
+var VALID_AUTH_MODES = /* @__PURE__ */ new Set(["none", "token", "password", "trusted-proxy"]);
+async function handleConfigGet(input, _server) {
+  const ac = new AbortController();
+  const ctx = buildContext({ stack: input.stackName });
+  const conn = await resolveConn(ctx);
+  const { session, release } = await acquireSession(conn);
+  try {
+    const result = await session.exec(`cat ${OPENCLAW_CONFIG}`, ac.signal);
+    let cfg;
+    try {
+      cfg = JSON.parse(result.stdout);
+    } catch {
+      return errText(`Cannot parse ${OPENCLAW_CONFIG}: ${result.stderr || result.stdout}`);
+    }
+    const value = input.key ? getPath(cfg, input.key) : cfg;
+    return okText(JSON.stringify(value, null, 2));
+  } finally {
+    release();
+    drainPool();
+  }
+}
+async function handleConfigSet(input, server) {
+  const elicit = await server.server.elicitInput({
+    message: `Set ${input.key} = ${input.value} on stack "${input.stackName ?? "default"}"?`,
+    requestedSchema: {
+      type: "object",
+      properties: { confirmed: { type: "boolean", title: "Confirm config change" } },
+      required: ["confirmed"]
+    }
+  });
+  if (elicit.action !== "accept" || !elicit.content?.["confirmed"]) {
+    return okText("Config change cancelled.");
+  }
+  const ac = new AbortController();
+  const ctx = buildContext({ stack: input.stackName });
+  const conn = await resolveConn(ctx);
+  const { session, release } = await acquireSession(conn);
+  try {
+    const readResult = await session.exec(`cat ${OPENCLAW_CONFIG}`, ac.signal);
+    let cfg;
+    try {
+      cfg = JSON.parse(readResult.stdout);
+    } catch {
+      return errText(`Cannot parse ${OPENCLAW_CONFIG}: ${readResult.stderr}`);
+    }
+    let parsedValue = input.value;
+    try {
+      parsedValue = JSON.parse(input.value);
+    } catch {
+    }
+    setPath(cfg, input.key, parsedValue);
+    try {
+      await atomicWriteConfig(session, cfg, ac.signal);
+    } catch (err) {
+      return errText(`Failed to write config: ${err.message}`);
+    }
+    let note = "";
+    if (input.restart) {
+      try {
+        await restartGateway(session, ac.signal);
+        note = " (gateway restarted)";
+      } catch (err) {
+        return errText(`Gateway restart failed: ${err.message}`);
+      }
+    }
+    return okText(`Config set: ${input.key}${note}`);
+  } finally {
+    release();
+    drainPool();
+  }
+}
+async function handleConfigUnset(input, server) {
+  const elicit = await server.server.elicitInput({
+    message: `Remove config key "${input.key}" on stack "${input.stackName ?? "default"}"?`,
+    requestedSchema: {
+      type: "object",
+      properties: { confirmed: { type: "boolean", title: "Confirm key removal" } },
+      required: ["confirmed"]
+    }
+  });
+  if (elicit.action !== "accept" || !elicit.content?.["confirmed"]) {
+    return okText("Config unset cancelled.");
+  }
+  const ac = new AbortController();
+  const ctx = buildContext({ stack: input.stackName });
+  const conn = await resolveConn(ctx);
+  const { session, release } = await acquireSession(conn);
+  try {
+    const readResult = await session.exec(`cat ${OPENCLAW_CONFIG}`, ac.signal);
+    let cfg;
+    try {
+      cfg = JSON.parse(readResult.stdout);
+    } catch {
+      return errText(`Cannot parse ${OPENCLAW_CONFIG}: ${readResult.stderr}`);
+    }
+    deletePath(cfg, input.key);
+    try {
+      await atomicWriteConfig(session, cfg, ac.signal);
+    } catch (err) {
+      return errText(`Failed to write config: ${err.message}`);
+    }
+    let note = "";
+    if (input.restart) {
+      try {
+        await restartGateway(session, ac.signal);
+        note = " (gateway restarted)";
+      } catch (err) {
+        return errText(`Gateway restart failed: ${err.message}`);
+      }
+    }
+    return okText(`Config key removed: ${input.key}${note}`);
+  } finally {
+    release();
+    drainPool();
+  }
+}
+async function handleConfigValidate(input, _server) {
+  const ac = new AbortController();
+  const ctx = buildContext({ stack: input.stackName });
+  const conn = await resolveConn(ctx);
+  const { session, release } = await acquireSession(conn);
+  try {
+    const result = await session.exec(`cat ${OPENCLAW_CONFIG}`, ac.signal);
+    let cfg;
+    try {
+      cfg = JSON.parse(result.stdout);
+    } catch {
+      return okText(JSON.stringify({ valid: false, issues: [`Invalid JSON: ${result.stderr || result.stdout}`] }));
+    }
+    const issues = validateOpenclawConfig(cfg);
+    return okText(JSON.stringify({ valid: issues.length === 0, issues }));
+  } finally {
+    release();
+    drainPool();
+  }
+}
+function getPath(obj, dotKey) {
+  return dotKey.split(".").reduce((cur, k) => {
+    if (cur !== null && typeof cur === "object") return cur[k];
+    return void 0;
+  }, obj);
+}
+function setPath(obj, dotKey, value) {
+  const keys = dotKey.split(".");
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (typeof cur[k] !== "object" || cur[k] === null) cur[k] = {};
+    cur = cur[k];
+  }
+  cur[keys[keys.length - 1]] = value;
+}
+function deletePath(obj, dotKey) {
+  const keys = dotKey.split(".");
+  let cur = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (typeof cur[k] !== "object" || cur[k] === null) return;
+    cur = cur[k];
+  }
+  delete cur[keys[keys.length - 1]];
+}
+function validateOpenclawConfig(cfg) {
+  const issues = [];
+  if ("version" in cfg) {
+    issues.push(
+      "Top-level 'version' is not a valid OpenClaw config key. Use 'meta.lastTouchedVersion' (string) instead."
+    );
+  }
+  if ("channels" in cfg && Array.isArray(cfg["channels"])) {
+    issues.push(
+      `'channels' must be an object keyed by provider name (e.g. {"discord":{...}}), not an array.`
+    );
+  }
+  const meta = cfg["meta"];
+  if (meta !== void 0 && (typeof meta !== "object" || Array.isArray(meta) || meta === null)) {
+    issues.push("'meta' must be an object.");
+  } else if (meta && typeof meta === "object") {
+    const ltv = meta["lastTouchedVersion"];
+    if (ltv !== void 0 && typeof ltv !== "string") {
+      issues.push("'meta.lastTouchedVersion' must be a string.");
+    }
+  }
+  const gateway = cfg["gateway"];
+  if (gateway !== void 0 && typeof gateway === "object" && !Array.isArray(gateway) && gateway !== null) {
+    const gw = gateway;
+    if ("port" in gw && typeof gw["port"] !== "number") {
+      issues.push("'gateway.port' must be a number.");
+    }
+    const auth = gw["auth"];
+    if (auth !== void 0 && typeof auth === "object" && !Array.isArray(auth) && auth !== null) {
+      const mode = auth["mode"];
+      if (mode !== void 0 && !VALID_AUTH_MODES.has(mode)) {
+        issues.push(
+          `'gateway.auth.mode' must be one of: ${[...VALID_AUTH_MODES].join(", ")}. Got: "${mode}".`
+        );
+      }
+    }
+  }
+  return issues;
+}
+
+export {
+  chalk,
+  success,
+  failure,
+  warn,
+  info,
+  spinner,
+  printCta,
+  resolveConn,
+  errText,
+  okText,
+  handleConfigGet,
+  handleConfigSet,
+  handleConfigUnset,
+  handleConfigValidate,
+  validateOpenclawConfig,
+  formatUptime,
+  gatherSnapshot,
+  monitor_default
+};