@clawops/cli 1.1.0 → 1.2.1

package/dist/chunk-UDNZUSKA.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+// src/plan/remote-config.ts
+var OPENCLAW_CONFIG_LINUX = "/home/clawops/openclaw.json";
+var OPENCLAW_CONFIG_MACOS = "~/.config/openclaw/config.json";
+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";
+}
+function configPathForOS(os) {
+  return os === "Darwin" ? OPENCLAW_CONFIG_MACOS : OPENCLAW_CONFIG_LINUX;
+}
+async function execWithFallbackSudo(session, cmd, signal) {
+  const result = await session.exec(cmd, signal);
+  if (result.code === 0) return result;
+  return session.exec(`sudo -n bash -c "${cmd}"`, signal);
+}
+async function readRemoteConfig(session, signal) {
+  const os = await detectOS(session, signal);
+  const configPath = configPathForOS(os);
+  const result = await session.exec(`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) {
+  const os = await detectOS(session, signal);
+  const configPath = configPathForOS(os);
+  const json = JSON.stringify(cfg, null, 2);
+  const b64 = Buffer.from(json, "utf-8").toString("base64");
+  const chown = os === "Linux" ? ` && chown clawops:clawops ${configPath}` : "";
+  const cmd = `echo '${b64}' | base64 -d > ${OPENCLAW_TMP} && mv ${OPENCLAW_TMP} ${configPath}` + chown;
+  const result = os === "Darwin" ? await session.exec(cmd, signal) : await execWithFallbackSudo(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 configPath = configPathForOS(os);
+  const pathPrefix = os === "Darwin" ? 'export PATH="/usr/local/bin:/opt/homebrew/bin:/Applications/Docker.app/Contents/Resources/bin:$PATH" && ' : "";
+  const imgCmd = `${pathPrefix}docker inspect openclaw --format '{{.Config.Image}}' 2>/dev/null || echo 'ghcr.io/openclaw/openclaw:latest'`;
+  const imgResult = os === "Darwin" ? await session.exec(imgCmd, signal) : await execWithFallbackSudo(session, imgCmd, signal);
+  const image = imgResult.stdout.trim();
+  const cfgResult = await session.exec(`cat ${configPath}`, signal);
+  let gatewayCmd = "node openclaw.mjs gateway run --allow-unconfigured";
+  try {
+    const cfg = JSON.parse(cfgResult.stdout);
+    const token = cfg?.["gateway"]?.["auth"];
+    const tokenVal = token?.["token"];
+    if (tokenVal) {
+      gatewayCmd = `node openclaw.mjs gateway run --allow-unconfigured --token '${tokenVal}'`;
+    }
+  } catch {
+  }
+  const restartCmd = pathPrefix + [
+    "docker stop openclaw 2>/dev/null || true",
+    "docker rm openclaw 2>/dev/null || true",
+    `docker run -d --name openclaw --restart unless-stopped -p 18789:18789 -v ${configPath}:/app/config.json:ro ${image} ${gatewayCmd}`
+  ].join(" && ");
+  const result = os === "Darwin" ? await session.exec(restartCmd, signal) : await execWithFallbackSudo(session, restartCmd, signal);
+  if (result.code !== 0) {
+    throw new Error(`Gateway restart failed: ${result.stderr}`);
+  }
+}
+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-ZVOEQCNW.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  connect
+} from "./chunk-4U3LTLWZ.js";
+import {
+  NetworkError
+} from "./chunk-KGXPLI7W.js";
+
+// src/transport/pool.ts
+var IDLE_TTL_MS = 5 * 60 * 1e3;
+var MAX_PER_HOST = 4;
+var CLEANUP_INTERVAL_MS = 3e4;
+var pool = /* @__PURE__ */ new Map();
+var cleanupTimer = null;
+function poolKey(opts) {
+  return `${opts.user}@${opts.host}:${opts.port}`;
+}
+function startCleanupTimer() {
+  if (cleanupTimer) return;
+  cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entries] of pool) {
+      const active = entries.filter((e) => {
+        if (!e.inUse && now - e.lastUsed > IDLE_TTL_MS) {
+          e.session.close();
+          return false;
+        }
+        return true;
+      });
+      if (active.length === 0) {
+        pool.delete(key);
+      } else {
+        pool.set(key, active);
+      }
+    }
+    if (pool.size === 0 && cleanupTimer) {
+      clearInterval(cleanupTimer);
+      cleanupTimer = null;
+    }
+  }, CLEANUP_INTERVAL_MS);
+  cleanupTimer.unref();
+}
+async function acquireSession(opts) {
+  const key = poolKey(opts);
+  const entries = pool.get(key) ?? [];
+  const idle = entries.find((e) => !e.inUse);
+  if (idle) {
+    idle.inUse = true;
+    idle.lastUsed = Date.now();
+    return {
+      session: idle.session,
+      release() {
+        idle.inUse = false;
+        idle.lastUsed = Date.now();
+      }
+    };
+  }
+  if (entries.length >= MAX_PER_HOST) {
+    throw new NetworkError(
+      `SSH connection pool exhausted for ${key} (max ${MAX_PER_HOST} concurrent connections).`
+    );
+  }
+  const session = await connect(opts);
+  const entry = { session, hostKey: key, lastUsed: Date.now(), inUse: true };
+  entries.push(entry);
+  pool.set(key, entries);
+  startCleanupTimer();
+  return {
+    session,
+    release() {
+      entry.inUse = false;
+      entry.lastUsed = Date.now();
+    }
+  };
+}
+function drainPool() {
+  for (const entries of pool.values()) {
+    for (const e of entries) {
+      e.session.close();
+    }
+  }
+  pool.clear();
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}
+
+export {
+  acquireSession,
+  drainPool
+};