@clawops/cli 2.1.2 → 2.2.0

package/dist/{chunk-GFUK6KDR.js → chunk-OUQVKIIA.js}

@@ -1,23 +1,35 @@
 #!/usr/bin/env node
+import {
+  listOverlays
+} from "./chunk-6ZFIFDBJ.js";
 import {
   inspectContainer
-} from "./chunk-3OLUJPCB.js";
+} from "./chunk-Z3XLWZWF.js";
 import {
   execPrivileged
-} from "./chunk-NUDIHZEH.js";
+} from "./chunk-WPZIJONN.js";
 import {
   interpretProbe,
   probeCommand
 } from "./chunk-LT4XMO5D.js";
 import {
   PUBLISH_INSPECT_CMD,
+  STATE_DIR_CONTAINER,
   STATE_DIR_HOST_LINUX,
   configPathForOS,
+  gatewayRunCommand,
   publishForRestart
-} from "./chunk-GIEVAGEK.js";
+} from "./chunk-N5ZYUTZS.js";
 import {
-  GATEWAY_PORT
+  GATEWAY_PORT,
+  IMAGE_INSPECT_CMD,
+  imageForRestart,
+  versionOf
 } from "./chunk-VOEJYRIK.js";
+import {
+  err,
+  ok
+} from "./chunk-EI7CQQ7D.js";
 import {
   chalk,
   failure
@@ -146,8 +158,8 @@ function renderSnapshot(snap, opts) {
   return lines.join("\n");
 }
 async function probeEntries() {
-  const { buildContext } = await import("./context-7VI3R6EK.js");
-  const { getConfig } = await import("./store-OVB3DAJR.js");
+  const { buildContext } = await import("./context-EHSLWKSH.js");
+  const { getConfig } = await import("./store-YOLQYXMB.js");
   const config = getConfig();
   if (!config) return [];
   return Promise.all(
@@ -215,7 +227,7 @@ function renderMenu(entries, selectedIdx, showAll, noColor, confirmDelete) {
   return lines.join("\n");
 }
 async function deleteFromRegistry(name) {
-  const { requireConfig, setConfig } = await import("./store-OVB3DAJR.js");
+  const { requireConfig, setConfig } = await import("./store-YOLQYXMB.js");
   const config = requireConfig();
   const newStacks = { ...config.stacks };
   delete newStacks[name];
@@ -323,9 +335,9 @@ async function runDashboard(session, stackName, opts, ac, setKeyHandler, menuMod
     try {
       lastSnapshot = await gatherSnapshot(session, ac.signal, opts.tailLines);
       redraw();
-    } catch (err) {
+    } catch (err2) {
       if (!ac.signal.aborted) {
-        process.stdout.write("\x1B[2J\x1B[H  Error gathering snapshot: " + (err instanceof Error ? err.message : String(err)) + "\n");
+        process.stdout.write("\x1B[2J\x1B[H  Error gathering snapshot: " + (err2 instanceof Error ? err2.message : String(err2)) + "\n");
       }
     }
     if (!ac.signal.aborted) scheduleRefresh();
@@ -373,8 +385,8 @@ var monitor_default = defineCommand({
     const tailLines = Math.max(1, parseInt(String(args.tail ?? "10"), 10) || 10);
     const isTTY = Boolean(process.stdout.isTTY);
     const noColor = Boolean(args["no-color"]) || !isTTY;
-    const { buildContext } = await import("./context-7VI3R6EK.js");
-    const { acquireSession, drainPool } = await import("./pool-PIIKJ4L2.js");
+    const { buildContext } = await import("./context-EHSLWKSH.js");
+    const { acquireSession, drainPool } = await import("./pool-NT4XBSUT.js");
     const ac = new AbortController();
     process.on("SIGINT", () => ac.abort());
     process.on("SIGTERM", () => ac.abort());
@@ -502,13 +514,211 @@ var monitor_default = defineCommand({
   }
 });
 
+// src/openclaw/upgrade.ts
+function judgePreflight(report) {
+  const { targetVersion, foundVersion, status, reason } = report;
+  if (status === "indeterminate") {
+    return {
+      ok: false,
+      reason: reason ?? "the database schema could not be determined, so compatibility with the target release is unknown"
+    };
+  }
+  if (typeof foundVersion === "number" && typeof targetVersion === "number") {
+    if (foundVersion > targetVersion) {
+      return {
+        ok: false,
+        reason: `the state database is at schema ${foundVersion}, but the target release understands ${targetVersion}. This is a downgrade across a schema boundary: the older release would read a database written by a newer one. Restore a backup taken before the upgrade instead.`
+      };
+    }
+    if (foundVersion < targetVersion) {
+      return { ok: true, note: `state will migrate from schema ${foundVersion} to ${targetVersion}` };
+    }
+    return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: reason ?? `preflight returned no schema version (status: ${status ?? "unknown"})`
+  };
+}
+function parsePreflight(stdout) {
+  try {
+    const parsed = JSON.parse(stdout.trim());
+    if (parsed !== null && typeof parsed === "object") return parsed;
+  } catch {
+  }
+  return void 0;
+}
+function snapshotCommand(image, stateDir, repo) {
+  return `docker run --rm -v ${stateDir}:/home/node/.openclaw ${image} openclaw backup sqlite create --global --repository ${repo} --json`;
+}
+function preflightCommand(targetImage, stateDir, snapshotDb) {
+  return `docker run --rm -v ${stateDir}:/home/node/.openclaw ${targetImage} openclaw database preflight ${snapshotDb} --json`;
+}
+function snapshotPathFrom(stdout) {
+  try {
+    const parsed = JSON.parse(stdout.trim());
+    if (parsed.ok === true && typeof parsed.snapshotPath === "string") return parsed.snapshotPath;
+  } catch {
+  }
+  return void 0;
+}
+function repairCommand(image, stateDir) {
+  return `docker run --rm -v ${stateDir}:/home/node/.openclaw ${image} openclaw doctor --fix --non-interactive --yes`;
+}
+function describeOutcome(o, version) {
+  switch (o.kind) {
+    case "started":
+      return `Gateway updated to ${version}.`;
+    case "repaired":
+      return `Gateway updated to ${version} after a one-shot repair (doctor --fix).`;
+    case "rolled-back":
+      return `Rolled back to ${o.to}: the gateway did not start on ${version} \u2014 ${o.reason}. The previous image is running again. If it also fails, restore the snapshot taken before the upgrade.`;
+    case "failed":
+      return `Upgrade to ${version} failed and the rollback did not come up either \u2014 ${o.reason}. The state snapshot taken before the upgrade is at ${o.snapshotPath}; restore it with \`openclaw backup sqlite restore\` before retrying.`;
+  }
+}
+async function resolveUpgrade(steps, ctx) {
+  const first = await steps.gate();
+  if (first.ok) return { kind: "started" };
+  await steps.repair();
+  await steps.run(ctx.version);
+  const second = await steps.gate();
+  if (second.ok) return { kind: "repaired" };
+  const reason = second.reason ?? first.reason ?? "unknown";
+  if (!ctx.previousVersion) return { kind: "failed", reason, snapshotPath: ctx.snapshotPath };
+  await steps.run(ctx.previousVersion);
+  const back = await steps.gate();
+  return back.ok ? { kind: "rolled-back", to: ctx.previousVersion, reason } : { kind: "failed", reason, snapshotPath: ctx.snapshotPath };
+}
+
+// src/openclaw/gateway-ops.ts
+function dockerRunCmd(version, publish = "loopback") {
+  return gatewayRunCommand({
+    image: `ghcr.io/openclaw/openclaw:${version}`,
+    stateDir: STATE_DIR_HOST_LINUX,
+    publish
+  });
+}
+var STATUS_FORMAT = '{"status":"{{.State.Status}}","started":"{{.State.StartedAt}}","image":"{{.Config.Image}}"}';
+async function gatewayStatus(session, signal) {
+  const inspected = await inspectContainer(session, "openclaw", STATUS_FORMAT, signal);
+  if (inspected.kind === "missing") return ok({ status: "not running", started: "", image: "" });
+  if (inspected.kind === "error") {
+    return err(`Could not ask docker about the gateway: ${inspected.detail}`);
+  }
+  try {
+    return ok(JSON.parse(inspected.value));
+  } catch {
+    return ok({ status: "unknown", started: "", image: "" });
+  }
+}
+async function resolveUpdateVersion(requested) {
+  const yaml = await import("./js-yaml-PTEEG4FO.js");
+  const { assertSupportedVersion, loadVersionSpec } = await import("./versions-W5LRQCAJ.js");
+  if (!requested) return ok(loadVersionSpec(yaml).support.recommended);
+  const result = await assertSupportedVersion(requested, yaml);
+  return result.ok ? ok(result.value) : err(result.error.message);
+}
+async function currentGatewayVersion(session, signal) {
+  const cur = imageForRestart((await execPrivileged(session, IMAGE_INSPECT_CMD, signal)).stdout);
+  return cur.ok ? versionOf(cur.value) : void 0;
+}
+async function updateGateway(session, version, hooks = {}) {
+  const { signal } = hooks;
+  const progress = hooks.onProgress ?? (() => {
+  });
+  const sleep = hooks.sleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
+  const targetImage = `ghcr.io/openclaw/openclaw:${version}`;
+  const pullResult = await execPrivileged(session, `docker pull ${targetImage}`, signal);
+  if (pullResult.code !== 0) {
+    return { ok: false, version, message: `Pull failed: ${pullResult.stderr}` };
+  }
+  progress("Checking state compatibility...");
+  const cur = imageForRestart((await execPrivileged(session, IMAGE_INSPECT_CMD, signal)).stdout);
+  const previousVersion = cur.ok ? versionOf(cur.value) : void 0;
+  const snapRepo = `${STATE_DIR_CONTAINER}/snapshots`;
+  const snapOut = await execPrivileged(
+    session,
+    snapshotCommand(cur.ok ? cur.value : targetImage, STATE_DIR_HOST_LINUX, snapRepo),
+    signal
+  );
+  const snapPath = snapshotPathFrom(snapOut.stdout);
+  const hostSnapPath = snapPath?.startsWith(STATE_DIR_CONTAINER) ? STATE_DIR_HOST_LINUX + snapPath.slice(STATE_DIR_CONTAINER.length) : snapPath;
+  if (!snapPath) {
+    return {
+      ok: false,
+      version,
+      message: "Could not snapshot the state database before upgrading, so neither the compatibility check nor a rollback point is available.\n" + (snapOut.stderr || snapOut.stdout).slice(0, 2e3)
+    };
+  }
+  const pre = await execPrivileged(
+    session,
+    preflightCommand(targetImage, STATE_DIR_HOST_LINUX, `${snapPath}/database.sqlite`),
+    signal
+  );
+  const report = parsePreflight(pre.stdout);
+  const verdict = report ? judgePreflight(report) : { ok: false, reason: `preflight produced no readable report: ${pre.stderr.slice(0, 200)}` };
+  if (!verdict.ok) {
+    return {
+      ok: false,
+      version,
+      message: `Refusing to upgrade to ${version}: ${verdict.reason}`,
+      hint: `A snapshot of the current state was kept at ${hostSnapPath}.`
+    };
+  }
+  if (verdict.note) hooks.onNote?.(verdict.note);
+  progress(`Updating gateway to ${version}...`);
+  const pubU = await execPrivileged(session, PUBLISH_INSPECT_CMD, signal);
+  const publish = publishForRestart(pubU.stdout);
+  const runResult = await execPrivileged(session, dockerRunCmd(version, publish), signal);
+  if (runResult.code !== 0) {
+    return {
+      ok: false,
+      version,
+      message: `Start failed: ${runResult.stderr}`,
+      hint: `State snapshot from before the upgrade: ${hostSnapPath}`
+    };
+  }
+  progress("Waiting for the gateway to start...");
+  const gate = async () => {
+    let last;
+    for (let i = 0; i < 15; i++) {
+      if (signal?.aborted) return { ok: false, reason: "aborted" };
+      const r = await execPrivileged(session, probeCommand("started", GATEWAY_PORT), signal);
+      const v = interpretProbe("started", r.stdout);
+      if (v.ok) return { ok: true };
+      last = v.reason;
+      await sleep(2e3);
+    }
+    return { ok: false, reason: last ?? "no response" };
+  };
+  const outcome = await resolveUpgrade(
+    {
+      gate,
+      repair: async () => {
+        progress("Gateway did not start; attempting one-shot repair...");
+        await execPrivileged(session, repairCommand(targetImage, STATE_DIR_HOST_LINUX), signal);
+      },
+      run: async (v) => {
+        await execPrivileged(session, dockerRunCmd(v, publish), signal);
+      }
+    },
+    { version, previousVersion, snapshotPath: hostSnapPath ?? snapPath }
+  );
+  const message = describeOutcome(outcome, version);
+  if (outcome.kind === "started" || outcome.kind === "repaired") {
+    return { ok: true, version, ...previousVersion ? { previousVersion } : {}, outcome, message };
+  }
+  return { ok: false, version, message, outcome };
+}
+
 // src/diagnostics/index.ts
 import process2 from "process";
 import { accessSync, mkdirSync, readFileSync, constants } from "fs";
 import ssh2 from "ssh2";
 import path from "path";
 async function runDiagnostics(opts = {}, deps = {}) {
-  const { getConfig, getConfigDir } = await import("./store-OVB3DAJR.js");
+  const { getConfig, getConfigDir } = await import("./store-YOLQYXMB.js");
   const config = getConfig();
   const sections = [];
   sections.push({ title: "Runtime", checks: await runtimeChecks(getConfigDir()) });
@@ -528,10 +738,10 @@ async function runDiagnostics(opts = {}, deps = {}) {
     let handle;
     try {
       handle = await open(opts.stack, opts.signal);
-    } catch (err) {
+    } catch (err2) {
       sections.push({
         title: "Remote health",
-        checks: [{ name: "Connection", status: "fail", detail: messageOf(err) }]
+        checks: [connectionCheck(messageOf(err2))]
       });
     }
     if (handle) {
@@ -546,7 +756,7 @@ async function runDiagnostics(opts = {}, deps = {}) {
         });
       } finally {
         handle.release();
-        const { drainPool } = await import("./pool-PIIKJ4L2.js");
+        const { drainPool } = await import("./pool-NT4XBSUT.js");
         drainPool();
       }
     }
@@ -654,8 +864,8 @@ async function providerCredentialCheck(provider, why) {
     const adapter = getProvider(provider);
     const result = await adapter.validateConfig();
     return result.ok ? { name: provider, status: "pass", detail: why } : { name: provider, status: "fail", detail: result.errors.join("; ") };
-  } catch (err) {
-    return { name: provider, status: "fail", detail: messageOf(err) };
+  } catch (err2) {
+    return { name: provider, status: "fail", detail: messageOf(err2) };
   }
 }
 async function credentialChecks(config, provider) {
@@ -682,15 +892,15 @@ async function credentialChecks(config, provider) {
       if (result.ok) {
         checks.push({ name: providerName, status: "pass", detail: `stack "${stackName}"` });
       } else {
-        for (const err of result.errors) {
-          checks.push({ name: providerName, status: "fail", detail: `stack "${stackName}" \u2014 ${err}` });
+        for (const err2 of result.errors) {
+          checks.push({ name: providerName, status: "fail", detail: `stack "${stackName}" \u2014 ${err2}` });
         }
       }
-    } catch (err) {
+    } catch (err2) {
       checks.push({
         name: providerName,
         status: "fail",
-        detail: `stack "${stackName}" \u2014 ${messageOf(err)}`
+        detail: `stack "${stackName}" \u2014 ${messageOf(err2)}`
       });
     }
   }
@@ -725,7 +935,7 @@ async function versionChecks() {
 }
 async function remoteChecks(session, signal) {
   const checks = [];
-  const { containerStatus } = await import("./docker-3PDO4TS7.js");
+  const { containerStatus } = await import("./docker-IKM5GRMC.js");
   const container = await containerStatus(session, "openclaw", signal);
   checks.push(
     container.error ? {
@@ -808,8 +1018,8 @@ async function deployedVersionCheck(image, deployedVersion) {
 }
 async function hardeningChecks(conn, stack, signal) {
   try {
-    const { MODULE_CATALOG, resolveModules, withRemoteExec } = await import("./harden-3KKCR7BL.js");
-    const { buildContext } = await import("./context-7VI3R6EK.js");
+    const { MODULE_CATALOG, resolveModules, withRemoteExec } = await import("./harden-UHAOVQMZ.js");
+    const { buildContext } = await import("./context-EHSLWKSH.js");
     const provider = buildContext({ stack }).adapter.name;
     const modules = resolveModules(MODULE_CATALOG, void 0, provider);
     const checks = [];
@@ -826,15 +1036,15 @@ async function hardeningChecks(conn, stack, signal) {
       }
     });
     return checks;
-  } catch (err) {
-    return [{ name: "Hardening checks", status: "fail", detail: messageOf(err) }];
+  } catch (err2) {
+    return [{ name: "Hardening checks", status: "fail", detail: messageOf(err2) }];
   }
 }
 async function defaultOpenSession(stack, signal) {
-  const { getConfig } = await import("./store-OVB3DAJR.js");
-  const { buildContext } = await import("./context-7VI3R6EK.js");
+  const { getConfig } = await import("./store-YOLQYXMB.js");
+  const { buildContext } = await import("./context-EHSLWKSH.js");
   const { extractBaseOutputs } = await import("./outputs-DJHBY7EE.js");
-  const { acquireSession } = await import("./pool-PIIKJ4L2.js");
+  const { acquireSession } = await import("./pool-NT4XBSUT.js");
   const config = getConfig();
   if (!config) throw new Error("no config \u2014 run `clawops init`");
   const ctx = buildContext({ stack });
@@ -859,8 +1069,18 @@ async function defaultOpenSession(stack, signal) {
   });
   return { session, release, conn };
 }
-function messageOf(err) {
-  return err instanceof Error ? err.message : String(err);
+function messageOf(err2) {
+  return err2 instanceof Error ? err2.message : String(err2);
+}
+function connectionCheck(message) {
+  const [summary, ...rest] = message.split("\n");
+  const remedy = rest.join("\n  ").trim();
+  return {
+    name: "Connection",
+    status: "fail",
+    detail: summary,
+    ...remedy ? { remedy } : {}
+  };
 }
 async function accountChecks(config, stack, provider, instanceType) {
   if (!config && !provider) return [];
@@ -883,8 +1103,8 @@ async function accountChecks(config, stack, provider, instanceType) {
       detail: r.detail,
       remedy: r.mutates ? `clawops setup can fix this: ${r.mutates}` : void 0
     }));
-  } catch (err) {
-    return [{ name: "Account preflight", status: "warn", detail: messageOf(err) }];
+  } catch (err2) {
+    return [{ name: "Account preflight", status: "warn", detail: messageOf(err2) }];
   }
 }
 function bucketFromStateUrl(stateUrl) {
@@ -893,9 +1113,127 @@ function bucketFromStateUrl(stateUrl) {
   return match?.[1];
 }
 
+// src/secrets/store.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync, unlinkSync } from "fs";
+import path2 from "path";
+import os from "os";
+import process3 from "process";
+function secretsDir() {
+  return path2.join(os.homedir(), ".clawops", "secrets");
+}
+function resolveSecretPath(name) {
+  const dir = secretsDir();
+  const invalid = name.length === 0 || name === "." || name === ".." || name.includes("/") || name.includes("\\") || name.includes("\0") || path2.dirname(path2.resolve(dir, name)) !== path2.resolve(dir);
+  if (invalid) {
+    return {
+      ok: false,
+      reason: `Secret name "${name}" is not valid: a secret name is a single file name inside ${dir} (no "/" or "\\", and not "." or "..").`
+    };
+  }
+  return { ok: true, path: path2.join(dir, name) };
+}
+function listSecretNames() {
+  if (!existsSync(secretsDir())) return [];
+  return readdirSync(secretsDir()).filter((f) => !f.startsWith("."));
+}
+function listSecrets() {
+  return listSecretNames().map((name) => {
+    const p = path2.join(secretsDir(), name);
+    try {
+      const stat = statSync(p);
+      const nonEmpty = readFileSync2(p, "utf-8").trim().length > 0;
+      const modified = stat.mtime.toISOString().slice(0, 10);
+      return { name, status: nonEmpty ? "ok" : "empty", source: "file", path: p, modified, resolvable: nonEmpty };
+    } catch {
+      return { name, status: "unreadable", source: "file", path: p, modified: "\u2014", resolvable: false };
+    }
+  });
+}
+var NO_SECRETS_MESSAGE = "No secrets stored in ~/.clawops/secrets/";
+var SET_SECRET_HINT = "Run `clawops secret set <name>` to add one.";
+function auditSecrets() {
+  const issues = [];
+  for (const name of listSecretNames()) {
+    const p = path2.join(secretsDir(), name);
+    try {
+      if (readFileSync2(p, "utf-8").trim().length === 0) {
+        issues.push({ kind: "empty-secret", secret: name, detail: `File exists but is empty: ${p}` });
+      }
+    } catch {
+      issues.push({ kind: "unreadable-secret", secret: name, detail: `Cannot read: ${p}` });
+    }
+  }
+  for (const overlay of listOverlays()) {
+    for (const s of overlay.secrets) {
+      if (s.source === "file") {
+        const ref = s.ref ?? path2.join(secretsDir(), s.name);
+        if (!existsSync(ref)) {
+          issues.push({ kind: "missing-file", stack: overlay.stackName, secret: s.name, detail: `File not found: ${ref}` });
+        }
+      } else if (s.source === "env") {
+        const envVar = s.ref ?? s.name;
+        if (!process3.env[envVar]) {
+          issues.push({ kind: "missing-env", stack: overlay.stackName, secret: s.name, detail: `Env var not set: ${envVar}` });
+        }
+      } else {
+        issues.push({ kind: "cloud-sm-unresolved", stack: overlay.stackName, secret: s.name, detail: `Source "${s.source}" is not auto-resolved \u2014 set manually` });
+      }
+    }
+  }
+  return { issues, ok: issues.length === 0 };
+}
+var AUDIT_CLEAN_MESSAGE = "All secrets are resolvable. No issues found.";
+var AUDIT_FIX_HINT = "Run `clawops secret set <name>` to update a missing or empty secret.";
+function auditIssuesHeadline(count) {
+  return `${count} issue${count === 1 ? "" : "s"} found:`;
+}
+function formatAuditIssue(issue) {
+  const prefix = issue.stack ? `[${issue.stack}] ` : "";
+  return `${prefix}${issue.secret}: ${issue.detail}`;
+}
+function prepareSecretDelete(name) {
+  const resolved = resolveSecretPath(name);
+  if (!resolved.ok) return { ok: false, kind: "invalid-name", reason: resolved.reason };
+  const p = resolved.path;
+  if (!existsSync(p)) {
+    return { ok: false, kind: "not-found", reason: `Secret "${name}" not found at ${p}` };
+  }
+  const referencingStacks = listOverlays().filter((o) => o.secrets.some((s) => s.name === name)).map((o) => o.stackName);
+  const warnings = referencingStacks.length > 0 ? [
+    `Secret "${name}" is referenced by stack(s): ${referencingStacks.join(", ")}`,
+    "Deleting it will leave those stacks with an unresolvable $secret: ref."
+  ] : [];
+  return { ok: true, name, path: p, referencingStacks, warnings };
+}
+function deleteConfirmQuestion(name) {
+  return `Delete secret "${name}"?`;
+}
+function deletePreparedSecret(prepared) {
+  unlinkSync(prepared.path);
+  return `Secret "${prepared.name}" deleted.`;
+}
+
 export {
+  dockerRunCmd,
+  gatewayStatus,
+  resolveUpdateVersion,
+  currentGatewayVersion,
+  updateGateway,
   runDiagnostics,
   formatUptime,
   gatherSnapshot,
-  monitor_default
+  monitor_default,
+  secretsDir,
+  resolveSecretPath,
+  listSecrets,
+  NO_SECRETS_MESSAGE,
+  SET_SECRET_HINT,
+  auditSecrets,
+  AUDIT_CLEAN_MESSAGE,
+  AUDIT_FIX_HINT,
+  auditIssuesHeadline,
+  formatAuditIssue,
+  prepareSecretDelete,
+  deleteConfirmQuestion,
+  deletePreparedSecret
 };

package/dist/{chunk-XFN3YDZE.js → chunk-PASAVVNS.js}

@@ -44,7 +44,7 @@ async function validatePlanConfig(plan) {
   ]);
   const { loadVersionSpec } = await import("./versions-W5LRQCAJ.js");
   const spec = loadVersionSpec(yaml);
-  const { deepMerge } = await import("./remote-config-3HZLUWEA.js");
+  const { deepMerge } = await import("./remote-config-OZYBMBSK.js");
   const merged = deepMerge(
     { gateway: { mode: "local" } },
     overlay