@clawops/cli 1.7.0 → 1.7.2

package/README.md

@@ -12,6 +12,68 @@ and Cursor drive them through typed MCP tools with explicit safety controls.
 
 ---
 
+## What's new in v1.7.0
+
+**`clawops harden`** — run an idempotent set of server-hardening modules against a deployed
+stack over SSH. Each module has a read-only `check()` and an `apply()` step; `check()` runs first
+and `apply()` is skipped when the box is already compliant. Sentinel files under
+`/etc/clawops/hardening/` record what has been applied.
+
+```bash
+clawops harden --list                          # show available modules
+clawops harden --stack prod --dry-run          # preview changes, apply nothing
+clawops harden --stack prod                     # apply the default module set
+clawops harden --stack prod --options ssh,ufw   # apply a specific subset
+```
+
+**Common modules (all providers), ON by default:** `ssh` (hardens `sshd_config`, guards against
+lockout by verifying `authorized_keys` is non-empty before restarting sshd), `ufw` (deny-all
+incoming, allow SSH + gateway 18789), `fail2ban` (SSH jail: 5 failures → 10-minute ban),
+`unattended-upgrades` (security-only auto updates), and `docker-socket` (verify
+`/var/run/docker.sock` is `root:docker 660`). **Opt-in:** `auditd`, `lynis` (CIS Level 1 scan →
+`~/.clawops/reports/`), `sysctl`.
+
+**AWS modules (check-only, ON by default):** `aws-sg-audit` (warns on `0.0.0.0/0` ingress on
+unexpected ports) and `aws-ssm-check` (verifies `AmazonSSMManagedInstanceCore` for emergency SSM
+shell access). **Opt-in:** `aws-flow-logs`, `aws-guardduty`.
+
+`clawops setup` now presents a multi-select hardening step after deploy (skippable with
+`--no-harden`), and `clawops doctor --stack <name>` gains a Hardening section showing which
+modules are applied, missing, or drifted.
+
+---
+
+## What's new in v1.6.0
+
+**`clawops bug`** — open a pre-filled GitHub issue with system context (version, Node, OS,
+provider, stack count, SSH key presence) populated automatically. `--json` emits the URL without
+prompting or opening a browser, suitable for scripting. `clawops doctor` now prints a `clawops bug`
+hint in its footer when it exits with an error.
+
+```bash
+clawops bug              # open a pre-filled issue in the browser
+clawops bug --json       # print the issue URL for scripting
+```
+
+**Cloud deploy bug fixes (AWS, GCP, Azure).** This release fixes 10 bugs found in a deploy audit,
+several deploy-blocking:
+
+- **Azure:** updated deprecated image reference `UbuntuServer/22.04-LTS` →
+  `0001-com-ubuntu-server-jammy/22_04-lts-gen2` — every Azure deployment was broken; and fixed a
+  malformed Key Vault `roleDefinitionId` that broke Key Vault RBAC entirely.
+- **AWS:** Bedrock startup script now uses the IMDSv2 PUT→GET token flow (a plain `curl` to IMDS
+  returned 401, so the region always fell back to `us-east-1`); replaced
+  `AmazonBedrockFullAccess` with a least-privilege inline policy.
+- **AWS (⚠️ migration impact):** migrated from inline Security Group ingress/egress arrays to
+  individual `SecurityGroupIngressRule`/`SecurityGroupEgressRule` resources so CIDR changes no
+  longer replace the whole Security Group. **Existing AWS stacks have their Security Group
+  replaced on the first `clawops up` after this upgrade** — see
+  `docs/decisions/0009-aws-sg-rule-resources.md` for the import-based mitigation.
+- **All providers:** `accessMode=auto` egress-IP detection now returns a `Result` and throws a
+  clear error on failure instead of silently producing a VM with zero ingress rules.
+
+---
+
 ## What's new in v1.5.0
 
 **`clawops mcp wire`** — wire the OpenClaw gateway's own AI as an MCP client of clawops.

package/dist/{apply-BTZFFGAD.js → apply-PZ5IIU7Z.js}

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   applyPlan
-} from "./chunk-ISFHLA4G.js";
-import "./chunk-YTH4L2GN.js";
+} from "./chunk-5SPESD5N.js";
 import "./chunk-6ZFIFDBJ.js";
 import "./chunk-BOPSG2LI.js";
-import "./chunk-ZFNPM2WG.js";
-import "./chunk-3MFZ7E74.js";
+import "./chunk-6X45DDGH.js";
+import "./chunk-O3F7OGH7.js";
+import "./chunk-P5LKWRPL.js";
+import "./chunk-PVUVI35Y.js";
 import "./chunk-A2I76FTA.js";
 import "./chunk-CX5SL5HP.js";
 import "./chunk-KGXPLI7W.js";

package/dist/{aws-D7Y6LCGK.js → aws-L4RR2LSE.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   makeStartupScript
-} from "./chunk-XKT42M34.js";
+} from "./chunk-C5X375RO.js";
 
 // src/providers/aws/index.ts
 import process2 from "process";

package/dist/{azure-JQAMNVHN.js → azure-7OXQENQL.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   makeStartupScript
-} from "./chunk-XKT42M34.js";
+} from "./chunk-C5X375RO.js";
 
 // src/providers/azure/index.ts
 import process2 from "process";

package/dist/{bootstrap-RY4VOSDJ.js → bootstrap-HL4DNUNG.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   acquireSession
-} from "./chunk-LCKD7L7X.js";
-import "./chunk-GJEF6UQA.js";
+} from "./chunk-DQDAWNGB.js";
+import "./chunk-3XK66DKK.js";
 import {
   writeLocalState
 } from "./chunk-A2I76FTA.js";
@@ -12,7 +12,7 @@ import {
 } from "./chunk-KGXPLI7W.js";
 
 // src/providers/local/bootstrap.ts
-import { readFileSync } from "fs";
+import { readFileSync, existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 var GATEWAY_PORT = 18789;
@@ -20,7 +20,16 @@ var HEALTH_POLL_INTERVAL_MS = 3e3;
 var HEALTH_TIMEOUT_MS = 12e4;
 function loadTemplate() {
   const dir = path.dirname(fileURLToPath(import.meta.url));
-  return readFileSync(path.join(dir, "bootstrap.sh.tmpl"), "utf-8");
+  const candidates = [
+    path.join(dir, "bootstrap.sh.tmpl"),
+    path.join(dir, "../src/providers/local/bootstrap.sh.tmpl")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return readFileSync(candidate, "utf-8");
+  }
+  throw new Error(
+    `Cannot find bootstrap.sh.tmpl (looked in: ${candidates.join(", ")}). If this is an installed package, the template may be missing from the build output.`
+  );
 }
 function renderScript(openclawVersion) {
   return loadTemplate().replace(/\{\{OPENCLAW_VERSION\}\}/g, openclawVersion);

package/dist/bootstrap.sh.tmpl

@@ -0,0 +1,204 @@
+#!/bin/bash
+# clawops bootstrap script — idempotent; safe to re-run.
+# Rendered by clawops and executed via SSH on the target host.
+# Supports: Ubuntu/Debian, RHEL/Fedora/CentOS (dnf/yum), Alpine (apk), macOS.
+set -euo pipefail
+
+OPENCLAW_VERSION="{{OPENCLAW_VERSION}}"
+OPENCLAW_PORT=18789
+
+# ── OS detection ──────────────────────────────────────────────────────────────
+OS="$(uname -s)"
+
+case "$OS" in
+  Linux)
+    if command -v apt-get &>/dev/null; then
+      PKG_MANAGER=apt
+    elif command -v dnf &>/dev/null; then
+      PKG_MANAGER=dnf
+    elif command -v yum &>/dev/null; then
+      PKG_MANAGER=yum
+    elif command -v apk &>/dev/null; then
+      PKG_MANAGER=apk
+    else
+      echo "clawops: unsupported Linux distribution (no apt/dnf/yum/apk found)" >&2
+      exit 1
+    fi
+    OPENCLAW_USER=clawops
+    OPENCLAW_CONFIG=/home/${OPENCLAW_USER}/openclaw.json
+    ;;
+  Darwin)
+    PKG_MANAGER=darwin
+    # When invoked via sudo the script runs as root but SUDO_USER is the real caller.
+    # Fall back to id -un for passwordless (non-sudo) invocations.
+    OPENCLAW_USER="${SUDO_USER:-$(id -un)}"
+    OPENCLAW_CONFIG="${HOME}/.config/openclaw/config.json"
+    mkdir -p "${HOME}/.config/openclaw"
+    # Fix ownership so subsequent non-sudo SSH writes (atomicWriteConfig) can overwrite.
+    chown "${OPENCLAW_USER}" "${HOME}/.config/openclaw" 2>/dev/null || true
+    # sudo resets PATH; add common Docker install locations so `command -v docker` works.
+    # Covers: Docker Desktop (Intel + AS), Homebrew (AS), Colima.
+    export PATH="/usr/local/bin:/opt/homebrew/bin:/Applications/Docker.app/Contents/Resources/bin:$PATH"
+    ;;
+  *)
+    echo "clawops: unsupported OS: $OS" >&2
+    exit 1
+    ;;
+esac
+
+# ── Create clawops user (Linux only) ─────────────────────────────────────────
+if [ "$OS" = "Linux" ]; then
+  id -u "${OPENCLAW_USER}" &>/dev/null || useradd -m -s /bin/bash "${OPENCLAW_USER}"
+fi
+
+# ── Install Docker ─────────────────────────────────────────────────────────────
+if ! command -v docker &>/dev/null; then
+  case "$PKG_MANAGER" in
+    darwin)
+      echo "clawops: Docker not found on macOS." >&2
+      echo "Install one of:" >&2
+      echo "  Docker Desktop: https://www.docker.com/products/docker-desktop/" >&2
+      echo "  Homebrew:       brew install --cask docker" >&2
+      echo "  Colima (FOSS):  brew install colima docker && colima start" >&2
+      exit 1
+      ;;
+    apt)
+      export DEBIAN_FRONTEND=noninteractive
+      apt-get update -q
+      apt-get install -y -q ca-certificates curl gnupg lsb-release
+      install -m 0755 -d /etc/apt/keyrings
+      # Detect Ubuntu vs Debian; use the correct Docker APT repo for each.
+      # /etc/os-release ID is 'ubuntu' on Ubuntu and 'debian' on Debian.
+      # Other debian-based distros (Raspbian, Mint, etc.) fall back to the debian repo.
+      . /etc/os-release
+      case "${ID:-ubuntu}" in
+        ubuntu) DOCKER_DISTRO=ubuntu ;;
+        *)      DOCKER_DISTRO=debian ;;
+      esac
+      curl -fsSL "https://download.docker.com/linux/${DOCKER_DISTRO}/gpg" \
+        | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+      chmod a+r /etc/apt/keyrings/docker.gpg
+      echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
+        https://download.docker.com/linux/${DOCKER_DISTRO} $(lsb_release -cs) stable" \
+        > /etc/apt/sources.list.d/docker.list
+      apt-get update -q
+      apt-get install -y -q docker-ce docker-ce-cli containerd.io
+      systemctl enable --now docker
+      ;;
+    dnf|yum)
+      $PKG_MANAGER install -y dnf-plugins-core 2>/dev/null || $PKG_MANAGER install -y yum-utils
+      $PKG_MANAGER config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
+      $PKG_MANAGER install -y docker-ce docker-ce-cli containerd.io
+      systemctl enable --now docker
+      ;;
+    apk)
+      apk add --no-cache docker
+      rc-update add docker boot
+      service docker start
+      ;;
+  esac
+fi
+
+# ── Verify Docker daemon is reachable ─────────────────────────────────────────
+# Try docker version (faster than docker info) across all known socket paths.
+docker_reachable() {
+  docker version >/dev/null 2>&1 && return 0
+  if [ "$OS" = "Darwin" ]; then
+    DOCKER_HOST="unix://${HOME}/.docker/run/docker.sock" docker version >/dev/null 2>&1 && return 0
+    DOCKER_HOST="unix://${HOME}/.colima/default/docker.sock" docker version >/dev/null 2>&1 && return 0
+  fi
+  return 1
+}
+
+if ! docker_reachable; then
+  echo "clawops: Docker is installed but the daemon is not running." >&2
+  if [ "$PKG_MANAGER" = "darwin" ]; then
+    echo "Start Docker Desktop or run: colima start" >&2
+  else
+    echo "Try: systemctl start docker" >&2
+  fi
+  exit 1
+fi
+
+# ── Add clawops user to docker group (Linux only) ────────────────────────────
+if [ "$OS" = "Linux" ]; then
+  usermod -aG docker "${OPENCLAW_USER}" || true
+fi
+
+# ── Pull OpenClaw image ────────────────────────────────────────────────────────
+docker pull "ghcr.io/openclaw/openclaw:${OPENCLAW_VERSION}"
+
+# ── Gateway auth token ────────────────────────────────────────────────────────
+# OpenClaw refuses to bind a non-loopback listener without auth, and in a container
+# it always binds 0.0.0.0 — so without a token the gateway exits 78 and systemd
+# restart-loops. Generated once and reused on re-runs so restarts don't rotate it.
+OPENCLAW_ENV_FILE=/home/clawops/openclaw.env
+if [ ! -s "${OPENCLAW_ENV_FILE}" ]; then
+  OPENCLAW_TOKEN=$(openssl rand -hex 32 2>/dev/null || head -c 32 /dev/urandom | od -An -tx1 | tr -d ' \n')
+  printf 'OPENCLAW_GATEWAY_TOKEN=%s\n' "${OPENCLAW_TOKEN}" > "${OPENCLAW_ENV_FILE}"
+  chmod 600 "${OPENCLAW_ENV_FILE}"
+  chown "${OPENCLAW_USER}" "${OPENCLAW_ENV_FILE}" 2>/dev/null || true
+fi
+
+# ── Write default openclaw.json if absent ─────────────────────────────────────
+# clawops up --config will overwrite this with the plan config overlay.
+if [ ! -f "${OPENCLAW_CONFIG}" ]; then
+  cat > "${OPENCLAW_CONFIG}" <<'OPENCLAWJSON'
+{"meta":{"lastTouchedVersion":"2026.4"},"gateway":{"port":18789,"auth":{"mode":"token"}},"models":{},"channels":{}}
+OPENCLAWJSON
+  if [ "$OS" = "Linux" ]; then
+    chown "${OPENCLAW_USER}:${OPENCLAW_USER}" "${OPENCLAW_CONFIG}"
+  else
+    chown "${OPENCLAW_USER}" "${OPENCLAW_CONFIG}" 2>/dev/null || true
+  fi
+fi
+
+# ── Start service ─────────────────────────────────────────────────────────────
+if [ "$OS" = "Linux" ]; then
+  SERVICE_FILE=/etc/systemd/system/openclaw.service
+  cat > "${SERVICE_FILE}" <<UNIT
+[Unit]
+Description=OpenClaw gateway
+After=docker.service
+Requires=docker.service
+
+[Service]
+User=${OPENCLAW_USER}
+Restart=always
+RestartSec=5
+ExecStartPre=-/usr/bin/docker stop openclaw
+ExecStartPre=-/usr/bin/docker rm openclaw
+ExecStart=/usr/bin/docker run --name openclaw --rm \
+  -p ${OPENCLAW_PORT}:${OPENCLAW_PORT} \
+  -e OPENCLAW_CONFIG_PATH=/app/config.json --add-host=host.docker.internal:host-gateway \
+  --env-file ${OPENCLAW_ENV_FILE} \
+  -v ${OPENCLAW_CONFIG}:/app/config.json:ro \
+  ghcr.io/openclaw/openclaw:${OPENCLAW_VERSION} \
+  node openclaw.mjs gateway run --allow-unconfigured --port ${OPENCLAW_PORT}
+ExecStop=/usr/bin/docker stop openclaw
+
+[Install]
+WantedBy=multi-user.target
+UNIT
+  systemctl daemon-reload
+  systemctl enable openclaw
+  systemctl restart openclaw
+
+elif [ "$OS" = "Darwin" ]; then
+  # macOS: no systemd; run as foreground-detached container.
+  # LaunchAgent support is a future enhancement.
+  docker stop openclaw 2>/dev/null || true
+  docker rm openclaw 2>/dev/null || true
+  docker run -d \
+    --name openclaw \
+    --restart unless-stopped \
+    -p "${OPENCLAW_PORT}:${OPENCLAW_PORT}" \
+    -e OPENCLAW_CONFIG_PATH=/app/config.json --add-host=host.docker.internal:host-gateway \
+    --env-file "${OPENCLAW_ENV_FILE}" \
+  --env-file ${OPENCLAW_ENV_FILE} \
+    -v "${OPENCLAW_CONFIG}":/app/config.json:ro \
+    "ghcr.io/openclaw/openclaw:${OPENCLAW_VERSION}" \
+    node openclaw.mjs gateway run --allow-unconfigured --port ${OPENCLAW_PORT}
+fi
+
+echo "clawops: bootstrap complete"

package/dist/chunk-2YOP6N7X.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import {
+  resolveSpecDir
+} from "./chunk-PVUVI35Y.js";
+
+// src/openclaw/versions.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// src/types/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/openclaw/versions.ts
+var MOVING_TAGS = ["latest", "stable", "dev", "main"];
+function isMovingTag(v) {
+  return MOVING_TAGS.includes(v);
+}
+var _spec;
+function loadVersionSpec(yaml) {
+  if (_spec) return _spec;
+  const specPath = join(resolveSpecDir(), "openclaw-versions.yaml");
+  try {
+    const raw = yaml.load(readFileSync(specPath, "utf-8"));
+    if (!raw?.support?.min) {
+      throw new Error("missing support.min");
+    }
+    _spec = {
+      support: {
+        min: raw.support.min,
+        max: raw.support.max ?? "",
+        recommended: raw.support.recommended ?? raw.support.min
+      }
+    };
+    return _spec;
+  } catch (e) {
+    throw new Error(
+      `Cannot load OpenClaw version support matrix from ${specPath}: ${e.message}`
+    );
+  }
+}
+function _resetVersionSpecCache() {
+  _spec = void 0;
+}
+function compareVersions(a, b) {
+  const parse = (v) => v.split(/[.-]/).map((seg) => Number.parseInt(seg, 10)).map((n) => Number.isNaN(n) ? 0 : n);
+  const pa = parse(a);
+  const pb = parse(b);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function checkVersion(version, support) {
+  if (isMovingTag(version)) {
+    return err({
+      requested: version,
+      resolved: version,
+      reason: "too-new",
+      supportedRange: describeRange(support),
+      message: `Cannot verify OpenClaw compatibility: "${version}" is a moving tag that was not resolved to a concrete release. Pin an explicit version (${support.recommended}) or re-run once tag resolution is available.`
+    });
+  }
+  if (compareVersions(version, support.min) < 0) {
+    return err({
+      requested: version,
+      resolved: version,
+      reason: "too-old",
+      supportedRange: describeRange(support),
+      message: `OpenClaw ${version} is older than this clawops release supports (${describeRange(support)}). Upgrade OpenClaw, or pin ${support.recommended}.`
+    });
+  }
+  if (support.max && compareVersions(version, support.max) > 0) {
+    return err({
+      requested: version,
+      resolved: version,
+      reason: "too-new",
+      supportedRange: describeRange(support),
+      message: `OpenClaw ${version} is newer than this clawops release supports (${describeRange(support)}).
+OpenClaw 2026.8.1+ changed the container runtime contract: state moved to SQLite, config moved to a writable path, and provider plugins became install-gated.
+Use clawops 2.x for OpenClaw 2026.9.1 and later:  npm install -g @clawops/cli@latest
+To stay on this line, pin an OpenClaw version at or below ${support.max}.`
+    });
+  }
+  return ok(version);
+}
+function describeRange(support) {
+  if (!support.max) return `>= ${support.min}`;
+  return `${support.min} \u2013 ${support.max}`;
+}
+async function resolveVersion(version, resolver) {
+  if (!isMovingTag(version)) return version;
+  if (!resolver) return version;
+  try {
+    return await resolver(version) ?? version;
+  } catch {
+    return version;
+  }
+}
+async function assertSupportedVersion(version, yaml, resolver) {
+  const spec = loadVersionSpec(yaml);
+  const resolved = await resolveVersion(version, resolver);
+  const result = checkVersion(resolved, spec.support);
+  if (!result.ok && resolved !== version) {
+    return err({ ...result.error, requested: version });
+  }
+  return result;
+}
+
+export {
+  MOVING_TAGS,
+  isMovingTag,
+  loadVersionSpec,
+  _resetVersionSpecCache,
+  compareVersions,
+  checkVersion,
+  describeRange,
+  resolveVersion,
+  assertSupportedVersion
+};

package/dist/{chunk-GJEF6UQA.js → chunk-3XK66DKK.js}

@@ -8,6 +8,98 @@ import { readFileSync, appendFileSync, mkdirSync } from "fs";
 import { createServer } from "net";
 import path from "path";
 import { Client } from "ssh2";
+
+// src/transport/known-hosts.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function hostEntryFor(host, port) {
+  return port === 22 ? host : `[${host}]:${port}`;
+}
+function parseKnownHosts(content) {
+  const entries = [];
+  for (const raw of content.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    let parts = line.split(/\s+/);
+    let marker;
+    if (parts[0]?.startsWith("@")) {
+      marker = parts[0];
+      parts = parts.slice(1);
+    }
+    const hostField = parts[0];
+    if (!hostField) continue;
+    const hosts = hostField.split(",");
+    if (parts.length >= 3) {
+      entries.push({ hosts, keyType: parts[1], base64Key: parts[2], ...marker ? { marker } : {} });
+    } else if (parts.length === 2 && /^[0-9a-f]+$/i.test(parts[1] ?? "")) {
+      entries.push({ hosts, hexKey: parts[1], ...marker ? { marker } : {} });
+    }
+  }
+  return entries;
+}
+function hashedHostMatches(token, hostEntry) {
+  const parts = token.split("|");
+  if (parts.length !== 4 || parts[1] !== "1") return false;
+  const salt = parts[2];
+  const expected = parts[3];
+  if (!salt || !expected) return false;
+  try {
+    const actual = createHmac("sha1", Buffer.from(salt, "base64")).update(hostEntry).digest("base64");
+    const a = Buffer.from(actual);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+  } catch {
+    return false;
+  }
+}
+function patternToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+var isPattern = (host) => host.includes("*") || host.includes("?");
+function entryMatchesHost(entry, hostEntry) {
+  let matched = false;
+  for (const host of entry.hosts) {
+    if (host.startsWith("|1|")) {
+      if (hashedHostMatches(host, hostEntry)) matched = true;
+      continue;
+    }
+    const negated = host.startsWith("!");
+    const pattern = negated ? host.slice(1) : host;
+    const hit = isPattern(pattern) ? patternToRegExp(pattern).test(hostEntry) : pattern === hostEntry;
+    if (hit) {
+      if (negated) return false;
+      matched = true;
+    }
+  }
+  return matched;
+}
+function verifyAgainstKnownHosts(content, host, port, key) {
+  const hostEntry = hostEntryFor(host, port);
+  const base64Key = key.toString("base64");
+  const hexKey = key.toString("hex");
+  let sawHost = false;
+  for (const entry of parseKnownHosts(content)) {
+    if (!entryMatchesHost(entry, hostEntry)) continue;
+    if (entry.marker === "@cert-authority") continue;
+    sawHost = true;
+    const matches = entry.base64Key ? entry.base64Key === base64Key : entry.hexKey?.toLowerCase() === hexKey.toLowerCase();
+    if (matches) return entry.marker === "@revoked" ? "mismatch" : "match";
+  }
+  return sawHost ? "mismatch" : "unknown";
+}
+function formatKnownHostsLine(host, port, keyType, key) {
+  return `${hostEntryFor(host, port)} ${keyType} ${key.toString("base64")}
+`;
+}
+function keyTypeFromBlob(key) {
+  if (key.length < 4) return void 0;
+  const len = key.readUInt32BE(0);
+  if (len === 0 || len > 64 || key.length < 4 + len) return void 0;
+  const type = key.subarray(4, 4 + len).toString("utf-8");
+  return /^[\x20-\x7e]+$/.test(type) ? type : void 0;
+}
+
+// src/transport/ssh.ts
 var Ssh2Session = class {
   constructor(client) {
     this.client = client;
@@ -147,27 +239,19 @@ async function connect(opts) {
   });
 }
 function verifyHostKey(host, port, keyHash, knownHostsPath) {
-  const keyHex = keyHash.toString("hex");
-  const hostEntry = port === 22 ? host : `[${host}]:${port}`;
-  let existing = null;
+  let content = "";
   try {
-    const content = readFileSync(knownHostsPath, "utf-8");
-    for (const line of content.split("\n")) {
-      const parts = line.trim().split(/\s+/);
-      if (parts[0] === hostEntry && parts.length >= 2) {
-        existing = parts[1] ?? null;
-        break;
-      }
-    }
+    content = readFileSync(knownHostsPath, "utf-8");
   } catch {
   }
-  if (existing !== null) {
-    return existing === keyHex;
-  }
+  const verdict = verifyAgainstKnownHosts(content, host, port, keyHash);
+  if (verdict === "match") return true;
+  if (verdict === "mismatch") return false;
+  const keyType = keyTypeFromBlob(keyHash);
+  if (!keyType) return false;
   try {
     mkdirSync(path.dirname(knownHostsPath), { recursive: true });
-    appendFileSync(knownHostsPath, `${hostEntry} ${keyHex}
-`, "utf-8");
+    appendFileSync(knownHostsPath, formatKnownHostsLine(host, port, keyType, keyHash), "utf-8");
   } catch {
   }
   return true;

package/dist/{chunk-ISFHLA4G.js → chunk-5SPESD5N.js}

@@ -1,22 +1,22 @@
 #!/usr/bin/env node
-import {
-  validatePlan
-} from "./chunk-YTH4L2GN.js";
 import {
   saveOverlay
 } from "./chunk-6ZFIFDBJ.js";
 import {
   resolveSecrets
 } from "./chunk-BOPSG2LI.js";
+import {
+  validatePlan
+} from "./chunk-6X45DDGH.js";
 import {
   atomicWriteConfig,
   deepMerge,
   readRemoteConfig,
   restartGateway
-} from "./chunk-ZFNPM2WG.js";
+} from "./chunk-O3F7OGH7.js";
 import {
   buildContext
-} from "./chunk-3MFZ7E74.js";
+} from "./chunk-P5LKWRPL.js";
 import {
   UsageError
 } from "./chunk-KGXPLI7W.js";
@@ -35,6 +35,8 @@ ${validation.errors.join("\n")}`
       "plan/apply is not supported for the local provider. Use `clawops up` directly."
     );
   }
+  const { guardOpenclawVersion } = await import("./version-guard-MZAO4KHS.js");
+  await guardOpenclawVersion(plan.spec.openclaw.version);
   const ctx = buildContext({
     stack: plan.spec.stackName,
     provider: plan.spec.provider
@@ -86,7 +88,7 @@ The diff you reviewed may no longer reflect what will be applied.
   };
 }
 async function applyConfigOverlay(plan, outputs, ctx, signal) {
-  const { connect } = await import("./ssh-E2AMBPZY.js");
+  const { connect } = await import("./ssh-CNJNLM3E.js");
   const connInfo = ctx.adapter.getConnectionInfo(outputs);
   const session = await connect({
     host: connInfo.host,

package/dist/{chunk-YTH4L2GN.js → chunk-6X45DDGH.js}

@@ -1,19 +1,20 @@
 #!/usr/bin/env node
+import {
+  resolveSpecDir
+} from "./chunk-PVUVI35Y.js";
 
 // src/plan/validate.ts
 import Ajv from "ajv/dist/2020";
 import addFormats from "ajv-formats";
 import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-import { join, dirname } from "path";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+import { join } from "path";
 var _validate;
 function getValidator() {
   if (_validate) return _validate;
   const ajv = new Ajv({ strict: false });
   addFormats(ajv);
   const schema = JSON.parse(
-    readFileSync(join(__dirname, "../../spec/deploy-plan.schema.json"), "utf-8")
+    readFileSync(join(resolveSpecDir(), "deploy-plan.schema.json"), "utf-8")
   );
   _validate = ajv.compile(schema);
   return _validate;