@everme/cli 0.2.4 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/cli",
-  "version": "0.2.4",
+  "version": "0.26.0",
   "description": "EverMe CLI — npm wrapper that downloads and runs the platform-native evercli binary on first use.",
   "license": "Apache-2.0",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "postinstall": "node scripts/install.js",
-    "test": "node --test tests/install.test.js"
+    "test": "node --test tests/install.test.js tests/upgrade-plugins.test.js"
   },
   "os": [
     "darwin",
@@ -26,6 +26,7 @@
     "scripts/install.js",
     "scripts/install-wizard.js",
     "scripts/run.js",
+    "scripts/upgrade-plugins.js",
     "sha256sums.txt",
     "LICENSE",
     "README.md"

package/scripts/install.js

@@ -24,6 +24,7 @@ const path = require("path");
 const os = require("os");
 const crypto = require("crypto");
 const { execFileSync } = require("child_process");
+const { refreshPlugins } = require("./upgrade-plugins.js");
 
 const VERSION = require("../package.json").version;
 const REPO = "EverMind-AI/EverMe";
@@ -359,6 +360,14 @@ if (require.main === module) {
 
   try {
     install();
+    // One-shot plugin refresh: bring already-installed hosts to the latest
+    // plugin line. Never fatal — guards + per-host try/catch live in the
+    // module; we belt-and-suspenders wrap here so nothing fails `npm i -g`.
+    try {
+      refreshPlugins({ binPath: dest, env: process.env });
+    } catch (e) {
+      console.error(`[@everme/cli] plugin refresh skipped: ${e.message}`);
+    }
   } catch (err) {
     console.error(`Failed to install ${NAME}:`, err.message);
     console.error(

package/scripts/upgrade-plugins.js

@@ -0,0 +1,201 @@
+// Copyright 2026 Evermind AI
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Plugin refresh invoked from @everme/cli postinstall. After the new binary
+ * is on disk, bring already-installed plugin hosts up to the latest plugin
+ * line — without any new evercli subcommand. Discovery reuses the read-only
+ * `plugin list`; refresh is per host class (see spec
+ * .work_context/specs/2026-06-23-cli-postinstall-one-shot-upgrade-design.md).
+ */
+
+"use strict";
+
+const fs = require("fs");
+const { execFileSync } = require("child_process");
+
+// Quote-delimited bare/latest spec pairs. JSON host configs (cursor, gemini,
+// claude-desktop, opencode) use double quotes; codex's config.toml uses single
+// quotes. Each pair is inherently idempotent — once `@latest` is present the
+// bare quoted token no longer exists (the closing quote sits after `@latest`).
+const MCP_SPEC_PAIRS = [
+  ['"@everme/memory-mcp"', '"@everme/memory-mcp@latest"'],
+  ["'@everme/memory-mcp'", "'@everme/memory-mcp@latest'"],
+];
+
+const NPX_PLATFORMS = new Set(["cursor", "claude-desktop", "codex", "gemini", "opencode"]);
+
+const LIST_TIMEOUT_MS = 15000;
+const REFRESH_TIMEOUT_MS = 60000;
+
+function npmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+function defaultRunner(file, args, opts) {
+  return execFileSync(file, args, opts);
+}
+
+// discoverHosts runs the read-only `plugin list --format json` against the
+// freshly-downloaded binary and returns the platforms array. Throws if the
+// envelope is missing or not ok so the caller treats discovery as failed.
+function discoverHosts(binPath, runner) {
+  const run = runner || defaultRunner;
+  const out = run(binPath, ["plugin", "list", "--format", "json"], {
+    encoding: "utf8",
+    timeout: LIST_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  const env = JSON.parse(out);
+  if (!env || env.ok !== true || !env.data || !Array.isArray(env.data.platforms)) {
+    throw new Error("unexpected `plugin list` envelope shape");
+  }
+  return env.data.platforms;
+}
+
+// patchNpxSpec adds @latest to the memory-mcp spec in a host config file by a
+// literal, format-agnostic replace of the quoted bare token. Idempotent: the
+// quoted bare token no longer exists once @latest is present. Touches only the
+// package spec — never credential fields.
+//
+// The replace is atomic: write a sibling temp file, fsync, then rename over the
+// original. These configs carry credentials, so an interrupted in-place
+// truncate/write (crash, disk full) must never leave a corrupted file. The
+// original mode is preserved (host configs are 0600).
+function patchNpxSpec(configPath) {
+  const before = fs.readFileSync(configPath, "utf8");
+  let after = before;
+  for (const [bare, latest] of MCP_SPEC_PAIRS) {
+    if (after.includes(bare)) after = after.split(bare).join(latest);
+  }
+  if (after === before) return false;
+  const mode = fs.statSync(configPath).mode & 0o777;
+  const tmp = `${configPath}.everme-tmp-${process.pid}`;
+  try {
+    const fd = fs.openSync(tmp, "w", mode);
+    try {
+      fs.writeFileSync(fd, after);
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+    fs.chmodSync(tmp, mode);
+    fs.renameSync(tmp, configPath);
+  } catch (e) {
+    try {
+      fs.unlinkSync(tmp);
+    } catch (_) {
+      // temp file may not exist if openSync failed — ignore.
+    }
+    throw e;
+  }
+  return true;
+}
+
+// refreshClaudeCode brings Claude Code to the latest plugin payload. Two steps
+// are required: `evercli plugin install claude-code` reuses an already-present
+// global npm package without upgrading it (pluginSourceSpec short-circuits on
+// the existing `npm root -g` path), so the @latest bump must happen first; the
+// re-install then runs `claude plugin marketplace add` + `claude plugin install`
+// so Claude Code actually loads the fresh hooks/commands/MCP. Step 2 rotates the
+// local agent token (per-(platform, fingerprint) — other devices unaffected).
+function refreshClaudeCode(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/claude-code@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "claude-code"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// `plugins update <id>` is the refresh verb: it bumps an already-tracked plugin
+// to latest by id (not an npm spec) and leaves openclaw.json alone, unlike
+// `install --force`, which reruns the full install-time config scaffolding and
+// rewrites the credential-bearing config. The host is already installed in the
+// refresh context; if it somehow isn't tracked, update errors and the caller
+// degrades it to a warning.
+function refreshOpenClaw(runner) {
+  const run = runner || defaultRunner;
+  run("openclaw", ["plugins", "update", "@everme/openclaw"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+function refreshHermes(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(binPath, ["plugin", "install", "hermes"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+function skipReason(env) {
+  if (env.EVERME_SKIP_PLUGIN_UPGRADE) return "EVERME_SKIP_PLUGIN_UPGRADE is set";
+  if (env.CI) return "CI environment";
+  if (typeof process.getuid === "function" && process.getuid() === 0) return "running as root";
+  if (env.SUDO_USER) return "running under sudo";
+  return null;
+}
+
+// refreshPlugins is the postinstall entrypoint. It NEVER throws: every failure
+// degrades to a stderr warning so `npm i -g` always succeeds.
+function refreshPlugins(opts) {
+  const { binPath, env, runner } = opts;
+  const log = opts.logger || ((m) => console.error(m));
+
+  const skip = skipReason(env);
+  if (skip) {
+    log(`[@everme/cli] Skipping plugin refresh (${skip}). ` +
+      `Re-run \`npm i -g @everme/cli@latest\` as your normal user to refresh plugins.`);
+    return;
+  }
+
+  let hosts;
+  try {
+    hosts = discoverHosts(binPath, runner);
+  } catch (e) {
+    log(`[@everme/cli] Could not enumerate plugin hosts; skipping plugin refresh: ${e.message}`);
+    return;
+  }
+
+  for (const h of hosts) {
+    if (!h || h.hasEverMeEntry !== true) continue;
+    try {
+      if (NPX_PLATFORMS.has(h.platform)) {
+        if (h.configPath && patchNpxSpec(h.configPath)) {
+          log(`[@everme/cli] ${h.platform}: pinned memory-mcp to @latest`);
+        }
+      } else if (h.platform === "claude-code") {
+        refreshClaudeCode(binPath, runner);
+      } else if (h.platform === "openclaw") {
+        refreshOpenClaw(runner);
+      } else if (h.platform === "hermes") {
+        refreshHermes(binPath, runner);
+      }
+    } catch (e) {
+      log(`[@everme/cli] ${h.platform}: refresh failed (continuing): ${e.message}`);
+    }
+  }
+}
+
+module.exports = {
+  NPX_PLATFORMS,
+  LIST_TIMEOUT_MS,
+  REFRESH_TIMEOUT_MS,
+  npmCommand,
+  discoverHosts,
+  patchNpxSpec,
+  refreshClaudeCode,
+  refreshOpenClaw,
+  refreshHermes,
+  skipReason,
+  refreshPlugins,
+};

package/sha256sums.txt

@@ -1,6 +1,6 @@
-b4a36757fd0e48427e82be57863f091e590794a48be44cdbae5cd0d8e5ec7010  evercli_darwin_amd64.tar.gz
-2b67e5feed77e12644240f0268b6f29ad1b77527b467d07f7f8bcb07fa526ad3  evercli_darwin_arm64.tar.gz
-48c3b712ee28f59d10fc46a5f9d99ea700a610aef0bd78803ed670ec96518f2a  evercli_linux_amd64.tar.gz
-f0f15e8e0412257dd62799137edf1dfcdb2bd9884dc825a5269965be8f4a1044  evercli_linux_arm64.tar.gz
-ab209d05674c924ea44d74a0d46e22699690e209b1ec9dac50a8e881c883124e  evercli_windows_amd64.zip
-021d3f19e033621b4392be9ef02bab7c15012eb8751f541a60747436ab1cecb8  evercli_windows_arm64.zip
+3f8e635e9a9a666fcfc3ed3a7cd3a765bc7a89d45de02e001b41d6b98461987d  evercli_darwin_amd64.tar.gz
+c600f0fff31c8fb69fa6288c97ef7f554501e626105c07f5ed0dfa72e9dae244  evercli_darwin_arm64.tar.gz
+29b4a45d8d968d8a1eac53bebbae592312fb0ca7f8a2bb6d5641b22cc1e8aa91  evercli_linux_amd64.tar.gz
+623bb61d4ec06015b872b936f221b8debef50a3d10b61aca74c0fd876ffaa3a7  evercli_linux_arm64.tar.gz
+d8acabbdee29bf28a456e2c62bd460df71a7d82469e2f70eaf139a18bc6a0a88  evercli_windows_amd64.zip
+bca20616dd634969a1b928f3179fc1d5e94840064a4572c5a6ef0e93a54be795  evercli_windows_arm64.zip