@clawops/cli 1.7.9 → 2.0.1

package/dist/chunk-LBE6COC4.js

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+import {
+  resolveSecrets
+} from "./chunk-BOPSG2LI.js";
+import {
+  saveOverlay
+} from "./chunk-6ZFIFDBJ.js";
+import {
+  atomicWriteConfig,
+  deepMerge,
+  readRemoteConfig,
+  restartGateway
+} from "./chunk-2I7KCMXZ.js";
+import {
+  writeStackConfig
+} from "./chunk-HSPHXG6W.js";
+import {
+  validatePlan
+} from "./chunk-BSLIYB5Q.js";
+import {
+  buildContext
+} from "./chunk-5XT5IAJK.js";
+import {
+  GATEWAY_PORT
+} from "./chunk-VOEJYRIK.js";
+import {
+  UsageError
+} from "./chunk-KGXPLI7W.js";
+
+// src/plan/apply.ts
+import process from "process";
+async function applyPlan(plan, opts) {
+  const validation = validatePlan(plan);
+  if (!validation.ok) {
+    throw new UsageError(
+      `Invalid deploy plan:
+${validation.errors.join("\n")}`
+    );
+  }
+  if (plan.spec.provider === "local") {
+    throw new UsageError(
+      "plan/apply is not supported for the local provider. Use `clawops up` directly."
+    );
+  }
+  const { guardOpenclawVersion } = await import("./version-guard-XVYW5WFJ.js");
+  await guardOpenclawVersion(plan.spec.openclaw.version);
+  const ctx = buildContext({
+    stack: plan.spec.stackName,
+    provider: plan.spec.provider
+  });
+  const stack = await ctx.getStack();
+  await writeStackConfig(stack, plan);
+  if (plan.metadata.stackVersion !== void 0) {
+    const currentInfo = await stack.info();
+    if (currentInfo !== void 0 && currentInfo.version !== plan.metadata.stackVersion) {
+      process.stderr.write(
+        `
+Warning: stack "${plan.spec.stackName}" has changed since this plan was generated (plan version: ${plan.metadata.stackVersion}, current: ${currentInfo.version}).
+The diff you reviewed may no longer reflect what will be applied.
+
+`
+      );
+      if (opts?.confirmDrift) {
+        await opts.confirmDrift();
+      }
+    }
+  }
+  const start = Date.now();
+  const result = await stack.up({ onOutput: opts?.onOutput, signal: opts?.signal });
+  const outputs = Object.fromEntries(
+    Object.entries(result.outputs).map(([k, v]) => [k, v.value])
+  );
+  const changeSummary = {};
+  if (result.summary.resourceChanges) {
+    for (const [op, count] of Object.entries(result.summary.resourceChanges)) {
+      changeSummary[op] = count;
+    }
+  }
+  const { waitForSsh } = await import("./wait-WO72TRRQ.js");
+  const conn = await connectionInfoFor(ctx, outputs);
+  if (opts?.skipReadiness) {
+    return { outputs, changeSummary, durationMs: Date.now() - start };
+  }
+  const readySession = await waitForSsh(conn, {
+    signal: opts?.signal,
+    onProgress: (line) => reportProgress(opts, line)
+  });
+  const { waitForGateway } = await import("./ready-KDNRBNSU.js");
+  try {
+    await waitForGateway(readySession, {
+      signal: opts?.signal,
+      port: plan.spec.network?.gatewayPort ?? GATEWAY_PORT,
+      onProgress: (line) => reportProgress(opts, line)
+    });
+  } finally {
+    readySession.close();
+  }
+  const hasOverlay = plan.spec.openclaw.config !== void 0 || plan.spec.openclaw.channels !== void 0;
+  if (hasOverlay) {
+    await applyConfigOverlay(plan, outputs, ctx, opts?.signal);
+  }
+  return {
+    outputs,
+    changeSummary,
+    durationMs: Date.now() - start
+  };
+}
+function reportProgress(opts, line) {
+  if (opts?.onProgress) opts.onProgress(line);
+  else opts?.onOutput?.(line);
+}
+async function connectionInfoFor(ctx, outputs) {
+  const { extractBaseOutputs } = await import("./outputs-DJHBY7EE.js");
+  return ctx.adapter.getConnectionInfo({
+    ...extractBaseOutputs(outputs),
+    privateKeyPath: expandHome(ctx.config.ssh.keyPath),
+    knownHostsPath: expandHome(ctx.config.ssh.knownHostsPath)
+  });
+}
+function expandHome(p) {
+  return p.replace(/^~/, process.env["HOME"] ?? "~");
+}
+async function applyConfigOverlay(plan, outputs, ctx, signal) {
+  const { connect } = await import("./ssh-VAI5DU5M.js");
+  const session = await connect({ ...await connectionInfoFor(ctx, outputs), signal });
+  try {
+    const remote = await readRemoteConfig(session, signal);
+    const configOverlay = plan.spec.openclaw.config ?? {};
+    const resolvedOverlay = resolveSecrets(
+      configOverlay,
+      plan.spec.secrets ?? []
+    );
+    const merged = deepMerge(remote, {
+      ...resolvedOverlay,
+      ...plan.spec.openclaw.channels !== void 0 ? { channels: plan.spec.openclaw.channels } : {}
+    });
+    await atomicWriteConfig(session, merged, signal, {
+      openclawVersion: plan.spec.openclaw.version
+    });
+    await installProviderPlugins(session, merged, plan.spec.openclaw.version, signal);
+    await installChannelPlugins(session, merged, plan.spec.openclaw.version, signal);
+    await restartGateway(session, signal);
+    await verifyProviders(session, merged, signal);
+    await verifyChannels(session, merged, signal);
+    saveOverlay(plan.spec.stackName, configOverlay, plan.spec.secrets ?? []);
+  } finally {
+    session.close();
+  }
+}
+async function installProviderPlugins(session, cfg, openclawVersion, signal) {
+  const [{ requiredPlugins, installCommand }, { STATE_DIR_HOST_LINUX }, yaml, { readFileSync }, { join }, { resolveSpecDir }] = await Promise.all([
+    import("./plugins-DTST3OER.js"),
+    import("./runtime-X3KW5TCP.js"),
+    import("./js-yaml-PTEEG4FO.js"),
+    import("fs"),
+    import("path"),
+    import("./spec-path-KQOOIQCA.js")
+  ]);
+  const catalog = yaml.load(
+    readFileSync(join(resolveSpecDir(), "models.yaml"), "utf-8")
+  );
+  const needed = requiredPlugins(cfg, catalog);
+  if (needed.length === 0) return;
+  const { execPrivileged } = await import("./privileged-JFA6LLTV.js");
+  const image = `ghcr.io/openclaw/openclaw:${openclawVersion}`;
+  for (const plugin of needed) {
+    const result = await execPrivileged(
+      session,
+      installCommand(plugin, image, STATE_DIR_HOST_LINUX),
+      signal
+    );
+    if (result.code !== 0) {
+      process.stderr.write(
+        `[clawops] warning: could not install ${plugin.package}@${plugin.version} for provider "${plugin.providerId}": ${result.stderr || result.stdout}
+`
+      );
+    }
+  }
+}
+async function verifyProviders(session, cfg, signal) {
+  const { missingProviders } = await import("./plugins-DTST3OER.js");
+  const { execPrivileged } = await import("./privileged-JFA6LLTV.js");
+  const result = await execPrivileged(
+    session,
+    "docker exec openclaw openclaw plugins list --json",
+    signal
+  );
+  if (result.code !== 0) return;
+  const missing = missingProviders(cfg, result.stdout);
+  if (missing.length > 0) {
+    process.stderr.write(
+      `[clawops] warning: the gateway is running, but these configured model providers did not load: ${missing.join(", ")}.
+[clawops] The deployment will look healthy and fail on first use. Check egress to ClawHub, then re-run apply.
+`
+    );
+  }
+}
+async function loadChannelCatalog() {
+  const [yaml, { readFileSync }, { join }, { resolveSpecDir }] = await Promise.all([
+    import("./js-yaml-PTEEG4FO.js"),
+    import("fs"),
+    import("path"),
+    import("./spec-path-KQOOIQCA.js")
+  ]);
+  return yaml.load(readFileSync(join(resolveSpecDir(), "integrations.yaml"), "utf-8"));
+}
+async function installChannelPlugins(session, cfg, openclawVersion, signal) {
+  const [{ requiredChannelPlugins, channelInstallCommand }, { STATE_DIR_HOST_LINUX }] = await Promise.all([import("./channels-KBUR42IU.js"), import("./runtime-X3KW5TCP.js")]);
+  const needed = requiredChannelPlugins(cfg, await loadChannelCatalog());
+  if (needed.length === 0) return;
+  const { execPrivileged } = await import("./privileged-JFA6LLTV.js");
+  const image = `ghcr.io/openclaw/openclaw:${openclawVersion}`;
+  for (const plugin of needed) {
+    const result = await execPrivileged(
+      session,
+      channelInstallCommand(plugin, image, STATE_DIR_HOST_LINUX),
+      signal
+    );
+    if (result.code !== 0) {
+      process.stderr.write(
+        `[clawops] warning: could not install ${plugin.package}@${plugin.version} for channel "${plugin.channelKey}": ${result.stderr || result.stdout}
+`
+      );
+    }
+  }
+}
+async function verifyChannels(session, cfg, signal) {
+  const { missingChannels, CHANNELS_LIST_CMD } = await import("./channels-KBUR42IU.js");
+  const { execPrivileged } = await import("./privileged-JFA6LLTV.js");
+  const result = await execPrivileged(session, CHANNELS_LIST_CMD, signal);
+  if (result.code !== 0) return;
+  const missing = missingChannels(cfg, result.stdout, await loadChannelCatalog());
+  if (missing.length > 0) {
+    process.stderr.write(
+      `[clawops] warning: the gateway is running, but these configured channels are not installed: ${missing.join(", ")}.
+[clawops] They will never connect. Check egress to registry.npmjs.org, then re-run apply.
+`
+    );
+  }
+}
+
+export {
+  applyPlan
+};