wattetheria 0.2.8 → 0.3.0

package/README.md

@@ -552,6 +552,29 @@ 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
+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

@@ -29,6 +29,27 @@ const WINDOWS_DOCKER_CANDIDATES = [
   "C:\\Program Files\\Docker\\Docker\\resources\\bin\\docker.exe",
   "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"]
+]);
+const BANNER_COMMANDS = new Set([
+  "help",
+  "install",
+  "start",
+  "up",
+  "update",
+  "restart",
+  "stop",
+  "down",
+  "uninstall",
+  "doctor"
+]);
+const ANSI_ORANGE = "\x1b[38;5;166m";
+const ANSI_MUTED = "\x1b[38;5;244m";
+const ANSI_RESET = "\x1b[0m";
 
 function printHelp() {
   console.log(`Wattetheria CLI ${PACKAGE_JSON.version}
@@ -52,7 +73,7 @@ Commands:
   doctor      Check local prerequisites
   help        Show this help
 
-Developer subcommands (forwarded to the local 'wattetheria-client-cli' Rust binary):
+Agent subcommands (forwarded to the bundled native CLI when available):
   identity    init | show | export-seed
   wallet      manage wallet payment accounts
   servicenet  provider register
@@ -485,7 +506,19 @@ function formatCliVersionString() {
 }
 
 function formatBanner(options) {
-  return `${formatReleaseVersionString(options)} — Local agent runtime with swarm sync and external agent reach.`;
+  const wordmark = [
+    " __        __    _   _      _   _               _       ",
+    " \\ \\      / /_ _| |_| |_ ___| |_| |__   ___ _ __(_) __ _ ",
+    "  \\ \\ /\\ / / _` | __| __/ _ \\ __| '_ \\ / _ \\ '__| |/ _` |",
+    "   \\ V  V / (_| | |_| ||  __/ |_| | | |  __/ |  | | (_| |",
+    "    \\_/\\_/ \\__,_|\\__|\\__\\___|\\__|_| |_|\\___|_|  |_|\\__,_|"
+  ].join("\n");
+  const subtitle = `${formatReleaseVersionString(options)} - local agent runtime, swarm sync, external agent reach`;
+
+  if (!supportsBannerColor()) {
+    return `${wordmark}\n${subtitle}`;
+  }
+  return `${ANSI_ORANGE}${wordmark}${ANSI_RESET}\n${ANSI_MUTED}${subtitle}${ANSI_RESET}`;
 }
 
 function formatDockerStatusMessage(status) {
@@ -694,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");
@@ -1170,7 +1224,10 @@ function printImages(options) {
 }
 
 function shouldPrintBanner(command) {
-  return !["help", "--help", "-h", "version", "images", "mcp-proxy"].includes(command);
+  return isInteractiveTerminal()
+    && !process.env.CI
+    && !process.env.WATTETHERIA_NO_BANNER
+    && BANNER_COMMANDS.has(command);
 }
 
 function printBanner(options) {
@@ -1178,6 +1235,12 @@ function printBanner(options) {
   console.log("");
 }
 
+function supportsBannerColor() {
+  return process.stdout.isTTY
+    && !process.env.NO_COLOR
+    && process.env.TERM !== "dumb";
+}
+
 // Forwarded subcommands delegate verbatim to the local Rust binary
 // `wattetheria-client-cli`. Keep the JS side stupid — no flag parsing here.
 const FORWARDED_SUBCOMMANDS = new Set([
@@ -1187,13 +1250,114 @@ const FORWARDED_SUBCOMMANDS = new Set([
   "publish",
 ]);
 
+function nativePlatformKey(platform = process.platform, arch = process.arch) {
+  const normalizedArch = NATIVE_ARCH_ALIASES.get(arch);
+  if (!normalizedArch || !["darwin", "linux", "win32"].includes(platform)) {
+    return "";
+  }
+  return `${platform}-${normalizedArch}`;
+}
+
+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) {
+    return "";
+  }
+  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,
-    "wattetheria-client-cli",
+    nativePackageRustBinaryPath(),
+    bundledRustBinaryPath(),
+    RUST_CLI_BASE_NAME,
   ].filter(Boolean);
 
   for (const candidate of candidates) {
@@ -1211,11 +1375,13 @@ function forwardToRustBinary(commandName, rawArgv) {
     }
   }
 
-  throw new Error(
-    `Could not find the Rust 'wattetheria-client-cli' binary on PATH. ` +
-      `Build it with 'cargo build --release -p wattetheria-client-cli' and ` +
-      `add it to your PATH, or set WATTETHERIA_CLI_BIN to its full path.`
-  );
+  const deployment = deploymentState();
+  if (deployment.runnable) {
+    runInstalledNodeCli(commandName, rawArgv, deployment);
+    return;
+  }
+
+  throw missingNativeCliError(commandName);
 }
 
 async function run(argv) {

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "wattetheria",
-  "version": "0.2.8",
+  "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/",
@@ -19,8 +21,17 @@
   "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"
+    "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": [
     "wattetheria",