@clawops/cli 2.1.2 → 2.2.0

package/dist/chunk-E6BRQK67.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+import {
+  compareVersions
+} from "./chunk-GAZPPSKU.js";
+import {
+  interpretProbe,
+  probeCommand
+} from "./chunk-LT4XMO5D.js";
+import {
+  CONFIG_FILENAME,
+  CONTAINER_UID,
+  GATEWAY_STOP_COMMAND,
+  STATE_DIR_HOST_LINUX,
+  gatewayRunCommand
+} from "./chunk-N5ZYUTZS.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+
+// src/openclaw/migrate.ts
+function imageVersion(image) {
+  const last = image.slice(image.lastIndexOf("/") + 1);
+  const colon = last.indexOf(":");
+  if (colon < 0) return void 0;
+  const m = /^(\d{4}\.\d+\.\d+(?:-\d+)?)(?:-[a-z]+)?$/.exec(last.slice(colon + 1));
+  return m?.[1];
+}
+async function migrate(steps, opts = {}) {
+  const sourceImage = await steps.inspectSource();
+  if (sourceImage && opts.targetLineMin) {
+    const source = imageVersion(sourceImage);
+    if (source !== void 0 && compareVersions(source, opts.targetLineMin) >= 0) {
+      return {
+        kind: "already-current",
+        reason: `This deployment already runs ${sourceImage}, which is OpenClaw ${opts.targetLineMin} or later \u2014 there is no 1.x state to migrate, and migrating would replace its config. To change versions within 2.x, use \`clawops gateway update <version>\`.`
+      };
+    }
+  }
+  if (!sourceImage) {
+    return {
+      kind: "nothing-to-migrate",
+      reason: "No running OpenClaw container was found, so there is no 1.x state to extract. If this deployment was restarted on a clawops release before 2.0, its state was already lost \u2014 clawops mounted none, so every container replacement discarded it. Deploy fresh with `clawops up`."
+    };
+  }
+  const identityBefore = await steps.deviceId();
+  const pulled = await steps.pullTarget();
+  if (!pulled.ok) {
+    return {
+      kind: "refused",
+      reason: `Could not pull the 2.x image, so nothing was stopped: ${pulled.detail}`
+    };
+  }
+  const backup = await steps.backup();
+  if (!backup.ok) {
+    return {
+      kind: "refused",
+      reason: `Refusing to migrate without a verified backup: ${backup.detail}
+This replaces the running container, and the state it extracts is the only copy.`
+    };
+  }
+  const extracted = await steps.extract();
+  if (!extracted.ok) {
+    return {
+      kind: "failed",
+      reason: "Could not extract state from the running container; it has not been touched.",
+      backupDetail: backup.detail
+    };
+  }
+  await steps.chown();
+  await steps.removeSource();
+  await steps.writeConfig();
+  await steps.start();
+  let restarts = 0;
+  let gate = await steps.gate();
+  if (!gate.ok) {
+    await steps.start();
+    restarts = 1;
+    gate = await steps.gate();
+  }
+  if (!gate.ok) {
+    return {
+      kind: "failed",
+      reason: gate.reason ?? "the gateway did not start after migration",
+      backupDetail: backup.detail
+    };
+  }
+  const identityAfter = await steps.deviceId();
+  const identity = identityBefore === void 0 || identityAfter === void 0 ? "unknown" : identityBefore === identityAfter ? "preserved" : "changed";
+  return { kind: "migrated", entries: extracted.entries, identity, restarts };
+}
+function describeMigration(o) {
+  switch (o.kind) {
+    case "migrated": {
+      const lines = [
+        `Migrated to the 2.0 runtime contract. Carried over: ${o.entries.join(", ") || "(nothing)"}.`
+      ];
+      if (o.restarts > 0) {
+        lines.push(
+          "The gateway needed a second start to finish its state-schema migration, which is expected for a 1.x database."
+        );
+      }
+      if (o.identity === "preserved") {
+        lines.push("Device identity preserved \u2014 paired devices do not need re-pairing.");
+      } else if (o.identity === "changed") {
+        lines.push(
+          "Device identity CHANGED. Paired devices and nodes must be re-paired \u2014 check `openclaw devices list` on the host for what was paired."
+        );
+      } else {
+        lines.push(
+          "Device identity could not be compared, so pairings may or may not have carried over. Check `openclaw devices list` before relying on them."
+        );
+      }
+      lines.push("Your 1.x config was NOT applied \u2014 it never took effect on 1.x either. Review it");
+      lines.push("and set what you need with `clawops config set`.");
+      return lines.join("\n");
+    }
+    case "nothing-to-migrate":
+      return o.reason;
+    case "already-current":
+      return o.reason;
+    case "refused":
+      return o.reason;
+    case "failed":
+      return `Migration failed: ${o.reason}
+A verified backup was taken first: ${o.backupDetail}
+Restore it with \`clawops backup restore --file <archive>\` before retrying.`;
+  }
+}
+
+// src/openclaw/migrate-flow.ts
+var PREMIGRATION_ARCHIVE = "/tmp/clawops-premigration.tar.gz";
+var SYNTHESISED_CONFIG = JSON.stringify({
+  meta: { lastTouchedVersion: "2026.9.2" },
+  gateway: { mode: "local", port: GATEWAY_PORT, auth: { mode: "token" } },
+  models: {},
+  channels: {}
+});
+async function prepareMigration(args) {
+  const { buildContext } = await import("./context-EHSLWKSH.js");
+  const { guardOpenclawVersion, defaultOpenclawVersion } = await import("./version-guard-XVYW5WFJ.js");
+  const version = args.openclawVersion ? await guardOpenclawVersion(args.openclawVersion) : await defaultOpenclawVersion();
+  const ctx = buildContext({ stack: args.stack });
+  return { ctx, stackName: ctx.stackName, version, image: `ghcr.io/openclaw/openclaw:${version}` };
+}
+function migrationSteps(run, opts) {
+  const step = opts.onStep ?? (() => {
+  });
+  const sleep = opts.sleep ?? ((ms) => new Promise((res) => setTimeout(res, ms)));
+  const archive = PREMIGRATION_ARCHIVE;
+  const configPath = `${STATE_DIR_HOST_LINUX}/${CONFIG_FILENAME}`;
+  return {
+    inspectSource: async () => {
+      const r = await run(`docker inspect openclaw --format '{{.Config.Image}}'`);
+      const image = r.stdout.trim();
+      return r.code === 0 && image.includes(":") ? image : void 0;
+    },
+    backup: async () => {
+      step("Taking a verified backup...");
+      const r = await run(
+        `docker exec openclaw openclaw backup create --output ${archive} --verify --json`
+      );
+      return r.code === 0 ? { ok: true, detail: `${archive} on the host (verified)` } : { ok: false, detail: (r.stderr || r.stdout).slice(0, 200) };
+    },
+    extract: async () => {
+      step("Extracting state from the running container...");
+      const mk = await run(`mkdir -p ${STATE_DIR_HOST_LINUX}`);
+      if (mk.code !== 0) return { ok: false, entries: [] };
+      const cp = await run(`docker cp openclaw:/home/node/.openclaw/. ${STATE_DIR_HOST_LINUX}/`);
+      if (cp.code !== 0) return { ok: false, entries: [] };
+      const ls = await run(`ls ${STATE_DIR_HOST_LINUX}`);
+      return { ok: true, entries: ls.stdout.trim().split(/\s+/).filter(Boolean) };
+    },
+    chown: async () => {
+      await run(`chown -R ${CONTAINER_UID}:${CONTAINER_UID} ${STATE_DIR_HOST_LINUX}`);
+    },
+    pullTarget: async () => {
+      step(`Pulling ${opts.targetImage}...`);
+      const r = await run(`docker pull ${opts.targetImage}`);
+      return { ok: r.code === 0, detail: (r.stderr || r.stdout).trim().slice(0, 500) };
+    },
+    removeSource: async () => {
+      step("Stopping the 1.x container...");
+      await run(GATEWAY_STOP_COMMAND);
+      await run("docker rm   openclaw 2>/dev/null || true");
+    },
+    writeConfig: async () => {
+      const b64 = Buffer.from(SYNTHESISED_CONFIG, "utf-8").toString("base64");
+      await run(
+        `echo '${b64}' | base64 -d > ${configPath} && chown ${CONTAINER_UID}:${CONTAINER_UID} ${configPath}`
+      );
+    },
+    start: async () => {
+      step("Starting the 2.0 gateway...");
+      await run(gatewayRunCommand({ image: opts.targetImage, stateDir: STATE_DIR_HOST_LINUX }));
+    },
+    gate: async () => {
+      step("Waiting for the gateway to start...");
+      let last;
+      let answeredFor = 0;
+      for (let i = 0; i < 60 && answeredFor < 15; i++) {
+        if (opts.signal?.aborted) return { ok: false, reason: "aborted" };
+        const r = await run(probeCommand("started", GATEWAY_PORT));
+        const v = interpretProbe("started", r.stdout);
+        if (v.ok) return { ok: true };
+        last = v.reason;
+        if (r.stdout.trim() !== "") answeredFor++;
+        await sleep(2e3);
+      }
+      const said = await run(
+        `echo "container: $(docker ps -a --filter name=^openclaw$ --format '{{.Status}}' | head -1)"; systemctl is-enabled openclaw >/dev/null 2>&1 && echo "unit: $(systemctl is-active openclaw)"; docker logs --tail 15 openclaw 2>&1 | tail -15`
+      );
+      const detail = said.stdout.trim();
+      return { ok: false, reason: (last ?? "no response") + (detail ? `
+${detail}` : "") };
+    },
+    deviceId: async () => {
+      const file = await run(
+        `docker exec openclaw sh -c 'cat ~/.openclaw/identity/device.json 2>/dev/null' || cat ${STATE_DIR_HOST_LINUX}/identity/device.json 2>/dev/null || true`
+      );
+      try {
+        const parsed = JSON.parse(file.stdout.trim());
+        return parsed.deviceId;
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function migrationResult(outcome) {
+  const report = describeMigration(outcome);
+  if (outcome.kind === "migrated") {
+    const [first, ...rest] = report.split("\n");
+    return {
+      outcome,
+      exitCode: 0,
+      lines: [
+        { level: "success", text: first },
+        ...rest.map((text) => ({
+          level: /CHANGED|could not be compared/.test(text) ? "warn" : "info",
+          text
+        })),
+        { level: "info", text: `Pre-migration backup: ${PREMIGRATION_ARCHIVE}` }
+      ]
+    };
+  }
+  const benign = outcome.kind === "nothing-to-migrate" || outcome.kind === "already-current";
+  return { outcome, exitCode: benign ? 0 : 1, lines: [{ level: "failure", text: report }] };
+}
+async function runMigration(target, opts = {}) {
+  const { resolveConn } = await import("./conn-M2V5HBPJ.js");
+  const { connect } = await import("./ssh-HOM7GF3M.js");
+  const { execPrivileged } = await import("./privileged-5Y6O4H7Z.js");
+  const { loadVersionSpec } = await import("./versions-W5LRQCAJ.js");
+  const yaml = await import("./js-yaml-PTEEG4FO.js");
+  const conn = await resolveConn(target.ctx);
+  const session = await connect({
+    host: conn.host,
+    port: conn.port,
+    user: conn.user,
+    privateKeyPath: conn.privateKeyPath,
+    knownHostsPath: conn.knownHostsPath,
+    ...opts.signal ? { signal: opts.signal } : {}
+  });
+  try {
+    opts.onStep?.("Inspecting the deployment...");
+    const steps = migrationSteps((cmd) => execPrivileged(session, cmd, opts.signal), {
+      targetImage: target.image,
+      ...opts.signal ? { signal: opts.signal } : {},
+      ...opts.onStep ? { onStep: opts.onStep } : {}
+    });
+    const outcome = await migrate(steps, { targetLineMin: loadVersionSpec(yaml).support.min });
+    return migrationResult(outcome);
+  } finally {
+    session.close();
+  }
+}
+function migrationQuestion(target) {
+  return `Migrate stack "${target.stackName}" from OpenClaw 1.x to ${target.version}? This takes a verified backup, then stops and replaces the running 1.x gateway container and writes a new minimal config. The 1.x config is not carried over.`;
+}
+
+export {
+  PREMIGRATION_ARCHIVE,
+  SYNTHESISED_CONFIG,
+  prepareMigration,
+  migrationSteps,
+  migrationResult,
+  runMigration,
+  migrationQuestion
+};

package/dist/{chunk-64PONSA5.js → chunk-GFIR2IIJ.js}

@@ -76,7 +76,9 @@ function getConfig() {
 function requireConfig() {
   const cfg = getConfig();
   if (!cfg) {
-    throw new UsageError("No config found. Run `clawops init` first.");
+    throw new UsageError(
+      `No clawops config at ${getConfigPath()}. Create one with \`clawops init\` in a terminal, or by calling the clawops_init tool. Either way it registers a stack \u2014 a provider and a state backend \u2014 and generates an SSH key; nothing is provisioned and nothing is charged.`
+    );
   }
   return cfg;
 }

package/dist/chunk-LV7UO5CG.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import {
+  requireConfig,
+  setConfig
+} from "./chunk-GFIR2IIJ.js";
+
+// src/config/stack-delete.ts
+function forgetNotice(name) {
+  return `This removes "${name}" from clawops config only. Cloud resources are NOT destroyed. Run \`clawops destroy --stack ` + name + "` first if you want to remove cloud resources.";
+}
+async function checkStackDelete(name, opts) {
+  const config = requireConfig();
+  if (!(name in config.stacks)) {
+    return { ok: false, refusal: "not-found", reason: `Stack "${name}" not found in config.` };
+  }
+  if (Object.keys(config.stacks).length === 1) {
+    return {
+      ok: false,
+      refusal: "only-stack",
+      reason: `Cannot delete the only remaining stack "${name}". Add another stack first or run \`clawops destroy\` to tear down resources.`
+    };
+  }
+  const isDefault = name === config.defaults.stack;
+  if (isDefault && !opts.force) {
+    return {
+      ok: false,
+      refusal: "default",
+      reason: `"${name}" is the default stack. Use --force to delete it (clawops will switch the default to another stack).`
+    };
+  }
+  const warnings = [];
+  if (!opts.force) {
+    let isDeployed = false;
+    try {
+      isDeployed = await isStackDeployed(name);
+    } catch {
+      warnings.push(`Could not verify deployment status for "${name}" \u2014 proceeding anyway.`);
+    }
+    if (isDeployed) {
+      return {
+        ok: false,
+        refusal: "deployed",
+        reason: `Stack "${name}" is still deployed. Run \`clawops down --stack ${name}\` first to destroy cloud resources, or pass --force to remove from registry only.`
+      };
+    }
+  }
+  return { ok: true, name, isDefault, warnings };
+}
+async function isStackDeployed(name) {
+  const { buildContext } = await import("./context-EHSLWKSH.js");
+  const ctx = buildContext({ stack: name });
+  if (ctx.adapter.name === "local") return !!ctx.localState;
+  const stack = await ctx.getStack();
+  const outputMap = await stack.outputs();
+  const outputs = Object.fromEntries(
+    Object.entries(outputMap).map(([k, v]) => [k, v.value])
+  );
+  return !!outputs["publicIp"];
+}
+function deleteStackFromConfig(name) {
+  const config = requireConfig();
+  const newStacks = { ...config.stacks };
+  delete newStacks[name];
+  const updated = { ...config, stacks: newStacks };
+  const wasDefault = name === config.defaults.stack;
+  if (wasDefault) {
+    updated.defaults = { ...config.defaults, stack: Object.keys(newStacks)[0] };
+  }
+  setConfig(updated);
+  const result = { name, message: `Stack "${name}" removed from config.` };
+  if (wasDefault) {
+    result.newDefault = updated.defaults.stack;
+    result.newDefaultMessage = `Default stack switched to "${updated.defaults.stack}".`;
+  }
+  return result;
+}
+
+export {
+  forgetNotice,
+  checkStackDelete,
+  deleteStackFromConfig
+};

package/dist/{chunk-GIEVAGEK.js → chunk-N5ZYUTZS.js}

@@ -67,14 +67,27 @@ function gatewayRunArgs(spec) {
     `node openclaw.mjs gateway run --port ${port}`
   ].filter(Boolean).join(" ");
 }
+var SYSTEMD_DROPIN = "/etc/systemd/system/openclaw.service.d/clawops-run.conf";
+var UNDER_SYSTEMD = "systemctl is-enabled openclaw >/dev/null 2>&1";
 function gatewayRunCommand(spec) {
   const { pathPrefix = "" } = spec;
-  return pathPrefix + [
+  const detached = [
     "docker stop openclaw 2>/dev/null || true",
     "docker rm   openclaw 2>/dev/null || true",
     gatewayRunArgs(spec)
   ].join(" && ");
+  if (pathPrefix) return pathPrefix + detached;
+  const execStart = gatewayRunArgs({ ...spec, supervisor: "systemd" });
+  const viaSystemd = [
+    `mkdir -p ${SYSTEMD_DROPIN.replace(/\/[^/]+$/, "")}`,
+    `printf '%s
+' '[Service]' 'ExecStart=' "ExecStart=/usr/bin/${execStart}" > ${SYSTEMD_DROPIN}`,
+    "systemctl daemon-reload",
+    "systemctl restart openclaw"
+  ].join(" && ");
+  return `if ${UNDER_SYSTEMD}; then ${viaSystemd}; else ${detached}; fi`;
 }
+var GATEWAY_STOP_COMMAND = `if ${UNDER_SYSTEMD}; then systemctl stop openclaw; fi; docker stop openclaw 2>/dev/null || true`;
 var PUBLISH_INSPECT_CMD = `docker inspect openclaw --format '{{json .HostConfig.PortBindings}}'`;
 function publishedGatewayPort(inspectStdout) {
   try {
@@ -119,7 +132,9 @@ export {
   SUPERVISOR_ENV,
   ADD_HOST_FLAG,
   gatewayRunArgs,
+  SYSTEMD_DROPIN,
   gatewayRunCommand,
+  GATEWAY_STOP_COMMAND,
   PUBLISH_INSPECT_CMD,
   publishedGatewayPort,
   publishForRestart