@clawops/cli 1.7.9 → 2.0.1

package/dist/apply-KYFPWI5U.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  applyPlan
+} from "./chunk-LBE6COC4.js";
+import "./chunk-BOPSG2LI.js";
+import "./chunk-6ZFIFDBJ.js";
+import "./chunk-2I7KCMXZ.js";
+import "./chunk-HSPHXG6W.js";
+import "./chunk-AEEMRFZV.js";
+import "./chunk-BSLIYB5Q.js";
+import "./chunk-5XT5IAJK.js";
+import "./chunk-NUDIHZEH.js";
+import "./chunk-JW5A7E3X.js";
+import "./chunk-LEVIW2PV.js";
+import "./chunk-GIEVAGEK.js";
+import "./chunk-VOEJYRIK.js";
+import "./chunk-EI7CQQ7D.js";
+import "./chunk-FEK7VJAY.js";
+import "./chunk-RHOWYIWT.js";
+import "./chunk-N4WZLWJ4.js";
+import "./chunk-A2I76FTA.js";
+import "./chunk-CX5SL5HP.js";
+import "./chunk-KGXPLI7W.js";
+import "./chunk-VUFMZEIM.js";
+export {
+  applyPlan
+};

package/dist/automation-RMAIBNVC.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import {
+  ensurePulumiCli
+} from "./chunk-W3OLNNJW.js";
+import {
+  ensurePassphrase
+} from "./chunk-V25QRZRB.js";
+import {
+  getConfigDir
+} from "./chunk-CX5SL5HP.js";
+import "./chunk-KGXPLI7W.js";
+
+// src/pulumi/automation.ts
+import path from "path";
+import { LocalWorkspace } from "@pulumi/pulumi/automation";
+async function getOrCreateStack(opts) {
+  const configDir = opts.configDir ?? getConfigDir();
+  const pulumiCommand = await ensurePulumiCli({ configDir, onInstall: opts.onInstall });
+  const passphrase = ensurePassphrase(configDir);
+  return await LocalWorkspace.createOrSelectStack(
+    {
+      stackName: opts.stack,
+      projectName: "clawops",
+      program: opts.program
+    },
+    {
+      pulumiCommand,
+      pulumiHome: path.join(configDir, ".pulumi"),
+      envVars: {
+        PULUMI_BACKEND_URL: opts.stateUrl,
+        PULUMI_SKIP_UPDATE_CHECK: "1",
+        // A self-managed backend has no key service, so a new stack cannot be created without
+        // a secrets manager, and the only one available is a passphrase. Undefined when the
+        // operator supplies their own — overriding it would orphan their existing stacks.
+        // See ./passphrase.ts and ADR 0011.
+        ...passphrase ? { PULUMI_CONFIG_PASSPHRASE: passphrase } : {}
+        // R6: cloud credentials inherited from process.env, never set here
+      }
+    }
+  );
+}
+export {
+  getOrCreateStack
+};

package/dist/bedrock-XVASJX2K.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/openclaw/bedrock.ts
+function resolveInferenceProfile(foundationModelId, profiles, region) {
+  const candidates = profiles.map((p) => p.inferenceProfileId).filter((id) => id.endsWith(`.${foundationModelId}`));
+  if (candidates.length === 0) {
+    return {
+      ok: false,
+      error: `No Bedrock inference profile for "${foundationModelId}" in ${region}. Bedrock refuses bare foundation-model ids for on-demand inference, so this model cannot be used there. Check the model is enabled in this region, or choose another.`
+    };
+  }
+  const geo = geographyFor(region);
+  const regional = candidates.find((id) => id.startsWith(`${geo}.`));
+  if (regional) return { ok: true, profileId: regional, why: `${geo} profile for ${region}` };
+  const global = candidates.find((id) => id.startsWith("global."));
+  if (global) {
+    return {
+      ok: true,
+      profileId: global,
+      why: `no ${geo} profile for ${region}; using the global profile`
+    };
+  }
+  return {
+    ok: false,
+    error: `Bedrock has inference profiles for "${foundationModelId}" (${candidates.join(", ")}) but none for ${region} or global. Using one would route inference to another geography; choose a region where the model is offered.`
+  };
+}
+function geographyFor(region) {
+  const prefix = region.split("-")[0] ?? region;
+  if (prefix === "ap") return "apac";
+  return prefix;
+}
+async function fetchInferenceProfiles(region, signal) {
+  try {
+    const { BedrockClient, ListInferenceProfilesCommand } = await import("@aws-sdk/client-bedrock");
+    const client = new BedrockClient({ region });
+    const profiles = [];
+    let nextToken;
+    do {
+      const page = await client.send(
+        new ListInferenceProfilesCommand({ maxResults: 100, nextToken }),
+        { abortSignal: signal }
+      );
+      for (const p of page.inferenceProfileSummaries ?? []) {
+        if (p.inferenceProfileId) profiles.push({ inferenceProfileId: p.inferenceProfileId });
+      }
+      nextToken = page.nextToken;
+    } while (nextToken);
+    return { ok: true, profiles };
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Could not list Bedrock inference profiles in ${region}: ${err instanceof Error ? err.message : String(err)}. The deploying identity needs bedrock:ListInferenceProfiles.`
+    };
+  }
+}
+export {
+  fetchInferenceProfiles,
+  geographyFor,
+  resolveInferenceProfile
+};

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

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
 import {
   acquireSession
-} from "./chunk-DQDAWNGB.js";
-import "./chunk-3XK66DKK.js";
+} from "./chunk-2Z7J3ERQ.js";
+import "./chunk-E4NJSJ54.js";
+import "./chunk-MC5ATCXS.js";
+import {
+  gatewayRunArgs,
+  gatewayRunCommand
+} from "./chunk-GIEVAGEK.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+import "./chunk-EI7CQQ7D.js";
 import {
   writeLocalState
 } from "./chunk-A2I76FTA.js";
@@ -15,7 +24,6 @@ import {
 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 +39,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 +74,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 +91,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 +143,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-2I7KCMXZ.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+import {
+  execPrivileged
+} from "./chunk-NUDIHZEH.js";
+import {
+  CONTAINER_UID,
+  PUBLISH_INSPECT_CMD,
+  configPathForOS,
+  gatewayRunCommand,
+  publishForRestart,
+  stateDirForOS
+} from "./chunk-GIEVAGEK.js";
+import {
+  GATEWAY_PORT,
+  IMAGE_INSPECT_CMD,
+  imageForRestart
+} from "./chunk-VOEJYRIK.js";
+
+// src/plan/remote-config.ts
+var OPENCLAW_CONFIG_LINUX = configPathForOS("Linux");
+var OPENCLAW_CONFIG_MACOS = configPathForOS("Darwin");
+var OPENCLAW_CONFIG = OPENCLAW_CONFIG_LINUX;
+var OPENCLAW_TMP = "/tmp/clawops-config.json.tmp";
+async function detectOS(session, signal) {
+  const result = await session.exec("uname -s", signal);
+  return result.stdout.trim() === "Darwin" ? "Darwin" : "Linux";
+}
+async function readRemoteConfig(session, signal) {
+  const os = await detectOS(session, signal);
+  const configPath = configPathForOS(os);
+  const result = os === "Darwin" ? await session.exec(`cat ${configPath}`, signal) : await execPrivileged(session, `cat ${configPath}`, signal);
+  if (result.code !== 0) {
+    throw new Error(`Cannot read ${configPath}: ${result.stderr}`);
+  }
+  try {
+    return JSON.parse(result.stdout);
+  } catch {
+    throw new Error(`Cannot parse ${configPath}: invalid JSON`);
+  }
+}
+async function atomicWriteConfig(session, cfg, signal, opts = {}) {
+  const os = await detectOS(session, signal);
+  const configPath = configPathForOS(os);
+  const json = JSON.stringify(cfg, null, 2);
+  if (!opts.skipValidation) {
+    const [{ validateConfig }, yaml] = await Promise.all([
+      import("./config-validate-K2N6XLDX.js"),
+      import("./js-yaml-PTEEG4FO.js")
+    ]);
+    const { loadVersionSpec } = await import("./versions-W5LRQCAJ.js");
+    const spec = loadVersionSpec(yaml);
+    const { errors, warnings } = await validateConfig(cfg, {
+      openclawVersion: opts.openclawVersion,
+      schemaCapturedFrom: spec.runtime?.configSchemaCapturedFrom
+    });
+    for (const w of warnings) process.stderr.write(`warning: ${w}
+`);
+    if (errors.length > 0) {
+      const rejected = `${configPath}.rejected.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      const b64r = Buffer.from(json, "utf-8").toString("base64");
+      await execPrivileged(session, `echo '${b64r}' | base64 -d > ${rejected}`, signal);
+      throw new Error(
+        `Refusing to write an invalid OpenClaw config:
+` + errors.map((e) => `  - ${e}`).join("\n") + `
+The rejected config was kept at ${rejected}. The deployment's current config is unchanged.`
+      );
+    }
+  }
+  const b64 = Buffer.from(json, "utf-8").toString("base64");
+  const chown = os === "Linux" ? ` && chown ${CONTAINER_UID}:${CONTAINER_UID} ${configPath}` : "";
+  const cmd = `echo '${b64}' | base64 -d > ${OPENCLAW_TMP} && mv ${OPENCLAW_TMP} ${configPath}` + chown;
+  const result = os === "Darwin" ? await session.exec(cmd, signal) : await execPrivileged(session, cmd, signal);
+  if (result.code !== 0) {
+    throw new Error(`Failed to write config: ${result.stderr}`);
+  }
+}
+async function restartGateway(session, signal) {
+  const os = await detectOS(session, signal);
+  const pathPrefix = os === "Darwin" ? 'export PATH="/usr/local/bin:/opt/homebrew/bin:/Applications/Docker.app/Contents/Resources/bin:$PATH" && ' : "";
+  const imgCmd = `${pathPrefix}${IMAGE_INSPECT_CMD}`;
+  const imgResult = os === "Darwin" ? await session.exec(imgCmd, signal) : await execPrivileged(session, imgCmd, signal);
+  const resolved = imageForRestart(imgResult.stdout);
+  if (!resolved.ok) throw new Error(resolved.error);
+  const image = resolved.value;
+  const pubCmd = `${pathPrefix}${PUBLISH_INSPECT_CMD}`;
+  const pubResult = os === "Darwin" ? await session.exec(pubCmd, signal) : await execPrivileged(session, pubCmd, signal);
+  const restartCmd = gatewayRunCommand({
+    image,
+    stateDir: stateDirForOS(os),
+    pathPrefix,
+    publish: publishForRestart(pubResult.stdout)
+  });
+  const result = os === "Darwin" ? await session.exec(restartCmd, signal) : await execPrivileged(session, restartCmd, signal);
+  if (result.code !== 0) {
+    throw new Error(`Gateway restart failed: ${result.stderr}`);
+  }
+  const healthy = await waitForGateway(session, pathPrefix, signal);
+  if (!healthy.ok) {
+    throw new Error(
+      `Gateway restarted but did not finish starting on port ${GATEWAY_PORT}` + (healthy.reason ? ` \u2014 ${healthy.reason}` : "") + `. The previous container has already been replaced; inspect it with \`docker logs openclaw\`. If the newly-applied config is at fault, revert it and restart \u2014 before v1.7.2 this config was never applied, so a value that has sat unused may now be taking effect.`
+    );
+  }
+}
+async function waitForGateway(session, pathPrefix, signal, attempts = 15) {
+  const { probeCommand, interpretProbe } = await import("./health-5CCOXYGG.js");
+  const probe = probeCommand("started", GATEWAY_PORT, pathPrefix);
+  let last = "no response from the gateway";
+  for (let i = 0; i < attempts; i++) {
+    if (signal?.aborted) return { ok: false, reason: "aborted" };
+    const r = await session.exec(probe, signal);
+    const verdict = interpretProbe("started", r.stdout);
+    if (verdict.ok) return { ok: true };
+    last = verdict.reason ?? last;
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+  }
+  return { ok: false, reason: last };
+}
+function deepMerge(base, overlay) {
+  const result = { ...base };
+  for (const [key, val] of Object.entries(overlay)) {
+    if (val !== null && typeof val === "object" && !Array.isArray(val) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(
+        result[key],
+        val
+      );
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+export {
+  OPENCLAW_CONFIG_LINUX,
+  OPENCLAW_CONFIG_MACOS,
+  OPENCLAW_CONFIG,
+  OPENCLAW_TMP,
+  readRemoteConfig,
+  atomicWriteConfig,
+  restartGateway,
+  deepMerge
+};

package/dist/{chunk-DQDAWNGB.js → chunk-2Z7J3ERQ.js}

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

package/dist/chunk-3OLUJPCB.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import {
+  execPrivileged
+} from "./chunk-NUDIHZEH.js";
+
+// src/openclaw/docker.ts
+function looksLikeStillBooting(detail) {
+  const text = detail.toLowerCase();
+  return text.includes("command not found") || text.includes("cannot connect to the docker daemon") || text.includes("is the docker daemon running") || text.includes("no such file or directory");
+}
+function saysNoSuchObject(text) {
+  return /no such (object|container)/i.test(text);
+}
+async function inspectContainer(session, name, format, signal, dockerCmd = "docker") {
+  const result = await execPrivileged(
+    session,
+    `${dockerCmd} inspect ${name} --format '${format}'`,
+    signal
+  );
+  if (result.code === 0) return { kind: "ok", value: result.stdout.trim() };
+  const text = `${result.stderr} ${result.stdout}`.trim();
+  if (saysNoSuchObject(text)) return { kind: "missing" };
+  return { kind: "error", detail: text === "" ? `docker inspect exited ${result.code}` : text };
+}
+async function containerStatus(session, name = "openclaw", signal) {
+  const result = await inspectContainer(session, name, "{{.State.Status}}", signal);
+  if (result.kind === "ok") return { status: result.value || "unknown" };
+  if (result.kind === "missing") return { status: "not found" };
+  return { status: "unknown", error: result.detail };
+}
+
+export {
+  looksLikeStillBooting,
+  inspectContainer,
+  containerStatus
+};