wattetheria 0.1.0

package/bin/wattetheria.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { run } = require("../lib/cli");
+
+run(process.argv.slice(2)).catch((error) => {
+  const message = error && error.message ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});

package/docker-compose.release.yml

@@ -0,0 +1,165 @@
+# Release deployment stack: wattetheria + wattswarm.
+#
+# This file is intended for published image deployment.
+# It should not depend on sibling local repositories or local Docker builds.
+#
+# Usage:
+#   export WATTSWARM_PG_PASSWORD='<strong-password>'
+#   docker compose -f docker-compose.release.yml up -d
+#
+# Notes:
+# - Use coordinated image tags for wattetheria and wattswarm.
+# - Prefer pinning image digests for production-grade reproducibility.
+# - Avoid `container_name` so multiple environments and rolling upgrades remain possible.
+
+services:
+  kernel:
+    image: ${WATTETHERIA_KERNEL_IMAGE:-wattetheria/wattetheria-kernel:latest}
+    restart: unless-stopped
+    depends_on:
+      wattswarm-kernel:
+        condition: service_started
+    environment:
+      WATTETHERIA_DATA_DIR: /var/lib/wattetheria
+      WATTETHERIA_CONTROL_PLANE_BIND: 0.0.0.0:7777
+      WATTETHERIA_WATTSWARM_UI_BASE_URL: http://wattswarm-kernel:7788
+      WATTETHERIA_WATTSWARM_SYNC_GRPC_ENDPOINT: http://wattswarm-kernel:7791
+      WATTETHERIA_BRAIN_PROVIDER_KIND: ${WATTETHERIA_BRAIN_PROVIDER_KIND:-rules}
+      WATTETHERIA_BRAIN_BASE_URL: ${WATTETHERIA_BRAIN_BASE_URL:-}
+      WATTETHERIA_BRAIN_MODEL: ${WATTETHERIA_BRAIN_MODEL:-}
+      WATTETHERIA_BRAIN_API_KEY_ENV: ${WATTETHERIA_BRAIN_API_KEY_ENV:-}
+      WATTETHERIA_SERVICENET_BASE_URL: ${WATTETHERIA_SERVICENET_BASE_URL:-}
+      WATTETHERIA_AUTONOMY_ENABLED: ${WATTETHERIA_AUTONOMY_ENABLED:-false}
+      WATTETHERIA_AUTONOMY_INTERVAL_SEC: ${WATTETHERIA_AUTONOMY_INTERVAL_SEC:-30}
+      OPENCLAW_API_KEY: ${OPENCLAW_API_KEY:-}
+    volumes:
+      - wattetheria_state:/var/lib/wattetheria
+    ports:
+      - "${WATTETHERIA_CONTROL_PLANE_BIND_HOST:-127.0.0.1}:${WATTETHERIA_CONTROL_PLANE_PORT:-7777}:7777"
+    networks:
+      - watt-internal
+    entrypoint: ["/app/scripts/docker-kernel-entrypoint.sh"]
+
+  observatory:
+    image: ${WATTETHERIA_OBSERVATORY_IMAGE:-wattetheria/wattetheria-observatory:latest}
+    restart: unless-stopped
+    depends_on:
+      - kernel
+    environment:
+      PORT: 8787
+    ports:
+      - "${WATTETHERIA_OBSERVATORY_BIND_HOST:-127.0.0.1}:${WATTETHERIA_OBSERVATORY_PORT:-8780}:8787"
+    networks:
+      - watt-internal
+    entrypoint: ["/app/scripts/docker-observatory-entrypoint.sh"]
+
+  wattswarm-postgres:
+    image: postgres:16
+    restart: unless-stopped
+    environment:
+      POSTGRES_DB: ${WATTSWARM_PG_DB:-wattswarm}
+      POSTGRES_USER: ${WATTSWARM_PG_USER:-postgres}
+      POSTGRES_PASSWORD: ${WATTSWARM_PG_PASSWORD:?WATTSWARM_PG_PASSWORD must be set}
+    volumes:
+      - wattswarm_pg_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${WATTSWARM_PG_USER:-postgres} -d ${WATTSWARM_PG_DB:-wattswarm}"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+    networks:
+      - watt-internal
+
+  wattswarm-runtime:
+    image: ${WATTSWARM_RUNTIME_IMAGE:-wattetheria/wattswarm-runtime:latest}
+    restart: unless-stopped
+    entrypoint: ["/app/target/release/wattswarm-runtime"]
+    command: ["--listen", "0.0.0.0:8787"]
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS http://127.0.0.1:8787/health > /dev/null"]
+      interval: 5s
+      timeout: 3s
+      retries: 20
+      start_period: 5s
+    networks:
+      - watt-internal
+
+  wattswarm-kernel:
+    image: ${WATTSWARM_KERNEL_IMAGE:-wattetheria/wattswarm-kernel:latest}
+    restart: unless-stopped
+    depends_on:
+      wattswarm-postgres:
+        condition: service_healthy
+      wattswarm-runtime:
+        condition: service_healthy
+    environment:
+      WATTSWARM_PG_URL: postgres://${WATTSWARM_PG_USER:-postgres}:${WATTSWARM_PG_PASSWORD:?WATTSWARM_PG_PASSWORD must be set}@wattswarm-postgres:5432/${WATTSWARM_PG_DB:-wattswarm}
+      WATTSWARM_STATE_DIR: /var/lib/wattswarm
+      WATTSWARM_STORE_NAME: wattswarm.state
+      WATTSWARM_UI_LISTEN: 0.0.0.0:7788
+      WATTSWARM_WATTETHERIA_SYNC_GRPC_LISTEN: "0.0.0.0:7791"
+      WATTSWARM_P2P_ENABLED: ${WATTSWARM_P2P_ENABLED:-true}
+      WATTSWARM_P2P_MDNS: ${WATTSWARM_P2P_MDNS:-true}
+      WATTSWARM_P2P_PORT: ${WATTSWARM_P2P_PORT:-4001}
+      WATTSWARM_BOOTSTRAP_EXECUTOR_NAME: rt
+      WATTSWARM_BOOTSTRAP_EXECUTOR_URL: http://wattswarm-runtime:8787
+      WATTSWARM_UDP_ANNOUNCE_ENABLED: ${WATTSWARM_UDP_ANNOUNCE_ENABLED:-false}
+      WATTSWARM_UDP_ANNOUNCE_MODE: ${WATTSWARM_UDP_ANNOUNCE_MODE:-multicast}
+      WATTSWARM_UDP_ANNOUNCE_ADDR: ${WATTSWARM_UDP_ANNOUNCE_ADDR:-239.255.42.99}
+      WATTSWARM_UDP_ANNOUNCE_PORT: ${WATTSWARM_UDP_ANNOUNCE_PORT:-37931}
+    volumes:
+      - wattswarm_state_data:/var/lib/wattswarm
+    ports:
+      - "${WATTSWARM_UI_BIND_HOST:-127.0.0.1}:${WATTSWARM_UI_PORT:-7788}:7788"
+      - "${WATTSWARM_P2P_HOST_PORT:-4001}:${WATTSWARM_P2P_PORT:-4001}"
+      - "${WATTSWARM_UDP_ANNOUNCE_HOST_PORT:-37931}:${WATTSWARM_UDP_ANNOUNCE_PORT:-37931}/udp"
+    networks:
+      - watt-internal
+    entrypoint: ["/app/scripts/docker-kernel-entrypoint.sh"]
+
+  wattswarm-worker:
+    image: ${WATTSWARM_WORKER_IMAGE:-wattetheria/wattswarm-worker:latest}
+    restart: unless-stopped
+    depends_on:
+      wattswarm-postgres:
+        condition: service_healthy
+      wattswarm-runtime:
+        condition: service_healthy
+      wattswarm-kernel:
+        condition: service_started
+    environment:
+      WATTSWARM_PG_URL: postgres://${WATTSWARM_PG_USER:-postgres}:${WATTSWARM_PG_PASSWORD:?WATTSWARM_PG_PASSWORD must be set}@wattswarm-postgres:5432/${WATTSWARM_PG_DB:-wattswarm}
+      WATTSWARM_STATE_DIR: /var/lib/wattswarm
+      WATTSWARM_STORE_NAME: wattswarm.state
+      WATTSWARM_WORKER_CONCURRENCY: ${WATTSWARM_WORKER_CONCURRENCY:-16}
+      WATTSWARM_WORKER_POLL_MS: ${WATTSWARM_WORKER_POLL_MS:-250}
+      WATTSWARM_WORKER_LEASE_MS: ${WATTSWARM_WORKER_LEASE_MS:-30000}
+    volumes:
+      - wattswarm_state_data:/var/lib/wattswarm
+    networks:
+      - watt-internal
+    entrypoint: ["/app/target/release/wattswarm"]
+    command:
+      - --state-dir
+      - /var/lib/wattswarm
+      - --store
+      - wattswarm.state
+      - run
+      - --pg-url
+      - postgres://${WATTSWARM_PG_USER:-postgres}:${WATTSWARM_PG_PASSWORD:?WATTSWARM_PG_PASSWORD must be set}@wattswarm-postgres:5432/${WATTSWARM_PG_DB:-wattswarm}
+      - worker
+      - --concurrency
+      - "${WATTSWARM_WORKER_CONCURRENCY:-16}"
+      - --poll-ms
+      - "${WATTSWARM_WORKER_POLL_MS:-250}"
+      - --lease-ms
+      - "${WATTSWARM_WORKER_LEASE_MS:-30000}"
+
+volumes:
+  wattetheria_state:
+  wattswarm_pg_data:
+  wattswarm_state_data:
+
+networks:
+  watt-internal:
+    driver: bridge

package/lib/cli.js

@@ -0,0 +1,423 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
+const DEFAULT_DEPLOY_DIR = path.join(os.homedir(), ".wattetheria", "deploy");
+const DEFAULT_PROJECT_NAME = "wattetheria";
+const DEFAULT_COMMAND = "install";
+const IMAGE_KEYS = [
+  "WATTETHERIA_KERNEL_IMAGE",
+  "WATTETHERIA_OBSERVATORY_IMAGE",
+  "WATTSWARM_KERNEL_IMAGE",
+  "WATTSWARM_RUNTIME_IMAGE",
+  "WATTSWARM_WORKER_IMAGE"
+];
+
+function printHelp() {
+  console.log(`Wattetheria CLI ${PACKAGE_JSON.version}
+
+Usage:
+  npx wattetheria [command] [options]
+  npx wattetheria install
+
+Commands:
+  install     Prepare deployment, pull images, and start the stack
+  start       Start an existing deployment
+  status      Show docker compose status
+  update      Update image tags, pull, and restart
+  stop        Stop the deployment
+  uninstall   Stop the deployment and optionally remove volumes
+  logs        Show docker compose logs
+  doctor      Check local prerequisites
+  help        Show this help
+
+Options:
+  --dir <path>           Deployment directory (default: ${DEFAULT_DEPLOY_DIR})
+  --project-name <name>  Docker compose project name (default: ${DEFAULT_PROJECT_NAME})
+  --tag <tag>            Override all release image tags
+  --force                Refresh deployment templates from package assets
+  --no-health-checks     Skip HTTP health checks
+  --volumes              With uninstall, remove named docker volumes
+  --purge                With uninstall, remove the deployment directory
+`);
+}
+
+function parseArgs(argv) {
+  let command = DEFAULT_COMMAND;
+  let index = 0;
+  if (argv[0] && !argv[0].startsWith("-")) {
+    command = argv[0];
+    index = 1;
+  }
+
+  const options = {
+    dir: DEFAULT_DEPLOY_DIR,
+    projectName: DEFAULT_PROJECT_NAME,
+    tag: PACKAGE_JSON.version,
+    force: false,
+    healthChecks: true,
+    volumes: false,
+    purge: false,
+    composeArgs: []
+  };
+
+  while (index < argv.length) {
+    const arg = argv[index];
+    if (arg === "--dir") {
+      options.dir = requireValue(arg, argv[++index]);
+    } else if (arg === "--project-name") {
+      options.projectName = requireValue(arg, argv[++index]);
+    } else if (arg === "--tag") {
+      options.tag = requireValue(arg, argv[++index]);
+    } else if (arg === "--force") {
+      options.force = true;
+    } else if (arg === "--no-health-checks") {
+      options.healthChecks = false;
+    } else if (arg === "--volumes") {
+      options.volumes = true;
+    } else if (arg === "--purge") {
+      options.purge = true;
+    } else if (arg === "--") {
+      options.composeArgs = argv.slice(index + 1);
+      break;
+    } else if (command === "logs") {
+      options.composeArgs.push(arg);
+    } else if (command === "help") {
+      break;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    index += 1;
+  }
+
+  return { command, options };
+}
+
+function requireValue(flag, value) {
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+
+function ensureCommandAvailable(command, helpText) {
+  const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+  if (result.error || result.status !== 0) {
+    throw new Error(helpText);
+  }
+}
+
+function ensureDockerAvailable() {
+  ensureCommandAvailable(
+    "docker",
+    "Docker is required. Install Docker Desktop or another Docker-compatible runtime first."
+  );
+
+  const compose = spawnSync("docker", ["compose", "version"], {
+    stdio: "ignore"
+  });
+  if (compose.error || compose.status !== 0) {
+    throw new Error("Docker Compose v2 is required.");
+  }
+
+  const info = spawnSync("docker", ["info"], { stdio: "ignore" });
+  if (info.error || info.status !== 0) {
+    throw new Error("Docker daemon is not reachable. Start Docker Desktop or the Docker service first.");
+  }
+}
+
+function ensureDeploymentAssets(options) {
+  fs.mkdirSync(options.dir, { recursive: true });
+
+  const templateEnvPath = path.join(PACKAGE_ROOT, ".env.release.example");
+  const templateComposePath = path.join(PACKAGE_ROOT, "docker-compose.release.yml");
+  const targetEnvPath = envFilePath(options);
+  const targetComposePath = composeFilePath(options);
+
+  if (options.force || !fs.existsSync(targetEnvPath)) {
+    fs.copyFileSync(templateEnvPath, targetEnvPath);
+  }
+  if (options.force || !fs.existsSync(targetComposePath)) {
+    fs.copyFileSync(templateComposePath, targetComposePath);
+  }
+
+  const envMap = readEnvFile(targetEnvPath);
+  ensureDatabasePassword(envMap);
+  if (options.tag) {
+    pinImageTags(envMap, options.tag);
+  }
+  writeEnvFile(targetEnvPath, envMap);
+}
+
+function envFilePath(options) {
+  return path.join(options.dir, ".env");
+}
+
+function composeFilePath(options) {
+  return path.join(options.dir, "docker-compose.yml");
+}
+
+function readEnvFile(filePath) {
+  const envMap = new Map();
+  const content = fs.readFileSync(filePath, "utf8");
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) {
+      continue;
+    }
+    const separator = rawLine.indexOf("=");
+    if (separator < 0) {
+      continue;
+    }
+    const key = rawLine.slice(0, separator).trim();
+    const value = rawLine.slice(separator + 1);
+    envMap.set(key, value);
+  }
+  return envMap;
+}
+
+function writeEnvFile(filePath, envMap) {
+  const lines = [];
+  for (const [key, value] of envMap.entries()) {
+    lines.push(`${key}=${value}`);
+  }
+  fs.writeFileSync(filePath, `${lines.join("\n")}\n`);
+}
+
+function ensureDatabasePassword(envMap) {
+  const placeholder = "replace-with-strong-password";
+  const current = envMap.get("WATTSWARM_PG_PASSWORD");
+  if (!current || current === placeholder) {
+    envMap.set("WATTSWARM_PG_PASSWORD", randomPassword());
+  }
+}
+
+function pinImageTags(envMap, tag) {
+  for (const key of IMAGE_KEYS) {
+    if (!envMap.has(key)) {
+      continue;
+    }
+    const current = envMap.get(key);
+    const index = current.lastIndexOf(":");
+    if (index <= current.lastIndexOf("/")) {
+      envMap.set(key, `${current}:${tag}`);
+    } else {
+      envMap.set(key, `${current.slice(0, index + 1)}${tag}`);
+    }
+  }
+}
+
+function randomPassword() {
+  return crypto
+    .randomBytes(24)
+    .toString("base64")
+    .replace(/\+/g, "A")
+    .replace(/\//g, "B")
+    .replace(/=/g, "");
+}
+
+function runCompose(options, args, capture = false) {
+  const result = spawnSync(
+    "docker",
+    [
+      "compose",
+      "--project-name",
+      options.projectName,
+      "--env-file",
+      envFilePath(options),
+      "-f",
+      composeFilePath(options),
+      ...args
+    ],
+    {
+      stdio: capture ? "pipe" : "inherit",
+      encoding: capture ? "utf8" : undefined
+    }
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    if (capture && result.stderr) {
+      throw new Error(result.stderr.trim() || `docker compose ${args.join(" ")} failed`);
+    }
+    throw new Error(`docker compose ${args.join(" ")} failed`);
+  }
+  return result;
+}
+
+async function waitForHttp(name, url, maxAttempts = 60, delayMs = 2000) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = await fetch(url, { method: "GET" });
+      if (response.ok) {
+        console.log(`[ok] ${name}: ${url}`);
+        return;
+      }
+    } catch (error) {
+      // retry
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  throw new Error(`Timed out waiting for ${name}: ${url}`);
+}
+
+function getEnvValue(envMap, key, defaultValue) {
+  const value = envMap.get(key);
+  return value && value.trim() ? value : defaultValue;
+}
+
+async function runHealthChecks(options) {
+  const envMap = readEnvFile(envFilePath(options));
+  const kernelHost = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_BIND_HOST", "127.0.0.1");
+  const kernelPort = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_PORT", "7777");
+  const uiHost = getEnvValue(envMap, "WATTSWARM_UI_BIND_HOST", "127.0.0.1");
+  const uiPort = getEnvValue(envMap, "WATTSWARM_UI_PORT", "7788");
+  const observatoryHost = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_BIND_HOST", "127.0.0.1");
+  const observatoryPort = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_PORT", "8780");
+
+  await waitForHttp("kernel health", `http://${kernelHost}:${kernelPort}/v1/health`);
+  await waitForHttp("wattswarm ui", `http://${uiHost}:${uiPort}/`);
+  await waitForHttp("observatory health", `http://${observatoryHost}:${observatoryPort}/healthz`);
+}
+
+function printSummary(options) {
+  const envMap = readEnvFile(envFilePath(options));
+  const kernelHost = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_BIND_HOST", "127.0.0.1");
+  const kernelPort = getEnvValue(envMap, "WATTETHERIA_CONTROL_PLANE_PORT", "7777");
+  const uiHost = getEnvValue(envMap, "WATTSWARM_UI_BIND_HOST", "127.0.0.1");
+  const uiPort = getEnvValue(envMap, "WATTSWARM_UI_PORT", "7788");
+  const observatoryHost = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_BIND_HOST", "127.0.0.1");
+  const observatoryPort = getEnvValue(envMap, "WATTETHERIA_OBSERVATORY_PORT", "8780");
+
+  console.log("");
+  console.log("Deployment complete.");
+  console.log(`Kernel:       http://${kernelHost}:${kernelPort}`);
+  console.log(`Wattswarm UI: http://${uiHost}:${uiPort}`);
+  console.log(`Observatory:  http://${observatoryHost}:${observatoryPort}`);
+  console.log(`Deploy dir:   ${options.dir}`);
+}
+
+async function install(options) {
+  ensureDockerAvailable();
+  ensureDeploymentAssets(options);
+  runCompose(options, ["config"], true);
+  console.log("Pulling release images...");
+  runCompose(options, ["pull"]);
+  console.log("Starting release stack...");
+  runCompose(options, ["up", "-d"]);
+  if (options.healthChecks) {
+    await runHealthChecks(options);
+  }
+  printSummary(options);
+}
+
+async function start(options) {
+  ensureDockerAvailable();
+  if (!fs.existsSync(composeFilePath(options)) || !fs.existsSync(envFilePath(options))) {
+    throw new Error("Deployment is not initialized. Run install first.");
+  }
+  runCompose(options, ["up", "-d"]);
+  if (options.healthChecks) {
+    await runHealthChecks(options);
+  }
+  printSummary(options);
+}
+
+function status(options) {
+  ensureDockerAvailable();
+  runCompose(options, ["ps"]);
+}
+
+async function update(options) {
+  ensureDockerAvailable();
+  if (!fs.existsSync(composeFilePath(options)) || !fs.existsSync(envFilePath(options))) {
+    throw new Error("Deployment is not initialized. Run install first.");
+  }
+  ensureDeploymentAssets(options);
+  console.log("Pulling updated images...");
+  runCompose(options, ["pull"]);
+  console.log("Restarting release stack...");
+  runCompose(options, ["up", "-d"]);
+  if (options.healthChecks) {
+    await runHealthChecks(options);
+  }
+  printSummary(options);
+}
+
+function stop(options) {
+  ensureDockerAvailable();
+  runCompose(options, ["down"]);
+}
+
+function uninstall(options) {
+  ensureDockerAvailable();
+  const args = ["down"];
+  if (options.volumes) {
+    args.push("-v");
+  }
+  runCompose(options, args);
+  if (options.purge && fs.existsSync(options.dir)) {
+    fs.rmSync(options.dir, { recursive: true, force: true });
+    console.log(`Removed deployment directory: ${options.dir}`);
+  }
+}
+
+function logs(options) {
+  ensureDockerAvailable();
+  runCompose(options, ["logs", ...options.composeArgs]);
+}
+
+function doctor() {
+  ensureDockerAvailable();
+  console.log("Docker runtime is available.");
+  console.log(`Node.js ${process.version} is available.`);
+}
+
+async function run(argv) {
+  const { command, options } = parseArgs(argv);
+
+  switch (command) {
+    case "install":
+      await install(options);
+      return;
+    case "start":
+    case "up":
+      await start(options);
+      return;
+    case "status":
+      status(options);
+      return;
+    case "update":
+      await update(options);
+      return;
+    case "stop":
+    case "down":
+      stop(options);
+      return;
+    case "uninstall":
+      uninstall(options);
+      return;
+    case "logs":
+      logs(options);
+      return;
+    case "doctor":
+      doctor();
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      return;
+    default:
+      throw new Error(`Unknown command: ${command}`);
+  }
+}
+
+module.exports = {
+  run
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "wattetheria",
+  "version": "0.1.0",
+  "description": "Wattetheria deployment CLI",
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "bin": {
+    "wattetheria": "./bin/wattetheria.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "docker-compose.release.yml",
+    ".env.release.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "node --check bin/wattetheria.js && node --check lib/cli.js"
+  },
+  "keywords": [
+    "wattetheria",
+    "wattswarm",
+    "docker",
+    "cli",
+    "deploy"
+  ]
+}