@everme/cli 0.33.12 → 0.33.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everme/cli",
-  "version": "0.33.12",
+  "version": "0.33.14",
   "description": "EverMe CLI — npm wrapper that downloads and runs the platform-native evercli binary on first use.",
   "license": "Apache-2.0",
   "bin": {

package/scripts/upgrade-plugins.js

@@ -23,7 +23,7 @@ const MCP_SPEC_PAIRS = [
   ["'@everme/memory-mcp'", "'@everme/memory-mcp@latest'"],
 ];
 
-const NPX_PLATFORMS = new Set(["cursor", "claude-desktop", "codex", "opencode"]);
+const NPX_PLATFORMS = new Set(["cursor", "claude-desktop", "codex", "opencode", "kilocode"]);
 
 const LIST_TIMEOUT_MS = 15000;
 const REFRESH_TIMEOUT_MS = 60000;
@@ -131,6 +131,17 @@ function refreshOpenClaw(runner) {
   });
 }
 
+// AstrBot's plugin is embedded in evercli like Hermes's provider; a re-install
+// rewrites data/plugins/astrbot_plugin_everme/ under the detected AstrBot root.
+function refreshAstrBot(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(binPath, ["plugin", "install", "astrbot"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
 function refreshHermes(binPath, runner) {
   const run = runner || defaultRunner;
   run(binPath, ["plugin", "install", "hermes"], {
@@ -225,6 +236,158 @@ function refreshQwenWork(binPath, runner) {
   });
 }
 
+// Qoder CLI runs a staged copy under ~/.qoder/everme (or ~/.qoder-cn/everme),
+// same shape as QwenWork.
+function refreshQoder(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/qoder@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "qoder"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// Copilot CLI runs a staged copy under ~/.copilot/everme, same shape as
+// QwenWork.
+function refreshCopilotCLI(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/copilot@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "copilot-cli"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// OpenCode and Kilo Code run a staged copy of @everme/opencode under their
+// config dir, same shape as QwenWork: bump the global package first so the
+// re-stage copies the new code, then let evercli re-point the plugin entry.
+function refreshOpenCodeFamily(platform, binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/opencode@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", platform], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// Qwen Code runs a staged copy under ~/.qwen/everme (or $QWEN_HOME/everme),
+// same shape as QwenWork.
+function refreshQwenCode(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/qwencode@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "qwencode"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// Cline CLI loads a staged copy from ~/.cline/plugins/everme: bump the global
+// package first so the re-stage copies the new code.
+function refreshCline(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/cline@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "cline"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// Grok Build runs a staged copy under <grok-home>/everme, same shape as
+// QwenWork: bump the global package first so the re-stage copies the new code,
+// then let evercli replace the stage and rewrite hooks/everme.json.
+function refreshGrokBuild(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/grok-build@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "install", "grok-build"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// PicoClaw runs staged copies of two bundles under ~/.picoclaw (the process
+// hook and memory-mcp). Bump both global packages, then re-stage them with
+// `plugin upgrade`, which writes no credential: a re-install would rotate the
+// token for no reason.
+function refreshPicoClaw(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/picoclaw@latest", "@everme/memory-mcp@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "upgrade", "--platform", "picoclaw", "--no-prompt"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// NanoClaw copies the bundle into every agent group's state volume. `plugin
+// upgrade` re-copies it into the groups that are already wired without
+// touching their credentials (a reinstall would rotate the token), so bump
+// the global package first and then let evercli re-copy it.
+function refreshNanoClaw(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/nanoclaw@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "upgrade", "--platform", "nanoclaw"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// ZeroClaw runs a staged copy under ~/.zeroclaw/everme, plus a Lucid wrapper
+// and skill evercli generates from it. Bump the global package, then let
+// `plugin upgrade` re-stage it: that path never mints a token or rewrites
+// everme.env, unlike a re-install.
+function refreshZeroclaw(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(npmCommand(), ["install", "-g", "@everme/zeroclaw@latest"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  run(binPath, ["plugin", "upgrade", "--platform", "zeroclaw"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
 // Pi records an unpinned npm source, but installing it again is not its update
 // contract. Use Pi's package-specific update command so the registered package
 // moves to the latest npm version without rewriting EverMe credentials.
@@ -237,9 +400,43 @@ function refreshPi(runner) {
   });
 }
 
+// oh-my-pi installs npm plugins with bun into ~/.omp/plugins; installing the
+// same unpinned name again moves it to the latest version.
+function refreshOmp(runner) {
+  const run = runner || defaultRunner;
+  run("omp", ["plugin", "install", "@everme/pi"], {
+    encoding: "utf8",
+    timeout: PI_REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
+// LobsterAI's plugin dir is written by evercli with the app's bundled
+// OpenClaw; `plugin upgrade` reinstalls the latest published bundle there and
+// leaves the credentials in LobsterAI's openclaw.json alone.
+function refreshLobsterAI(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(binPath, ["plugin", "upgrade", "--platform", "lobsterai"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
 // Raven's Python backend is embedded in the evercli binary, so the freshly
 // downloaded binary is the new payload — re-running install is what
 // rewrites ~/.raven/plugins/everme-memory/. Nothing to bump on npm.
+// CowAgent's plugin is embedded in evercli. `plugin upgrade` rewrites the
+// code files only, so the owner's everme.env and config.json stay as they are.
+function refreshCowAgent(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(binPath, ["plugin", "upgrade", "--platform", "cowagent"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
 function refreshRaven(binPath, runner) {
   const run = runner || defaultRunner;
   run(binPath, ["plugin", "install", "raven"], {
@@ -249,6 +446,18 @@ function refreshRaven(binPath, runner) {
   });
 }
 
+// nanobot's package ships inside the evercli binary, like raven's, but it
+// has a payload-only refresh: `plugin upgrade --platform nanobot` rewrites the
+// package in the site-packages recorded at install and keeps the token.
+function refreshNanobot(binPath, runner) {
+  const run = runner || defaultRunner;
+  run(binPath, ["plugin", "upgrade", "--platform", "nanobot", "--no-prompt"], {
+    encoding: "utf8",
+    timeout: REFRESH_TIMEOUT_MS,
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+}
+
 function refreshDSH(binPath, runner) {
   const run = runner || defaultRunner;
   run(binPath, ["plugin", "install", "dsh"], {
@@ -314,8 +523,14 @@ function refreshPlugins(opts) {
         refreshOpenClaw(runner);
       } else if (h.platform === "hermes") {
         refreshHermes(binPath, runner);
+      } else if (h.platform === "astrbot") {
+        refreshAstrBot(binPath, runner);
+        log("[@everme/cli] astrbot: plugin re-staged — restart AstrBot or reload astrbot_plugin_everme in the WebUI");
       } else if (h.platform === "raven") {
         refreshRaven(binPath, runner);
+      } else if (h.platform === "nanobot") {
+        refreshNanobot(binPath, runner);
+        log("[@everme/cli] nanobot: package refreshed — restart nanobot to load it");
       } else if (h.platform === "dsh") {
         if (shouldRefreshDSH(h)) {
           refreshDSH(binPath, runner);
@@ -329,9 +544,44 @@ function refreshPlugins(opts) {
         refreshMinimaxCode(binPath, runner);
       } else if (h.platform === "pi") {
         refreshPi(runner);
+      } else if (h.platform === "omp") {
+        refreshOmp(runner);
+      } else if (h.platform === "lobsterai") {
+        refreshLobsterAI(binPath, runner);
+        log("[@everme/cli] lobsterai: plugin reinstalled — restart LobsterAI so its gateway loads it");
+      } else if (h.platform === "picoclaw") {
+        refreshPicoClaw(binPath, runner);
+        log("[@everme/cli] picoclaw: hook re-staged — restart the PicoClaw gateway so it starts the new hook process");
       } else if (h.platform === "qwenwork") {
         refreshQwenWork(binPath, runner);
         log("[@everme/cli] qwenwork: hooks re-staged — restart QwenWork so it re-reads settings.json");
+      } else if (h.platform === "qoder") {
+        refreshQoder(binPath, runner);
+        log("[@everme/cli] qoder: hooks re-staged — start a new Qoder CLI session to load them");
+      } else if (h.platform === "copilot-cli") {
+        refreshCopilotCLI(binPath, runner);
+        log("[@everme/cli] copilot-cli: hooks re-staged — start a new Copilot CLI session to load them");
+      } else if (h.platform === "opencode" || h.platform === "kilocode") {
+        refreshOpenCodeFamily(h.platform, binPath, runner);
+        log(`[@everme/cli] ${h.platform}: plugin re-staged — restart the host to load it`);
+      } else if (h.platform === "qwencode") {
+        refreshQwenCode(binPath, runner);
+        log("[@everme/cli] qwencode: hooks re-staged — start a new Qwen Code session to load them");
+      } else if (h.platform === "cline") {
+        refreshCline(binPath, runner);
+        log("[@everme/cli] cline: plugin re-staged — start a new Cline CLI session to load it");
+      } else if (h.platform === "grok-build") {
+        refreshGrokBuild(binPath, runner);
+        log("[@everme/cli] grok-build: hook re-staged — start a new grok session to load it");
+      } else if (h.platform === "cowagent") {
+        refreshCowAgent(binPath, runner);
+        log("[@everme/cli] cowagent: plugin code refreshed — restart CowAgent to load it");
+      } else if (h.platform === "nanoclaw") {
+        refreshNanoClaw(binPath, runner);
+        log("[@everme/cli] nanoclaw: bundle re-copied — restart the agent groups (`ncl groups restart --id <id>`) so their containers load it");
+      } else if (h.platform === "zeroclaw") {
+        refreshZeroclaw(binPath, runner);
+        log("[@everme/cli] zeroclaw: bridge re-staged — start a new ZeroClaw session or run `zeroclaw service restart`");
       } else if (h.platform === "workbuddy") {
         refreshWorkBuddy(binPath, runner);
         log("[@everme/cli] workbuddy: hooks re-staged — quit WorkBuddy completely (Cmd+Q) and reopen it so the engine re-reads settings.json");
@@ -358,7 +608,15 @@ function logUnconnectedHosts(hosts, log) {
 module.exports = {
   NPX_PLATFORMS,
   refreshQwenWork,
+  refreshQoder,
+  refreshCopilotCLI,
+  refreshOpenCodeFamily,
+  refreshQwenCode,
+  refreshCline,
+  refreshNanoClaw,
   refreshWorkBuddy,
+  refreshGrokBuild,
+  refreshZeroclaw,
   LIST_TIMEOUT_MS,
   REFRESH_TIMEOUT_MS,
   DSH_REFRESH_TIMEOUT_MS,
@@ -370,10 +628,16 @@ module.exports = {
   refreshCodex,
   refreshOpenClaw,
   refreshHermes,
+  refreshAstrBot,
   refreshKimicode,
   refreshMinimaxCode,
   refreshPi,
+  refreshOmp,
+  refreshLobsterAI,
+  refreshPicoClaw,
   refreshRaven,
+  refreshNanobot,
+  refreshCowAgent,
   refreshDSH,
   shouldRefreshDSH,
   skipReason,

package/sha256sums.txt

@@ -1,6 +1,6 @@
-460211b8f241b07cf9b648b6e79659bd2f31efe1fc5ad515b0243133c67bb130  evercli_darwin_amd64.tar.gz
-70c7607e23365a8034507efa8d9fc35a1dd9c30f084822e4cd1117cb4cd6b645  evercli_darwin_arm64.tar.gz
-102e9f14498884e817acbf6177a466277cf868d238863e301e74b21385b2d13d  evercli_linux_amd64.tar.gz
-7489a11acd1ff725bba392e188cc3c23f9f756d3b949ffde7915640b771d947b  evercli_linux_arm64.tar.gz
-b745f75bd03a8b820df78e84ed337ebe6b48960b3fdb746b866c4e6e15380f9a  evercli_windows_amd64.zip
-630193a368e9174bf710d0a4903d1d918435bc22466f4d2d89ff5fdba33e2412  evercli_windows_arm64.zip
+bceb72c3fe351dc027a1138f586b2a960e502b64001750fd6b8d3c04d8763c1e  evercli_darwin_amd64.tar.gz
+fc1a75acfbbba44f20f7ed21bc3aaab8196dd78cb1f8fe61a1f17b31067de12d  evercli_darwin_arm64.tar.gz
+cfba5d64f3e0cdb0a92c48c63198258d9e0d8c98b2834f764c509fd2e8a8c9ad  evercli_linux_amd64.tar.gz
+96b2dbdaee543c5c753e46f78c82be2004a656aff1478c508dcfd2940098337e  evercli_linux_arm64.tar.gz
+a35e0416b77329fffef7386281b7d06c7c1c34d0a2777cece5ab8cb76e417d04  evercli_windows_amd64.zip
+3344781d7eb0e6f08da8e17ee5b380caf7eb35f3537fecae5cb555c7bc0e6ef7  evercli_windows_arm64.zip