@clawops/cli 1.7.9 → 2.0.1

package/dist/chunk-5XT5IAJK.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import {
+  readLocalState
+} from "./chunk-A2I76FTA.js";
+import {
+  getConfigDir,
+  requireConfig
+} from "./chunk-CX5SL5HP.js";
+import {
+  UsageError
+} from "./chunk-KGXPLI7W.js";
+import {
+  getProvider
+} from "./chunk-VUFMZEIM.js";
+
+// src/cli/context.ts
+function buildContext(args) {
+  const config = requireConfig();
+  const stackName = typeof args.stack === "string" ? args.stack : config.defaults.stack;
+  const providerName = typeof args.provider === "string" ? args.provider : config.stacks[stackName]?.provider ?? config.defaults.provider;
+  const adapter = loadProvider(providerName);
+  const localState = providerName === "local" ? readLocalState(stackName) : void 0;
+  let stackCache = null;
+  return {
+    config,
+    adapter,
+    stackName,
+    localState,
+    async getStack() {
+      if (providerName === "local") {
+        throw new UsageError(
+          "The local provider does not use Pulumi stacks. Use `clawops up` to bootstrap the host instead."
+        );
+      }
+      if (stackCache) return stackCache;
+      const stackConfig = config.stacks[stackName];
+      if (!stackConfig) {
+        throw new UsageError(
+          `Stack "${stackName}" not found in config. Run \`clawops init\` or use \`--stack\` to specify a different stack.`
+        );
+      }
+      const { getOrCreateStack } = await import("./automation-RMAIBNVC.js");
+      stackCache = await getOrCreateStack({
+        stack: stackName,
+        stateUrl: stackConfig.stateUrl,
+        program: adapter.program,
+        configDir: getConfigDir()
+      });
+      return stackCache;
+    }
+  };
+}
+function loadProvider(name) {
+  try {
+    return getProvider(name);
+  } catch {
+    throw new UsageError(
+      `Provider "${name}" is not yet supported. Supported providers: gcp, aws, azure, local`
+    );
+  }
+}
+async function loadAdapterModule(name) {
+  return loadProvider(name);
+}
+
+export {
+  buildContext,
+  loadAdapterModule
+};

package/dist/chunk-AEEMRFZV.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+// src/plan/ssh-key.ts
+import { existsSync, readFileSync } from "fs";
+import ssh2 from "ssh2";
+function resolvePublicKey(privateKeyPath) {
+  const pub = `${privateKeyPath}.pub`;
+  if (existsSync(pub)) {
+    const contents = readFileSync(pub, "utf-8").trim();
+    if (contents !== "") return contents;
+  }
+  if (!existsSync(privateKeyPath)) return void 0;
+  try {
+    const parsed = ssh2.utils.parseKey(readFileSync(privateKeyPath));
+    if (parsed instanceof Error || !("getPublicSSH" in parsed)) return void 0;
+    return `${parsed.type} ${parsed.getPublicSSH().toString("base64")} clawops`;
+  } catch {
+    return void 0;
+  }
+}
+
+export {
+  resolvePublicKey
+};

package/dist/chunk-BSLIYB5Q.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import {
+  resolveSpecDir
+} from "./chunk-JW5A7E3X.js";
+
+// src/plan/validate.ts
+import Ajv from "ajv/dist/2020";
+import addFormats from "ajv-formats";
+import { readFileSync } from "fs";
+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(resolveSpecDir(), "deploy-plan.schema.json"), "utf-8")
+  );
+  _validate = ajv.compile(schema);
+  return _validate;
+}
+function validatePlan(plan) {
+  const validate = getValidator();
+  const ok = validate(plan);
+  if (ok) return { ok: true, errors: [] };
+  const errors = (validate.errors ?? []).map(
+    (e) => `${e.instancePath} ${e.message ?? ""}`.trim()
+  );
+  return { ok: false, errors };
+}
+function assertValidPlan(plan) {
+  const result = validatePlan(plan);
+  if (!result.ok) {
+    throw new Error(`Invalid deploy plan:
+${result.errors.join("\n")}`);
+  }
+}
+async function validatePlanConfig(plan) {
+  const overlay = plan.spec?.openclaw?.config;
+  if (overlay === void 0 || overlay === null) return { ok: true, errors: [], warnings: [] };
+  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 { deepMerge } = await import("./remote-config-3HZLUWEA.js");
+  const merged = deepMerge(
+    { gateway: { mode: "local" } },
+    overlay
+  );
+  const { errors, warnings } = await validateConfig(merged, {
+    openclawVersion: plan.spec?.openclaw?.version,
+    schemaCapturedFrom: spec.runtime?.configSchemaCapturedFrom
+  });
+  return { ok: errors.length === 0, errors, warnings };
+}
+function validatePlanNetwork(plan) {
+  const net = plan.spec?.network;
+  if (!net) return { ok: true, errors: [], warnings: [] };
+  const errors = [];
+  const warnings = [];
+  const publish = net.publishGateway ?? "loopback";
+  const gatewayCidrs = net.allowedGatewayCidrs ?? [];
+  if (publish === "loopback" && gatewayCidrs.length > 0) {
+    errors.push(
+      `network.allowedGatewayCidrs lists ${gatewayCidrs.length} CIDR(s) but network.publishGateway is "loopback", so the gateway binds 127.0.0.1 on the host and nothing is listening on a routable interface. Those rules would admit traffic to a closed port. Either drop them and reach the gateway with \`clawops tunnel\`, or set publishGateway to "all" \u2014 which serves plaintext HTTP, so put TLS in front of it.`
+    );
+  }
+  if ((net.allowedSshCidrs ?? []).length === 0) {
+    warnings.push(
+      "network.allowedSshCidrs is empty, so this deployment will accept no SSH connections at all \u2014 `clawops ssh`, `logs`, `tunnel` and `harden` will not be able to reach it. Pass `--ssh-cidr auto` (this machine) or an explicit CIDR when generating the plan."
+    );
+  }
+  for (const [field, cidrs] of [
+    ["allowedSshCidrs", net.allowedSshCidrs ?? []],
+    ["allowedGatewayCidrs", gatewayCidrs]
+  ]) {
+    if (cidrs.some((c) => c === "0.0.0.0/0" || c === "::/0")) {
+      warnings.push(
+        `network.${field} admits the whole internet. clawops will create the rule you asked for, but \`clawops harden\` reports it as a finding.`
+      );
+    }
+  }
+  const configured = gatewayPortFromConfig(plan.spec?.openclaw?.config);
+  if (net.gatewayPort !== void 0 && configured !== void 0 && configured !== net.gatewayPort) {
+    errors.push(
+      `network.gatewayPort is ${net.gatewayPort} but the config overlay sets gateway.port to ${configured}. The container would publish one port while the gateway listened on the other. Set one of them, not both.`
+    );
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function gatewayPortFromConfig(config) {
+  if (config === null || typeof config !== "object") return void 0;
+  const gateway = config["gateway"];
+  if (gateway === null || typeof gateway !== "object") return void 0;
+  const port = gateway["port"];
+  return typeof port === "number" ? port : void 0;
+}
+
+export {
+  validatePlan,
+  assertValidPlan,
+  validatePlanConfig,
+  validatePlanNetwork
+};

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

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  formatKnownHostsLine,
+  keyTypeFromBlob,
+  verifyAgainstKnownHosts
+} from "./chunk-MC5ATCXS.js";
 import {
   NetworkError
 } from "./chunk-KGXPLI7W.js";
@@ -8,98 +13,6 @@ 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;
@@ -140,6 +53,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) {
@@ -199,6 +153,15 @@ var Ssh2Session = class {
     this.client.end();
   }
 };
+function describeConnectError(message, opts) {
+  if (!/host.*(denied|verification)/i.test(message)) {
+    return `SSH connection failed: ${message}`;
+  }
+  const entry = opts.port === 22 ? opts.host : `[${opts.host}]:${opts.port}`;
+  return `the host key for ${opts.host}:${opts.port} does not match the one recorded in ${opts.knownHostsPath}. If your cloud reassigned this address \u2014 the usual cause \u2014 drop the stale entry and retry:
+  ssh-keygen -R ${entry} -f ${opts.knownHostsPath}
+If you did not expect this address to change hands, do not connect.`;
+}
 async function connect(opts) {
   let privateKey;
   try {
@@ -225,7 +188,7 @@ async function connect(opts) {
     });
     client.on("error", (err) => {
       opts.signal?.removeEventListener("abort", onAbort);
-      reject(new NetworkError(`SSH connection failed: ${err.message}`));
+      reject(new NetworkError(describeConnectError(err.message, opts)));
     });
     const config = {
       host: opts.host,
@@ -258,5 +221,6 @@ function verifyHostKey(host, port, keyHash, knownHostsPath) {
 }
 
 export {
+  describeConnectError,
   connect
 };

package/dist/chunk-FEK7VJAY.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// src/providers/azure/sizes.ts
+var INSTANCE_TYPE_MAP = {
+  micro: "Standard_B1s",
+  small: "Standard_B2s",
+  medium: "Standard_B4ms",
+  large: "Standard_B8ms",
+  gpu: "Standard_NC6s_v3"
+};
+var DEFAULT_ALIAS = "small";
+
+export {
+  INSTANCE_TYPE_MAP,
+  DEFAULT_ALIAS
+};

package/dist/{chunk-UKTP332Z.js → chunk-GAZPPSKU.js}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
+import {
+  resolveSpecDir
+} from "./chunk-JW5A7E3X.js";
 import {
   err,
   ok
 } from "./chunk-EI7CQQ7D.js";
-import {
-  resolveSpecDir
-} from "./chunk-PVUVI35Y.js";
 
 // src/openclaw/versions.ts
 import { readFileSync } from "fs";
@@ -28,7 +28,8 @@ function loadVersionSpec(yaml) {
         min: raw.support.min,
         max: raw.support.max ?? "",
         recommended: raw.support.recommended ?? raw.support.min
-      }
+      },
+      ...raw.runtime ? { runtime: raw.runtime } : {}
     };
     return _spec;
   } catch (e) {
@@ -77,9 +78,7 @@ function checkVersion(version, support) {
       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}.`
+Pin an OpenClaw version at or below ${support.max}, or upgrade clawops.`
     });
   }
   return ok(version);

package/dist/chunk-GIEVAGEK.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+
+// 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_PATH = `${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_FLAG = "--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_FLAG,
+    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 {
+  STATE_DIR_CONTAINER,
+  STATE_DIR_HOST_LINUX,
+  STATE_DIR_HOST_MACOS,
+  CONFIG_FILENAME,
+  CONTAINER_UID,
+  CONFIG_MOUNT_PATH,
+  stateDirForOS,
+  configPathForOS,
+  ENV_FILE_PATH,
+  SECURITY_FLAGS,
+  SUPERVISOR_ENV,
+  ADD_HOST_FLAG,
+  gatewayRunArgs,
+  gatewayRunCommand,
+  PUBLISH_INSPECT_CMD,
+  publishedGatewayPort,
+  publishForRestart
+};

package/dist/chunk-HSPHXG6W.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  resolvePublicKey
+} from "./chunk-AEEMRFZV.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+import {
+  getConfig
+} from "./chunk-CX5SL5HP.js";
+import {
+  UsageError
+} from "./chunk-KGXPLI7W.js";
+
+// src/plan/stack-config.ts
+import process from "process";
+async function writeStackConfig(stack, plan) {
+  const sshPublicKey = plan.spec.ssh?.publicKey ?? fallbackPublicKey();
+  if (!sshPublicKey) {
+    throw new UsageError(
+      "This plan carries no SSH public key, and none could be resolved from `ssh.keyPath` in ~/.clawops/config.json. The instance would have no way to admit anyone. Run `clawops doctor` to see why the key is unusable, then regenerate the plan."
+    );
+  }
+  await stack.setConfig("sshPublicKey", { value: sshPublicKey });
+  await stack.setConfig("instanceType", { value: plan.spec.instanceType });
+  if (plan.spec.region) {
+    await stack.setConfig("region", { value: plan.spec.region });
+  }
+  await stack.setConfig("openclawVersion", { value: plan.spec.openclaw.version });
+  await stack.setConfig("publishGateway", {
+    value: plan.spec.network?.publishGateway ?? "loopback"
+  });
+  await stack.setConfig("gatewayPort", {
+    value: String(plan.spec.network?.gatewayPort ?? GATEWAY_PORT)
+  });
+  if (plan.spec.provider === "gcp") {
+    const { resolveProjectId } = await import("./preflight-EF52S3WW.js");
+    const project = resolveProjectId();
+    if (project) await stack.setConfig("gcp:project", { value: project });
+  }
+  if (plan.spec.provider === "azure") {
+    const { resolveSubscriptionId } = await import("./cli-auth-GD5SK7JU.js");
+    const subscription = resolveSubscriptionId();
+    if (subscription) await stack.setConfig("azure-native:subscriptionId", { value: subscription });
+  }
+  await stack.setConfig("accessMode", { value: "restricted" });
+  await stack.setConfig("sshCidrs", {
+    value: (plan.spec.network?.allowedSshCidrs ?? []).join(",")
+  });
+  await stack.setConfig("gatewayCidrs", {
+    value: (plan.spec.network?.allowedGatewayCidrs ?? []).join(",")
+  });
+  const modelProvider = plan.spec.openclaw.config?.["models"]?.["provider"];
+  if (modelProvider === "bedrock") {
+    await stack.setConfig("bedrockEnabled", { value: "true" });
+  }
+}
+function fallbackPublicKey() {
+  const config = getConfig();
+  if (!config) return void 0;
+  const keyPath = config.ssh.keyPath.replace(/^~/, process.env["HOME"] ?? "~");
+  return resolvePublicKey(keyPath);
+}
+
+export {
+  writeStackConfig
+};