@agentlayer.tech/wallet 0.1.43 → 0.1.44

package/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "name": "agentlayer",
+  "description": "AgentLayer plugins for Claude Code. Install the wallet bridge and its backend runtime without leaving the CLI.",
+  "owner": {
+    "name": "AgentLayer",
+    "url": "https://github.com/lopushok9/Agent-Layer"
+  },
+  "plugins": [
+    {
+      "name": "agent-wallet",
+      "displayName": "Agent Wallet",
+      "description": "Bridge to the local AgentLayer wallet runtime (Solana, Bitcoin, EVM). Installs and connects the backend runtime on first use.",
+      "category": "development",
+      "source": "./claude-code/plugins/agent-wallet"
+    }
+  ]
+}

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "contracts": {
     "tools": [
       "close_empty_token_accounts",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## Unreleased
 
+## v0.1.44 - 2026-06-12
+
+- Added anonymous, privacy-first adoption telemetry so wallet usage can be
+  measured across hosts (Claude Code / Codex / Hermes / OpenClaw) without any
+  PII.
+  - The wallet emits one event per tool invocation through the shared
+    `openclaw_cli invoke` chokepoint. Events carry only a random local install
+    id, host, the registered tool name, backend family, plugin version, and a
+    success flag — never addresses, balances, amounts, tx hashes, arguments, or
+    secrets. Secret-touching commands (onboard/wallet-create/unlock/import) are
+    never instrumented.
+  - Delivery uses a durable local spool plus a detached best-effort flush to the
+    provider-gateway, so a short-lived CLI process never adds latency or loses
+    events.
+  - Opt out at any time with `AGENT_WALLET_NO_TELEMETRY=1` (zero footprint).
+  - Per-frontend `host` tagging via `AGENT_WALLET_HOST` in each bridge.
+
 ## v0.1.41 - 2026-06-07
 
 - Hardened Uniswap Trading API swap execution on active EVM mainnet markets.

package/README.md

@@ -18,6 +18,20 @@ For Codex:
 npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet codex install --yes
 ```
 
+For Claude Code:
+
+```bash
+npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet claude-code install --yes
+```
+
+Or install entirely from inside the Claude Code CLI, via the plugin marketplace
+(no terminal/npx needed) — two commands, then restart:
+
+```text
+/plugin marketplace add lopushok9/Agent-Layer
+/plugin install agent-wallet@agentlayer
+```
+
 For Hermes:
 
 ```bash

package/VERSION

@@ -1 +1 @@
-0.1.43
+0.1.44

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.43"
+__version__ = "0.1.44"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/openclaw_cli.py

@@ -11,6 +11,12 @@ from typing import Any
 
 from agent_wallet.wallet_layer.base import WalletBackendError
 
+try:  # telemetry is optional and must never break the CLI
+    from agent_wallet.telemetry import record as _telemetry_record
+except Exception:  # pragma: no cover - defensive
+    def _telemetry_record(*_args: Any, **_kwargs: Any) -> None:
+        return None
+
 
 def _parse_bool(value: Any) -> str:
     if value is None:
@@ -610,6 +616,15 @@ def main() -> int:
                 )
             )
     except Exception as exc:
+        # Anonymous adoption telemetry for tool invocations only (never for
+        # onboard/wallet-create/unlock/import — those touch secrets). Records
+        # just the tool name + backend family + failure flag; never raises.
+        if getattr(args, "command", "") == "invoke":
+            _telemetry_record(
+                getattr(args, "tool", ""),
+                backend=str(locals().get("config", {}).get("backend", "") or ""),
+                ok=False,
+            )
         error_payload: dict[str, Any] = {"ok": False, "error": str(exc)}
         if isinstance(exc, WalletBackendError):
             if exc.code:
@@ -619,6 +634,13 @@ def main() -> int:
         print(json.dumps(error_payload), file=sys.stderr)
         return 1
 
+    if getattr(args, "command", "") == "invoke":
+        _telemetry_record(
+            getattr(args, "tool", ""),
+            backend=str(config.get("backend", "") or ""),
+            ok=True,
+        )
+
     print(json.dumps(payload))
     return 0
 

package/agent-wallet/agent_wallet/telemetry.py

@@ -0,0 +1,306 @@
+"""Anonymous, privacy-first adoption telemetry for the AgentLayer wallet.
+
+Why this exists: we want to know how many people use the wallet and through which
+host (Claude Code / Codex / Hermes / OpenClaw) — nothing more. It deliberately
+records NO PII: no wallet addresses, balances, amounts, tx hashes, tool
+arguments, or secrets. Only a random local install id, the host name, the
+invoked tool's registered name, the backend family, the plugin version, and a
+success flag.
+
+Design for a short-lived CLI subprocess:
+  - `record()` appends one JSON line to a local spool file. This is instant and
+    durable: a single small append is atomic on POSIX, and the event survives
+    even if this process exits before any network call completes.
+  - A throttled, best-effort flush claims the spool (atomic rename), POSTs each
+    event to the provider-gateway, and re-spools anything that failed. Because
+    durability lives in the spool, a killed flush never loses data — the next
+    invocation (or a longer-lived process) ships it.
+
+Everything here swallows its own errors. Telemetry must never slow down or break
+a wallet operation. Users opt out with AGENT_WALLET_NO_TELEMETRY=1.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+import uuid
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .config import DEFAULT_PROVIDER_GATEWAY_URL, resolve_openclaw_home
+
+ALLOWED_HOSTS = {"claude-code", "codex", "hermes", "openclaw"}
+
+SPOOL_NAME = "telemetry_spool.jsonl"
+ID_NAME = "telemetry_id"
+LAST_FLUSH_NAME = "telemetry_last_flush"
+
+# Keep the spool bounded if the gateway is unreachable for a long time.
+MAX_SPOOL_LINES = 500
+# Don't attempt a network flush more than this often (seconds), unless the spool
+# has grown past the soft cap below.
+FLUSH_THROTTLE_SECONDS = 20
+FLUSH_FORCE_LINES = 50
+# Tight network bounds: telemetry never blocks meaningfully.
+HTTP_TIMEOUT_SECONDS = 1.5
+MAX_EVENTS_PER_FLUSH = 100
+
+
+def _enabled() -> bool:
+    raw = os.getenv("AGENT_WALLET_NO_TELEMETRY", "").strip().lower()
+    return raw not in ("1", "true", "yes", "on")
+
+
+def _home() -> Path:
+    return resolve_openclaw_home()
+
+
+def _gateway_url() -> str:
+    url = os.getenv("PROVIDER_GATEWAY_URL", "").strip() or DEFAULT_PROVIDER_GATEWAY_URL
+    return url.rstrip("/")
+
+
+def _host() -> str:
+    host = os.getenv("AGENT_WALLET_HOST", "").strip().lower()
+    return host if host in ALLOWED_HOSTS else "unknown"
+
+
+def _install_id() -> str:
+    """Stable, random, non-identifying id for this install. Created once."""
+    path = _home() / ID_NAME
+    try:
+        existing = path.read_text(encoding="utf-8").strip()
+        if existing:
+            return existing
+    except OSError:
+        pass
+    new_id = uuid.uuid4().hex
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(new_id, encoding="utf-8")
+    except OSError:
+        pass
+    return new_id
+
+
+def record(
+    tool: str,
+    *,
+    backend: str = "",
+    ok: bool = True,
+    event: str = "tool_invoke",
+) -> None:
+    """Append an anonymous event to the spool and best-effort flush. Never raises."""
+    try:
+        if not _enabled():
+            return
+        payload = {
+            "event": event,
+            "install_id": _install_id(),
+            "host": _host(),
+            "tool": tool or "",
+            "backend": backend or "",
+            "plugin_version": __version__,
+            "ok": bool(ok),
+            "ts": int(time.time()),
+        }
+        _append_spool(payload)
+        _maybe_spawn_flush()
+    except Exception:
+        # Telemetry is never allowed to affect the wallet call.
+        pass
+
+
+# --- spool I/O --------------------------------------------------------------
+
+
+def _spool_path() -> Path:
+    return _home() / SPOOL_NAME
+
+
+def _append_spool(payload: dict[str, Any]) -> None:
+    path = _spool_path()
+    line = json.dumps(payload, separators=(",", ":")) + "\n"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    # A single write of a short line is atomic across processes on POSIX.
+    with open(path, "a", encoding="utf-8") as fh:
+        fh.write(line)
+
+
+def _spool_line_count() -> int:
+    try:
+        with open(_spool_path(), "r", encoding="utf-8") as fh:
+            return sum(1 for _ in fh)
+    except OSError:
+        return 0
+
+
+def _should_flush_now() -> bool:
+    count = _spool_line_count()
+    if count == 0:
+        return False
+    if count >= FLUSH_FORCE_LINES:
+        return True
+    last_path = _home() / LAST_FLUSH_NAME
+    try:
+        last = float(last_path.read_text(encoding="utf-8").strip() or "0")
+    except (OSError, ValueError):
+        last = 0.0
+    return (time.time() - last) >= FLUSH_THROTTLE_SECONDS
+
+
+def _mark_flush_attempt() -> None:
+    try:
+        (_home() / LAST_FLUSH_NAME).write_text(str(time.time()), encoding="utf-8")
+    except OSError:
+        pass
+
+
+def _maybe_spawn_flush() -> None:
+    """Trigger a flush in a DETACHED subprocess that outlives this process.
+
+    A per-tool CLI invocation exits microseconds after recording, so a thread
+    would be killed mid-flush. A detached child (its own session, no wait) runs
+    the network call on its own time and re-spools failures reliably. Throttling
+    keeps this to roughly one spawn per FLUSH_THROTTLE_SECONDS, so most calls
+    just append to the spool and return.
+    """
+    if not _should_flush_now():
+        return
+    _mark_flush_attempt()
+    try:
+        subprocess.Popen(
+            [sys.executable, "-m", "agent_wallet.telemetry", "--flush"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            stdin=subprocess.DEVNULL,
+            start_new_session=True,  # detach so parent exit doesn't kill it
+        )
+    except Exception:
+        pass
+
+
+def _pid_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True  # exists but owned by another user
+    except OSError:
+        return True
+    return True
+
+
+def _claim_suffix_pid(path: Path) -> int | None:
+    # ...telemetry_spool.jsonl.flushing.<pid>
+    try:
+        return int(path.name.rsplit(".flushing.", 1)[1])
+    except (IndexError, ValueError):
+        return None
+
+
+def _flush() -> None:
+    """Claim the spool atomically, adopt dead-PID orphans, POST, re-spool failures."""
+    spool = _spool_path()
+    home = _home()
+    claim = spool.with_suffix(spool.suffix + f".flushing.{os.getpid()}")
+
+    claims: list[Path] = []
+    try:
+        os.rename(spool, claim)  # atomic; only one process wins the live spool
+        claims.append(claim)
+    except OSError:
+        pass  # nothing to flush, or another process claimed it
+
+    # Recover orphans left by a flush that died mid-run (crash/exit after the
+    # rename but before re-spooling). Only adopt claims whose PID is gone so we
+    # never steal a batch a live sibling is still working.
+    try:
+        for orphan in home.glob(SPOOL_NAME + ".flushing.*"):
+            if orphan == claim:
+                continue
+            pid = _claim_suffix_pid(orphan)
+            if pid is None or not _pid_alive(pid):
+                claims.append(orphan)
+    except OSError:
+        pass
+
+    if not claims:
+        return
+
+    lines: list[str] = []
+    for c in claims:
+        try:
+            lines.extend(c.read_text(encoding="utf-8").splitlines())
+        except OSError:
+            pass
+
+    # Bound a long backlog (gateway down for a while): keep the most recent.
+    if len(lines) > MAX_SPOOL_LINES:
+        lines = lines[-MAX_SPOOL_LINES:]
+
+    url = _gateway_url() + "/v1/telemetry"
+    failed: list[str] = []
+    sent = 0
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        if sent >= MAX_EVENTS_PER_FLUSH:
+            failed.append(line)  # defer the rest to the next flush
+            continue
+        if _post(url, line):
+            sent += 1
+        else:
+            failed.append(line)
+
+    # Re-spool failures BEFORE removing claims: favors at-least-once delivery
+    # (a crash here re-sends, never drops). Successes are gone from the claims.
+    if failed:
+        try:
+            with open(spool, "a", encoding="utf-8") as fh:
+                fh.write("\n".join(failed) + "\n")
+        except OSError:
+            pass
+
+    for c in claims:
+        try:
+            c.unlink()
+        except OSError:
+            pass
+
+
+def _post(url: str, body: str) -> bool:
+    try:
+        req = urllib.request.Request(
+            url,
+            data=body.encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT_SECONDS) as resp:
+            return 200 <= resp.status < 300
+    except Exception:
+        return False
+
+
+def _flush_main() -> int:
+    """Entry point for the detached flush subprocess (`-m agent_wallet.telemetry --flush`)."""
+    try:
+        _flush()
+    except Exception:
+        pass
+    return 0
+
+
+if __name__ == "__main__":
+    if "--flush" in sys.argv[1:]:
+        raise SystemExit(_flush_main())
+    raise SystemExit(0)

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.43"
+version = "0.1.44"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/claude-code/plugins/agent-wallet/README.md

@@ -30,7 +30,36 @@ Primary design rules:
 
 ## Installation
 
-### Automated (recommended)
+### From inside Claude Code (no terminal needed)
+
+The plugin ships in a git marketplace at the repo root, so you can install it —
+and its backend runtime — without leaving the CLI. Two commands, then restart:
+
+```text
+/plugin marketplace add lopushok9/Agent-Layer
+/plugin install agent-wallet@agentlayer
+```
+
+Restart Claude Code (or `/reload-plugins`). On the next session start a
+`SessionStart` hook runs `scripts/bootstrap_backend.sh`, a thin bridge to the
+npm installer (`npx @agentlayer.tech/wallet install --yes`). The marketplace only
+copies this MCP bridge into Claude Code's cache; the bootstrap step lays down the
+Python backend runtime (venv + `agent_wallet` + `server.py`) that the bridge
+talks to, with the wallet configured out of the box. It is idempotent and a
+no-op once the backend is healthy.
+
+- `/wallet-setup` — install (or repair) the backend explicitly instead of
+  waiting for the hook (requires `/reload-plugins` first so the command is
+  registered).
+- `AGENT_WALLET_AUTO_BOOTSTRAP=0` — opt out of the auto-install: the
+  `SessionStart` hook then only reminds you to run `/wallet-setup` instead of
+  installing the backend itself.
+
+For near-zero typed commands, pre-register the marketplace in
+`.claude/settings.json` with `extraKnownMarketplaces` + `enabledPlugins` so
+Claude Code prompts to install on trust.
+
+### Automated via npm
 
 ```bash
 npx @agentlayer.tech/wallet install --yes

package/claude-code/plugins/agent-wallet/commands/wallet-setup.md

@@ -0,0 +1,24 @@
+---
+description: Install or repair the AgentLayer wallet backend runtime without leaving Claude Code.
+allowed-tools: Bash(sh:*), Bash(npx:*)
+---
+
+Install (or repair) the AgentLayer wallet backend that this plugin bridges to.
+
+Run the bootstrap bridge to the npm installer:
+
+```
+sh "${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap_backend.sh" install
+```
+
+Then report the outcome to the user:
+
+- If it succeeded, tell them the backend is installed and that they should
+  restart Claude Code (or reload the `agent-wallet` plugin) so the wallet tools
+  become available.
+- If it failed because Node.js or Python is missing, relay the exact requirement
+  (Node.js 18+, Python >= 3.10 with venv) and the manual fallback command from
+  the script output.
+
+Do not pass or generate any secrets. The npm installer manages the local wallet
+keys and sealed secrets under `OPENCLAW_HOME` on its own.

package/claude-code/plugins/agent-wallet/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear",
+        "hooks": [
+          {
+            "type": "command",
+            "timeout": 300,
+            "command": "sh -c 'if [ \"${AGENT_WALLET_AUTO_BOOTSTRAP:-1}\" = \"1\" ]; then \"${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap_backend.sh\" install >&2; else \"${CLAUDE_PLUGIN_ROOT}/scripts/bootstrap_backend.sh\" check >/dev/null 2>&1 || echo \"AgentLayer wallet backend is not installed. Run /wallet-setup to install it.\"; fi'"
+          }
+        ]
+      }
+    ]
+  }
+}

package/claude-code/plugins/agent-wallet/scripts/bootstrap_backend.sh

@@ -0,0 +1,136 @@
+#!/bin/sh
+set -eu
+
+# bootstrap_backend.sh — the in-CLI bridge to the npm installer.
+#
+# Claude Code's plugin marketplace only copies the plugin files (this MCP bridge
+# and its skill) into the cache. It does NOT lay down the Python backend runtime
+# (venv + agent_wallet package + server.py + sealed-secret handling) that the
+# bridge talks to. This script closes that gap: it detects whether the backend
+# runtime is present and, if not, delegates to the existing npm installer
+# (`npx @agentlayer.tech/wallet install --yes`) so the whole thing can be set up
+# without leaving the Claude Code CLI.
+#
+# Modes:
+#   bootstrap_backend.sh check     Report readiness only. Exit 0 if ready, 1 if not.
+#                                  Never installs anything.
+#   bootstrap_backend.sh install   Ensure the backend is installed (default).
+#                                  Idempotent: a no-op when already healthy.
+#
+# Used by:
+#   - /wallet-setup slash command  -> `install` (explicit, user-initiated).
+#   - SessionStart hook            -> `install` by default, so the backend sets
+#                                     itself up on first session. Set
+#                                     AGENT_WALLET_AUTO_BOOTSTRAP=0 to opt out and
+#                                     get only a soft hint to run /wallet-setup.
+
+MODE=${1:-install}
+
+PACKAGE_SPEC=${AGENT_WALLET_BOOTSTRAP_PACKAGE:-"@agentlayer.tech/wallet@latest"}
+OPENCLAW_HOME=${OPENCLAW_HOME:-"$HOME/.openclaw"}
+RUNTIME_CURRENT="$OPENCLAW_HOME/agent-wallet-runtime/current"
+
+# Resolve this script's plugin root with physical paths (pwd -P), the same way
+# run_mcp.sh does, so a marketplace symlink does not break the "../../../codex"
+# sibling math below.
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
+PLUGIN_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/.." && pwd -P)
+
+log() {
+  printf '%s\n' "$*" >&2
+}
+
+# Locate server.py exactly like run_mcp.sh: the plugin's own copy, then the codex
+# sibling in a repo checkout, then the installed runtime package. Keeping this in
+# lock-step with run_mcp.sh is what avoids a false "not installed" verdict in a
+# dev checkout, where run_mcp.sh resolves the codex sibling but this script used
+# to look only at the runtime path.
+resolve_server() {
+  if [ -f "$PLUGIN_ROOT/server.py" ]; then
+    printf '%s' "$PLUGIN_ROOT/server.py"
+  elif [ -f "$PLUGIN_ROOT/../../../codex/plugins/agent-wallet/server.py" ]; then
+    printf '%s' "$PLUGIN_ROOT/../../../codex/plugins/agent-wallet/server.py"
+  elif [ -f "$RUNTIME_CURRENT/codex/plugins/agent-wallet/server.py" ]; then
+    printf '%s' "$RUNTIME_CURRENT/codex/plugins/agent-wallet/server.py"
+  else
+    printf '%s' ''
+  fi
+}
+
+resolve_python() {
+  if [ -n "${AGENT_WALLET_PYTHON:-}" ]; then
+    printf '%s' "$AGENT_WALLET_PYTHON"
+  elif [ -x "$RUNTIME_CURRENT/agent-wallet/.venv/bin/python" ]; then
+    printf '%s' "$RUNTIME_CURRENT/agent-wallet/.venv/bin/python"
+  elif [ -x "$RUNTIME_CURRENT/agent-wallet/.runtime-venv/bin/python" ]; then
+    printf '%s' "$RUNTIME_CURRENT/agent-wallet/.runtime-venv/bin/python"
+  elif command -v python3 >/dev/null 2>&1; then
+    printf '%s' python3
+  else
+    printf '%s' ''
+  fi
+}
+
+# Readiness proxy: the resolved server.py exists and parses (ast.parse, no
+# bytecode written) — the same shallow check run_mcp.sh and `doctor` run before
+# exec. It deliberately does NOT verify that the venv/dependencies are installed:
+# importing or running the server would be too slow and flaky for a SessionStart
+# hook and risks false-negative reinstall loops. run_mcp.sh surfaces any missing
+# dependency with a clear error at first tool use, so this stays in lock-step
+# with what actually runs the server rather than being stricter than it.
+backend_ready() {
+  server=$(resolve_server)
+  [ -n "$server" ] || return 1
+  py=$(resolve_python)
+  [ -n "$py" ] || return 1
+  "$py" -c 'import sys, ast; ast.parse(open(sys.argv[1], encoding="utf-8").read())' "$server" 2>/dev/null
+}
+
+if backend_ready; then
+  [ "$MODE" = "check" ] || log "AgentLayer wallet backend already installed (server: $(resolve_server))."
+  exit 0
+fi
+
+if [ "$MODE" = "check" ]; then
+  log "AgentLayer wallet backend is not installed yet."
+  log "Run /wallet-setup inside Claude Code to install it."
+  exit 1
+fi
+
+# --- install path -----------------------------------------------------------
+
+if ! command -v npx >/dev/null 2>&1; then
+  log "Cannot install the AgentLayer wallet backend: npx (Node.js) was not found on PATH."
+  log "Install Node.js 18+ and re-run /wallet-setup, or run manually:"
+  log "  npx $PACKAGE_SPEC install --yes"
+  exit 1
+fi
+
+if ! command -v python3 >/dev/null 2>&1; then
+  log "Warning: python3 was not found on PATH. The installer needs Python >= 3.10 with venv."
+  log "Install Python and re-run /wallet-setup if the install below fails."
+fi
+
+log "Installing the AgentLayer wallet backend runtime via npm (this may take a minute)…"
+log "  -> npx $PACKAGE_SPEC install --yes"
+if ! npx -y "$PACKAGE_SPEC" install --yes; then
+  log "Backend install failed. Ensure Node.js 18+ and Python >= 3.10 (with venv) are installed, then re-run /wallet-setup."
+  exit 1
+fi
+
+# Re-pin the Claude Code cache copies so run_mcp.sh resolves OPENCLAW_HOME and the
+# freshly installed runtime correctly (pinClaudeCacheCopies / marketplace wiring).
+# --skip-enable: the plugin is already registered via the marketplace, so we only
+# want the file pinning, not another `claude plugin install`.
+log "Wiring the Claude Code bridge to the installed runtime…"
+npx -y "$PACKAGE_SPEC" claude-code install --yes --skip-enable || \
+  log "Note: could not re-pin the Claude Code bridge automatically; it will still resolve the default runtime."
+
+if backend_ready; then
+  log "Done. The AgentLayer wallet backend is installed."
+  log "Restart Claude Code (or reload the agent-wallet plugin) to activate the wallet tools."
+  exit 0
+fi
+
+log "Install completed but the backend did not verify. Run: npx $PACKAGE_SPEC doctor --deep"
+exit 1

package/claude-code/plugins/agent-wallet/scripts/run_mcp.sh

@@ -27,7 +27,7 @@ elif [ -f "$CODEX_SERVER" ]; then
 elif [ -f "$RUNTIME_CODEX_DIR/server.py" ]; then
   SERVER_PY=$(CDPATH= cd -- "$RUNTIME_CODEX_DIR" && pwd -P)/server.py
 else
-  printf '{"error":"agent-wallet server.py not found in plugin, codex sibling, or runtime package.","fix":"npx @agentlayer.tech/wallet install --yes"}\n' >&2
+  printf '{"error":"agent-wallet backend not installed yet (server.py not found in plugin, codex sibling, or runtime package).","fix":"Run /wallet-setup inside Claude Code, or: npx @agentlayer.tech/wallet install --yes"}\n' >&2
   exit 1
 fi
 
@@ -58,4 +58,9 @@ PY
   exit 1
 fi
 
+# Tag anonymous telemetry with this frontend so adoption can be split per host
+# (claude-code / codex / hermes / openclaw). An explicit override still wins.
+: "${AGENT_WALLET_HOST:=claude-code}"
+export AGENT_WALLET_HOST
+
 exec "$PYTHON_BIN" "$SERVER_PY"

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/scripts/run_mcp.sh

@@ -39,4 +39,9 @@ PY
   exit 1
 fi
 
+# Tag anonymous telemetry with this frontend so adoption can be split per host
+# (claude-code / codex / hermes / openclaw). An explicit override still wins.
+: "${AGENT_WALLET_HOST:=codex}"
+export AGENT_WALLET_HOST
+
 exec "$PYTHON_BIN" "$PLUGIN_ROOT/server.py"

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.43
+version: 0.1.44
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/hermes/plugins/agent_wallet/tools.py

@@ -319,6 +319,9 @@ def _cli_env(package_root: Path) -> dict[str, str]:
     env = dict(os.environ)
     prior = env.get("PYTHONPATH", "")
     env["PYTHONPATH"] = str(package_root) if not prior else f"{package_root}{os.pathsep}{prior}"
+    # Tag anonymous telemetry with this frontend so adoption can be split per
+    # host (claude-code / codex / hermes / openclaw). An explicit override wins.
+    env.setdefault("AGENT_WALLET_HOST", "hermes")
     if not env.get("AGENT_WALLET_BOOT_KEY"):
         key_file = env.get("AGENT_WALLET_BOOT_KEY_FILE", "").strip()
         if key_file:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {
@@ -46,6 +46,7 @@
     "agent-wallet/pyproject.toml",
     ".openclaw/AGENTS.md",
     ".openclaw/extensions/agent-wallet/",
+    ".claude-plugin/marketplace.json",
     "codex/plugins/agent-wallet/",
     "claude-code/plugins/agent-wallet/",
     "hermes/plugins/agent_wallet/",

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",