wattetheria 0.2.9 → 0.3.0

package/README.md

@@ -553,10 +553,28 @@ CLI prerequisites:
 The CLI handles image pull, deployment directory setup, environment generation, container start,
 and health checks internally.
 Agent commands such as `identity`, `wallet`, `servicenet`, and `publish` are forwarded to the
-platform native `wattetheria-client-cli` bundled under `bin/native/<platform>-<arch>/`; installed
-release packages should not require Rust on the user's machine. Release publishing can stage a
-native CLI binary with `npm run stage:native-cli -- --platform <platform> --arch <arch> --source <path>`.
-`WATTETHERIA_CLI_BIN` remains an advanced override for custom local binaries.
+native `wattetheria-client-cli`; installed release packages should not require Rust on the user's
+machine. The JS wrapper resolves `WATTETHERIA_CLI_BIN` first, then the matching optional native
+package such as `@wattetheria/cli-win32-x64`, then `bin/native/<platform>-<arch>/`, then `PATH`.
+If no host native CLI is available but the local Wattetheria node deployment is installed, the
+wrapper runs the same command inside the `kernel` container using the node's
+`/var/lib/wattetheria` data directory.
+
+NPM publish flow:
+
+1. Set the repository secret `NPM_TOKEN` to an npm token that can publish `wattetheria`.
+2. Run the manual GitHub Actions workflow `npm-publish`.
+3. Keep `dry_run` enabled first. It checks syntax, packs the main package, and runs npm publish
+   dry-run without building native packages.
+4. Rerun with `dry_run=false` to publish the main `wattetheria` package.
+
+The main package does not block on platform native packages. Windows and other platform-specific
+publisher execution is handled either by the optional native package or by the installed
+Wattetheria node image fallback.
+
+Standalone native publisher packages are optional and can be released separately with the manual
+`npm-native-cli-release` workflow. Use that workflow when publishing new `@wattetheria/cli-*`
+packages for users who want to run `servicenet` or `publish` before installing the local node.
 
 Version commands:
 

package/lib/cli.js

@@ -30,6 +30,7 @@ const WINDOWS_DOCKER_CANDIDATES = [
   "C:\\Program Files\\Docker\\cli-plugins\\docker.exe"
 ];
 const RUST_CLI_BASE_NAME = "wattetheria-client-cli";
+const NATIVE_CLI_PACKAGE_PREFIX = "@wattetheria/cli";
 const NATIVE_ARCH_ALIASES = new Map([
   ["x64", "x64"],
   ["arm64", "arm64"]
@@ -506,11 +507,11 @@ function formatCliVersionString() {
 
 function formatBanner(options) {
   const wordmark = [
-    " __        __    _   _   _          _   _               _       ",
-    " \\ \\      / /_ _| |_| |_| |__   ___| |_| |__   ___ _ __(_) __ _ ",
-    "  \\ \\ /\\ / / _` | __| __| '_ \\ / _ \\ __| '_ \\ / _ \\ '__| |/ _` |",
-    "   \\ V  V / (_| | |_| |_| | | |  __/ |_| | | |  __/ |  | | (_| |",
-    "    \\_/\\_/ \\__,_|\\__|\\__|_| |_|\\___|\\__|_| |_|\\___|_|  |_|\\__,_|"
+    " __        __    _   _      _   _               _       ",
+    " \\ \\      / /_ _| |_| |_ ___| |_| |__   ___ _ __(_) __ _ ",
+    "  \\ \\ /\\ / / _` | __| __/ _ \\ __| '_ \\ / _ \\ '__| |/ _` |",
+    "   \\ V  V / (_| | |_| ||  __/ |_| | | |  __/ |  | | (_| |",
+    "    \\_/\\_/ \\__,_|\\__|\\__\\___|\\__|_| |_|\\___|_|  |_|\\__,_|"
   ].join("\n");
   const subtitle = `${formatReleaseVersionString(options)} - local agent runtime, swarm sync, external agent reach`;
 
@@ -726,6 +727,27 @@ function composeFilePath(options) {
   return path.join(options.dir, "docker-compose.yml");
 }
 
+function deploymentState(dir = DEFAULT_DEPLOY_DIR) {
+  const envPath = path.join(dir, ".env");
+  const composePath = path.join(dir, "docker-compose.yml");
+  const stateDir = fs.existsSync(envPath)
+    ? resolveConfiguredPath(
+        dir,
+        getEnvValue(readEnvFile(envPath), "WATTETHERIA_HOST_STATE_DIR", "./data/wattetheria")
+      )
+    : path.join(dir, "data", "wattetheria");
+  const tokenPath = path.join(stateDir, "control.token");
+  return {
+    dir,
+    envPath,
+    composePath,
+    stateDir,
+    tokenPath,
+    installed: fs.existsSync(envPath) || fs.existsSync(composePath) || fs.existsSync(tokenPath),
+    runnable: fs.existsSync(envPath) && fs.existsSync(composePath)
+  };
+}
+
 function readEnvFile(filePath) {
   const envMap = new Map();
   const content = fs.readFileSync(filePath, "utf8");
@@ -1240,6 +1262,27 @@ function rustCliBinaryName(platform = process.platform) {
   return platform === "win32" ? `${RUST_CLI_BASE_NAME}.exe` : RUST_CLI_BASE_NAME;
 }
 
+function nativePackageName(platform = process.platform, arch = process.arch) {
+  const platformKey = nativePlatformKey(platform, arch);
+  return platformKey ? `${NATIVE_CLI_PACKAGE_PREFIX}-${platformKey}` : "";
+}
+
+function nativePackageRustBinaryPath() {
+  const packageName = nativePackageName();
+  if (!packageName) {
+    return "";
+  }
+
+  try {
+    const manifestPath = require.resolve(`${packageName}/package.json`, {
+      paths: [PACKAGE_ROOT]
+    });
+    return path.join(path.dirname(manifestPath), "bin", rustCliBinaryName());
+  } catch (_error) {
+    return "";
+  }
+}
+
 function bundledRustBinaryPath() {
   const platformKey = nativePlatformKey();
   if (!platformKey) {
@@ -1248,12 +1291,71 @@ function bundledRustBinaryPath() {
   return path.join(PACKAGE_ROOT, "bin", "native", platformKey, rustCliBinaryName());
 }
 
+function missingNativeCliError(commandName) {
+  const platformKey = nativePlatformKey() || `${process.platform}-${process.arch}`;
+  const deployment = deploymentState();
+  if (deployment.installed) {
+    return new Error(
+      `Wattetheria node deployment was found at ${deployment.dir}, but this npm package does not include ` +
+        `the native publisher CLI for ${platformKey}. ` +
+        `Run 'npx wattetheria status' to check the installed node, or update the local node image.`
+    );
+  }
+  return new Error(
+    `Could not run '${commandName}' because no Wattetheria node deployment or native CLI was found. ` +
+      `Run 'npx wattetheria install' to install the local node, or set WATTETHERIA_CLI_BIN to ` +
+      `the full path of ${rustCliBinaryName()}.`
+  );
+}
+
+function forwardedArgsForInstalledNode(commandName, rawArgv) {
+  const args = [commandName];
+  if (!rawArgv.some((arg) => arg === "--data-dir" || arg.startsWith("--data-dir="))) {
+    args.push("--data-dir", "/var/lib/wattetheria");
+  }
+  args.push(...rawArgv.slice(1));
+  return args;
+}
+
+function runInstalledNodeCli(commandName, rawArgv, deployment) {
+  const dockerCommand = resolveDockerCommand();
+  if (!dockerCommand) {
+    throw new Error(
+      `Wattetheria node deployment was found at ${deployment.dir}, but Docker is not available ` +
+        `to run '${commandName}' inside the installed node. Start Docker Desktop and retry.`
+    );
+  }
+  const result = spawnSync(
+    dockerCommand,
+    [
+      "compose",
+      "--project-name",
+      DEFAULT_PROJECT_NAME,
+      "--env-file",
+      deployment.envPath,
+      "-f",
+      deployment.composePath,
+      "exec",
+      "-T",
+      "kernel",
+      "/app/target/release/wattetheria-client-cli",
+      ...forwardedArgsForInstalledNode(commandName, rawArgv)
+    ],
+    { stdio: "inherit" }
+  );
+  if (typeof result.status === "number") {
+    process.exit(result.status);
+  }
+  throw result.error ?? new Error(`Failed to run '${commandName}' inside the installed node`);
+}
+
 function forwardToRustBinary(commandName, rawArgv) {
   // Only the Rust binary name is allowed here. The bare `wattetheria` name
   // resolves to this JS shim on most user PATHs (via the npm bin link), so
   // including it would create an infinite spawn loop.
   const candidates = [
     process.env.WATTETHERIA_CLI_BIN,
+    nativePackageRustBinaryPath(),
     bundledRustBinaryPath(),
     RUST_CLI_BASE_NAME,
   ].filter(Boolean);
@@ -1273,12 +1375,13 @@ function forwardToRustBinary(commandName, rawArgv) {
     }
   }
 
-  const platformKey = nativePlatformKey() || `${process.platform}-${process.arch}`;
-  throw new Error(
-    `Could not find the Wattetheria native CLI for ${platformKey}. ` +
-      `Install a package that includes bin/native/${platformKey}/${rustCliBinaryName()}, ` +
-      `or set WATTETHERIA_CLI_BIN to the full path of ${rustCliBinaryName()}.`
-  );
+  const deployment = deploymentState();
+  if (deployment.runnable) {
+    runInstalledNodeCli(commandName, rawArgv, deployment);
+    return;
+  }
+
+  throw missingNativeCliError(commandName);
 }
 
 async function run(argv) {

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "wattetheria",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "Wattetheria deployment CLI",
   "license": "Apache-2.0",
   "type": "commonjs",
-  "bin": "bin/wattetheria.js",
+  "bin": {
+    "wattetheria": "bin/wattetheria.js"
+  },
   "files": [
     "bin/",
     "lib/",
-    "scripts/stage-native-cli.js",
     ".env.release",
     "docker-compose.release.yml",
     "README.md",
@@ -20,8 +21,16 @@
   "publishConfig": {
     "access": "public"
   },
+  "optionalDependencies": {
+    "@wattetheria/cli-darwin-arm64": "0.3.0",
+    "@wattetheria/cli-darwin-x64": "0.3.0",
+    "@wattetheria/cli-linux-arm64": "0.3.0",
+    "@wattetheria/cli-linux-x64": "0.3.0",
+    "@wattetheria/cli-win32-arm64": "0.3.0",
+    "@wattetheria/cli-win32-x64": "0.3.0"
+  },
   "scripts": {
-    "check": "node --check bin/wattetheria.js && node --check lib/cli.js && node --check scripts/stage-native-cli.js",
+    "check": "node --check bin/wattetheria.js && node --check lib/cli.js && node --check scripts/stage-native-cli.js && node --check scripts/check-native-package-binary.js",
     "stage:native-cli": "node scripts/stage-native-cli.js"
   },
   "keywords": [

package/scripts/stage-native-cli.js

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-
-const ROOT_DIR = path.resolve(__dirname, "..");
-const BASE_NAME = "wattetheria-client-cli";
-const SUPPORTED_PLATFORMS = new Set(["darwin", "linux", "win32"]);
-const SUPPORTED_ARCHES = new Set(["x64", "arm64"]);
-
-function parseArgs(argv) {
-  const options = {
-    platform: process.env.WATTETHERIA_NATIVE_PLATFORM || process.platform,
-    arch: process.env.WATTETHERIA_NATIVE_ARCH || process.arch,
-    source: process.env.WATTETHERIA_NATIVE_CLI_BIN || "",
-  };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "--platform") {
-      options.platform = requireValue(arg, argv[++index]);
-    } else if (arg === "--arch") {
-      options.arch = requireValue(arg, argv[++index]);
-    } else if (arg === "--source") {
-      options.source = requireValue(arg, argv[++index]);
-    } else {
-      throw new Error(`Unknown option: ${arg}`);
-    }
-  }
-
-  return options;
-}
-
-function requireValue(flag, value) {
-  if (!value || value.startsWith("-")) {
-    throw new Error(`Missing value for ${flag}`);
-  }
-  return value;
-}
-
-function binaryName(platform) {
-  return platform === "win32" ? `${BASE_NAME}.exe` : BASE_NAME;
-}
-
-function defaultSource(platform) {
-  return path.join(ROOT_DIR, "target", "release", binaryName(platform));
-}
-
-function targetKey(platform, arch) {
-  if (!SUPPORTED_PLATFORMS.has(platform)) {
-    throw new Error(`Unsupported native CLI platform: ${platform}`);
-  }
-  if (!SUPPORTED_ARCHES.has(arch)) {
-    throw new Error(`Unsupported native CLI arch: ${arch}`);
-  }
-  return `${platform}-${arch}`;
-}
-
-function stageNativeCli(options) {
-  const key = targetKey(options.platform, options.arch);
-  const source = path.resolve(options.source || defaultSource(options.platform));
-  if (!fs.existsSync(source)) {
-    throw new Error(
-      `Native CLI binary not found at ${source}. Build it first or pass --source.`
-    );
-  }
-
-  const targetDir = path.join(ROOT_DIR, "bin", "native", key);
-  const target = path.join(targetDir, binaryName(options.platform));
-  fs.mkdirSync(targetDir, { recursive: true });
-  fs.copyFileSync(source, target);
-  if (options.platform !== "win32") {
-    fs.chmodSync(target, 0o755);
-  }
-  console.log(`staged ${target}`);
-}
-
-try {
-  stageNativeCli(parseArgs(process.argv.slice(2)));
-} catch (error) {
-  console.error(error && error.message ? error.message : String(error));
-  process.exit(1);
-}