@clawops/cli 1.2.0 → 1.2.1

package/README.md

@@ -45,78 +45,140 @@ and Cursor drive them through typed MCP tools with explicit safety controls.
 
 ---
 
-## Quick Start — local VM (fastest path)
+## Quick Start
 
-The local provider needs only a Linux host reachable over SSH — no cloud account required.
+```bash
+npm install -g @clawops/cli
+clawops setup
+```
+
+`clawops setup` is an interactive wizard that gets OpenClaw running in about 2 minutes. It
+handles everything in one flow — no config files to write by hand, no commands to memorize.
+
+### What the wizard does
+
+**Step 1 — Choose a deployment target**
+
+Pick an existing server you can SSH into (Linux or macOS), or a new cloud VM on AWS, GCP, or
+Azure. Cloud deployments walk you through authenticating with the provider CLI if you aren't
+already signed in.
+
+**Step 2 — Pick an LLM provider**
+
+Choose from Anthropic, OpenAI, Amazon Bedrock, Ollama, or others. The wizard prompts for your
+API key and saves it locally (in `~/.clawops/secrets/`, chmod 600) — it is never sent anywhere
+except to OpenClaw on the target host when the config is applied.
+
+**Step 3 — Add chat integrations (optional)**
+
+Select any combination of Discord, Telegram, Slack, WhatsApp, or Teams. The wizard collects each
+integration's bot token the same way as the API key — paste it in, reference an env var, or point
+to a file.
+
+**Step 4 — Wire your AI editor**
+
+Select which AI apps should have access to clawops — Claude Desktop, Claude Code, Cursor,
+Windsurf, VS Code, and Zed are all supported. The wizard writes an MCP server entry into each
+app's config file using the absolute binary path so the app can launch it independently.
 
-**Prerequisites:** Node.js ≥ 22, an SSH key, a Linux host (Ubuntu/Debian/RHEL) you can reach.
+**Step 5 — Deploy**
+
+The wizard bootstraps OpenClaw on the target host over SSH (installs Docker, pulls the image,
+starts the container), applies your LLM and integration config, generates a gateway auth token,
+and prints a direct dashboard URL:
+
+```
+✔ All done! OpenClaw is running.
+ℹ Open dashboard: http://192.168.1.50:18789?token=<your-token>
+ℹ Token saved to ~/.clawops/secrets/GATEWAY_TOKEN_my-stack
+```
+
+**Prerequisites:** Node.js ≥ 22, an SSH key, and either an SSH-reachable Linux/macOS host or a
+cloud account with CLI credentials configured (`aws configure`, `gcloud auth login`, or `az login`).
+
+For a full narrated walkthrough with example output, see [`docs/demo-script.md`](docs/demo-script.md).
+
+---
+
+### Manual setup — existing server
+
+If you prefer step-by-step control, or are adding clawops to an already-running deployment:
 
 ```bash
 npm install -g @clawops/cli
 
-# Check your environment
-clawops doctor
+clawops doctor   # verify environment
 
-# Configure clawops for a local host
 clawops init --provider local --host 192.168.1.50 --user ubuntu --key-path ~/.ssh/id_ed25519
-
-# Bootstrap OpenClaw on the host (installs Docker + OpenClaw over SSH)
-clawops up
-
-# Verify it's running
+clawops up       # installs Docker + OpenClaw over SSH
 clawops status
-
-# Start the MCP server for Claude Code
-clawops mcp serve
 ```
 
-See [`docs/examples/local-vm.md`](docs/examples/local-vm.md) for the full walkthrough including
-SSH prerequisites, firewall setup, and troubleshooting.
+See [`docs/examples/local-vm.md`](docs/examples/local-vm.md) for SSH prerequisites, firewall
+setup, and troubleshooting.
 
-## Quick Start — cloud (AWS)
+### Manual setup — cloud (AWS)
 
 ```bash
 npm install -g @clawops/cli
-# or: npx @clawops/cli
 
 # Requires AWS credentials in your environment (AWS_PROFILE or ~/.aws/credentials)
 clawops init --provider aws
 
-# Edit ~/.clawops/config.json — set stateUrl to your S3 bucket:
-#   "stateUrl": "s3://my-clawops-state"
+# Edit ~/.clawops/config.json — set stateUrl to your S3 bucket
 
-# Generate a deploy plan (runs pulumi preview internally)
 clawops plan --provider aws --stack default --out /tmp/plan.json
-
-# Review the plan, then apply
 clawops apply /tmp/plan.json
 ```
 
 ---
 
-## Connect Claude Code
+## Connect an AI editor
+
+The `setup` wizard handles this automatically (Step 4). To wire or re-wire editors at any time:
+
+```bash
+clawops mcp install
+```
+
+This opens the same interactive checkbox used in the wizard — select Claude Desktop, Claude Code,
+Cursor, Windsurf, VS Code, or Zed and clawops writes the MCP entry into each app's config using
+the correct absolute binary path.
 
-Add to your Claude Code MCP config (`~/.claude.json` or project `.mcp.json`):
+To add the entry manually instead, paste this into your editor's MCP config:
 
 ```json
 {
   "mcpServers": {
     "clawops": {
-      "command": "clawops",
+      "command": "/path/to/clawops",
       "args": ["mcp", "serve", "--read-only"]
     }
   }
 }
 ```
 
+Replace `/path/to/clawops` with the output of `which clawops`. Config file locations:
+
+| App | Path |
+|---|---|
+| Claude Desktop (macOS) | `~/Library/Application Support/Claude/claude_desktop_config.json` |
+| Claude Desktop (Linux) | `~/.config/Claude/claude_desktop_config.json` |
+| Claude Code | `~/.claude.json` |
+| Cursor | `~/.cursor/mcp.json` |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` |
+| VS Code (macOS) | `~/Library/Application Support/Code/User/mcp.json` |
+| VS Code (Linux) | `~/.config/Code/User/mcp.json` |
+| Zed | `~/.config/zed/settings.json` (key: `context_servers`) |
+
 **Start with `--read-only`** — it enables status, logs, config reads, and diagnostics while
-blocking any operation that mutates infrastructure. Remove `--read-only` only once you understand
-which tools are destructive and have reviewed [`docs/security/mcp-safety.md`](docs/security/mcp-safety.md).
+blocking mutations. Remove it only after reviewing
+[`docs/security/mcp-safety.md`](docs/security/mcp-safety.md).
 
 Destructive tools (`clawops_destroy`, `clawops_up`, `clawops_config_set`, etc.) require explicit
-confirmation from the agent before executing — they will never run silently.
+confirmation before executing — they will never run silently.
 
-For Cursor, VS Code, or HTTP mode setup see [`docs/mcp/`](docs/mcp/).
+For HTTP mode setup see [`docs/mcp/`](docs/mcp/).
 
 ---
 
@@ -160,7 +222,9 @@ clawops down --yes          # Destroy local-provider stack
 | `backup` | Create or restore an OpenClaw state backup |
 | `stacks` | List named stacks and their state |
 | `doctor` | Check Node version, config, SSH key, provider credentials, and Pulumi home |
-| `mcp` | Start the embedded MCP server (`mcp serve`) |
+| `mcp serve` | Start the embedded MCP server (stdio or HTTP) |
+| `mcp install` | Interactively wire clawops into AI editors |
+| `help` | List all commands and global flags |
 
 Full flag reference: `clawops <command> --help`
 
@@ -198,23 +262,29 @@ See [`docs/plan-apply.md`](docs/plan-apply.md) for full semantics, drift guidanc
 clawops ships an embedded [MCP](https://modelcontextprotocol.io/) server. Claude Code, Cursor, and
 any MCP-compatible agent can drive deployments without leaving the chat interface.
 
-### Stdio mode (Claude Code / VS Code)
+### Wire your editor
 
-```json
-{
-  "mcpServers": {
-    "clawops": {
-      "command": "clawops",
-      "args": ["mcp", "serve", "--read-only"]
-    }
-  }
-}
+```bash
+clawops mcp install   # interactive checkbox — writes config for selected apps
+```
+
+The wizard resolves the absolute binary path automatically so app launchers can find `clawops`
+without inheriting your shell's `PATH`. See [Connect an AI editor](#connect-an-ai-editor) above
+for manual config paths.
+
+### Stdio mode (Claude Code / Cursor / VS Code)
+
+Start the server manually or confirm your config is correct:
+
+```bash
+clawops mcp serve --read-only   # safe for first evaluation
+clawops mcp serve               # full mode — enables provisioning, config write, ssh exec
 ```
 
 ### HTTP mode (remote / multi-client)
 
 ```bash
-clawops mcp serve --http --port 3333 --bind 127.0.0.1
+clawops mcp serve --http 3333 --bind 127.0.0.1
 # MCP HTTP server listening on 127.0.0.1:3333
 ```
 

package/dist/chunk-OIGTOLB3.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+// src/cli/mcp-apps.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import path from "path";
+import os from "os";
+var MCP_APPS = [
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    configPath: () => process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json") : path.join(os.homedir(), ".config", "Claude", "claude_desktop_config.json"),
+    isInstalled: () => existsSync(
+      process.platform === "darwin" ? path.join(os.homedir(), "Library", "Application Support", "Claude") : path.join(os.homedir(), ".config", "Claude")
+    )
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    configPath: () => path.join(os.homedir(), ".claude.json"),
+    isInstalled: () => {
+      if (existsSync(path.join(os.homedir(), ".claude.json"))) return true;
+      try {
+        execSync("claude --version", { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    configPath: () => path.join(os.homedir(), ".cursor", "mcp.json"),
+    isInstalled: () => existsSync(path.join(os.homedir(), ".cursor"))
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    configPath: () => path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+    isInstalled: () => existsSync(path.join(os.homedir(), ".codeium", "windsurf"))
+  },
+  {
+    id: "vscode",
+    name: "VS Code",
+    configPath: () => process.platform === "linux" ? path.join(os.homedir(), ".config", "Code", "User", "mcp.json") : path.join(os.homedir(), "Library", "Application Support", "Code", "User", "mcp.json"),
+    isInstalled: () => existsSync(
+      process.platform === "linux" ? path.join(os.homedir(), ".config", "Code") : path.join(os.homedir(), "Library", "Application Support", "Code")
+    )
+  },
+  {
+    id: "zed",
+    name: "Zed",
+    configPath: () => path.join(os.homedir(), ".config", "zed", "settings.json"),
+    isInstalled: () => existsSync(path.join(os.homedir(), ".config", "zed")),
+    configKey: "context_servers",
+    entryExtra: { type: "stdio" }
+  }
+];
+function buildMcpEntry() {
+  try {
+    const bin = execSync("which clawops", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (bin) return { command: bin, args: ["mcp", "serve", "--read-only"], resolved: true };
+  } catch {
+  }
+  return { command: "clawops", args: ["mcp", "serve", "--read-only"], resolved: false };
+}
+function writeAppConfigs(apps, entry) {
+  return apps.map((app) => {
+    const cfgPath = app.configPath();
+    try {
+      let config = {};
+      if (existsSync(cfgPath)) {
+        try {
+          config = JSON.parse(readFileSync(cfgPath, "utf-8"));
+        } catch {
+        }
+      }
+      mkdirSync(path.dirname(cfgPath), { recursive: true });
+      const key = app.configKey ?? "mcpServers";
+      const servers = config[key] ?? {};
+      servers["clawops"] = { ...entry, ...app.entryExtra ?? {} };
+      config[key] = servers;
+      writeFileSync(cfgPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      return { app, configPath: cfgPath, ok: true };
+    } catch (err) {
+      return { app, configPath: cfgPath, ok: false, error: err.message };
+    }
+  });
+}
+
+export {
+  MCP_APPS,
+  buildMcpEntry,
+  writeAppConfigs
+};

package/dist/{chunk-QMXM2SMO.js → chunk-SSB6SGPQ.js}

@@ -45,7 +45,7 @@ async function generatePlan(intent, _opts) {
       "plan/apply is not supported for the local provider. Use `clawops up` directly."
     );
   }
-  const { version } = await import("./package-3JZ767DN.js");
+  const { version } = await import("./package-SE3M4NJA.js");
   const config = getConfig();
   const instanceType = intent.instanceType ?? "small";
   const openclawVersion = intent.openclawVersion ?? "latest";

package/dist/cli.js

@@ -2,6 +2,11 @@
 import {
   validateOpenclawConfig
 } from "./chunk-QJ6ERXHN.js";
+import {
+  MCP_APPS,
+  buildMcpEntry,
+  writeAppConfigs
+} from "./chunk-OIGTOLB3.js";
 import "./chunk-ACYJBSLJ.js";
 import "./chunk-BRPU7AQC.js";
 import "./chunk-ZVOEQCNW.js";
@@ -19,7 +24,7 @@ import {
 } from "./chunk-KGXPLI7W.js";
 
 // src/cli/index.ts
-import { defineCommand as defineCommand19, runMain } from "citty";
+import { defineCommand as defineCommand20, runMain } from "citty";
 
 // src/cli/commands/init.ts
 import { defineCommand } from "citty";
@@ -495,7 +500,7 @@ var plan_default = defineCommand5({
   },
   async run({ args }) {
     const { buildContext } = await import("./context-VUAYRAJY.js");
-    const { generatePlan } = await import("./generate-WG5VONSE.js");
+    const { generatePlan } = await import("./generate-PZPLG3ZM.js");
     const ctx = buildContext(args);
     if (ctx.adapter.name === "local") {
       throw new UsageError(
@@ -1782,13 +1787,11 @@ var doctor_default = defineCommand16({
 
 // src/cli/commands/mcp.ts
 import { defineCommand as defineCommand17 } from "citty";
-import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import path3 from "path";
-import os from "os";
-var mcp_default = defineCommand17({
+import process19 from "process";
+var serveCmd = defineCommand17({
   meta: {
-    name: "mcp",
-    description: "MCP server operations (serve | install)"
+    name: "serve",
+    description: "Start the clawops MCP server"
   },
   args: {
     http: { type: "string", description: "HTTP port for standalone mode" },
@@ -1796,25 +1799,10 @@ var mcp_default = defineCommand17({
     "read-only": { type: "boolean", description: "Only register read toolset" },
     "no-destructive": { type: "boolean", description: "Filter out destructive tools" },
     toolsets: { type: "string", description: "Comma-separated toolsets to enable" },
-    inspector: { type: "boolean", description: "Enable MCP inspector" },
-    claude: { type: "boolean", description: "Install for Claude Desktop" },
-    cursor: { type: "boolean", description: "Install for Cursor" },
-    vscode: { type: "boolean", description: "Install for VS Code" },
-    windsurf: { type: "boolean", description: "Install for Windsurf" },
-    zed: { type: "boolean", description: "Install for Zed" }
+    inspector: { type: "boolean", description: "Enable MCP inspector" }
   },
   async run({ args }) {
-    const installFlags = ["claude", "cursor", "vscode", "windsurf", "zed"];
-    const requestedClients = installFlags.filter((f) => Boolean(args[f]));
-    if (requestedClients.length > 0) {
-      for (const client of requestedClients) {
-        installMcp(client);
-        process.stderr.write(`Installed MCP config for: ${client}
-`);
-      }
-      return;
-    }
-    const { serveMcp } = await import("./server-QJRWK2RV.js");
+    const { serveMcp } = await import("./server-4DNHLGEG.js");
     await serveMcp({
       port: args.http ? Number(args.http) : void 0,
       bind: args.bind,
@@ -1825,60 +1813,86 @@ var mcp_default = defineCommand17({
     });
   }
 });
-var CLAWOPS_ENTRY = {
-  command: "clawops",
-  args: ["mcp", "serve"],
-  type: "stdio"
-};
-function getConfigPath(client) {
-  const home = os.homedir();
-  const isLinux = process.platform === "linux";
-  switch (client) {
-    case "claude":
-      return isLinux ? path3.join(home, ".config", "Claude", "claude_desktop_config.json") : path3.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-    case "cursor":
-      return path3.join(home, ".cursor", "mcp.json");
-    case "vscode":
-      return isLinux ? path3.join(home, ".config", "Code", "User", "mcp.json") : path3.join(home, "Library", "Application Support", "Code", "User", "mcp.json");
-    case "windsurf":
-      return path3.join(home, ".codeium", "windsurf", "mcp_config.json");
-    case "zed":
-      return path3.join(home, ".config", "zed", "settings.json");
-  }
-}
-function installMcp(client) {
-  const configPath = getConfigPath(client);
-  const dir = path3.dirname(configPath);
-  if (!existsSync2(dir)) {
-    mkdirSync3(dir, { recursive: true });
-  }
-  let config = {};
-  if (existsSync2(configPath)) {
-    try {
-      config = JSON.parse(readFileSync3(configPath, "utf-8"));
-    } catch {
+var installCmd = defineCommand17({
+  meta: {
+    name: "install",
+    description: "Interactively wire clawops into AI editors (Claude Desktop, Claude Code, Cursor, \u2026)"
+  },
+  args: {},
+  async run() {
+    const inquirer = (await import("inquirer")).default;
+    const { MCP_APPS: MCP_APPS2, buildMcpEntry: buildMcpEntry2, writeAppConfigs: writeAppConfigs2 } = await import("./mcp-apps-KY44ED3Y.js");
+    const mcpEntry = buildMcpEntry2();
+    if (!mcpEntry.resolved) {
+      info("clawops is not installed globally \u2014 AI apps may not be able to start the MCP server.");
+      info("Install it first:  npm install -g @clawops/cli");
+      info('The config will still be written now using "clawops" as the command name.\n');
+    }
+    info("Use \u2191\u2193 to move, Space to select/deselect, Enter to confirm.");
+    const choices = MCP_APPS2.map((app) => ({
+      name: app.isInstalled() ? app.name : `${app.name}  (not detected \u2014 config will be written anyway)`,
+      value: app.id,
+      checked: app.isInstalled()
+    }));
+    const { selectedIds } = await inquirer.prompt([{
+      type: "checkbox",
+      name: "selectedIds",
+      message: "Which AI editors should have access to clawops?",
+      choices,
+      pageSize: MCP_APPS2.length + 1
+    }]);
+    const selected = MCP_APPS2.filter((app) => selectedIds.includes(app.id));
+    if (selected.length === 0) {
+      info("No apps selected. Add this to an app's MCP config manually:");
+      process19.stdout.write(JSON.stringify({
+        mcpServers: { clawops: { command: mcpEntry.command, args: mcpEntry.args } }
+      }, null, 2) + "\n\n");
+      info("Config file locations:");
+      for (const app of MCP_APPS2) {
+        info(`  ${app.name.padEnd(18)} ${app.configPath()}`);
+      }
+      return;
+    }
+    const results = writeAppConfigs2(selected, { command: mcpEntry.command, args: mcpEntry.args });
+    for (const r of results) {
+      if (r.ok) {
+        success(`${r.app.name} configured  (${r.configPath})`);
+      } else {
+        failure(`Could not configure ${r.app.name}: ${r.error ?? "unknown error"}`);
+      }
+    }
+    const needsRestart = selected.filter((app) => app.id !== "claude-code");
+    if (needsRestart.length > 0) {
+      info(`Restart ${needsRestart.map((a) => a.name).join(", ")} to load the clawops tool.`);
     }
   }
-  if (client === "zed") {
-    const contextServers = config["context_servers"] ?? {};
-    contextServers["clawops"] = CLAWOPS_ENTRY;
-    config["context_servers"] = contextServers;
-  } else {
-    const mcpServers = config["mcpServers"] ?? {};
-    mcpServers["clawops"] = CLAWOPS_ENTRY;
-    config["mcpServers"] = mcpServers;
+});
+var mcp_default = defineCommand17({
+  meta: {
+    name: "mcp",
+    description: "MCP server operations"
+  },
+  args: {},
+  subCommands: {
+    serve: serveCmd,
+    install: installCmd
+  },
+  run() {
+    process19.stdout.write("Usage: clawops mcp <serve | install>\n\n");
+    process19.stdout.write("  serve    Start the MCP server (stdio or HTTP)\n");
+    process19.stdout.write("  install  Wire clawops into AI editors interactively\n\n");
+    process19.stdout.write("Run `clawops mcp <command> --help` for flags.\n");
   }
-  writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-}
+});
 
 // src/cli/commands/setup.ts
 import { defineCommand as defineCommand18 } from "citty";
-import process19 from "process";
-import os2 from "os";
+import process20 from "process";
+import os from "os";
 import { randomBytes } from "crypto";
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync3, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "fs";
 import { execSync, spawnSync, spawn as spawn2 } from "child_process";
-import path4 from "path";
+import path3 from "path";
 import { fileURLToPath } from "url";
 var setup_default = defineCommand18({
   meta: {
@@ -1895,16 +1909,16 @@ var setup_default = defineCommand18({
     const catalogs = loadCatalogs(yaml);
     const dryRun = Boolean(args["dry-run"]);
     const ac = new AbortController();
-    process19.on("SIGINT", () => {
+    process20.on("SIGINT", () => {
       ac.abort();
-      process19.exit(130);
+      process20.exit(130);
     });
-    process19.on("SIGTERM", () => {
+    process20.on("SIGTERM", () => {
       ac.abort();
-      process19.exit(143);
+      process20.exit(143);
     });
-    process19.stdout.write("\nWelcome to clawops setup. This wizard will help you deploy OpenClaw\n");
-    process19.stdout.write("and connect it to your AI tools. It takes about 2 minutes.\n\n");
+    process20.stdout.write("\nWelcome to clawops setup. This wizard will help you deploy OpenClaw\n");
+    process20.stdout.write("and connect it to your AI tools. It takes about 2 minutes.\n\n");
     const { deploymentType } = await inquirer.prompt([{
       type: "list",
       name: "deploymentType",
@@ -1916,7 +1930,7 @@ var setup_default = defineCommand18({
     }]);
     let provider;
     let localHost = "";
-    let localUser = os2.userInfo().username;
+    let localUser = os.userInfo().username;
     let localKeyPath = detectSshKey();
     let localPort = 22;
     let localSudoPassword = "";
@@ -1932,12 +1946,12 @@ var setup_default = defineCommand18({
         ]
       }]);
       provider = answer.provider;
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       await ensureCloudAuth(provider, inquirer);
     } else {
       provider = "local";
       info("We'll connect to your server over SSH to install and configure OpenClaw.\n");
-      if (!existsSync3(localKeyPath)) {
+      if (!existsSync2(localKeyPath)) {
         info(`No SSH key found at ${localKeyPath}.`);
         const { genKey } = await inquirer.prompt([{
           type: "confirm",
@@ -1973,7 +1987,7 @@ var setup_default = defineCommand18({
           name: "keyPath",
           message: `SSH private key file: (the key file on your computer used to log in \u2014 e.g. ~/.ssh/id_ed25519)`,
           default: localKeyPath,
-          validate: (v) => existsSync3(v.trim()) || `File not found: ${v.trim()}`
+          validate: (v) => existsSync2(v.trim()) || `File not found: ${v.trim()}`
         }
       ]);
       localHost = localAnswers.host;
@@ -1988,7 +2002,7 @@ var setup_default = defineCommand18({
       }]);
       localSudoPassword = sudoPass;
     }
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     const stackAnswers = await inquirer.prompt([
       {
         type: "input",
@@ -2036,7 +2050,7 @@ var setup_default = defineCommand18({
         default: "latest"
       }
     ]);
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     info("Choose the AI model that your OpenClaw agent will use.");
     info("You'll need an API key from your chosen provider (except Bedrock and Ollama).\n");
     const { modelProviderId } = await inquirer.prompt([{
@@ -2065,7 +2079,7 @@ var setup_default = defineCommand18({
       secrets.push(entry);
       modelConfig["apiKey"] = `$secret:${secretName}`;
     } else if (modelProvider.credentialSource === "aws-profile") {
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       info(modelProvider.iamNote ?? "Bedrock uses your AWS server's IAM role \u2014 no API key needed.");
       info("Make sure your EC2 instance has the AmazonBedrockFullAccess IAM policy attached.\n");
     } else if (modelProvider.id === "ollama") {
@@ -2082,7 +2096,7 @@ var setup_default = defineCommand18({
       ...selectedModel.modelId ? { modelId: selectedModel.modelId } : { model: selectedModel.id },
       ...modelConfig
     };
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     info("Use \u2191\u2193 to move, Space to select/deselect, Enter to confirm.");
     const { selectedIntegrationIds } = await inquirer.prompt([{
       type: "checkbox",
@@ -2098,7 +2112,7 @@ var setup_default = defineCommand18({
     const channelsConfig = {};
     const infraRequired = [];
     for (const integ of catalogs.integrations.filter((i) => selectedIntegrationIds.includes(i.id))) {
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       info(`Setting up ${integ.displayName}:`);
       const channelConfig = {};
       for (const field of integ.fields) {
@@ -2134,11 +2148,11 @@ var setup_default = defineCommand18({
       }
     }
     const gatewayToken = randomBytes(24).toString("hex");
-    const secretsDir = path4.join(os2.homedir(), ".clawops", "secrets");
-    mkdirSync4(secretsDir, { recursive: true });
+    const secretsDir = path3.join(os.homedir(), ".clawops", "secrets");
+    mkdirSync3(secretsDir, { recursive: true });
     spawnSync("chmod", ["700", secretsDir], { stdio: "ignore" });
-    const tokenPath = path4.join(secretsDir, `GATEWAY_TOKEN_${stackAnswers.stackName}`);
-    writeFileSync4(tokenPath, gatewayToken, { encoding: "utf-8", mode: 384 });
+    const tokenPath = path3.join(secretsDir, `GATEWAY_TOKEN_${stackAnswers.stackName}`);
+    writeFileSync3(tokenPath, gatewayToken, { encoding: "utf-8", mode: 384 });
     const openclawConfigOverlay = {
       models: builtModelConfig,
       gateway: { auth: { mode: "token", token: gatewayToken } }
@@ -2148,17 +2162,17 @@ var setup_default = defineCommand18({
     }
     let outputPath;
     if (provider === "local") {
-      outputPath = path4.join(outDir, `openclaw-${stackAnswers.stackName}.json`);
-      writeFileSync4(outputPath, JSON.stringify(openclawConfigOverlay, null, 2), "utf-8");
-      process19.stdout.write("\n");
+      outputPath = path3.join(outDir, `openclaw-${stackAnswers.stackName}.json`);
+      writeFileSync3(outputPath, JSON.stringify(openclawConfigOverlay, null, 2), "utf-8");
+      process20.stdout.write("\n");
       success(`Config file saved to ${outputPath}`);
     } else {
       let sshPublicKey = "";
       try {
-        sshPublicKey = readFileSync4(stackAnswers.sshKeyPath ?? "", "utf-8").trim();
+        sshPublicKey = readFileSync3(stackAnswers.sshKeyPath ?? "", "utf-8").trim();
       } catch {
         failure(`Cannot read SSH public key at ${stackAnswers.sshKeyPath ?? ""}`);
-        process19.exit(1);
+        process20.exit(1);
       }
       const plan = {
         apiVersion: "clawops.dev/v1",
@@ -2187,12 +2201,12 @@ var setup_default = defineCommand18({
           ...stackAnswers.stateBucket ? { stateBucket: stackAnswers.stateBucket } : {}
         }
       };
-      outputPath = path4.join(outDir, `clawops-${stackAnswers.stackName}-plan.json`);
-      writeFileSync4(outputPath, JSON.stringify(plan, null, 2), "utf-8");
-      process19.stdout.write("\n");
+      outputPath = path3.join(outDir, `clawops-${stackAnswers.stackName}-plan.json`);
+      writeFileSync3(outputPath, JSON.stringify(plan, null, 2), "utf-8");
+      process20.stdout.write("\n");
       success(`Deployment plan saved to ${outputPath}`);
     }
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     const mcpEntry = buildMcpEntry();
     if (!mcpEntry.resolved) {
       info("Note: clawops is not installed globally \u2014 AI apps will not be able to start");
@@ -2215,21 +2229,12 @@ var setup_default = defineCommand18({
     }]);
     const selectedApps = MCP_APPS.filter((app) => selectedAppIds.includes(app.id));
     if (selectedApps.length > 0) {
-      for (const app of selectedApps) {
-        const cfgPath = app.configPath();
-        try {
-          let existing = {};
-          if (existsSync3(cfgPath)) {
-            existing = JSON.parse(readFileSync4(cfgPath, "utf-8"));
-          }
-          const mcpServers = existing["mcpServers"] ?? {};
-          mcpServers["clawops"] = { command: mcpEntry.command, args: mcpEntry.args };
-          existing["mcpServers"] = mcpServers;
-          mkdirSync4(path4.dirname(cfgPath), { recursive: true });
-          writeFileSync4(cfgPath, JSON.stringify(existing, null, 2), "utf-8");
-          success(`${app.name} configured  (${cfgPath})`);
-        } catch (err) {
-          failure(`Could not configure ${app.name}: ${err.message}`);
+      const results = writeAppConfigs(selectedApps, { command: mcpEntry.command, args: mcpEntry.args });
+      for (const r of results) {
+        if (r.ok) {
+          success(`${r.app.name} configured  (${r.configPath})`);
+        } else {
+          failure(`Could not configure ${r.app.name}: ${r.error ?? "unknown error"}`);
           info("Add this to its MCP config manually:");
           printMcpSnippet();
         }
@@ -2247,7 +2252,7 @@ var setup_default = defineCommand18({
       }
     }
     if (infraRequired.length > 0) {
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       info("\u2500\u2500 Action required: webhook registration \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       info("These integrations need a webhook URL set up in their developer portal:");
       for (const integ of infraRequired) {
@@ -2258,7 +2263,7 @@ var setup_default = defineCommand18({
       }
     }
     if (modelProvider.id === "ollama" && selectedModel.pullSuffix !== void 0) {
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       info("\u2500\u2500 Action required: download the Ollama model \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
       info("After deployment, run this command on the server (or locally if Ollama is local):");
       info(`  ollama pull ${selectedModel.id}${selectedModel.pullSuffix}`);
@@ -2288,8 +2293,8 @@ var setup_default = defineCommand18({
         });
       } else {
         const { getConfigDir: getConfigDir2 } = await import("./store-SDUR52Z5.js");
-        const knownHostsPath = path4.join(getConfigDir2(), "known_hosts");
-        process19.stdout.write("\n");
+        const knownHostsPath = path3.join(getConfigDir2(), "known_hosts");
+        process20.stdout.write("\n");
         info("To deploy later, run these two commands:");
         info(`  clawops init --provider local --host ${localHost} --port ${localPort} --user ${localUser} --key ${localKeyPath} --stack ${stackAnswers.stackName}`);
         info(`  clawops up --stack ${stackAnswers.stackName} --config ${outputPath}`);
@@ -2305,17 +2310,17 @@ var setup_default = defineCommand18({
       }]);
       if (applyNow) {
         const { applyPlan } = await import("./apply-KBF7OPWL.js");
-        const plan = JSON.parse(readFileSync4(outputPath, "utf-8"));
+        const plan = JSON.parse(readFileSync3(outputPath, "utf-8"));
         try {
           await applyPlan(plan, {
-            onOutput: (line) => process19.stdout.write(line),
+            onOutput: (line) => process20.stdout.write(line),
             signal: ac.signal
           });
           success("Server provisioned and OpenClaw installed.");
           info(`Run: clawops doctor --stack ${stackAnswers.stackName}  to verify everything is healthy`);
         } catch (err) {
           failure(err instanceof Error ? err.message : String(err));
-          process19.exit(1);
+          process20.exit(1);
         }
       } else {
         info(`
@@ -2330,7 +2335,7 @@ async function runLocalDeploy(opts) {
   const { connect } = await import("./ssh-IQXNME3D.js");
   const { readRemoteConfig, atomicWriteConfig, restartGateway, deepMerge } = await import("./remote-config-JQ77SRC2.js");
   const { resolveSecrets } = await import("./secrets-SVZWNAPK.js");
-  const knownHostsPath = path4.join(getConfigDir2(), "known_hosts");
+  const knownHostsPath = path3.join(getConfigDir2(), "known_hosts");
   const existing = getConfig2();
   const stackEntry = {
     provider: "local",
@@ -2409,9 +2414,9 @@ async function runLocalDeploy(opts) {
   }
   const { drainPool } = await import("./pool-FBFHATDG.js");
   drainPool();
-  const tokenPath = path4.join(os2.homedir(), ".clawops", "secrets", `GATEWAY_TOKEN_${opts.stackName}`);
+  const tokenPath = path3.join(os.homedir(), ".clawops", "secrets", `GATEWAY_TOKEN_${opts.stackName}`);
   const dashboardUrl = `${state.gatewayUrl}?token=${opts.gatewayToken}`;
-  process19.stdout.write("\n");
+  process20.stdout.write("\n");
   success("All done! OpenClaw is running.");
   info(`Open dashboard: ${dashboardUrl}`);
   info(`  (or enter the token manually in the "Gateway Token" field: ${opts.gatewayToken})`);
@@ -2465,7 +2470,7 @@ ${cfg.loginHint}`);
     default: true
   }]);
   if (runNow) {
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     const result = spawnSync(cfg.loginCmd[0], cfg.loginCmd.slice(1), { stdio: "inherit" });
     if (result.error) {
       failure(`Could not launch ${cliName} \u2014 is it installed? (${result.error.message})`);
@@ -2475,10 +2480,10 @@ ${cfg.loginHint}`);
     }
     try {
       const identity = cfg.check();
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       success(`Authenticated: ${cfg.identity(identity)}`);
     } catch {
-      process19.stdout.write("\n");
+      process20.stdout.write("\n");
       failure(`Still not authenticated \u2014 the sign-in may have been cancelled or failed.`);
       info("Re-run `clawops setup` after signing in, or continue and authenticate before running `clawops up`.\n");
     }
@@ -2492,7 +2497,7 @@ function cliInstallUrl(provider) {
   return "https://learn.microsoft.com/en-us/cli/azure/install-azure-cli";
 }
 async function promptSecret(name, label, envDefault, inquirer) {
-  const secretsDir = path4.join(os2.homedir(), ".clawops", "secrets");
+  const secretsDir = path3.join(os.homedir(), ".clawops", "secrets");
   const { secretSource } = await inquirer.prompt([{
     type: "list",
     name: "secretSource",
@@ -2510,10 +2515,10 @@ async function promptSecret(name, label, envDefault, inquirer) {
       message: `Paste your ${label}: (input is hidden)`,
       validate: (v) => v.trim() !== "" || "Value cannot be empty"
     }]);
-    mkdirSync4(secretsDir, { recursive: true });
+    mkdirSync3(secretsDir, { recursive: true });
     spawnSync("chmod", ["700", secretsDir], { stdio: "ignore" });
-    const secretPath = path4.join(secretsDir, name);
-    writeFileSync4(secretPath, secretValue.trim(), { encoding: "utf-8", mode: 384 });
+    const secretPath = path3.join(secretsDir, name);
+    writeFileSync3(secretPath, secretValue.trim(), { encoding: "utf-8", mode: 384 });
     success(`Secret saved to ${secretPath}  (chmod 600)`);
     return { name, source: "file", ref: secretPath };
   }
@@ -2530,7 +2535,7 @@ async function promptSecret(name, label, envDefault, inquirer) {
     type: "input",
     name: "filePath",
     message: `File path: (full path to the file containing your ${label})`,
-    validate: (v) => existsSync3(v.trim()) || `File not found: ${v.trim()}`
+    validate: (v) => existsSync2(v.trim()) || `File not found: ${v.trim()}`
   }]);
   return { name, source: "file", ref: filePath };
 }
@@ -2663,7 +2668,7 @@ async function pollUntilDockerReady(label) {
   throw new Error("Docker daemon did not become ready within timeout.");
 }
 async function startDockerAndWait(inquirer) {
-  const isLinux = process19.platform === "linux";
+  const isLinux = process20.platform === "linux";
   const { choice } = await inquirer.prompt([{
     type: "list",
     name: "choice",
@@ -2727,12 +2732,12 @@ async function startDockerAndWait(inquirer) {
 var LOCALHOST_ALIASES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
 async function ensureAuthorizedKey(keyPath, host, inquirer) {
   const pubKeyPath = `${keyPath}.pub`;
-  if (!existsSync3(pubKeyPath)) return;
-  const pubKey = readFileSync4(pubKeyPath, "utf-8").trim();
+  if (!existsSync2(pubKeyPath)) return;
+  const pubKey = readFileSync3(pubKeyPath, "utf-8").trim();
   const isLocal = LOCALHOST_ALIASES.has(host.toLowerCase());
-  const authorizedKeysPath = path4.join(os2.homedir(), ".ssh", "authorized_keys");
+  const authorizedKeysPath = path3.join(os.homedir(), ".ssh", "authorized_keys");
   if (isLocal) {
-    const existing = existsSync3(authorizedKeysPath) ? readFileSync4(authorizedKeysPath, "utf-8") : "";
+    const existing = existsSync2(authorizedKeysPath) ? readFileSync3(authorizedKeysPath, "utf-8") : "";
     if (existing.includes(pubKey)) {
       success("SSH public key is already in authorized_keys.");
       return;
@@ -2745,9 +2750,9 @@ async function ensureAuthorizedKey(keyPath, host, inquirer) {
       default: true
     }]);
     if (addKey) {
-      mkdirSync4(path4.join(os2.homedir(), ".ssh"), { recursive: true });
+      mkdirSync3(path3.join(os.homedir(), ".ssh"), { recursive: true });
       const entry = existing.endsWith("\n") || existing === "" ? pubKey + "\n" : "\n" + pubKey + "\n";
-      writeFileSync4(authorizedKeysPath, existing + entry, { encoding: "utf-8", flag: "a" });
+      writeFileSync3(authorizedKeysPath, existing + entry, { encoding: "utf-8", flag: "a" });
       spawnSync("chmod", ["600", authorizedKeysPath], { stdio: "ignore" });
       success("Public key added to ~/.ssh/authorized_keys.");
     } else {
@@ -2755,15 +2760,15 @@ async function ensureAuthorizedKey(keyPath, host, inquirer) {
       info(`  ${pubKey}`);
     }
   } else {
-    process19.stdout.write("\n");
+    process20.stdout.write("\n");
     info("Make sure this public key is in ~/.ssh/authorized_keys on your server:");
     info(`  ${pubKey}`);
     info("(If you just created the server, paste the line above into the server's ~/.ssh/authorized_keys file.)\n");
   }
 }
 async function generateSshKey() {
-  const keyPath = path4.join(os2.homedir(), ".ssh", "id_ed25519");
-  mkdirSync4(path4.join(os2.homedir(), ".ssh"), { recursive: true });
+  const keyPath = path3.join(os.homedir(), ".ssh", "id_ed25519");
+  mkdirSync3(path3.join(os.homedir(), ".ssh"), { recursive: true });
   const result = spawnSync("ssh-keygen", ["-t", "ed25519", "-f", keyPath, "-N", "", "-C", "clawops"], {
     stdio: ["ignore", "pipe", "pipe"]
   });
@@ -2772,77 +2777,30 @@ async function generateSshKey() {
   }
   success(`SSH key pair generated: ${keyPath}`);
   info(`Public key (add this to your server's ~/.ssh/authorized_keys if needed):
-  ${readFileSync4(`${keyPath}.pub`, "utf-8").trim()}`);
+  ${readFileSync3(`${keyPath}.pub`, "utf-8").trim()}`);
   return keyPath;
 }
 function detectSshKey() {
   const candidates = ["id_ed25519", "id_ecdsa", "id_rsa", "id_dsa"];
   for (const name of candidates) {
-    const p = path4.join(os2.homedir(), ".ssh", name);
-    if (existsSync3(p)) return p;
-  }
-  return path4.join(os2.homedir(), ".ssh", "id_ed25519");
-}
-function buildMcpEntry() {
-  try {
-    const bin = execSync("which clawops", {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    if (bin) return { command: bin, args: ["mcp", "serve", "--read-only"], resolved: true };
-  } catch {
+    const p = path3.join(os.homedir(), ".ssh", name);
+    if (existsSync2(p)) return p;
   }
-  return { command: "clawops", args: ["mcp", "serve", "--read-only"], resolved: false };
+  return path3.join(os.homedir(), ".ssh", "id_ed25519");
 }
-var MCP_APPS = [
-  {
-    id: "claude-desktop",
-    name: "Claude Desktop",
-    configPath: () => process19.platform === "darwin" ? path4.join(os2.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json") : path4.join(os2.homedir(), ".config", "Claude", "claude_desktop_config.json"),
-    isInstalled: () => existsSync3(
-      process19.platform === "darwin" ? path4.join(os2.homedir(), "Library", "Application Support", "Claude") : path4.join(os2.homedir(), ".config", "Claude")
-    )
-  },
-  {
-    id: "claude-code",
-    name: "Claude Code",
-    configPath: () => path4.join(os2.homedir(), ".claude.json"),
-    isInstalled: () => {
-      if (existsSync3(path4.join(os2.homedir(), ".claude.json"))) return true;
-      try {
-        execSync("claude --version", { stdio: "ignore" });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  },
-  {
-    id: "cursor",
-    name: "Cursor",
-    configPath: () => path4.join(os2.homedir(), ".cursor", "mcp.json"),
-    isInstalled: () => existsSync3(path4.join(os2.homedir(), ".cursor"))
-  },
-  {
-    id: "windsurf",
-    name: "Windsurf",
-    configPath: () => path4.join(os2.homedir(), ".codeium", "windsurf", "mcp_config.json"),
-    isInstalled: () => existsSync3(path4.join(os2.homedir(), ".codeium", "windsurf"))
-  }
-];
 function printMcpSnippet() {
-  process19.stdout.write("\n");
-  process19.stdout.write(JSON.stringify({
+  process20.stdout.write("\n");
+  process20.stdout.write(JSON.stringify({
     mcpServers: {
       clawops: { command: "clawops", args: ["mcp", "serve", "--read-only"] }
     }
   }, null, 2) + "\n\n");
 }
 function loadCatalogs(yaml) {
-  const specDir = path4.join(path4.dirname(fileURLToPath(import.meta.url)), "../../../spec");
+  const specDir = path3.join(path3.dirname(fileURLToPath(import.meta.url)), "../../../spec");
   try {
-    const modelsRaw = yaml.load(readFileSync4(path4.join(specDir, "models.yaml"), "utf-8"));
-    const integrationsRaw = yaml.load(readFileSync4(path4.join(specDir, "integrations.yaml"), "utf-8"));
+    const modelsRaw = yaml.load(readFileSync3(path3.join(specDir, "models.yaml"), "utf-8"));
+    const integrationsRaw = yaml.load(readFileSync3(path3.join(specDir, "integrations.yaml"), "utf-8"));
     return {
       models: modelsRaw.providers,
       integrations: integrationsRaw.integrations
@@ -2887,26 +2845,96 @@ function instanceChoices(provider) {
   return table[provider] ?? [];
 }
 
+// src/cli/commands/help.ts
+import { defineCommand as defineCommand19 } from "citty";
+var COMMANDS = [
+  ["setup", "Interactive first-run wizard \u2014 configure, deploy, and wire AI apps"],
+  ["init", "Write config and generate SSH key pair (non-interactive)"],
+  ["up", "Provision or update a stack"],
+  ["down", "Destroy a local-provider stack (requires --yes)"],
+  ["destroy", "Destroy a cloud-provider stack with confirmation prompt (requires --yes)"],
+  ["status", "Show stack outputs: IP, gateway URL, region, provisioned time"],
+  ["plan", "Generate a deploy-plan JSON artifact (dry-run safe)"],
+  ["apply", "Apply a previously reviewed plan file"],
+  ["ssh", "Interactive SSH session or run a remote command (--command)"],
+  ["logs", "Stream OpenClaw logs (-f, --tail N, --since 5m)"],
+  ["tunnel", "Port-forward gateway UI to localhost over SSH"],
+  ["config", "Get / set / validate remote OpenClaw config values"],
+  ["agents", "List or restart OpenClaw agents"],
+  ["gateway", "Restart the OpenClaw gateway service"],
+  ["backup", "Create or restore an OpenClaw state backup"],
+  ["stacks", "List named stacks and their state"],
+  ["doctor", "Check Node version, config, SSH key, provider credentials, and Pulumi home"],
+  ["mcp", "MCP server operations (mcp serve | mcp install)"],
+  ["help", "Show this help message"]
+];
+var GLOBAL_FLAGS = [
+  ["--stack <name>", "Target named stack (overrides config default)"],
+  ["--provider <name>", "Override provider  (aws | gcp | azure | local)"],
+  ["--json", "Emit JSON to stdout"],
+  ["--quiet", "Suppress non-error output"],
+  ["--dry-run", "Preview without applying (mutating commands)"],
+  ["--yes", "Skip interactive confirmations (CI mode)"]
+];
+var help_default = defineCommand19({
+  meta: {
+    name: "help",
+    description: "Show available commands and global flags"
+  },
+  args: {},
+  run() {
+    const bold = chalk.bold;
+    const dim = chalk.dim;
+    const cyan = chalk.cyan;
+    const cmdWidth = Math.max(...COMMANDS.map(([c]) => c.length));
+    const flagWidth = Math.max(...GLOBAL_FLAGS.map(([f]) => f.length));
+    process.stdout.write(`
+${bold("clawops")} \u2014 Deploy and manage self-hosted OpenClaw instances
+
+`);
+    process.stdout.write(`${bold("Usage:")}  clawops <command> [flags]
+
+`);
+    process.stdout.write(`${bold("Commands:")}
+`);
+    for (const [cmd, desc] of COMMANDS) {
+      process.stdout.write(`  ${cyan(cmd.padEnd(cmdWidth))}  ${desc}
+`);
+    }
+    process.stdout.write(`
+${bold("Global flags:")}
+`);
+    for (const [flag, desc] of GLOBAL_FLAGS) {
+      process.stdout.write(`  ${flag.padEnd(flagWidth)}  ${dim(desc)}
+`);
+    }
+    process.stdout.write(`
+${dim("Run `clawops <command> --help` for command-specific flags.")}
+
+`);
+  }
+});
+
 // src/cli/error-handler.ts
-import process20 from "process";
+import process21 from "process";
 function handleError(err) {
   if (err instanceof ClawopsError) {
     failure(err.message);
-    process20.exit(err.exitCode);
+    process21.exit(err.exitCode);
   }
   if (err instanceof Error) {
     failure(`Unexpected error: ${err.message}`);
-    if (process20.env["DEBUG"]) {
-      process20.stderr.write(err.stack ?? "\n");
+    if (process21.env["DEBUG"]) {
+      process21.stderr.write(err.stack ?? "\n");
     }
-    process20.exit(1);
+    process21.exit(1);
   }
   failure(`Unknown error: ${String(err)}`);
-  process20.exit(1);
+  process21.exit(1);
 }
 
 // src/cli/index.ts
-var main = defineCommand19({
+var main = defineCommand20({
   meta: {
     name: "clawops",
     description: "Deploy and manage self-hosted OpenClaw instances across clouds",
@@ -2939,7 +2967,8 @@ var main = defineCommand19({
     stacks: stacks_default,
     doctor: doctor_default,
     mcp: mcp_default,
-    setup: setup_default
+    setup: setup_default,
+    help: help_default
   }
 });
 try {

package/dist/{generate-WG5VONSE.js → generate-PZPLG3ZM.js}

@@ -2,7 +2,7 @@
 import {
   generatePlan,
   planId
-} from "./chunk-QMXM2SMO.js";
+} from "./chunk-SSB6SGPQ.js";
 import "./chunk-YTH4L2GN.js";
 import "./chunk-ACYJBSLJ.js";
 import "./chunk-BRPU7AQC.js";

package/dist/mcp-apps-KY44ED3Y.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import {
+  MCP_APPS,
+  buildMcpEntry,
+  writeAppConfigs
+} from "./chunk-OIGTOLB3.js";
+export {
+  MCP_APPS,
+  buildMcpEntry,
+  writeAppConfigs
+};

package/dist/{package-3JZ767DN.js → package-SE3M4NJA.js}

@@ -2,7 +2,7 @@
 
 // package.json
 var name = "@clawops/cli";
-var version = "1.2.0";
+var version = "1.2.1";
 var description = "Deploy and manage self-hosted OpenClaw instances across clouds";
 var type = "module";
 var bin = {

package/dist/{server-QJRWK2RV.js → server-4DNHLGEG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   generatePlan
-} from "./chunk-QMXM2SMO.js";
+} from "./chunk-SSB6SGPQ.js";
 import {
   applyPlan
 } from "./chunk-LU63NZD3.js";
@@ -1231,7 +1231,7 @@ If none of the above resolves the issue:
 
 // src/mcp/server.ts
 async function serveMcp(opts) {
-  const { version } = await import("./package-3JZ767DN.js");
+  const { version } = await import("./package-SE3M4NJA.js");
   const server = new McpServer({ name: "clawops", version });
   registerTools(server, opts);
   registerResources(server);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawops/cli",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Deploy and manage self-hosted OpenClaw instances across clouds",
   "type": "module",
   "bin": {