wattetheria 0.1.0 → 0.1.1

package/lib/cli.js

@@ -3,6 +3,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
+const { createInterface } = require("node:readline/promises");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
@@ -16,6 +17,11 @@ const IMAGE_KEYS = [
   "WATTSWARM_RUNTIME_IMAGE",
   "WATTSWARM_WORKER_IMAGE"
 ];
+const DOCKER_INSTALL_URLS = {
+  darwin: "https://www.docker.com/products/docker-desktop/",
+  win32: "https://www.docker.com/products/docker-desktop/",
+  linux: "https://docs.docker.com/engine/install/"
+};
 
 function printHelp() {
   console.log(`Wattetheria CLI ${PACKAGE_JSON.version}
@@ -36,6 +42,7 @@ Commands:
   help        Show this help
 
 Options:
+  --version              Show CLI version
   --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
@@ -47,6 +54,22 @@ Options:
 }
 
 function parseArgs(argv) {
+  if (argv[0] === "--version" || argv[0] === "-v") {
+    return {
+      command: "version",
+      options: {
+        dir: DEFAULT_DEPLOY_DIR,
+        projectName: DEFAULT_PROJECT_NAME,
+        tag: PACKAGE_JSON.version,
+        force: false,
+        healthChecks: true,
+        volumes: false,
+        purge: false,
+        composeArgs: []
+      }
+    };
+  }
+
   let command = DEFAULT_COMMAND;
   let index = 0;
   if (argv[0] && !argv[0].startsWith("-")) {
@@ -104,29 +127,168 @@ function requireValue(flag, value) {
   return value;
 }
 
-function ensureCommandAvailable(command, helpText) {
-  const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+function getDockerInstallUrl() {
+  return DOCKER_INSTALL_URLS[process.platform] || DOCKER_INSTALL_URLS.linux;
+}
+
+function getGitRevision() {
+  if (typeof PACKAGE_JSON.gitHead === "string" && PACKAGE_JSON.gitHead.trim()) {
+    return PACKAGE_JSON.gitHead.trim();
+  }
+
+  const result = spawnSync("git", ["rev-parse", "--short=7", "HEAD"], {
+    cwd: PACKAGE_ROOT,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
   if (result.error || result.status !== 0) {
-    throw new Error(helpText);
+    return "";
   }
+  return (result.stdout || "").trim();
 }
 
-function ensureDockerAvailable() {
-  ensureCommandAvailable(
-    "docker",
-    "Docker is required. Install Docker Desktop or another Docker-compatible runtime first."
-  );
+function formatVersionString() {
+  const revision = getGitRevision();
+  if (revision) {
+    return `Wattetheria ${PACKAGE_JSON.version} (${revision})`;
+  }
+  return `Wattetheria ${PACKAGE_JSON.version}`;
+}
+
+function formatBanner() {
+  return `${formatVersionString()} — Local agent runtime with swarm sync and external agent reach.`;
+}
+
+function formatDockerStatusMessage(status) {
+  const installUrl = status.installUrl || getDockerInstallUrl();
+  switch (status.code) {
+    case "missing-docker":
+      return [
+        "Docker runtime not found.",
+        "Install Docker Desktop or another Docker-compatible runtime, then run the command again.",
+        `Download: ${installUrl}`
+      ].join("\n");
+    case "missing-compose":
+      return [
+        "Docker Compose v2 is required.",
+        "Install or upgrade Docker Desktop so `docker compose` is available.",
+        `Help: ${installUrl}`
+      ].join("\n");
+    case "daemon-unreachable":
+      return [
+        "Docker is installed but the daemon is not reachable.",
+        "Start Docker Desktop or your Docker service, wait until it is ready, then retry."
+      ].join("\n");
+    default:
+      return "Docker runtime check failed.";
+  }
+}
+
+function getDockerStatus() {
+  const installUrl = getDockerInstallUrl();
+  const docker = spawnSync("docker", ["--version"], { stdio: "ignore" });
+  if (docker.error || docker.status !== 0) {
+    return {
+      ready: false,
+      code: "missing-docker",
+      installUrl
+    };
+  }
 
   const compose = spawnSync("docker", ["compose", "version"], {
     stdio: "ignore"
   });
   if (compose.error || compose.status !== 0) {
-    throw new Error("Docker Compose v2 is required.");
+    return {
+      ready: false,
+      code: "missing-compose",
+      installUrl
+    };
   }
 
   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.");
+    return {
+      ready: false,
+      code: "daemon-unreachable",
+      installUrl
+    };
+  }
+
+  return {
+    ready: true
+  };
+}
+
+function isInteractiveTerminal() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function openUrl(url) {
+  let command;
+  let args;
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+
+  const result = spawnSync(command, args, { stdio: "ignore" });
+  return !result.error && result.status === 0;
+}
+
+async function promptForDockerSetup(status) {
+  const installUrl = status.installUrl || getDockerInstallUrl();
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    while (true) {
+      console.log("");
+      console.log("Wattetheria needs Docker before it can install the local stack.");
+      console.log(formatDockerStatusMessage(status));
+      console.log("");
+      console.log("1. Open Docker install page");
+      console.log("2. Retry Docker check");
+      console.log("3. Cancel");
+
+      const answer = (await rl.question("Select an option [1-3]: ")).trim();
+      if (answer === "1") {
+        const opened = openUrl(installUrl);
+        console.log(opened ? "Opened Docker install page." : `Open this URL in your browser: ${installUrl}`);
+        continue;
+      }
+      if (answer === "2") {
+        return;
+      }
+      if (answer === "3" || answer === "") {
+        throw new Error(formatDockerStatusMessage(status));
+      }
+      console.log("Please choose 1, 2, or 3.");
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function ensureDockerAvailable(options = {}) {
+  const interactive = Boolean(options.interactive);
+  while (true) {
+    const status = getDockerStatus();
+    if (status.ready) {
+      return;
+    }
+    if (!interactive || !isInteractiveTerminal()) {
+      throw new Error(formatDockerStatusMessage(status));
+    }
+    await promptForDockerSetup(status);
   }
 }
 
@@ -303,7 +465,7 @@ function printSummary(options) {
 }
 
 async function install(options) {
-  ensureDockerAvailable();
+  await ensureDockerAvailable({ interactive: true });
   ensureDeploymentAssets(options);
   runCompose(options, ["config"], true);
   console.log("Pulling release images...");
@@ -317,7 +479,7 @@ async function install(options) {
 }
 
 async function start(options) {
-  ensureDockerAvailable();
+  await ensureDockerAvailable();
   if (!fs.existsSync(composeFilePath(options)) || !fs.existsSync(envFilePath(options))) {
     throw new Error("Deployment is not initialized. Run install first.");
   }
@@ -328,13 +490,13 @@ async function start(options) {
   printSummary(options);
 }
 
-function status(options) {
-  ensureDockerAvailable();
+async function status(options) {
+  await ensureDockerAvailable();
   runCompose(options, ["ps"]);
 }
 
 async function update(options) {
-  ensureDockerAvailable();
+  await ensureDockerAvailable();
   if (!fs.existsSync(composeFilePath(options)) || !fs.existsSync(envFilePath(options))) {
     throw new Error("Deployment is not initialized. Run install first.");
   }
@@ -349,13 +511,13 @@ async function update(options) {
   printSummary(options);
 }
 
-function stop(options) {
-  ensureDockerAvailable();
+async function stop(options) {
+  await ensureDockerAvailable();
   runCompose(options, ["down"]);
 }
 
-function uninstall(options) {
-  ensureDockerAvailable();
+async function uninstall(options) {
+  await ensureDockerAvailable();
   const args = ["down"];
   if (options.volumes) {
     args.push("-v");
@@ -367,20 +529,40 @@ function uninstall(options) {
   }
 }
 
-function logs(options) {
-  ensureDockerAvailable();
+async function logs(options) {
+  await ensureDockerAvailable();
   runCompose(options, ["logs", ...options.composeArgs]);
 }
 
 function doctor() {
-  ensureDockerAvailable();
+  const status = getDockerStatus();
+  if (!status.ready) {
+    throw new Error(formatDockerStatusMessage(status));
+  }
   console.log("Docker runtime is available.");
   console.log(`Node.js ${process.version} is available.`);
 }
 
+function printVersion() {
+  console.log(formatVersionString());
+}
+
+function shouldPrintBanner(command) {
+  return !["help", "--help", "-h", "version"].includes(command);
+}
+
+function printBanner() {
+  console.log(formatBanner());
+  console.log("");
+}
+
 async function run(argv) {
   const { command, options } = parseArgs(argv);
 
+  if (shouldPrintBanner(command)) {
+    printBanner();
+  }
+
   switch (command) {
     case "install":
       await install(options);
@@ -390,24 +572,27 @@ async function run(argv) {
       await start(options);
       return;
     case "status":
-      status(options);
+      await status(options);
       return;
     case "update":
       await update(options);
       return;
     case "stop":
     case "down":
-      stop(options);
+      await stop(options);
       return;
     case "uninstall":
-      uninstall(options);
+      await uninstall(options);
       return;
     case "logs":
-      logs(options);
+      await logs(options);
       return;
     case "doctor":
       doctor();
       return;
+    case "version":
+      printVersion();
+      return;
     case "help":
     case "--help":
     case "-h":

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "wattetheria",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Wattetheria deployment CLI",
   "license": "Apache-2.0",
   "type": "commonjs",
-  "bin": {
-    "wattetheria": "./bin/wattetheria.js"
-  },
+  "bin": "bin/wattetheria.js",
   "files": [
     "bin/",
     "lib/",