@clawops/cli 1.7.8 → 2.0.0

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

@@ -1,24 +1,29 @@
 #!/usr/bin/env node
 import {
   makeStartupScript
-} from "./chunk-C5X375RO.js";
+} from "./chunk-CKSPROD5.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-6TIYVHPX.js";
+import "./chunk-EI7CQQ7D.js";
 
 // src/providers/aws/index.ts
 import process2 from "process";
 
 // src/providers/aws/program.ts
-var GATEWAY_PORT = 18789;
 var SSH_PORT = 22;
 var awsProgram = async () => {
-  const [pulumi, aws, { resolveIngressCidrs, detectEgressIp }] = await Promise.all([
+  const [pulumi, aws, { resolveIngressCidrs, resolveGatewayIngressCidrs, resolveGatewayPort, detectEgressIp }] = await Promise.all([
     import("@pulumi/pulumi"),
     import("@pulumi/aws"),
-    import("./firewall-XQGO7HWK.js")
+    import("./firewall-T3NTPZJD.js")
   ]);
   const cfg = new pulumi.Config();
   const instanceType = cfg.get("instanceType") ?? "t3.small";
   const region = cfg.get("region") ?? "us-east-1";
   const openclawVersion = cfg.get("openclawVersion") ?? "latest";
+  const publishGateway = cfg.get("publishGateway") === "all" ? "all" : "loopback";
+  const gatewayPort = resolveGatewayPort(cfg.get("gatewayPort"), GATEWAY_PORT);
   const accessMode = cfg.get("accessMode") ?? "restricted";
   const allowedCidrs = cfg.get("allowedCidrs") ?? "";
   const sshCidrs = cfg.get("sshCidrs") ?? "";
@@ -38,7 +43,13 @@ var awsProgram = async () => {
     );
   }
   const sshIngressCidrs = resolveIngressCidrs(accessMode, allowedCidrs, sshCidrs, egressResult);
-  const gatewayIngressCidrs = resolveIngressCidrs(accessMode, allowedCidrs, gatewayCidrs, egressResult);
+  const gatewayIngressCidrs = resolveGatewayIngressCidrs(
+    publishGateway,
+    accessMode,
+    allowedCidrs,
+    gatewayCidrs,
+    egressResult
+  );
   const vpc = new aws.ec2.Vpc("clawops-vpc", {
     cidrBlock: "10.0.0.0/16",
     enableDnsHostnames: true,
@@ -91,8 +102,8 @@ var awsProgram = async () => {
     new aws.vpc.SecurityGroupIngressRule(`clawops-sg-gw-${i}`, {
       securityGroupId: sg.id,
       ipProtocol: "tcp",
-      fromPort: GATEWAY_PORT,
-      toPort: GATEWAY_PORT,
+      fromPort: gatewayPort,
+      toPort: gatewayPort,
       cidrIpv4: cidr,
       tags: { Name: `clawops-gateway-${i}` }
     });
@@ -159,7 +170,7 @@ var awsProgram = async () => {
     vpcSecurityGroupIds: [sg.id],
     iamInstanceProfile: instanceProfile.name,
     keyName: keyPair.keyName,
-    userData: makeStartupScript({ openclawVersion, os: "ubuntu", bedrockEnabled }),
+    userData: makeStartupScript({ openclawVersion, os: "ubuntu", bedrockEnabled, publishGateway, gatewayPort }),
     // IMDSv2 with hopLimit=2 so Docker containers on this host can reach IMDS
     // and obtain the instance role credentials (required for Bedrock access).
     metadataOptions: {
@@ -179,7 +190,7 @@ var awsProgram = async () => {
   return {
     instanceId: instance.id,
     publicIp: eip.publicIp,
-    gatewayUrl: pulumi.interpolate`https://${eip.publicIp}:${GATEWAY_PORT}`,
+    gatewayUrl: pulumi.interpolate`https://${eip.publicIp}:${gatewayPort}`,
     sshHost: eip.publicIp,
     sshPort: SSH_PORT,
     sshUser: "ubuntu",

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

@@ -1,27 +1,32 @@
 #!/usr/bin/env node
 import {
   makeStartupScript
-} from "./chunk-C5X375RO.js";
+} from "./chunk-CKSPROD5.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-6TIYVHPX.js";
+import "./chunk-EI7CQQ7D.js";
 
 // src/providers/azure/index.ts
 import process2 from "process";
 
 // src/providers/azure/program.ts
 import { createHash } from "crypto";
-var GATEWAY_PORT = 18789;
 var SSH_PORT = 22;
 var azureProgram = async () => {
-  const [pulumi, azure, random, { resolveIngressCidrs, detectEgressIp }] = await Promise.all([
+  const [pulumi, azure, random, { resolveIngressCidrs, resolveGatewayIngressCidrs, resolveGatewayPort, detectEgressIp }] = await Promise.all([
     import("@pulumi/pulumi"),
     import("@pulumi/azure-native"),
     import("@pulumi/random"),
-    import("./firewall-XQGO7HWK.js")
+    import("./firewall-T3NTPZJD.js")
   ]);
   const cfg = new pulumi.Config();
   const stackName = pulumi.getStack();
   const instanceType = cfg.get("instanceType") ?? "Standard_B2s";
   const location = cfg.get("region") ?? "eastus";
   const openclawVersion = cfg.get("openclawVersion") ?? "latest";
+  const publishGateway = cfg.get("publishGateway") === "all" ? "all" : "loopback";
+  const gatewayPort = resolveGatewayPort(cfg.get("gatewayPort"), GATEWAY_PORT);
   const accessMode = cfg.get("accessMode") ?? "restricted";
   const allowedCidrs = cfg.get("allowedCidrs") ?? "";
   const sshCidrs = cfg.get("sshCidrs") ?? "";
@@ -42,7 +47,13 @@ var azureProgram = async () => {
     );
   }
   const sshIngressCidrs = resolveIngressCidrs(accessMode, allowedCidrs, sshCidrs, egressResult);
-  const gatewayIngressCidrs = resolveIngressCidrs(accessMode, allowedCidrs, gatewayCidrs, egressResult);
+  const gatewayIngressCidrs = resolveGatewayIngressCidrs(
+    publishGateway,
+    accessMode,
+    allowedCidrs,
+    gatewayCidrs,
+    egressResult
+  );
   const rg = new azure.resources.ResourceGroup("clawops-rg", {
     resourceGroupName,
     location
@@ -82,7 +93,7 @@ var azureProgram = async () => {
       sourceAddressPrefix: cidr,
       sourcePortRange: "*",
       destinationAddressPrefix: "*",
-      destinationPortRange: String(GATEWAY_PORT)
+      destinationPortRange: String(gatewayPort)
     });
   }
   const nsg = new azure.network.NetworkSecurityGroup("clawops-nsg", {
@@ -115,7 +126,7 @@ var azureProgram = async () => {
     osProfile: {
       adminUsername: "clawops",
       computerName: "clawops",
-      customData: Buffer.from(makeStartupScript({ openclawVersion, os: "ubuntu" })).toString("base64"),
+      customData: Buffer.from(makeStartupScript({ openclawVersion, os: "ubuntu", publishGateway, gatewayPort })).toString("base64"),
       linuxConfiguration: {
         disablePasswordAuthentication: true,
         ssh: {
@@ -181,7 +192,7 @@ var azureProgram = async () => {
   return {
     instanceId: vm.id,
     publicIp: resolvedIp,
-    gatewayUrl: pulumi.interpolate`https://${resolvedIp}:${GATEWAY_PORT}`,
+    gatewayUrl: pulumi.interpolate`https://${resolvedIp}:${gatewayPort}`,
     sshHost: resolvedIp,
     sshPort: SSH_PORT,
     sshUser: "clawops",

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

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   acquireSession
-} from "./chunk-DQDAWNGB.js";
-import "./chunk-3XK66DKK.js";
+} from "./chunk-3WYA2QDM.js";
+import "./chunk-AHAAEXWC.js";
 import {
   writeLocalState
 } from "./chunk-A2I76FTA.js";
@@ -10,12 +10,17 @@ import "./chunk-CX5SL5HP.js";
 import {
   ProviderError
 } from "./chunk-KGXPLI7W.js";
+import {
+  GATEWAY_PORT,
+  gatewayRunArgs,
+  gatewayRunCommand
+} from "./chunk-6TIYVHPX.js";
+import "./chunk-EI7CQQ7D.js";
 
 // src/providers/local/bootstrap.ts
 import { readFileSync, existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-var GATEWAY_PORT = 18789;
 var HEALTH_POLL_INTERVAL_MS = 3e3;
 var HEALTH_TIMEOUT_MS = 12e4;
 function loadTemplate() {
@@ -31,11 +36,18 @@ function loadTemplate() {
     `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);
+function renderScript(openclawVersion, gatewayPort = GATEWAY_PORT) {
+  const shared = {
+    image: "ghcr.io/openclaw/openclaw:${OPENCLAW_VERSION}",
+    stateDir: '"${OPENCLAW_STATE_DIR}"',
+    envFilePath: '"${OPENCLAW_ENV_FILE}"',
+    port: "${OPENCLAW_PORT}"
+  };
+  return loadTemplate().replace(/\{\{GATEWAY_RUN_SYSTEMD\}\}/g, gatewayRunArgs({ ...shared, supervisor: "systemd" })).replace(/\{\{GATEWAY_RUN_DARWIN\}\}/g, gatewayRunCommand(shared)).replace(/\{\{OPENCLAW_VERSION\}\}/g, openclawVersion).replace(/\{\{OPENCLAW_PORT\}\}/g, String(gatewayPort));
 }
 async function localBootstrap(opts) {
-  const script = renderScript(opts.openclawVersion);
+  const gatewayPort = opts.gatewayPort ?? GATEWAY_PORT;
+  const script = renderScript(opts.openclawVersion, gatewayPort);
   const b64 = Buffer.from(script, "utf-8").toString("base64");
   const command = opts.sudoPassword ? `printf '%s
 ' ${shellQuote(opts.sudoPassword)} | sudo -S -p '' bash -c "echo '${b64}' | base64 -d | bash"` : `echo '${b64}' | base64 -d | sudo bash`;
@@ -59,13 +71,14 @@ ${result.stderr || result.stdout}`
         );
       }
     }
+    if (!opts.noWait) await waitForGateway(session, gatewayPort, opts.signal);
   } finally {
     release();
   }
   const state = {
     instanceId: `local:${opts.host}`,
     publicIp: opts.host,
-    gatewayUrl: `http://${opts.host}:${GATEWAY_PORT}`,
+    gatewayUrl: `http://${opts.host}:${gatewayPort}`,
     sshHost: opts.host,
     sshPort: opts.port,
     sshUser: opts.user,
@@ -75,27 +88,22 @@ ${result.stderr || result.stdout}`
     knownHostsPath: opts.knownHostsPath
   };
   writeLocalState(opts.stackName, state);
-  if (!opts.noWait) {
-    await waitForGateway(opts.host, GATEWAY_PORT, opts.signal);
-  }
   return state;
 }
-async function waitForGateway(host, port, signal) {
-  const url = `http://${host}:${port}/health`;
+async function waitForGateway(session, gatewayPort, signal) {
+  const { probeCommand, interpretProbe } = await import("./health-5CCOXYGG.js");
+  const probe = probeCommand("started", gatewayPort);
   const deadline = Date.now() + HEALTH_TIMEOUT_MS;
   while (Date.now() < deadline) {
     if (signal?.aborted) {
       throw new ProviderError("Bootstrap aborted while waiting for gateway");
     }
-    try {
-      const res = await fetch(url, { signal });
-      if (res.ok) return;
-    } catch {
-    }
+    const result = await session.exec(probe, signal);
+    if (interpretProbe("started", result.stdout).ok) return;
     await sleep(HEALTH_POLL_INTERVAL_MS);
   }
   throw new ProviderError(
-    `Gateway at ${url} did not become healthy within ${HEALTH_TIMEOUT_MS / 1e3}s`
+    `Gateway did not finish starting within ${HEALTH_TIMEOUT_MS / 1e3}s. Probed /startupz on the host's loopback; check \`clawops logs\`.`
   );
 }
 function sleep(ms) {
@@ -132,5 +140,6 @@ ${stderr}`);
   }
 }
 export {
-  localBootstrap
+  localBootstrap,
+  renderScript
 };

package/dist/bootstrap.sh.tmpl

@@ -5,7 +5,7 @@
 set -euo pipefail
 
 OPENCLAW_VERSION="{{OPENCLAW_VERSION}}"
-OPENCLAW_PORT=18789
+OPENCLAW_PORT={{OPENCLAW_PORT}}
 
 # ── OS detection ──────────────────────────────────────────────────────────────
 OS="$(uname -s)"
@@ -25,17 +25,20 @@ case "$OS" in
       exit 1
     fi
     OPENCLAW_USER=clawops
-    OPENCLAW_CONFIG=/home/${OPENCLAW_USER}/openclaw.json
+    OPENCLAW_STATE_DIR=/var/lib/clawops/openclaw
+    OPENCLAW_CONFIG="${OPENCLAW_STATE_DIR}/openclaw.json"
+    OPENCLAW_LEGACY_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"
+    OPENCLAW_STATE_DIR="${HOME}/.clawops/openclaw"
+    OPENCLAW_CONFIG="${OPENCLAW_STATE_DIR}/openclaw.json"
+    OPENCLAW_LEGACY_CONFIG="${HOME}/.config/openclaw/config.json"
     # Fix ownership so subsequent non-sudo SSH writes (atomicWriteConfig) can overwrite.
-    chown "${OPENCLAW_USER}" "${HOME}/.config/openclaw" 2>/dev/null || true
+    chown "${OPENCLAW_USER}" "${OPENCLAW_STATE_DIR}" 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"
@@ -140,17 +143,51 @@ if [ ! -s "${OPENCLAW_ENV_FILE}" ]; then
   chown "${OPENCLAW_USER}" "${OPENCLAW_ENV_FILE}" 2>/dev/null || true
 fi
 
+# ── State directory ───────────────────────────────────────────────────────────
+# One directory holds config, the SQLite state and any plugins installed into it, so a
+# container replacement no longer destroys sessions and credentials.
+mkdir -p "${OPENCLAW_STATE_DIR}"
+
+# Migrate a pre-2.0 deployment. The config used to be a bare file elsewhere; without this
+# an in-place upgrade comes up with no configuration at all. Guarded on the target being
+# absent, so re-running the bootstrap never clobbers a later edit.
+if [ -f "${OPENCLAW_LEGACY_CONFIG}" ] && [ ! -f "${OPENCLAW_CONFIG}" ]; then
+  cp -p "${OPENCLAW_LEGACY_CONFIG}" "${OPENCLAW_CONFIG}"
+  mv "${OPENCLAW_LEGACY_CONFIG}" "${OPENCLAW_LEGACY_CONFIG}.migrated"
+  echo "clawops: migrated config from ${OPENCLAW_LEGACY_CONFIG}"
+  OPENCLAW_MIGRATED=1
+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":{}}
+  # Unquoted heredoc, so ${OPENCLAW_PORT} expands. gateway.port and the -p mapping have to
+  # be the same number: a container that publishes one port while the gateway listens on
+  # another starts, looks healthy to Docker, and answers nothing.
+  cat > "${OPENCLAW_CONFIG}" <<OPENCLAWJSON
+{"meta":{"lastTouchedVersion":"2026.9"},"gateway":{"mode":"local","port":${OPENCLAW_PORT},"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
+
+# Ownership last, so it covers the config and anything migrated above.
+if [ "$OS" = "Linux" ]; then
+  # NUMERIC, never clawops:clawops. useradd gets uid 1001 on Ubuntu 24.04 because the
+  # ubuntu user already holds 1000, and the container runs as 1000 — a 1001-owned state
+  # dir makes the gateway exit 1 with EACCES on its own SQLite WAL.
+  chown -R 1000:1000 "${OPENCLAW_STATE_DIR}"
+else
+  chown -R "${OPENCLAW_USER}" "${OPENCLAW_STATE_DIR}" 2>/dev/null || true
+fi
+
+# A 1.x config has no gateway.mode, and clawops no longer passes --allow-unconfigured, so a
+# migrated deployment would exit 78. Normalised with OpenClaw's own tooling — schema-aware,
+# atomic, and it applies OpenClaw's internal config migrations too. After the chown, so the
+# container can write.
+if [ "${OPENCLAW_MIGRATED:-0}" = "1" ]; then
+  docker run --rm -v "${OPENCLAW_STATE_DIR}":/home/node/.openclaw \
+    "ghcr.io/openclaw/openclaw:${OPENCLAW_VERSION}" \
+    openclaw config set gateway.mode local || \
+    echo "clawops: WARNING could not set gateway.mode; gateway may refuse to start" >&2
 fi
 
 # ── Start service ─────────────────────────────────────────────────────────────
@@ -168,13 +205,7 @@ 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}
+ExecStart=/usr/bin/{{GATEWAY_RUN_SYSTEMD}}
 ExecStop=/usr/bin/docker stop openclaw
 
 [Install]
@@ -187,18 +218,7 @@ UNIT
 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}
+  {{GATEWAY_RUN_DARWIN}}
 fi
 
 echo "clawops: bootstrap complete"

package/dist/channels-KBUR42IU.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// src/openclaw/channels.ts
+function requiredChannelPlugins(cfg, catalog) {
+  const configured = configuredChannelKeys(cfg);
+  const out = [];
+  for (const entry of catalog.integrations) {
+    const plugin = entry.plugin;
+    if (!plugin || plugin.source === "bundled" || !plugin.package) continue;
+    if (configured.has(entry.channelKey)) {
+      out.push({
+        channelKey: entry.channelKey,
+        package: plugin.package,
+        version: plugin.version ?? ""
+      });
+    }
+  }
+  return out;
+}
+function channelInstallCommand(plugin, image, stateDir) {
+  const spec = plugin.version ? `${plugin.package}@${plugin.version}` : plugin.package;
+  return `docker run --rm -v ${stateDir}:/home/node/.openclaw ${image} openclaw plugins install '${spec}' --accept-capabilities`;
+}
+var CHANNELS_LIST_CMD = "docker exec openclaw openclaw channels list --all --json";
+function missingChannels(cfg, channelsListJson, catalog) {
+  let installed;
+  try {
+    const parsed = JSON.parse(channelsListJson);
+    const chat = parsed.chat ?? {};
+    installed = new Set(
+      Object.entries(chat).filter(([, v]) => v.installed === true).map(([k]) => k)
+    );
+  } catch {
+    return [];
+  }
+  const bundled = new Set(
+    catalog.integrations.filter((i) => i.plugin?.source === "bundled").map((i) => i.channelKey)
+  );
+  return [...configuredChannelKeys(cfg)].filter((k) => !installed.has(k) && !bundled.has(k));
+}
+function configuredChannelKeys(cfg) {
+  if (cfg === null || typeof cfg !== "object") return /* @__PURE__ */ new Set();
+  const channels = cfg["channels"];
+  if (channels === null || typeof channels !== "object") return /* @__PURE__ */ new Set();
+  const notAChannel = /* @__PURE__ */ new Set(["defaults", "modelByChannel"]);
+  return new Set(Object.keys(channels).filter((k) => !notAChannel.has(k)));
+}
+export {
+  CHANNELS_LIST_CMD,
+  channelInstallCommand,
+  missingChannels,
+  requiredChannelPlugins
+};

package/dist/{chunk-DQDAWNGB.js → chunk-3WYA2QDM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   connect
-} from "./chunk-3XK66DKK.js";
+} from "./chunk-AHAAEXWC.js";
 import {
   NetworkError
 } from "./chunk-KGXPLI7W.js";

package/dist/chunk-6TIYVHPX.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import {
+  err,
+  ok
+} from "./chunk-EI7CQQ7D.js";
+
+// src/openclaw/run-flags.ts
+var CONFIG_MOUNT_PATH = "/app/config.json";
+var GATEWAY_PORT = 18789;
+var CONFIG_PATH_ENV = `-e OPENCLAW_CONFIG_PATH=${CONFIG_MOUNT_PATH}`;
+var ADD_HOST_FLAG = "--add-host=host.docker.internal:host-gateway";
+var PORT_PIN = `--port ${GATEWAY_PORT}`;
+var COMMON_RUN_FLAGS = `${CONFIG_PATH_ENV} ${ADD_HOST_FLAG}`;
+var IMAGE_INSPECT_CMD = `docker inspect openclaw --format '{{.Config.Image}}'`;
+function imageForRestart(inspectStdout) {
+  const image = inspectStdout.trim();
+  if (!image || image.includes("Error") || !image.includes(":")) {
+    return err(
+      "No running OpenClaw container found, so there is no image version to reuse. Deploy one with `clawops up --openclaw-version <version>`. clawops does not fall back to `latest` or `stable` here: both now point at OpenClaw 2.0, which this release line does not support."
+    );
+  }
+  return ok(image);
+}
+function versionOf(image) {
+  return image.split(":")[1] ?? "unknown";
+}
+
+// src/openclaw/runtime.ts
+var STATE_DIR_CONTAINER = "/home/node/.openclaw";
+var STATE_DIR_HOST_LINUX = "/var/lib/clawops/openclaw";
+var STATE_DIR_HOST_MACOS = "${HOME}/.clawops/openclaw";
+var CONFIG_FILENAME = "openclaw.json";
+var CONTAINER_UID = 1e3;
+var CONFIG_MOUNT_PATH2 = `${STATE_DIR_CONTAINER}/${CONFIG_FILENAME}`;
+function stateDirForOS(os) {
+  return os === "Darwin" ? STATE_DIR_HOST_MACOS : STATE_DIR_HOST_LINUX;
+}
+function configPathForOS(os) {
+  return `${stateDirForOS(os)}/${CONFIG_FILENAME}`;
+}
+var ENV_FILE_PATH = "/home/clawops/openclaw.env";
+var SECURITY_FLAGS = [
+  "--cap-drop=ALL",
+  "--security-opt no-new-privileges",
+  "--init",
+  "--pids-limit 512"
+].join(" ");
+var SUPERVISOR_ENV = "-e OPENCLAW_SUPERVISOR_MODE=external";
+var ADD_HOST_FLAG2 = "--add-host=host.docker.internal:host-gateway";
+function publishFlag(port, scope) {
+  return scope === "loopback" ? `-p 127.0.0.1:${port}:${port}` : `-p ${port}:${port}`;
+}
+function gatewayRunArgs(spec) {
+  const {
+    image,
+    stateDir,
+    port = GATEWAY_PORT,
+    envFilePath = ENV_FILE_PATH,
+    supervisor = "docker",
+    publish = "loopback",
+    limits
+  } = spec;
+  const envFileArg = `$([ -s ${envFilePath} ] && echo --env-file ${envFilePath})`;
+  const lifecycle = supervisor === "systemd" ? "--rm" : "-d --restart unless-stopped";
+  const capacity = [
+    limits?.memory ? `--memory ${limits.memory}` : "",
+    limits?.cpus ? `--cpus ${limits.cpus}` : ""
+  ].filter(Boolean).join(" ");
+  return [
+    `docker run ${lifecycle} --name openclaw`,
+    publishFlag(port, publish),
+    SECURITY_FLAGS,
+    capacity,
+    // No OPENCLAW_CONFIG_PATH: STATE_DIR_CONTAINER is OpenClaw's own default, so mounting
+    // it there *is* the configuration. One fewer thing to keep in sync.
+    ADD_HOST_FLAG2,
+    SUPERVISOR_ENV,
+    envFileArg,
+    // The directory, writable. Never the file, and never :ro — see GatewayRunSpec.stateDir.
+    `-v ${stateDir}:${STATE_DIR_CONTAINER}`,
+    spec.extraArgs?.trim() ?? "",
+    image,
+    // No --allow-unconfigured. That flag bypasses a check upstream describes as detecting
+    // "suspicious or clobbered config", and clawops passed it permanently — meaning a
+    // clobbered config would have started silently on defaults instead of failing.
+    // Provisioning writes `gateway.mode: "local"`, which is what the check actually wants.
+    // Measured on 2026.9.2: with the mode present the gateway starts without the flag; a
+    // config lacking it exits 78, which is the signal we want rather than one we suppress.
+    `node openclaw.mjs gateway run --port ${port}`
+  ].filter(Boolean).join(" ");
+}
+function gatewayRunCommand(spec) {
+  const { pathPrefix = "" } = spec;
+  return pathPrefix + [
+    "docker stop openclaw 2>/dev/null || true",
+    "docker rm   openclaw 2>/dev/null || true",
+    gatewayRunArgs(spec)
+  ].join(" && ");
+}
+var PUBLISH_INSPECT_CMD = `docker inspect openclaw --format '{{json .HostConfig.PortBindings}}'`;
+function publishedGatewayPort(inspectStdout) {
+  try {
+    const bindings = JSON.parse(inspectStdout.trim());
+    if (!bindings) return void 0;
+    for (const hostPorts of Object.values(bindings)) {
+      for (const binding of hostPorts ?? []) {
+        const port = Number(binding.HostPort);
+        if (Number.isInteger(port) && port > 0 && port < 65536) return port;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function publishForRestart(inspectStdout) {
+  try {
+    const bindings = JSON.parse(inspectStdout.trim());
+    if (!bindings) return "loopback";
+    for (const hostPorts of Object.values(bindings)) {
+      for (const binding of hostPorts ?? []) {
+        const ip = binding.HostIp ?? "";
+        if (ip === "" || ip === "0.0.0.0" || ip === "::") return "all";
+      }
+    }
+  } catch {
+  }
+  return "loopback";
+}
+
+export {
+  GATEWAY_PORT,
+  IMAGE_INSPECT_CMD,
+  imageForRestart,
+  versionOf,
+  STATE_DIR_CONTAINER,
+  STATE_DIR_HOST_LINUX,
+  STATE_DIR_HOST_MACOS,
+  CONFIG_FILENAME,
+  CONTAINER_UID,
+  CONFIG_MOUNT_PATH2 as CONFIG_MOUNT_PATH,
+  stateDirForOS,
+  configPathForOS,
+  ENV_FILE_PATH,
+  SECURITY_FLAGS,
+  SUPERVISOR_ENV,
+  ADD_HOST_FLAG2 as ADD_HOST_FLAG,
+  gatewayRunArgs,
+  gatewayRunCommand,
+  PUBLISH_INSPECT_CMD,
+  publishedGatewayPort,
+  publishForRestart
+};

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

@@ -140,6 +140,47 @@ var Ssh2Session = class {
       });
     });
   }
+  execWithInput(command, input, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted) {
+        reject(new NetworkError("Operation aborted"));
+        return;
+      }
+      this.client.exec(command, (err, channel) => {
+        if (err) {
+          reject(new NetworkError(`SSH exec failed: ${err.message}`));
+          return;
+        }
+        let stdout = "";
+        let stderr = "";
+        const onAbort = () => {
+          channel.destroy();
+          reject(new NetworkError("Operation aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        channel.on("data", (data) => {
+          stdout += data.toString("utf-8");
+        });
+        channel.stderr.on("data", (data) => {
+          stderr += data.toString("utf-8");
+        });
+        channel.on("close", (code) => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve({ stdout, stderr, code: code ?? 0 });
+        });
+        channel.on("error", (chanErr) => {
+          signal?.removeEventListener("abort", onAbort);
+          reject(new NetworkError(`SSH channel error: ${chanErr.message}`));
+        });
+        input.on("error", (readErr) => {
+          channel.destroy();
+          signal?.removeEventListener("abort", onAbort);
+          reject(new NetworkError(`Failed reading input: ${readErr.message}`));
+        });
+        input.pipe(channel);
+      });
+    });
+  }
   stream(command, signal) {
     return new Promise((resolve, reject) => {
       if (signal?.aborted) {