openclaw-ani-installer 2026.3.292

package/README.md

@@ -0,0 +1,24 @@
+# @wzfukui/openclaw-ani
+
+Installer and updater for the ANI plugin on OpenClaw.
+
+## Usage
+
+```bash
+npx -y @wzfukui/openclaw-ani install
+npx -y @wzfukui/openclaw-ani update
+```
+
+## Options
+
+```bash
+npx -y @wzfukui/openclaw-ani install --version 2026.3.282
+npx -y @wzfukui/openclaw-ani update --openclaw-home ~/.openclaw
+npx -y @wzfukui/openclaw-ani install --dry-run
+```
+
+## Notes
+
+- The installer always resolves the ANI plugin from npm as a tarball first.
+- It then hydrates runtime dependencies and performs an atomic replacement into `~/.openclaw/extensions/ani`.
+- This avoids known compatibility issues in older OpenClaw releases when installing third-party scoped npm plugins directly.

package/bin/openclaw-ani.mjs

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const INSTALLER_VERSION = "2026.3.29";
+const PLUGIN_ID = "ani";
+const PLUGIN_NPM_NAME = "@wzfukui/ani";
+
+function fail(message, code = 1) {
+  console.error(message);
+  process.exit(code);
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: options.capture ? ["ignore", "pipe", "pipe"] : "inherit",
+    encoding: "utf8",
+    env: options.env ?? process.env,
+    cwd: options.cwd,
+  });
+  if (options.capture) {
+    return result;
+  }
+  if (result.status !== 0) {
+    fail(`${command} ${args.join(" ")} failed with exit code ${result.status ?? 1}`);
+  }
+  return result;
+}
+
+function parseArgs(argv) {
+  const args = {
+    command: "install",
+    version: "latest",
+    dryRun: false,
+    openclawHome: process.env.OPENCLAW_HOME || path.join(os.homedir(), ".openclaw"),
+  };
+  const positional = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--version") {
+      args.version = argv[i + 1] || fail("missing value for --version");
+      i += 1;
+      continue;
+    }
+    if (token === "--openclaw-home") {
+      args.openclawHome = argv[i + 1] || fail("missing value for --openclaw-home");
+      i += 1;
+      continue;
+    }
+    if (token === "--dry-run") {
+      args.dryRun = true;
+      continue;
+    }
+    if (token === "-h" || token === "--help") {
+      printHelp();
+      process.exit(0);
+    }
+    positional.push(token);
+  }
+  if (positional.length > 0) {
+    args.command = positional[0];
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`openclaw-ani ${INSTALLER_VERSION}
+
+Usage:
+  openclaw-ani install [--version <version>] [--openclaw-home <dir>] [--dry-run]
+  openclaw-ani update  [--version <version>] [--openclaw-home <dir>] [--dry-run]
+  openclaw-ani doctor  [--openclaw-home <dir>]
+`);
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function writeJson(file, value) {
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function resolveOpenClawBinary(homeDir) {
+  const candidate = path.join(homeDir, "bin", "openclaw");
+  if (fs.existsSync(candidate)) {
+    return candidate;
+  }
+  const which = run("bash", ["-lc", "command -v openclaw"], { capture: true });
+  if (which.status === 0) {
+    return which.stdout.trim();
+  }
+  fail(`openclaw binary not found under ${candidate} or PATH`);
+}
+
+function resolveState(homeDir) {
+  const configPath = path.join(homeDir, "openclaw.json");
+  if (!fs.existsSync(configPath)) {
+    fail(`OpenClaw config not found: ${configPath}`);
+  }
+  return {
+    configPath,
+    pluginsDir: path.join(homeDir, "extensions"),
+    pluginDir: path.join(homeDir, "extensions", PLUGIN_ID),
+    tmpDir: fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-ani-installer-")),
+  };
+}
+
+function cleanupTemp(tmpDir) {
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+}
+
+function npmPack(spec, cwd, env) {
+  const result = run("npm", ["pack", spec], { cwd, env, capture: true });
+  if (result.status !== 0) {
+    fail(result.stderr || result.stdout || `npm pack failed for ${spec}`);
+  }
+  const filename = result.stdout.trim().split(/\n/).filter(Boolean).at(-1);
+  if (!filename) {
+    fail(`npm pack produced no filename for ${spec}`);
+  }
+  return path.join(cwd, filename);
+}
+
+function hydratePackage(extractDir, env) {
+  const packageJsonPath = path.join(extractDir, "package.json");
+  const pkg = readJson(packageJsonPath);
+  delete pkg.devDependencies;
+  delete pkg.peerDependencies;
+  writeJson(packageJsonPath, pkg);
+  const install = run("npm", ["install", "--omit=dev", "--package-lock=false"], {
+    cwd: extractDir,
+    env,
+    capture: true,
+  });
+  if (install.status !== 0) {
+    fail(install.stderr || install.stdout || "npm install failed while hydrating ANI");
+  }
+}
+
+function extractTarball(tgzPath, destDir) {
+  ensureDir(destDir);
+  const result = run("tar", ["-xzf", tgzPath, "-C", destDir, "--strip-components=1"], {
+    capture: true,
+  });
+  if (result.status !== 0) {
+    fail(result.stderr || result.stdout || `failed to extract ${tgzPath}`);
+  }
+}
+
+function updateConfigInstallRecord(configPath, tgzPath, pluginDir, version) {
+  const config = readJson(configPath);
+  const plugins = (config.plugins ??= {});
+  const installs = (plugins.installs ??= {});
+  installs[PLUGIN_ID] = {
+    source: "archive",
+    sourcePath: tgzPath,
+    installPath: pluginDir,
+    version,
+    installedAt: new Date().toISOString(),
+  };
+  const allow = new Set(Array.isArray(plugins.allow) ? plugins.allow : []);
+  allow.add(PLUGIN_ID);
+  plugins.allow = [...allow];
+  const entries = (plugins.entries ??= {});
+  entries[PLUGIN_ID] = { ...(entries[PLUGIN_ID] ?? {}), enabled: true };
+  writeJson(configPath, config);
+}
+
+function atomicReplaceDir(sourceDir, targetDir) {
+  const backupDir = `${targetDir}.bak-${Date.now()}`;
+  if (fs.existsSync(targetDir)) {
+    fs.renameSync(targetDir, backupDir);
+  }
+  fs.renameSync(sourceDir, targetDir);
+  if (fs.existsSync(backupDir)) {
+    fs.rmSync(backupDir, { recursive: true, force: true });
+  }
+}
+
+function getInstalledVersion(pluginDir) {
+  const packageJsonPath = path.join(pluginDir, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    return readJson(packageJsonPath).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function runOpenClawCheck(openclawBin, args) {
+  const result = run(openclawBin, args, { capture: true });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout?.trim() ?? "",
+    stderr: result.stderr?.trim() ?? "",
+  };
+}
+
+function installOrUpdate(params) {
+  const openclawBin = resolveOpenClawBinary(params.openclawHome);
+  const state = resolveState(params.openclawHome);
+  const env = { ...process.env };
+  try {
+    const spec =
+      params.version === "latest" ? PLUGIN_NPM_NAME : `${PLUGIN_NPM_NAME}@${params.version}`;
+    const tgzPath = npmPack(spec, state.tmpDir, env);
+    const extractDir = path.join(state.tmpDir, "plugin");
+    extractTarball(tgzPath, extractDir);
+    hydratePackage(extractDir, env);
+    const version = getInstalledVersion(extractDir);
+    if (!version) {
+      fail("Unable to determine packaged ANI version after extraction");
+    }
+    if (params.dryRun) {
+      console.log(
+        JSON.stringify(
+          {
+            action: params.command,
+            spec,
+            openclawHome: params.openclawHome,
+            installPath: state.pluginDir,
+            version,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    ensureDir(state.pluginsDir);
+    atomicReplaceDir(extractDir, state.pluginDir);
+    const persistedTgz = path.join(os.tmpdir(), path.basename(tgzPath));
+    fs.copyFileSync(tgzPath, persistedTgz);
+    updateConfigInstallRecord(state.configPath, persistedTgz, state.pluginDir, version);
+    const inspect = runOpenClawCheck(openclawBin, ["plugins", "inspect", PLUGIN_ID]);
+    if (!inspect.ok) {
+      fail(inspect.stderr || inspect.stdout || "OpenClaw failed to inspect ANI after install");
+    }
+    console.log(inspect.stdout);
+    const doctor = runOpenClawCheck(openclawBin, ["plugins", "doctor"]);
+    if (!doctor.ok) {
+      fail(doctor.stderr || doctor.stdout || "OpenClaw plugin doctor reported errors");
+    }
+    console.log(doctor.stdout);
+  } finally {
+    cleanupTemp(state.tmpDir);
+  }
+}
+
+function doctor(params) {
+  const openclawBin = resolveOpenClawBinary(params.openclawHome);
+  const inspect = runOpenClawCheck(openclawBin, ["plugins", "inspect", PLUGIN_ID]);
+  if (inspect.stdout) {
+    console.log(inspect.stdout);
+  }
+  if (inspect.stderr) {
+    console.error(inspect.stderr);
+  }
+  const doctorResult = runOpenClawCheck(openclawBin, ["plugins", "doctor"]);
+  if (doctorResult.stdout) {
+    console.log(doctorResult.stdout);
+  }
+  if (doctorResult.stderr) {
+    console.error(doctorResult.stderr);
+  }
+  process.exit(doctorResult.ok ? 0 : 1);
+}
+
+const args = parseArgs(process.argv.slice(2));
+if (!["install", "update", "doctor"].includes(args.command)) {
+  printHelp();
+  fail(`unknown command: ${args.command}`);
+}
+
+if (args.command === "doctor") {
+  doctor(args);
+} else {
+  installOrUpdate(args);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "openclaw-ani-installer",
+  "version": "2026.3.292",
+  "description": "Installer and updater for the ANI OpenClaw plugin",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "openclaw-ani": "./bin/openclaw-ani.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "keywords": [
+    "openclaw",
+    "ani",
+    "installer"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wzfukui/openclaw-ani-installer.git"
+  },
+  "homepage": "https://github.com/wzfukui/openclaw-ani-installer#readme",
+  "bugs": {
+    "url": "https://github.com/wzfukui/openclaw-ani-installer/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}