@clawops/cli 1.7.9 → 2.0.1

package/dist/{chunk-PVUVI35Y.js → chunk-JW5A7E3X.js}

@@ -23,7 +23,11 @@ function resolveSpecDir(startUrl = import.meta.url) {
     `Cannot locate the spec/ directory (searched upward from ${dirname(fileURLToPath(startUrl))}). If this is an installed package, spec/ may be missing from the published files.`
   );
 }
+function _resetSpecDirCache() {
+  _cached = void 0;
+}
 
 export {
-  resolveSpecDir
+  resolveSpecDir,
+  _resetSpecDirCache
 };

package/dist/{chunk-GZN7PKP4.js → chunk-KC3GC3PE.js}

@@ -1,40 +1,50 @@
 #!/usr/bin/env node
 import {
   applyPlan
-} from "./chunk-35WVQY3X.js";
+} from "./chunk-LBE6COC4.js";
 import {
   extractBaseOutputs
 } from "./chunk-3QJBNAHW.js";
+import {
+  atomicWriteConfig,
+  readRemoteConfig,
+  restartGateway
+} from "./chunk-2I7KCMXZ.js";
 import {
   generatePlan
-} from "./chunk-A4QR4TXW.js";
+} from "./chunk-STLRHLLV.js";
 import {
   validatePlan
-} from "./chunk-6X45DDGH.js";
+} from "./chunk-BSLIYB5Q.js";
+import {
+  acquireSession,
+  drainPool
+} from "./chunk-2Z7J3ERQ.js";
+import {
+  buildContext
+} from "./chunk-5XT5IAJK.js";
 import {
-  errText,
   formatUptime,
   gatherSnapshot,
-  handleConfigGet,
-  handleConfigSet,
-  handleConfigUnset,
-  handleConfigValidate,
-  okText,
-  resolveConn
-} from "./chunk-FNS56UQY.js";
+  runDiagnostics
+} from "./chunk-IVWP4QUJ.js";
 import {
-  acquireSession,
-  drainPool
-} from "./chunk-DQDAWNGB.js";
+  GATEWAY_LOGS_PROBE,
+  chooseLogSource,
+  containerLogsCommand,
+  gatewayLogsCommand
+} from "./chunk-NUL5F6YV.js";
+import {
+  execPrivileged
+} from "./chunk-NUDIHZEH.js";
+import {
+  STATE_DIR_HOST_LINUX,
+  gatewayRunCommand
+} from "./chunk-GIEVAGEK.js";
 import {
   IMAGE_INSPECT_CMD,
-  OPENCLAW_CONFIG,
-  gatewayRunCommand,
   imageForRestart
-} from "./chunk-SEZMVVAS.js";
-import {
-  buildContext
-} from "./chunk-P5LKWRPL.js";
+} from "./chunk-VOEJYRIK.js";
 import {
   getConfig,
   getConfigDir
@@ -141,6 +151,18 @@ var clawops_statusAnnotations = {
   openWorldHint: true,
   toolsets: ["cli", "read"]
 };
+var clawops_doctorSchema = z.object({
+  stackName: z.string().optional(),
+  failuresOnly: z.boolean().optional().default(false)
+});
+var clawops_doctorAnnotations = {
+  title: "Run Diagnostics",
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true,
+  toolsets: ["cli", "read"]
+};
 var clawops_logs_tailSchema = z.object({
   stackName: z.string().optional(),
   tailLines: z.number().int().optional().default(100),
@@ -202,7 +224,10 @@ var clawops_upSchema = z.object({
   stackName: z.string().optional(),
   provider: z.enum(["aws", "gcp", "azure", "local"]).optional(),
   region: z.string().optional(),
-  instanceType: z.enum(["micro", "small", "medium", "large", "gpu"]).optional().default("small"),
+  instanceType: z.string().optional().default("small"),
+  sshCidr: z.string().optional(),
+  gatewayCidr: z.string().optional(),
+  publishGateway: z.enum(["loopback", "all"]).optional(),
   openclawVersion: z.string().optional(),
   dryRun: z.boolean().optional().default(false)
 });
@@ -291,18 +316,6 @@ var clawops_config_validateAnnotations = {
   openWorldHint: true,
   toolsets: ["cli", "read"]
 };
-var clawops_agents_restartSchema = z.object({
-  stackName: z.string().optional(),
-  agentId: z.string()
-});
-var clawops_agents_restartAnnotations = {
-  title: "Restart OpenClaw Agent",
-  readOnlyHint: false,
-  destructiveHint: true,
-  idempotentHint: true,
-  openWorldHint: true,
-  toolsets: ["cli"]
-};
 var clawops_gateway_restartSchema = z.object({
   stackName: z.string().optional()
 });
@@ -353,6 +366,7 @@ var clawops_task_statusAnnotations = {
 var TOOLSETS = {
   cli: [
     "clawops_status",
+    "clawops_doctor",
     "clawops_logs_tail",
     "clawops_monitor",
     "clawops_config_get",
@@ -364,7 +378,6 @@ var TOOLSETS = {
     "clawops_config_set",
     "clawops_config_unset",
     "clawops_config_validate",
-    "clawops_agents_restart",
     "clawops_gateway_restart",
     "clawops_task_status"
   ],
@@ -374,6 +387,7 @@ var TOOLSETS = {
   ],
   read: [
     "clawops_status",
+    "clawops_doctor",
     "clawops_logs_tail",
     "clawops_monitor",
     "clawops_stacks_list",
@@ -421,32 +435,102 @@ function text(t) {
   return { content: [{ type: "text", text: t }] };
 }
 
-// src/mcp/tools/cli/logs.ts
+// 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: extractBaseOutputs2 } = 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 = extractBaseOutputs2(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/_trim.ts
+import { writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import path2 from "path";
 var MAX_BYTES = 8 * 1024;
+function trimForMcp(output, stackName) {
+  try {
+    const dir = path2.join(getConfigDir(), "state");
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(path2.join(dir, `${stackName}.last-run.json`), JSON.stringify({ output }), "utf-8");
+  } catch {
+  }
+  if (Buffer.byteLength(output) <= MAX_BYTES) {
+    return { content: output, truncated: false };
+  }
+  const trimmed = output.slice(0, MAX_BYTES);
+  return {
+    content: trimmed + `
+
+[Output truncated at 8KB. Full output available at clawops://stacks/${stackName}/last-run]`,
+    truncated: true
+  };
+}
+
+// src/mcp/tools/cli/doctor.ts
+async function handleDoctor(input, _server) {
+  const ac = new AbortController();
+  const report = await runDiagnostics({ stack: input.stackName, signal: ac.signal });
+  const payload = input.failuresOnly ? failuresOnly(report) : report;
+  const { content } = trimForMcp(JSON.stringify(payload, null, 2), input.stackName ?? "local");
+  return okText(content);
+}
+function failuresOnly(report) {
+  const sections = report.sections.map((s) => ({ ...s, checks: s.checks.filter((c) => c.status === "fail" || c.status === "warn") })).filter((s) => s.checks.length > 0);
+  return { sections, ok: report.ok, counts: report.counts };
+}
+
+// src/mcp/tools/cli/logs.ts
+var MAX_BYTES2 = 8 * 1024;
 async function handleLogsTail(input, _server) {
   const ctx = buildContext({ stack: input.stackName });
   const conn = await resolveConn(ctx);
   const { session, release } = await acquireSession(conn);
   try {
     const tailLines = input.tailLines ?? 100;
-    const sinceFlag = input.sinceMin ? `--since "${input.sinceMin} min ago"` : "";
-    const command = [
-      "journalctl -u openclaw",
-      `-n ${tailLines}`,
-      sinceFlag,
-      "2>/dev/null",
-      "|| docker logs openclaw",
-      `-n ${tailLines}`
-    ].filter(Boolean).join(" ");
-    const result = await session.exec(command);
+    const since = input.sinceMin ? `${input.sinceMin}m` : void 0;
+    const probe = since ? { stdout: "" } : await execPrivileged(session, GATEWAY_LOGS_PROBE);
+    const choice = chooseLogSource({ since, gatewayReachable: probe.stdout.trim() === "ok" });
+    const opts = { tail: tailLines, follow: false, since, json: choice.source === "gateway" };
+    const command = choice.source === "gateway" ? gatewayLogsCommand(opts) : containerLogsCommand(opts);
+    const result = await execPrivileged(session, command);
     if (result.code !== 0 && !result.stdout) {
       return errText(`Failed to fetch logs: ${result.stderr}`);
     }
-    let output = result.stdout;
-    if (Buffer.byteLength(output) > MAX_BYTES) {
-      output = output.slice(0, MAX_BYTES) + "\n\n[output truncated at 8KB]";
+    let output = `[source: ${choice.source} \u2014 ${choice.reason}]
+${result.stdout}`;
+    if (Buffer.byteLength(output) > MAX_BYTES2) {
+      output = output.slice(0, MAX_BYTES2) + "\n\n[output truncated at 8KB]";
     }
-    return okText(output || "(no log output)");
+    return okText(result.stdout ? output : `[source: ${choice.source}]
+(no log output)`);
   } finally {
     release();
     drainPool();
@@ -469,42 +553,182 @@ async function handleStacksList(_input, _server) {
   return { content: [{ type: "text", text: JSON.stringify({ stacks }, null, 2) }] };
 }
 
-// src/mcp/tools/cli/agents.ts
-async function handleAgentsList(input, _server) {
+// src/mcp/tools/cli/config.ts
+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('docker exec openclaw openclaw agents list --json 2>&1 || echo "[]"');
-    return okText(result.stdout.trim());
+    let cfg;
+    try {
+      cfg = await readRemoteConfig(session, ac.signal);
+    } catch (err) {
+      return errText(err.message);
+    }
+    const value = input.key ? getPath(cfg, input.key) : cfg;
+    return okText(JSON.stringify(value, null, 2));
   } finally {
     release();
     drainPool();
   }
 }
-async function handleAgentsRestart(input, server) {
+async function handleConfigSet(input, server) {
   const elicit = await server.server.elicitInput({
-    message: `Restart agent "${input.agentId}" on stack "${input.stackName ?? "default"}"?`,
+    message: `Set ${input.key} = ${input.value} on stack "${input.stackName ?? "default"}"?`,
     requestedSchema: {
       type: "object",
-      properties: { confirmed: { type: "boolean", title: "Confirm restart" } },
+      properties: { confirmed: { type: "boolean", title: "Confirm config change" } },
       required: ["confirmed"]
     }
   });
   if (elicit.action !== "accept" || !elicit.content?.["confirmed"]) {
-    return okText("Agent restart cancelled.");
+    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 result = await session.exec(
-      `docker exec openclaw openclaw agents restart ${input.agentId} 2>&1`
-    );
+    let cfg;
+    try {
+      cfg = await readRemoteConfig(session, ac.signal);
+    } catch (err) {
+      return errText(err.message);
+    }
+    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 {
+    let cfg;
+    try {
+      cfg = await readRemoteConfig(session, ac.signal);
+    } catch (err) {
+      return errText(err.message);
+    }
+    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 {
+    let cfg;
+    try {
+      cfg = await readRemoteConfig(session, ac.signal);
+    } catch (err) {
+      return okText(JSON.stringify({ valid: false, issues: [err.message] }));
+    }
+    const { validateConfig } = await import("./config-validate-K2N6XLDX.js");
+    const yaml = await import("./js-yaml-PTEEG4FO.js");
+    const { loadVersionSpec } = await import("./versions-W5LRQCAJ.js");
+    const spec = loadVersionSpec(yaml);
+    const { errors, warnings } = await validateConfig(cfg, {
+      schemaCapturedFrom: spec.runtime?.configSchemaCapturedFrom
+    });
+    return okText(JSON.stringify({ valid: errors.length === 0, issues: errors, warnings }));
+  } 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]];
+}
+
+// src/mcp/tools/cli/agents.ts
+async function handleAgentsList(input, _server) {
+  const ctx = buildContext({ stack: input.stackName });
+  const conn = await resolveConn(ctx);
+  const { session, release } = await acquireSession(conn);
+  try {
+    const result = await execPrivileged(session, "docker exec openclaw openclaw agents list --json");
     if (result.code !== 0) {
-      return errText(`Failed to restart agent: ${result.stderr || result.stdout}`);
+      return errText(`Cannot list agents: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`}`);
     }
-    return okText(`Agent "${input.agentId}" restarted.`);
+    return okText(result.stdout.trim() || "[]");
   } finally {
     release();
     drainPool();
@@ -528,11 +752,12 @@ async function handleGatewayRestart(input, server) {
   const conn = await resolveConn(ctx);
   const { session, release } = await acquireSession(conn);
   try {
-    const imgResult = await session.exec(IMAGE_INSPECT_CMD);
+    const imgResult = await execPrivileged(session, IMAGE_INSPECT_CMD);
     const image = imageForRestart(imgResult.stdout);
     if (!image.ok) return errText(image.error);
-    const result = await session.exec(
-      gatewayRunCommand({ image: image.value, configPath: OPENCLAW_CONFIG })
+    const result = await execPrivileged(
+      session,
+      gatewayRunCommand({ image: image.value, stateDir: STATE_DIR_HOST_LINUX })
     );
     if (result.code !== 0) {
       return errText(`Gateway restart failed: ${result.stderr}`);
@@ -578,31 +803,7 @@ function makeProgressEmitter(server, progressToken) {
   };
 }
 
-// src/mcp/tools/_trim.ts
-import { writeFileSync, mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
-var MAX_BYTES2 = 8 * 1024;
-function trimForMcp(output, stackName) {
-  try {
-    const dir = path2.join(getConfigDir(), "state");
-    mkdirSync2(dir, { recursive: true });
-    writeFileSync(path2.join(dir, `${stackName}.last-run.json`), JSON.stringify({ output }), "utf-8");
-  } catch {
-  }
-  if (Buffer.byteLength(output) <= MAX_BYTES2) {
-    return { content: output, truncated: false };
-  }
-  const trimmed = output.slice(0, MAX_BYTES2);
-  return {
-    content: trimmed + `
-
-[Output truncated at 8KB. Full output available at clawops://stacks/${stackName}/last-run]`,
-    truncated: true
-  };
-}
-
 // src/mcp/tools/cli/up.ts
-var VALID_INSTANCE_TYPES = ["micro", "small", "medium", "large", "gpu"];
 async function handleUp(input, server) {
   if (!input.dryRun) {
     const elicit = await server.server.elicitInput({
@@ -627,7 +828,7 @@ async function handleUp(input, server) {
       );
     }
     const { localOpts } = stackConfig;
-    const { localBootstrap } = await import("./bootstrap-HL4DNUNG.js");
+    const { localBootstrap } = await import("./bootstrap-HNGKY6WW.js");
     const ac = new AbortController();
     const state = await localBootstrap({
       host: localOpts.host,
@@ -642,10 +843,6 @@ async function handleUp(input, server) {
     });
     return okText(JSON.stringify({ stack: ctx.stackName, ...state }, null, 2));
   }
-  const instanceAlias = input.instanceType ?? "small";
-  if (!VALID_INSTANCE_TYPES.includes(instanceAlias)) {
-    throw new UsageError(`Invalid instanceType: ${instanceAlias}`);
-  }
   const validation = await ctx.adapter.validateConfig();
   if (!validation.ok) {
     return errText(`Provider config invalid: ${validation.errors.join("; ")}`);
@@ -654,38 +851,47 @@ async function handleUp(input, server) {
   const progressToken = void 0;
   const emit = makeProgressEmitter(server, progressToken);
   startTask(taskId, `clawops_up stack=${ctx.stackName}`);
-  const stack = await ctx.getStack();
-  const region = input.region ?? ctx.adapter.defaultRegion();
-  const instanceType = ctx.adapter.normalizeInstanceType(instanceAlias);
-  await stack.setConfig("region", { value: region });
-  await stack.setConfig("instanceType", { value: instanceType });
-  await stack.setConfig("openclawVersion", { value: openclawVersion });
-  if (input.dryRun) {
-    const lines = [];
-    await stack.preview({ onOutput: (o) => {
-      emit(o.trim());
-      lines.push(o);
-    } });
-    const output = lines.join("");
-    updateTask(taskId, "completed", output);
-    const { content } = trimForMcp(output, ctx.stackName);
-    return okText(content);
-  }
+  const { generatePlan: generatePlan2 } = await import("./generate-I6YQ5V2T.js");
+  const { applyPlan: applyPlan2 } = await import("./apply-KYFPWI5U.js");
+  const { resolveNetworkFlags } = await import("./network-args-PYJRJBYO.js");
+  const { detectEgressIp } = await import("./firewall-5VKZ4WBH.js");
+  const network = await resolveNetworkFlags(
+    {
+      ...input.sshCidr ? { sshCidr: input.sshCidr } : {},
+      ...input.gatewayCidr ? { gatewayCidr: input.gatewayCidr } : {},
+      ...input.publishGateway ? { publishGateway: input.publishGateway } : {}
+    },
+    { detectEgressIp: () => detectEgressIp("https://ifconfig.me/ip") }
+  );
   try {
+    const plan = await generatePlan2({
+      stackName: ctx.stackName,
+      provider: ctx.adapter.name,
+      ...input.region ? { region: input.region } : {},
+      ...input.instanceType ? { instanceType: input.instanceType } : {},
+      openclawVersion,
+      network
+    });
+    if (input.dryRun) {
+      const summary2 = JSON.stringify(plan.diff ?? { totalChanges: 0 }, null, 2);
+      updateTask(taskId, "completed", summary2);
+      const { content } = trimForMcp(summary2, ctx.stackName);
+      return okText(content);
+    }
     const lines = [];
-    const result = await stack.up({
+    const result = await applyPlan2(plan, {
       onOutput: (o) => {
         emit(o.trim());
         lines.push(o);
-      }
+      },
+      onProgress: (o) => emit(o)
     });
     const summary = `Stack "${ctx.stackName}" deployed.
-` + (result.outputs["publicIp"] ? `Public IP: ${result.outputs["publicIp"].value}
-` : "") + (result.outputs["gatewayUrl"] ? `Gateway URL: ${result.outputs["gatewayUrl"].value}
+` + (result.outputs["publicIp"] ? `Public IP: ${String(result.outputs["publicIp"])}
+` : "") + (result.outputs["gatewayUrl"] ? `Gateway URL: ${String(result.outputs["gatewayUrl"])}
 ` : "");
     updateTask(taskId, "completed", summary);
-    const fullOutput = lines.join("");
-    trimForMcp(fullOutput, ctx.stackName);
+    trimForMcp(lines.join(""), ctx.stackName);
     return okText(summary);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -850,7 +1056,7 @@ async function handleTaskStatus(input, _server) {
 
 // src/mcp/tools/cli/monitor.ts
 async function handleMonitor(input, _server) {
-  const { acquireSession: acquireSession2, drainPool: drainPool2 } = await import("./pool-QGFQRMGU.js");
+  const { acquireSession: acquireSession2, drainPool: drainPool2 } = await import("./pool-PIIKJ4L2.js");
   const ctx = buildContext({ stack: input.stackName });
   const tailLines = input.tailLines ?? 5;
   let conn;
@@ -1015,6 +1221,7 @@ function makeEntry(schema, annotations, handler) {
 }
 var TOOL_REGISTRY = {
   clawops_status: makeEntry(clawops_statusSchema, clawops_statusAnnotations, handleStatus),
+  clawops_doctor: makeEntry(clawops_doctorSchema, clawops_doctorAnnotations, handleDoctor),
   clawops_logs_tail: makeEntry(clawops_logs_tailSchema, clawops_logs_tailAnnotations, handleLogsTail),
   clawops_monitor: makeEntry(clawops_monitorSchema, clawops_monitorAnnotations, handleMonitor),
   clawops_stacks_list: makeEntry(clawops_stacks_listSchema, clawops_stacks_listAnnotations, handleStacksList),
@@ -1027,12 +1234,12 @@ var TOOL_REGISTRY = {
   clawops_config_set: makeEntry(clawops_config_setSchema, clawops_config_setAnnotations, handleConfigSet),
   clawops_config_unset: makeEntry(clawops_config_unsetSchema, clawops_config_unsetAnnotations, handleConfigUnset),
   clawops_config_validate: makeEntry(clawops_config_validateSchema, clawops_config_validateAnnotations, handleConfigValidate),
-  clawops_agents_restart: makeEntry(clawops_agents_restartSchema, clawops_agents_restartAnnotations, handleAgentsRestart),
   clawops_gateway_restart: makeEntry(clawops_gateway_restartSchema, clawops_gateway_restartAnnotations, handleGatewayRestart),
   clawops_workflow_deploy_app: makeEntry(clawops_workflow_deploy_appSchema, clawops_workflow_deploy_appAnnotations, handleWorkflowDeployApp),
   clawops_workflow_recover: makeEntry(clawops_workflow_recoverSchema, clawops_workflow_recoverAnnotations, handleWorkflowRecover),
   clawops_task_status: makeEntry(clawops_task_statusSchema, clawops_task_statusAnnotations, handleTaskStatus)
 };
+var TOOL_NAMES = Object.keys(TOOL_REGISTRY);
 function resolveEnabledTools(opts) {
   let names;
   if (opts.readOnly) {
@@ -1258,7 +1465,7 @@ clawops_gateway_restart({ stackName: "${s}" })
 ### Agents not running
 \`\`\`
 clawops_agents_list({ stackName: "${s}" })
-clawops_agents_restart({ stackName: "${s}" })
+clawops_gateway_restart({ stackName: "${s}" })
 \`\`\`
 
 ### Bootstrap failed or incomplete
@@ -1325,7 +1532,7 @@ function bearerFrom(header) {
   return match?.[1]?.trim();
 }
 async function serveMcp(opts) {
-  const { version } = await import("./package-5AR4ZPK4.js");
+  const { version } = await import("./package-5BCMEBTE.js");
   const makeServer = () => {
     const server = new McpServer({ name: "clawops", version });
     registerTools(server, opts);